X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer_funcs.C;h=5bb3ed0b0f6343d64e942c139eba72a20b29fa2d;hb=52eb91c94fb70d58dceef430659c8781de2eccda;hp=c3902373af5a878ef0b879ab2f87589c20773b64;hpb=2b6b957d3ed8931b5ab281befef549a4ef7e0236;p=lyx.git diff --git a/src/buffer_funcs.C b/src/buffer_funcs.C index c3902373af..5bb3ed0b0f 100644 --- a/src/buffer_funcs.C +++ b/src/buffer_funcs.C @@ -13,7 +13,6 @@ #include #include "buffer_funcs.h" - #include "buffer.h" #include "bufferlist.h" #include "bufferparams.h" @@ -23,20 +22,25 @@ #include "Floating.h" #include "FloatList.h" #include "gettext.h" +#include "language.h" #include "LaTeX.h" #include "lyxtextclass.h" #include "paragraph.h" #include "paragraph_funcs.h" -#include "ParagraphList_fwd.h" +#include "ParagraphList.h" #include "ParagraphParameters.h" #include "pariterator.h" #include "lyxvc.h" #include "texrow.h" +#include "TocBackend.h" #include "vc-backend.h" #include "frontends/Alert.h" #include "insets/insetbibitem.h" +#include "insets/insetcaption.h" +#include "insets/insetinclude.h" +#include "insets/insettabular.h" #include "support/filetools.h" #include "support/fs_extras.h" @@ -45,47 +49,53 @@ #include #include -using lyx::pit_type; -using lyx::support::bformat; -using lyx::support::LibFileSearch; -using lyx::support::MakeDisplayPath; -using lyx::support::OnlyFilename; -using lyx::support::OnlyPath; -using lyx::support::unlink; + +namespace lyx { + +using namespace std; + +using support::bformat; +using support::FileName; +using support::libFileSearch; +using support::makeAbsPath; +using support::makeDisplayPath; +using support::onlyFilename; +using support::onlyPath; +using support::unlink; using std::min; using std::string; +namespace Alert = frontend::Alert; namespace fs = boost::filesystem; -extern BufferList bufferlist; - namespace { -bool readFile(Buffer * const b, string const & s) +bool readFile(Buffer * const b, FileName const & s) { BOOST_ASSERT(b); // File information about normal file - if (!fs::exists(s)) { - string const file = MakeDisplayPath(s, 50); - string text = bformat(_("The specified document\n%1$s" - "\ncould not be read."), file); + if (!fs::exists(s.toFilesystemEncoding())) { + docstring const file = makeDisplayPath(s.absFilename(), 50); + docstring text = bformat(_("The specified document\n%1$s" + "\ncould not be read."), file); Alert::error(_("Could not read document"), text); return false; } // Check if emergency save file exists and is newer. - string const e = OnlyPath(s) + OnlyFilename(s) + ".emergency"; + FileName const e(s.absFilename() + ".emergency"); - if (fs::exists(e) && fs::exists(s) - && fs::last_write_time(e) > fs::last_write_time(s)) + if (fs::exists(e.toFilesystemEncoding()) && + fs::exists(s.toFilesystemEncoding()) && + fs::last_write_time(e.toFilesystemEncoding()) > fs::last_write_time(s.toFilesystemEncoding())) { - string const file = MakeDisplayPath(s, 20); - string const text = + docstring const file = makeDisplayPath(s.absFilename(), 20); + docstring const text = bformat(_("An emergency save of the document " "%1$s exists.\n\n" - "Recover emergency save?"), file); + "Recover emergency save?"), file); switch (Alert::prompt(_("Load emergency save?"), text, 0, 2, _("&Recover"), _("&Load Original"), _("&Cancel"))) @@ -102,16 +112,17 @@ bool readFile(Buffer * const b, string const & s) } // Now check if autosave file is newer. - string const a = OnlyPath(s) + '#' + OnlyFilename(s) + '#'; + FileName const a(onlyPath(s.absFilename()) + '#' + onlyFilename(s.absFilename()) + '#'); - if (fs::exists(a) && fs::exists(s) - && fs::last_write_time(a) > fs::last_write_time(s)) + if (fs::exists(a.toFilesystemEncoding()) && + fs::exists(s.toFilesystemEncoding()) && + fs::last_write_time(a.toFilesystemEncoding()) > fs::last_write_time(s.toFilesystemEncoding())) { - string const file = MakeDisplayPath(s, 20); - string const text = + docstring const file = makeDisplayPath(s.absFilename(), 20); + docstring const text = bformat(_("The backup of the document " "%1$s is newer.\n\nLoad the " - "backup instead?"), file); + "backup instead?"), file); switch (Alert::prompt(_("Load backup?"), text, 0, 2, _("&Load backup"), _("Load &original"), _("&Cancel") )) @@ -136,24 +147,24 @@ bool readFile(Buffer * const b, string const & s) -bool loadLyXFile(Buffer * b, string const & s) +bool loadLyXFile(Buffer * b, FileName const & s) { BOOST_ASSERT(b); - if (fs::is_readable(s)) { + if (fs::is_readable(s.toFilesystemEncoding())) { if (readFile(b, s)) { b->lyxvc().file_found_hook(s); - if (!fs::is_writable(s)) + if (!fs::is_writable(s.toFilesystemEncoding())) b->setReadonly(true); return true; } } else { - string const file = MakeDisplayPath(s, 20); + docstring const file = makeDisplayPath(s.absFilename(), 20); // Here we probably should run if (LyXVC::file_not_found_hook(s)) { - string const text = + docstring const text = bformat(_("Do you want to retrieve the document" - " %1$s from version control?"), file); + " %1$s from version control?"), file); int const ret = Alert::prompt(_("Retrieve from version control?"), text, 0, 1, _("&Retrieve"), _("&Cancel")); @@ -169,27 +180,30 @@ bool loadLyXFile(Buffer * b, string const & s) return false; } - +// FIXME newFile() should probably be a member method of Application... Buffer * newFile(string const & filename, string const & templatename, bool const isNamed) { // get a free buffer - Buffer * b = bufferlist.newBuffer(filename); + Buffer * b = theBufferList().newBuffer(filename); BOOST_ASSERT(b); - string tname; + FileName tname; // use defaults.lyx as a default template if it exists. if (templatename.empty()) - tname = LibFileSearch("templates", "defaults.lyx"); + tname = libFileSearch("templates", "defaults.lyx"); else - tname = templatename; + tname = makeAbsPath(templatename); if (!tname.empty()) { if (!b->readFile(tname)) { - string const file = MakeDisplayPath(tname, 50); - string const text = bformat(_("The specified document template\n%1$s\ncould not be read."), file); + docstring const file = makeDisplayPath(tname.absFilename(), 50); + docstring const text = bformat( + _("The specified document template\n%1$s\ncould not be read."), + file); Alert::error(_("Could not read template"), text); - // no template, start with empty buffer + theBufferList().release(b); + return 0; } } @@ -206,36 +220,35 @@ Buffer * newFile(string const & filename, string const & templatename, } -void bufferErrors(Buffer const & buf, TeXErrors const & terr) +void bufferErrors(Buffer const & buf, TeXErrors const & terr, + ErrorList & errorList) { TeXErrors::Errors::const_iterator cit = terr.begin(); TeXErrors::Errors::const_iterator end = terr.end(); for (; cit != end; ++cit) { - int par_id = -1; - int posstart = -1; - int const errorrow = cit->error_in_line; - buf.texrow().getIdFromRow(errorrow, par_id, posstart); - int posend = -1; - buf.texrow().getIdFromRow(errorrow + 1, par_id, posend); - buf.error(ErrorItem(cit->error_desc, - cit->error_text, - par_id, posstart, posend)); + int id_start = -1; + int pos_start = -1; + int errorrow = cit->error_in_line; + bool found = buf.texrow().getIdFromRow(errorrow, id_start, + pos_start); + int id_end = -1; + int pos_end = -1; + do { + ++errorrow; + found = buf.texrow().getIdFromRow(errorrow, id_end, + pos_end); + } while (found && id_start == id_end && pos_start == pos_end); + + errorList.push_back(ErrorItem(cit->error_desc, + cit->error_text, id_start, pos_start, pos_end)); } } -void bufferErrors(Buffer const & buf, ErrorList const & el) +string const bufferFormat(Buffer const & buffer) { - for_each(el.begin(), el.end(), bind(ref(buf.error), _1)); -} - - -string const BufferFormat(Buffer const & buffer) -{ - if (buffer.isLinuxDoc()) - return "linuxdoc"; - else if (buffer.isDocBook()) + if (buffer.isDocBook()) return "docbook"; else if (buffer.isLiterate()) return "literate"; @@ -253,7 +266,7 @@ int countWords(DocIterator const & from, DocIterator const & to) if (dit.inTexted() && dit.pos() != dit.lastpos() && dit.paragraph().isLetter(dit.pos()) - && !isDeletedText(dit.paragraph(), dit.pos())) { + && !dit.paragraph().isDeleted(dit.pos())) { if (!inword) { ++count; inword = true; @@ -268,90 +281,153 @@ int countWords(DocIterator const & from, DocIterator const & to) namespace { -void incrementItemDepth(ParagraphList & pars, pit_type pit, pit_type first_pit) +depth_type getDepth(DocIterator const & it) { - int const cur_labeltype = pars[pit].layout()->labeltype; + depth_type depth = 0; + for (size_t i = 0 ; i < it.depth() ; ++i) + if (!it[i].inset().inMathed()) + depth += it[i].paragraph().getDepth() + 1; + // remove 1 since the outer inset does not count + return depth - 1; +} - if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE) - return; +depth_type getItemDepth(ParIterator const & it) +{ + Paragraph const & par = *it; + LYX_LABEL_TYPES const labeltype = par.layout()->labeltype; - int const cur_depth = pars[pit].getDepth(); + if (labeltype != LABEL_ENUMERATE && labeltype != LABEL_ITEMIZE) + return 0; - pit_type prev_pit = pit - 1; + // this will hold the lowest depth encountered up to now. + depth_type min_depth = getDepth(it); + ParIterator prev_it = it; while (true) { - int const prev_depth = pars[prev_pit].getDepth(); - int const prev_labeltype = pars[prev_pit].layout()->labeltype; - if (prev_depth == 0 && cur_depth > 0) { - if (prev_labeltype == cur_labeltype) { - pars[pit].itemdepth = pars[prev_pit].itemdepth + 1; + if (prev_it.pit()) + --prev_it.top().pit(); + else { + // start of nested inset: go to outer par + prev_it.pop_back(); + if (prev_it.empty()) { + // start of document: nothing to do + return 0; } - break; - } else if (prev_depth < cur_depth) { - if (prev_labeltype == cur_labeltype) { - pars[pit].itemdepth = pars[prev_pit].itemdepth + 1; - break; + } + + // We search for the first paragraph with same label + // that is not more deeply nested. + Paragraph & prev_par = *prev_it; + depth_type const prev_depth = getDepth(prev_it); + if (labeltype == prev_par.layout()->labeltype) { + if (prev_depth < min_depth) { + return prev_par.itemdepth + 1; } - } else if (prev_depth == cur_depth) { - if (prev_labeltype == cur_labeltype) { - pars[pit].itemdepth = pars[prev_pit].itemdepth; - break; + else if (prev_depth == min_depth) { + return prev_par.itemdepth; } } - if (prev_pit == first_pit) - break; + min_depth = std::min(min_depth, prev_depth); + // small optimization: if we are at depth 0, we won't + // find anything else + if (prev_depth == 0) { + return 0; + } + } +} + - --prev_pit; +bool needEnumCounterReset(ParIterator const & it) +{ + Paragraph const & par = *it; + BOOST_ASSERT(par.layout()->labeltype == LABEL_ENUMERATE); + depth_type const cur_depth = par.getDepth(); + ParIterator prev_it = it; + while (prev_it.pit()) { + --prev_it.top().pit(); + Paragraph const & prev_par = *prev_it; + if (prev_par.getDepth() <= cur_depth) + return prev_par.layout()->labeltype != LABEL_ENUMERATE; } + // start of nested inset: reset + return true; } -void resetEnumCounterIfNeeded(ParagraphList & pars, pit_type pit, - pit_type firstpit, Counters & counters) +void setCaptionLabels(InsetBase & inset, string const & type, + docstring const label, Counters & counters) { - if (pit == firstpit) + LyXText * text = inset.getText(0); + if (!text) return; - int const cur_depth = pars[pit].getDepth(); - pit_type prev_pit = pit - 1; - while (true) { - int const prev_depth = pars[prev_pit].getDepth(); - int const prev_labeltype = pars[prev_pit].layout()->labeltype; - if (prev_depth <= cur_depth) { - if (prev_labeltype != LABEL_ENUMERATE) { - switch (pars[pit].itemdepth) { - case 0: - counters.reset("enumi"); - case 1: - counters.reset("enumii"); - case 2: - counters.reset("enumiii"); - case 3: - counters.reset("enumiv"); - } + ParagraphList & pars = text->paragraphs(); + if (pars.empty()) + return; + + docstring const counter = from_ascii(type); + + ParagraphList::iterator p = pars.begin(); + for (; p != pars.end(); ++p) { + InsetList::iterator it2 = p->insetlist.begin(); + InsetList::iterator end2 = p->insetlist.end(); + // Any caption within this float should have the same + // label prefix but different numbers. + for (; it2 != end2; ++it2) { + InsetBase & icap = *it2->inset; + // Look deeper just in case. + setCaptionLabels(icap, type, label, counters); + if (icap.lyxCode() == InsetBase::CAPTION_CODE) { + // We found a caption! + counters.step(counter); + int number = counters.value(counter); + InsetCaption & ic = static_cast(icap); + ic.setType(type); + ic.setCount(number); + ic.setCustomLabel(label); } - break; } + } +} - if (prev_pit == firstpit) - break; - --prev_pit; +void setCaptions(Paragraph & par, LyXTextClass const & textclass) +{ + if (par.insetlist.empty()) + return; + + Counters & counters = textclass.counters(); + + InsetList::iterator it = par.insetlist.begin(); + InsetList::iterator end = par.insetlist.end(); + for (; it != end; ++it) { + InsetBase & inset = *it->inset; + if (inset.lyxCode() == InsetBase::FLOAT_CODE + || inset.lyxCode() == InsetBase::WRAP_CODE) { + docstring const & name = inset.getInsetName(); + if (name.empty()) + continue; + + Floating const & fl = textclass.floats().getType(to_ascii(name)); + // FIXME UNICODE + string const & type = fl.type(); + docstring const label = from_utf8(fl.name()); + setCaptionLabels(inset, type, label, counters); + } + else if (inset.lyxCode() == InsetBase::TABULAR_CODE + && static_cast(inset).tabular.isLongTabular()) { + // FIXME: are "table" and "Table" the correct type and label? + setCaptionLabels(inset, "table", from_ascii("Table"), counters); + } } } - -// set the counter of a paragraph. This includes the labels -void setCounter(Buffer const & buf, ParIterator & it) +// set the label of a paragraph. This includes the counters. +void setLabel(Buffer const & buf, ParIterator & it, LyXTextClass const & textclass) { Paragraph & par = *it; - BufferParams const & bufparams = buf.params(); - LyXTextClass const & textclass = bufparams.getLyXTextClass(); LyXLayout_ptr const & layout = par.layout(); Counters & counters = textclass.counters(); - // Always reset - par.itemdepth = 0; - if (it.pit() == 0) { par.params().appendix(par.params().startOfAppendix()); } else { @@ -361,62 +437,61 @@ void setCounter(Buffer const & buf, ParIterator & it) par.params().appendix(true); textclass.counters().reset(); } - - // Maybe we have to increment the item depth. - incrementItemDepth(it.plist(), it.pit(), 0); } - // erase what was there before - par.params().labelString(string()); + // Compute the item depth of the paragraph + par.itemdepth = getItemDepth(it); if (layout->margintype == MARGIN_MANUAL) { if (par.params().labelWidthString().empty()) - par.setLabelWidthString(layout->labelstring()); + par.params().labelWidthString(par.translateIfPossible(layout->labelstring(), buf.params())); } else { - par.setLabelWidthString(string()); + par.params().labelWidthString(docstring()); } + // Optimisation: setLabel() can be called for each for each + // paragraph of the document. So we make the string static to + // avoid the repeated instanciation. + static docstring itemlabel; + // is it a layout that has an automatic label? if (layout->labeltype == LABEL_COUNTER) { if (layout->toclevel <= buf.params().secnumdepth && (layout->latextype != LATEX_ENVIRONMENT || isFirstInSequence(it.pit(), it.plist()))) { counters.step(layout->counter); - string label = expandLabel(textclass, layout, - par.params().appendix()); - par.params().labelString(label); - } + par.params().labelString( + par.expandLabel(layout, buf.params())); + } else + par.params().labelString(docstring()); + } else if (layout->labeltype == LABEL_ITEMIZE) { // At some point of time we should do something more // clever here, like: // par.params().labelString( - // bufparams.user_defined_bullet(par.itemdepth).getText()); + // buf.params().user_defined_bullet(par.itemdepth).getText()); // for now, use a simple hardcoded label - string itemlabel; switch (par.itemdepth) { case 0: - itemlabel = "*"; + itemlabel = char_type(0x2022); break; case 1: - itemlabel = "-"; + itemlabel = char_type(0x2013); break; case 2: - itemlabel = "@"; + itemlabel = char_type(0x2217); break; case 3: - itemlabel = "ยท"; + itemlabel = char_type(0x2219); // or 0x00b7 break; } - par.params().labelString(itemlabel); - } else if (layout->labeltype == LABEL_ENUMERATE) { - // Maybe we have to reset the enumeration counter. - resetEnumCounterIfNeeded(it.plist(), it.pit(), 0, counters); + } else if (layout->labeltype == LABEL_ENUMERATE) { // FIXME // Yes I know this is a really, really! bad solution // (Lgb) - string enumcounter = "enum"; + docstring enumcounter = from_ascii("enum"); switch (par.itemdepth) { case 2: @@ -434,56 +509,166 @@ void setCounter(Buffer const & buf, ParIterator & it) break; } + // Maybe we have to reset the enumeration counter. + if (needEnumCounterReset(it)) + counters.reset(enumcounter); + counters.step(enumcounter); - par.params().labelString(counters.enumLabel(enumcounter)); + string format; + + switch (par.itemdepth) { + case 0: + format = N_("\\arabic{enumi}."); + break; + case 1: + format = N_("(\\alph{enumii})"); + break; + case 2: + format = N_("\\roman{enumiii}."); + break; + case 3: + format = N_("\\Alph{enumiv}."); + break; + default: + // not a valid enumdepth... + break; + } + + par.params().labelString(counters.counterLabel( + par.translateIfPossible(from_ascii(format), buf.params()))); + } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302 - counters.step("bibitem"); - int number = counters.value("bibitem"); - if (par.bibitem()) + counters.step(from_ascii("bibitem")); + int number = counters.value(from_ascii("bibitem")); + if (par.bibitem()) par.bibitem()->setCounter(number); - par.params().labelString(layout->labelstring()); - // In biblio should't be following counters but... + + par.params().labelString( + par.translateIfPossible(layout->labelstring(), buf.params())); + // In biblio shouldn't be following counters but... } else if (layout->labeltype == LABEL_SENSITIVE) { // Search for the first float or wrap inset in the iterator - string type; size_t i = it.depth(); + InsetBase * in = 0; while (i > 0) { --i; - InsetBase * const in = &it[i].inset(); - if (in->lyxCode() == InsetBase::FLOAT_CODE - || in->lyxCode() == InsetBase::WRAP_CODE) - type = in->getInsetName(); + InsetBase::Code const code = it[i].inset().lyxCode(); + if (code == InsetBase::FLOAT_CODE || + code == InsetBase::WRAP_CODE) { + in = &it[i].inset(); break; + } } + // FIXME Can getInsetName() return an empty name for wide or + // float insets? If not we can put the definition of type + // inside the if (in) clause and use that instead of + // if (!type.empty()). + docstring type; + if (in) + type = in->getInsetName(); - string s; if (!type.empty()) { - Floating const & fl = textclass.floats().getType(type); - - counters.step(fl.type()); + Floating const & fl = textclass.floats().getType(to_ascii(type)); + // FIXME UNICODE + counters.step(from_ascii(fl.type())); // Doesn't work... yet. - s = bformat(_("%1$s #:"), buf.B_(fl.name())); + par.params().labelString(par.translateIfPossible( + bformat(from_ascii("%1$s #:"), from_utf8(fl.name())), + buf.params())); } else { // par->SetLayout(0); - s = buf.B_(layout->labelstring()); + par.params().labelString(par.translateIfPossible( + layout->labelstring(), buf.params())); } - par.params().labelString(s); - } else - par.params().labelString(buf.B_(layout->labelstring())); + } else if (layout->labeltype == LABEL_NO_LABEL) + par.params().labelString(docstring()); + else + par.params().labelString( + par.translateIfPossible(layout->labelstring(), buf.params())); } } // anon namespace -void updateCounters(Buffer const & buf) +bool updateCurrentLabel(Buffer const & buf, + ParIterator & it) +{ + if (it == par_iterator_end(buf.inset())) + return false; + +// if (it.lastpit == 0 && LyXText::isMainText(buf)) +// return false; + + switch (it->layout()->labeltype) { + + case LABEL_NO_LABEL: + case LABEL_MANUAL: + case LABEL_BIBLIO: + case LABEL_TOP_ENVIRONMENT: + case LABEL_CENTERED_TOP_ENVIRONMENT: + case LABEL_STATIC: + case LABEL_ITEMIZE: + setLabel(buf, it, buf.params().getLyXTextClass()); + return true; + + case LABEL_SENSITIVE: + case LABEL_COUNTER: + // do more things with enumerate later + case LABEL_ENUMERATE: + return false; + } + + // This is dead code which get rid of a warning: + return true; +} + + +void updateLabels(Buffer const & buf, + ParIterator & from, ParIterator & to, bool childonly) { - // start over - buf.params().getLyXTextClass().counters().reset(); + for (ParIterator it = from; it != to; ++it) { + if (it.pit() > it.lastpit()) + return; + if (!updateCurrentLabel (buf, it)) { + updateLabels(buf, childonly); + return; + } + } +} + + +void updateLabels(Buffer const & buf, ParIterator & iter, bool childonly) +{ + if (updateCurrentLabel(buf, iter)) + return; + + updateLabels(buf, childonly); +} - for (ParIterator it = par_iterator_begin(buf.inset()); it; ++it) { + +void updateLabels(Buffer const & buf, bool childonly) +{ + // Use the master text class also for child documents + LyXTextClass const & textclass = buf.params().getLyXTextClass(); + + if (!childonly) { + // If this is a child document start with the master + Buffer const * const master = buf.getMasterBuffer(); + if (master != &buf) { + updateLabels(*master); + return; + } + + // start over the counters + textclass.counters().reset(); + } + + ParIterator const end = par_iterator_end(buf.inset()); + + for (ParIterator it = par_iterator_begin(buf.inset()); it != end; ++it) { // reduce depth if necessary if (it.pit()) { Paragraph const & prevpar = it.plist()[it.pit() - 1]; @@ -493,30 +678,25 @@ void updateCounters(Buffer const & buf) it->params().depth(0); // set the counter for this paragraph - setCounter(buf, it); - } -} - - -string expandLabel(LyXTextClass const & textclass, - LyXLayout_ptr const & layout, bool appendix) -{ - string fmt = appendix ? - layout->labelstring_appendix() : layout->labelstring(); - - // handle 'inherited level parts' in 'fmt', - // i.e. the stuff between '@' in '@Section@.\arabic{subsection}' - size_t const i = fmt.find('@', 0); - if (i != string::npos) { - size_t const j = fmt.find('@', i + 1); - if (j != string::npos) { - string parent(fmt, i + 1, j - i - 1); - string label = expandLabel(textclass, textclass[parent], appendix); - fmt = string(fmt, 0, i) + label + string(fmt, j + 1, string::npos); + setLabel(buf, it, textclass); + + // It is better to set the captions after setLabel because + // the caption number might need the section number in the + // future. + setCaptions(*it, textclass); + + // Now included docs + InsetList::const_iterator iit = it->insetlist.begin(); + InsetList::const_iterator end = it->insetlist.end(); + for (; iit != end; ++iit) { + if (iit->inset->lyxCode() == InsetBase::INCLUDE_CODE) + static_cast(iit->inset) + ->updateLabels(buf); } } - return textclass.counters().counterLabel(fmt); + const_cast(buf).tocBackend().update(); } +} // namespace lyx