X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer_funcs.C;h=d13042f063674f4755cc359f6293036416c323db;hb=37d42d45f3f4a5d3e916a080af50b37ae4a9d118;hp=2aee55c78e46fdcff8ebad41570bd9eaecec3f8f;hpb=70572847e26adde4e83b638bf42015b19e473e33;p=lyx.git diff --git a/src/buffer_funcs.C b/src/buffer_funcs.C index 2aee55c78e..d13042f063 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,6 +22,7 @@ #include "Floating.h" #include "FloatList.h" #include "gettext.h" +#include "language.h" #include "LaTeX.h" #include "lyxtextclass.h" #include "paragraph.h" @@ -215,13 +215,15 @@ void bufferErrors(Buffer const & buf, TeXErrors const & terr) int id_start = -1; int pos_start = -1; int errorrow = cit->error_in_line; - buf.texrow().getIdFromRow(errorrow, id_start, pos_start); + bool found = buf.texrow().getIdFromRow(errorrow, id_start, + pos_start); int id_end = -1; int pos_end = -1; do { ++errorrow; - buf.texrow().getIdFromRow(errorrow, id_end, pos_end); - } while (id_start == id_end && pos_start == pos_end); + 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)); @@ -272,75 +274,75 @@ 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; } @@ -353,9 +355,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 { @@ -365,11 +364,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()); @@ -414,9 +413,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) @@ -438,9 +434,33 @@ 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"); @@ -456,9 +476,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;