From: André Pönitz Date: Sun, 16 Nov 2008 17:49:00 +0000 (+0000) Subject: move more stuff from buffer_func to Buffer X-Git-Tag: 2.0.0~7707 X-Git-Url: https://git.lyx.org/gitweb/?a=commitdiff_plain;h=32a53f8d6a19cd6b3ec91ef6afc862137ed0ffd5;p=features.git move more stuff from buffer_func to Buffer git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@27565 a592a061-630c-0410-9148-cb99ea01b6c8 --- diff --git a/src/Buffer.cpp b/src/Buffer.cpp index d7ab7ab52e..f73bbb1ba1 100644 --- a/src/Buffer.cpp +++ b/src/Buffer.cpp @@ -2684,7 +2684,7 @@ void Buffer::updateLabels(bool childonly) const // do the real work ParIterator parit = cbuf.par_iterator_begin(); - lyx::updateLabels(*this, parit); + updateLabels(parit); if (master != this) // TocBackend update will be done later. @@ -2695,4 +2695,256 @@ void Buffer::updateLabels(bool childonly) const cbuf.structureChanged(); } + +static depth_type getDepth(DocIterator const & it) +{ + 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; +} + +static depth_type getItemDepth(ParIterator const & it) +{ + Paragraph const & par = *it; + LabelType const labeltype = par.layout().labeltype; + + if (labeltype != LABEL_ENUMERATE && labeltype != LABEL_ITEMIZE) + return 0; + + // this will hold the lowest depth encountered up to now. + depth_type min_depth = getDepth(it); + ParIterator prev_it = it; + while (true) { + 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; + } + } + + // 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; + if (prev_depth == min_depth) + return prev_par.itemdepth; + } + min_depth = 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; + } +} + + +static bool needEnumCounterReset(ParIterator const & it) +{ + Paragraph const & par = *it; + LASSERT(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; +} + + +// set the label of a paragraph. This includes the counters. +static void setLabel(Buffer const & buf, ParIterator & it) +{ + BufferParams const & bp = buf.masterBuffer()->params(); + DocumentClass const & textclass = bp.documentClass(); + Paragraph & par = it.paragraph(); + Layout const & layout = par.layout(); + Counters & counters = textclass.counters(); + + if (par.params().startOfAppendix()) { + // FIXME: only the counter corresponding to toplevel + // sectionning should be reset + counters.reset(); + counters.appendix(true); + } + par.params().appendix(counters.appendix()); + + // Compute the item depth of the paragraph + par.itemdepth = getItemDepth(it); + + if (layout.margintype == MARGIN_MANUAL) { + if (par.params().labelWidthString().empty()) + par.params().labelWidthString(par.translateIfPossible(layout.labelstring(), bp)); + } else { + par.params().labelWidthString(docstring()); + } + + switch(layout.labeltype) { + case LABEL_COUNTER: + if (layout.toclevel <= bp.secnumdepth + && (layout.latextype != LATEX_ENVIRONMENT + || isFirstInSequence(it.pit(), it.plist()))) { + counters.step(layout.counter); + par.params().labelString( + par.expandLabel(layout, bp)); + } else + par.params().labelString(docstring()); + break; + + case LABEL_ITEMIZE: { + // At some point of time we should do something more + // clever here, like: + // par.params().labelString( + // bp.user_defined_bullet(par.itemdepth).getText()); + // for now, use a simple hardcoded label + docstring itemlabel; + switch (par.itemdepth) { + case 0: + itemlabel = char_type(0x2022); + break; + case 1: + itemlabel = char_type(0x2013); + break; + case 2: + itemlabel = char_type(0x2217); + break; + case 3: + itemlabel = char_type(0x2219); // or 0x00b7 + break; + } + par.params().labelString(itemlabel); + break; + } + + case LABEL_ENUMERATE: { + // FIXME: Yes I know this is a really, really! bad solution + // (Lgb) + docstring enumcounter = from_ascii("enum"); + + switch (par.itemdepth) { + case 2: + enumcounter += 'i'; + case 1: + enumcounter += 'i'; + case 0: + enumcounter += 'i'; + break; + case 3: + enumcounter += "iv"; + break; + default: + // not a valid enumdepth... + break; + } + + // Maybe we have to reset the enumeration counter. + if (needEnumCounterReset(it)) + counters.reset(enumcounter); + + counters.step(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), bp))); + + break; + } + + case LABEL_SENSITIVE: { + string const & type = counters.current_float(); + docstring full_label; + if (type.empty()) + full_label = buf.B_("Senseless!!! "); + else { + docstring name = buf.B_(textclass.floats().getType(type).name()); + if (counters.hasCounter(from_utf8(type))) { + counters.step(from_utf8(type)); + full_label = bformat(from_ascii("%1$s %2$s:"), + name, + counters.theCounter(from_utf8(type))); + } else + full_label = bformat(from_ascii("%1$s #:"), name); + } + par.params().labelString(full_label); + break; + } + + case LABEL_NO_LABEL: + par.params().labelString(docstring()); + break; + + case LABEL_MANUAL: + case LABEL_TOP_ENVIRONMENT: + case LABEL_CENTERED_TOP_ENVIRONMENT: + case LABEL_STATIC: + case LABEL_BIBLIO: + par.params().labelString( + par.translateIfPossible(layout.labelstring(), bp)); + break; + } +} + + +void Buffer::updateLabels(ParIterator & parit) const +{ + LASSERT(parit.pit() == 0, /**/); + + // set the position of the text in the buffer to be able + // to resolve macros in it. This has nothing to do with + // labels, but by putting it here we avoid implementing + // a whole bunch of traversal routines just for this call. + parit.text()->setMacrocontextPosition(parit); + + depth_type maxdepth = 0; + pit_type const lastpit = parit.lastpit(); + for ( ; parit.pit() <= lastpit ; ++parit.pit()) { + // reduce depth if necessary + parit->params().depth(min(parit->params().depth(), maxdepth)); + maxdepth = parit->getMaxDepthAfter(); + + // set the counter for this paragraph + setLabel(*this, parit); + + // Now the insets + InsetList::const_iterator iit = parit->insetList().begin(); + InsetList::const_iterator end = parit->insetList().end(); + for (; iit != end; ++iit) { + parit.pos() = iit->pos; + iit->inset->updateLabels(parit); + } + } +} + } // namespace lyx diff --git a/src/Buffer.h b/src/Buffer.h index db5f9737e2..57cf298e4f 100644 --- a/src/Buffer.h +++ b/src/Buffer.h @@ -469,6 +469,8 @@ public: // FIXME: buf should should be const because updateLabels() modifies // the contents of the paragraphs. void updateLabels(bool childonly = false) const; + /// + void updateLabels(ParIterator & parit) const; private: /// search for macro in local (buffer) table or in children diff --git a/src/LyXFunc.cpp b/src/LyXFunc.cpp index b8600360cd..9207ef56df 100644 --- a/src/LyXFunc.cpp +++ b/src/LyXFunc.cpp @@ -1796,20 +1796,20 @@ bool LyXFunc::wasMetaKey() const } -void LyXFunc::updateLayout(DocumentClass const * const oldlayout, Buffer * buffer) +void LyXFunc::updateLayout(DocumentClass const * const oldlayout, Buffer * buf) { lyx_view_->message(_("Converting document to new document class...")); StableDocIterator backcur(view()->cursor()); - ErrorList & el = buffer->errorList("Class Switch"); + ErrorList & el = buf->errorList("Class Switch"); cap::switchBetweenClasses( - oldlayout, buffer->params().documentClassPtr(), - static_cast(buffer->inset()), el); + oldlayout, buf->params().documentClassPtr(), + static_cast(buf->inset()), el); - view()->setCursor(backcur.asDocIterator(&(buffer->inset()))); + view()->setCursor(backcur.asDocIterator(&(buf->inset()))); - buffer->errors("Class Switch"); - buffer->updateLabels(); + buf->errors("Class Switch"); + buf->updateLabels(); } @@ -1827,6 +1827,7 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new) case LyXRC::RC_ACCEPT_COMPOUND: case LyXRC::RC_ALT_LANG: case LyXRC::RC_PLAINTEXT_LINELEN: + case LyXRC::RC_PLAINTEXT_ROFF_COMMAND: case LyXRC::RC_AUTOREGIONDELETE: case LyXRC::RC_AUTORESET_OPTIONS: case LyXRC::RC_AUTOSAVE: @@ -1969,6 +1970,4 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new) } } // namespace anon - - } // namespace lyx diff --git a/src/buffer_funcs.cpp b/src/buffer_funcs.cpp index 9e0350a9ef..861413dcd9 100644 --- a/src/buffer_funcs.cpp +++ b/src/buffer_funcs.cpp @@ -87,9 +87,10 @@ Buffer * checkAndLoadLyXFile(FileName const & filename) return 0; } Buffer * b = theBufferList().newBuffer(filename.absFilename()); - if (!b) + if (!b) { // Buffer creation is not possible. return 0; + } if (!b->loadLyXFile(filename)) { theBufferList().release(b); return 0; @@ -216,259 +217,4 @@ int countChars(DocIterator const & from, DocIterator const & to, bool with_blank return chars + blanks; } - -namespace { - -depth_type getDepth(DocIterator const & it) -{ - 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; -} - -depth_type getItemDepth(ParIterator const & it) -{ - Paragraph const & par = *it; - LabelType const labeltype = par.layout().labeltype; - - if (labeltype != LABEL_ENUMERATE && labeltype != LABEL_ITEMIZE) - return 0; - - // this will hold the lowest depth encountered up to now. - depth_type min_depth = getDepth(it); - ParIterator prev_it = it; - while (true) { - 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; - } - } - - // 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; - if (prev_depth == min_depth) - return prev_par.itemdepth; - } - min_depth = 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; - } -} - - -bool needEnumCounterReset(ParIterator const & it) -{ - Paragraph const & par = *it; - LASSERT(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; -} - - -// set the label of a paragraph. This includes the counters. -void setLabel(Buffer const & buf, ParIterator & it) -{ - BufferParams const & bp = buf.masterBuffer()->params(); - DocumentClass const & textclass = bp.documentClass(); - Paragraph & par = it.paragraph(); - Layout const & layout = par.layout(); - Counters & counters = textclass.counters(); - - if (par.params().startOfAppendix()) { - // FIXME: only the counter corresponding to toplevel - // sectionning should be reset - counters.reset(); - counters.appendix(true); - } - par.params().appendix(counters.appendix()); - - // Compute the item depth of the paragraph - par.itemdepth = getItemDepth(it); - - if (layout.margintype == MARGIN_MANUAL) { - if (par.params().labelWidthString().empty()) - par.params().labelWidthString(par.translateIfPossible(layout.labelstring(), bp)); - } else { - par.params().labelWidthString(docstring()); - } - - switch(layout.labeltype) { - case LABEL_COUNTER: - if (layout.toclevel <= bp.secnumdepth - && (layout.latextype != LATEX_ENVIRONMENT - || isFirstInSequence(it.pit(), it.plist()))) { - counters.step(layout.counter); - par.params().labelString( - par.expandLabel(layout, bp)); - } else - par.params().labelString(docstring()); - break; - - case LABEL_ITEMIZE: { - // At some point of time we should do something more - // clever here, like: - // par.params().labelString( - // bp.user_defined_bullet(par.itemdepth).getText()); - // for now, use a simple hardcoded label - docstring itemlabel; - switch (par.itemdepth) { - case 0: - itemlabel = char_type(0x2022); - break; - case 1: - itemlabel = char_type(0x2013); - break; - case 2: - itemlabel = char_type(0x2217); - break; - case 3: - itemlabel = char_type(0x2219); // or 0x00b7 - break; - } - par.params().labelString(itemlabel); - break; - } - - case LABEL_ENUMERATE: { - // FIXME: Yes I know this is a really, really! bad solution - // (Lgb) - docstring enumcounter = from_ascii("enum"); - - switch (par.itemdepth) { - case 2: - enumcounter += 'i'; - case 1: - enumcounter += 'i'; - case 0: - enumcounter += 'i'; - break; - case 3: - enumcounter += "iv"; - break; - default: - // not a valid enumdepth... - break; - } - - // Maybe we have to reset the enumeration counter. - if (needEnumCounterReset(it)) - counters.reset(enumcounter); - - counters.step(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), bp))); - - break; - } - - case LABEL_SENSITIVE: { - string const & type = counters.current_float(); - docstring full_label; - if (type.empty()) - full_label = buf.B_("Senseless!!! "); - else { - docstring name = buf.B_(textclass.floats().getType(type).name()); - if (counters.hasCounter(from_utf8(type))) { - counters.step(from_utf8(type)); - full_label = bformat(from_ascii("%1$s %2$s:"), - name, - counters.theCounter(from_utf8(type))); - } else - full_label = bformat(from_ascii("%1$s #:"), name); - } - par.params().labelString(full_label); - break; - } - - case LABEL_NO_LABEL: - par.params().labelString(docstring()); - break; - - case LABEL_MANUAL: - case LABEL_TOP_ENVIRONMENT: - case LABEL_CENTERED_TOP_ENVIRONMENT: - case LABEL_STATIC: - case LABEL_BIBLIO: - par.params().labelString( - par.translateIfPossible(layout.labelstring(), bp)); - break; - } -} - -} // anon namespace - -void updateLabels(Buffer const & buf, ParIterator & parit) -{ - LASSERT(parit.pit() == 0, /**/); - - // set the position of the text in the buffer to be able - // to resolve macros in it. This has nothing to do with - // labels, but by putting it here we avoid implementing - // a whole bunch of traversal routines just for this call. - parit.text()->setMacrocontextPosition(parit); - - depth_type maxdepth = 0; - pit_type const lastpit = parit.lastpit(); - for ( ; parit.pit() <= lastpit ; ++parit.pit()) { - // reduce depth if necessary - parit->params().depth(min(parit->params().depth(), maxdepth)); - maxdepth = parit->getMaxDepthAfter(); - - // set the counter for this paragraph - setLabel(buf, parit); - - // Now the insets - InsetList::const_iterator iit = parit->insetList().begin(); - InsetList::const_iterator end = parit->insetList().end(); - for (; iit != end; ++iit) { - parit.pos() = iit->pos; - iit->inset->updateLabels(parit); - } - } -} - } // namespace lyx diff --git a/src/buffer_funcs.h b/src/buffer_funcs.h index 55780ec63b..d34a7406c3 100644 --- a/src/buffer_funcs.h +++ b/src/buffer_funcs.h @@ -47,9 +47,6 @@ int countWords(DocIterator const & from, DocIterator const & to); /// Count the number of chars in the text between these two iterators int countChars(DocIterator const & from, DocIterator const & to, bool with_blanks); -/// -void updateLabels(Buffer const &, ParIterator &); - } // namespace lyx #endif // BUFFER_FUNCS_H diff --git a/src/insets/InsetTabular.cpp b/src/insets/InsetTabular.cpp index 7338daba1e..e9e2c31033 100644 --- a/src/insets/InsetTabular.cpp +++ b/src/insets/InsetTabular.cpp @@ -3220,7 +3220,7 @@ void InsetTabular::updateLabels(ParIterator const & it) it2.forwardPos(); size_t const end = it2.nargs(); for ( ; it2.idx() < end; it2.top().forwardIdx()) - lyx::updateLabels(buffer(), it2); + buffer().updateLabels(it2); //reset afterwards if (tabular.is_long_tabular) diff --git a/src/insets/InsetText.cpp b/src/insets/InsetText.cpp index e4722e1238..078d8154db 100644 --- a/src/insets/InsetText.cpp +++ b/src/insets/InsetText.cpp @@ -458,13 +458,13 @@ void InsetText::updateLabels(ParIterator const & it) { ParIterator it2 = it; it2.forwardPos(); - LASSERT(&it2.inset() == this && it2.pit() == 0, /**/); - if (producesOutput()) - lyx::updateLabels(buffer(), it2); - else { + LASSERT(&it2.inset() == this && it2.pit() == 0, return); + if (producesOutput()) { + buffer().updateLabels(it2); + } else { DocumentClass const & tclass = buffer().masterBuffer()->params().documentClass(); Counters const savecnt = tclass.counters(); - lyx::updateLabels(buffer(), it2); + buffer().updateLabels(it2); tclass.counters() = savecnt; } }