X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer_funcs.C;h=5c545cbcddc603302ed301696f09d3ab738122c7;hb=5e3b997b852fc96eef2387934b600262d3037745;hp=057be070d7e6639f621d2e1b129f443c9631e365;hpb=1e7112db43e14f6e4f2c021dd3daeea0a46cc808;p=lyx.git diff --git a/src/buffer_funcs.C b/src/buffer_funcs.C index 057be070d7..5c545cbcdd 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,15 +22,18 @@ #include "Floating.h" #include "FloatList.h" #include "gettext.h" +#include "language.h" #include "LaTeX.h" #include "lyxtextclass.h" #include "paragraph.h" -#include "ParagraphList_fwd.h" +#include "paragraph_funcs.h" +#include "ParagraphList.h" #include "ParagraphParameters.h" #include "pariterator.h" #include "lyxvc.h" #include "texrow.h" #include "vc-backend.h" +#include "toc.h" #include "frontends/Alert.h" @@ -41,15 +43,19 @@ #include "support/fs_extras.h" #include "support/lyxlib.h" +#include + #include #include +using namespace std; + 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::libFileSearch; +using lyx::support::makeDisplayPath; +using lyx::support::onlyFilename; +using lyx::support::onlyPath; using lyx::support::unlink; using std::min; @@ -67,7 +73,7 @@ bool readFile(Buffer * const b, string const & s) // File information about normal file if (!fs::exists(s)) { - string const file = MakeDisplayPath(s, 50); + string const file = makeDisplayPath(s, 50); string text = bformat(_("The specified document\n%1$s" "\ncould not be read."), file); Alert::error(_("Could not read document"), text); @@ -75,12 +81,12 @@ bool readFile(Buffer * const b, string const & s) } // Check if emergency save file exists and is newer. - string const e = OnlyPath(s) + OnlyFilename(s) + ".emergency"; + string const e = onlyPath(s) + onlyFilename(s) + ".emergency"; if (fs::exists(e) && fs::exists(s) && fs::last_write_time(e) > fs::last_write_time(s)) { - string const file = MakeDisplayPath(s, 20); + string const file = makeDisplayPath(s, 20); string const text = bformat(_("An emergency save of the document " "%1$s exists.\n\n" @@ -101,12 +107,12 @@ bool readFile(Buffer * const b, string const & s) } // Now check if autosave file is newer. - string const a = OnlyPath(s) + '#' + OnlyFilename(s) + '#'; + string const a = onlyPath(s) + '#' + onlyFilename(s) + '#'; if (fs::exists(a) && fs::exists(s) && fs::last_write_time(a) > fs::last_write_time(s)) { - string const file = MakeDisplayPath(s, 20); + string const file = makeDisplayPath(s, 20); string const text = bformat(_("The backup of the document " "%1$s is newer.\n\nLoad the " @@ -147,7 +153,7 @@ bool loadLyXFile(Buffer * b, string const & s) return true; } } else { - string const file = MakeDisplayPath(s, 20); + string const file = makeDisplayPath(s, 20); // Here we probably should run if (LyXVC::file_not_found_hook(s)) { string const text = @@ -179,13 +185,13 @@ Buffer * newFile(string const & filename, string const & templatename, string 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; if (!tname.empty()) { if (!b->readFile(tname)) { - string const file = MakeDisplayPath(tname, 50); + string const file = makeDisplayPath(tname, 50); string 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 @@ -211,15 +217,21 @@ void bufferErrors(Buffer const & buf, TeXErrors const & terr) 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); + + buf.error(ErrorItem(cit->error_desc, cit->error_text, + id_start, pos_start, pos_end)); } } @@ -230,7 +242,7 @@ void bufferErrors(Buffer const & buf, ErrorList const & el) } -string const BufferFormat(Buffer const & buffer) +string const bufferFormat(Buffer const & buffer) { if (buffer.isLinuxDoc()) return "linuxdoc"; @@ -267,80 +279,80 @@ int countWords(DocIterator const & from, DocIterator const & to) namespace { -void incrementItemDepth(ParagraphList & pars, pit_type pit, pit_type first_pit) +lyx::depth_type getDepth(DocIterator const & it) { - int const cur_labeltype = pars[pit].layout()->labeltype; + lyx::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; +lyx::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. + lyx::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; + lyx::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; - - --prev_pit; + 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; + } } } -void resetEnumCounterIfNeeded(ParagraphList & pars, pit_type pit, - pit_type firstpit, Counters & counters) +bool needEnumCounterReset(ParIterator const & it) { - if (pit == firstpit) - 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"); - } - } - break; - } - - if (prev_pit == firstpit) - break; - - --prev_pit; + Paragraph const & par = *it; + BOOST_ASSERT(par.layout()->labeltype == LABEL_ENUMERATE); + lyx::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; } -// 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) { Paragraph & par = *it; BufferParams const & bufparams = buf.params(); @@ -348,9 +360,6 @@ void setCounter(Buffer const & buf, ParIterator & it) 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 { @@ -360,11 +369,11 @@ 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); } + // Compute the item depth of the paragraph + par.itemdepth = getItemDepth(it); + // erase what was there before par.params().labelString(string()); @@ -377,9 +386,14 @@ void setCounter(Buffer const & buf, ParIterator & it) // is it a layout that has an automatic label? if (layout->labeltype == LABEL_COUNTER) { - counters.step(layout->counter); - string label = expandLabel(textclass, layout, par.params().appendix()); - par.params().labelString(label); + if (layout->toclevel <= buf.params().secnumdepth + && (layout->latextype != LATEX_ENVIRONMENT + || isFirstInSequence(it.pit(), it.plist()))) { + counters.step(layout->counter); + string label = expandLabel(buf, layout, + par.params().appendix()); + par.params().labelString(label); + } } else if (layout->labeltype == LABEL_ITEMIZE) { // At some point of time we should do something more // clever here, like: @@ -404,9 +418,6 @@ void setCounter(Buffer const & buf, ParIterator & it) 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); - // FIXME // Yes I know this is a really, really! bad solution // (Lgb) @@ -428,16 +439,39 @@ 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(buf.B_(format))); } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302 counters.step("bibitem"); int number = counters.value("bibitem"); - if (par.bibitem()) { + if (par.bibitem()) par.bibitem()->setCounter(number); - par.params().labelString(layout->labelstring()); - } + par.params().labelString(buf.B_(layout->labelstring())); // In biblio should't be following counters but... } else if (layout->labeltype == LABEL_SENSITIVE) { // Search for the first float or wrap inset in the iterator @@ -447,9 +481,10 @@ void setCounter(Buffer const & buf, ParIterator & it) --i; InsetBase * const in = &it[i].inset(); if (in->lyxCode() == InsetBase::FLOAT_CODE - || in->lyxCode() == InsetBase::WRAP_CODE) + || in->lyxCode() == InsetBase::WRAP_CODE) { type = in->getInsetName(); break; + } } string s; @@ -466,19 +501,80 @@ void setCounter(Buffer const & buf, ParIterator & it) } par.params().labelString(s); - } else + } else if (layout->labeltype == LABEL_NO_LABEL) + par.params().labelString(string()); + else par.params().labelString(buf.B_(layout->labelstring())); } } // 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()) +// 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); + 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) +{ + for (ParIterator it = from; it != to; ++it) { + if (it.pit() > it.lastpit()) + return; + if (!updateCurrentLabel (buf, it)) { + updateLabels(buf); + return; + } + } +} + + +void updateLabels(Buffer const & buf, + ParIterator & iter) +{ + if (updateCurrentLabel(buf, iter)) + return; + + updateLabels(buf); +} + + +void updateLabels(Buffer const & buf) { - // start over + // start over the counters buf.params().getLyXTextClass().counters().reset(); + + ParIterator const end = par_iterator_end(buf.inset()); - for (ParIterator it = par_iterator_begin(buf.inset()); it; ++it) { + 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]; @@ -488,16 +584,20 @@ void updateCounters(Buffer const & buf) it->params().depth(0); // set the counter for this paragraph - setCounter(buf, it); + setLabel(buf, it); } + + lyx::toc::updateToc(buf); } -string expandLabel(LyXTextClass const & textclass, +string expandLabel(Buffer const & buf, LyXLayout_ptr const & layout, bool appendix) { - string fmt = appendix ? - layout->labelstring_appendix() : layout->labelstring(); + LyXTextClass const & tclass = buf.params().getLyXTextClass(); + + string fmt = buf.B_(appendix ? layout->labelstring_appendix() + : layout->labelstring()); // handle 'inherited level parts' in 'fmt', // i.e. the stuff between '@' in '@Section@.\arabic{subsection}' @@ -506,12 +606,10 @@ string expandLabel(LyXTextClass const & textclass, 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); + string label = expandLabel(buf, tclass[parent], appendix); fmt = string(fmt, 0, i) + label + string(fmt, j + 1, string::npos); } } - return textclass.counters().counterLabel(fmt); + return tclass.counters().counterLabel(fmt); } - -