X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBuffer.cpp;h=8105d5261ba8b57006528033b55105e4116f2080;hb=2420f5ed1e9fe98c6273de3c9d661641aefc011b;hp=161178bd561addbd719f242176562407946206dd;hpb=c1173eb11c5f218cd459924eb44276445c499069;p=lyx.git diff --git a/src/Buffer.cpp b/src/Buffer.cpp index 161178bd56..8105d5261b 100644 --- a/src/Buffer.cpp +++ b/src/Buffer.cpp @@ -3,7 +3,7 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author Stefan Schimanski * * Full author contact details are available in file CREDITS. @@ -101,6 +101,7 @@ #include #include #include +#include #include #include #include @@ -115,13 +116,17 @@ namespace os = support::os; namespace { -int const LYX_FORMAT = 340; //jamatos: add plain layout +// Do not remove the comment below, so we get merge conflict in +// independent branches. Instead add your own. +int const LYX_FORMAT = 348; // uwestoehr: add support for \*phantom typedef map DepClean; typedef map > RefCache; } // namespace anon +class BufferSet : public std::set {}; + class Buffer::Impl { public: @@ -275,12 +280,21 @@ Buffer::~Buffer() // GuiView already destroyed gui_ = 0; + if (d->unnamed && d->filename.extension() == "internal") { + // No need to do additional cleanups for internal buffer. + delete d; + return; + } // loop over children Impl::BufferPositionMap::iterator it = d->children_positions.begin(); Impl::BufferPositionMap::iterator end = d->children_positions.end(); - for (; it != end; ++it) - theBufferList().releaseChild(this, const_cast(it->first)); + for (; it != end; ++it) { + Buffer * child = const_cast(it->first); + // The child buffer might have been closed already. + if (theBufferList().isLoaded(child)) + theBufferList().releaseChild(this, child); + } // clear references to children in macro tables d->children_positions.clear(); @@ -367,6 +381,12 @@ string const Buffer::temppath() const } +TexRow & Buffer::texrow() +{ + return d->texrow; +} + + TexRow const & Buffer::texrow() const { return d->texrow; @@ -531,7 +551,7 @@ int Buffer::readHeader(Lexer & lex) // Uwe C. Schroeder // changed to be public and have one parameter -// Returns false if "\end_document" is not read (Asger) +// Returns true if "\end_document" is not read (Asger) bool Buffer::readDocument(Lexer & lex) { ErrorList & errorList = d->errorLists["Parse"]; @@ -550,19 +570,19 @@ bool Buffer::readDocument(Lexer & lex) if (params().outputChanges) { bool dvipost = LaTeXFeatures::isAvailable("dvipost"); - bool xcolorsoul = LaTeXFeatures::isAvailable("soul") && + bool xcolorulem = LaTeXFeatures::isAvailable("ulem") && LaTeXFeatures::isAvailable("xcolor"); - if (!dvipost && !xcolorsoul) { + if (!dvipost && !xcolorulem) { Alert::warning(_("Changes not shown in LaTeX output"), _("Changes will not be highlighted in LaTeX output, " - "because neither dvipost nor xcolor/soul are installed.\n" + "because neither dvipost nor xcolor/ulem are installed.\n" "Please install these packages or redefine " "\\lyxadded and \\lyxdeleted in the LaTeX preamble.")); - } else if (!xcolorsoul) { + } else if (!xcolorulem) { Alert::warning(_("Changes not shown in LaTeX output"), _("Changes will not be highlighted in LaTeX output " - "when using pdflatex, because xcolor and soul are not installed.\n" + "when using pdflatex, because xcolor and ulem are not installed.\n" "Please install both packages or redefine " "\\lyxadded and \\lyxdeleted in the LaTeX preamble.")); } @@ -572,8 +592,24 @@ bool Buffer::readDocument(Lexer & lex) FileName const master_file = makeAbsPath(params().master, onlyPath(absFileName())); if (isLyXFilename(master_file.absFilename())) { - Buffer * master = checkAndLoadLyXFile(master_file); - d->parent_buffer = master; + Buffer * master = + checkAndLoadLyXFile(master_file, true); + if (master) { + // set master as master buffer, but only + // if we are a real child + if (master->isChild(this)) + setParent(master); + // if the master is not fully loaded + // it is probably just loading this + // child. No warning needed then. + else if (master->isFullyLoaded()) + LYXERR0("The master '" + << params().master + << "' assigned to this document '" + << absFileName() + << "' does not include " + "this document. Ignoring the master assignment."); + } } } @@ -619,11 +655,8 @@ void Buffer::insertStringAsLines(ParagraphList & pars, ++pos; space_inserted = true; } else { - const pos_type n = 8 - pos % 8; - for (pos_type i = 0; i < n; ++i) { - par.insertChar(pos, ' ', font, params().trackChanges); - ++pos; - } + par.insertChar(pos, *cit, font, params().trackChanges); + ++pos; space_inserted = true; } } else if (!isPrintable(*cit)) { @@ -672,6 +705,8 @@ bool Buffer::readFile(FileName const & filename) { FileName fname(filename); + params().compressed = fname.isZippedFile(); + // remove dummy empty par paragraphs().clear(); Lexer lex; @@ -744,7 +779,7 @@ Buffer::ReadStatus Buffer::readFile(Lexer & lex, FileName const & filename, bformat(_("%1$s is from a different" " version of LyX, but a temporary" " file for converting it could" - " not be created."), + " not be created."), from_utf8(filename.absFilename()))); return failure; } @@ -754,7 +789,7 @@ Buffer::ReadStatus Buffer::readFile(Lexer & lex, FileName const & filename, bformat(_("%1$s is from a different" " version of LyX, but the" " conversion script lyx2lyx" - " could not be found."), + " could not be found."), from_utf8(filename.absFilename()))); return failure; } @@ -773,7 +808,7 @@ Buffer::ReadStatus Buffer::readFile(Lexer & lex, FileName const & filename, Alert::error(_("Conversion script failed"), bformat(_("%1$s is from a different version" " of LyX, but the lyx2lyx script" - " failed to convert it."), + " failed to convert it."), from_utf8(filename.absFilename()))); return failure; } else { @@ -952,7 +987,7 @@ bool Buffer::makeLaTeXFile(FileName const & fname, string const encoding = runparams.encoding->iconvName(); LYXERR(Debug::LATEX, "makeLaTeXFile encoding: " << encoding << "..."); - odocfstream ofs; + ofdocstream ofs; try { ofs.reset(encoding); } catch (iconv_codecvt_facet_exception & e) { lyxerr << "Caught iconv exception: " << e.what() << endl; @@ -1022,6 +1057,9 @@ void Buffer::writeLaTeXSource(odocstream & os, OutputParams runparams = runparams_in; + // Classify the unicode characters appearing in math insets + Encodings::initUnicodeMath(*this); + // validate the buffer. LYXERR(Debug::LATEX, " Validating buffer..."); LaTeXFeatures features(*this, params(), runparams); @@ -1168,7 +1206,7 @@ void Buffer::makeDocBookFile(FileName const & fname, { LYXERR(Debug::LATEX, "makeDocBookFile..."); - odocfstream ofs; + ofdocstream ofs; if (!openFileWrite(ofs, fname)) return; @@ -1330,10 +1368,10 @@ void Buffer::getLabelList(vector & list) const } -void Buffer::updateBibfilesCache() const +void Buffer::updateBibfilesCache(UpdateScope scope) const { // If this is a child document, use the parent's cache instead. - if (d->parent_buffer) { + if (d->parent_buffer && scope != UpdateChildOnly) { d->parent_buffer->updateBibfilesCache(); return; } @@ -1352,7 +1390,7 @@ void Buffer::updateBibfilesCache() const static_cast(*it); inset.updateBibfilesCache(); support::FileNameList const & bibfiles = - inset.getBibfilesCache(*this); + inset.getBibfilesCache(); d->bibfilesCache_.insert(d->bibfilesCache_.end(), bibfiles.begin(), bibfiles.end()); @@ -1369,15 +1407,15 @@ void Buffer::invalidateBibinfoCache() } -support::FileNameList const & Buffer::getBibfilesCache() const +support::FileNameList const & Buffer::getBibfilesCache(UpdateScope scope) const { // If this is a child document, use the parent's cache instead. - if (d->parent_buffer) + if (d->parent_buffer && scope != UpdateChildOnly) return d->parent_buffer->getBibfilesCache(); // We update the cache when first used instead of at loading time. if (d->bibfilesCache_.empty()) - const_cast(this)->updateBibfilesCache(); + const_cast(this)->updateBibfilesCache(scope); return d->bibfilesCache_; } @@ -1499,17 +1537,18 @@ bool Buffer::isMultiLingual() const DocIterator Buffer::getParFromID(int const id) const { + Buffer * buf = const_cast(this); if (id < 0) { // John says this is called with id == -1 from undo lyxerr << "getParFromID(), id: " << id << endl; - return doc_iterator_end(inset()); + return doc_iterator_end(buf); } - for (DocIterator it = doc_iterator_begin(inset()); !it.atEnd(); it.forwardPar()) + for (DocIterator it = doc_iterator_begin(buf); !it.atEnd(); it.forwardPar()) if (it.paragraph().id() == id) return it; - return doc_iterator_end(inset()); + return doc_iterator_end(buf); } @@ -1521,25 +1560,25 @@ bool Buffer::hasParWithID(int const id) const ParIterator Buffer::par_iterator_begin() { - return ParIterator(doc_iterator_begin(inset())); + return ParIterator(doc_iterator_begin(this)); } ParIterator Buffer::par_iterator_end() { - return ParIterator(doc_iterator_end(inset())); + return ParIterator(doc_iterator_end(this)); } ParConstIterator Buffer::par_iterator_begin() const { - return lyx::par_const_iterator_begin(inset()); + return ParConstIterator(doc_iterator_begin(this)); } ParConstIterator Buffer::par_iterator_end() const { - return lyx::par_const_iterator_end(inset()); + return ParConstIterator(doc_iterator_end(this)); } @@ -1669,12 +1708,38 @@ void Buffer::setParent(Buffer const * buffer) } -Buffer const * Buffer::parent() +Buffer const * Buffer::parent() const { return d->parent_buffer; } +void Buffer::collectRelatives(BufferSet & bufs) const +{ + bufs.insert(this); + if (parent()) + parent()->collectRelatives(bufs); + + // loop over children + Impl::BufferPositionMap::iterator it = d->children_positions.begin(); + Impl::BufferPositionMap::iterator end = d->children_positions.end(); + for (; it != end; ++it) + bufs.insert(const_cast(it->first)); +} + + +std::vector Buffer::allRelatives() const +{ + BufferSet bufs; + collectRelatives(bufs); + BufferSet::iterator it = bufs.begin(); + std::vector ret; + for (; it != bufs.end(); ++it) + ret.push_back(*it); + return ret; +} + + Buffer const * Buffer::masterBuffer() const { if (!d->parent_buffer) @@ -1690,6 +1755,35 @@ bool Buffer::isChild(Buffer * child) const } +DocIterator Buffer::firstChildPosition(Buffer const * child) +{ + Impl::BufferPositionMap::iterator it; + it = d->children_positions.find(child); + if (it == d->children_positions.end()) + return DocIterator(this); + return it->second; +} + + +std::vector Buffer::getChildren() const +{ + std::vector clist; + // loop over children + Impl::BufferPositionMap::iterator it = d->children_positions.begin(); + Impl::BufferPositionMap::iterator end = d->children_positions.end(); + for (; it != end; ++it) { + Buffer * child = const_cast(it->first); + clist.push_back(child); + // there might be grandchildren + std::vector glist = child->getChildren(); + for (vector::const_iterator git = glist.begin(); + git != glist.end(); ++git) + clist.push_back(*git); + } + return clist; +} + + template typename M::iterator greatest_below(M & m, typename M::key_type const & x) { @@ -1720,11 +1814,11 @@ MacroData const * Buffer::getBufferMacro(docstring const & name, // find macro definitions for name Impl::NamePositionScopeMacroMap::iterator nameIt - = d->macros.find(name); + = d->macros.find(name); if (nameIt != d->macros.end()) { // find last definition in front of pos or at pos itself Impl::PositionScopeMacroMap::const_iterator it - = greatest_below(nameIt->second, pos); + = greatest_below(nameIt->second, pos); if (it != nameIt->second.end()) { while (true) { // scope ends behind pos? @@ -1747,7 +1841,7 @@ MacroData const * Buffer::getBufferMacro(docstring const & name, // find macros in included files Impl::PositionScopeBufferMap::const_iterator it - = greatest_below(d->position_to_children, pos); + = greatest_below(d->position_to_children, pos); if (it == d->position_to_children.end()) // no children before return bestData; @@ -1854,8 +1948,7 @@ void Buffer::updateMacros(DocIterator & it, DocIterator & scope) const // is it a nested text inset? if (iit->inset->asInsetText()) { // Inset needs its own scope? - InsetText const * itext - = iit->inset->asInsetText(); + InsetText const * itext = iit->inset->asInsetText(); bool newScope = itext->isMacroScope(); // scope which ends just behind the inset @@ -1872,20 +1965,19 @@ void Buffer::updateMacros(DocIterator & it, DocIterator & scope) const // is it an external file? if (iit->inset->lyxCode() == INCLUDE_CODE) { // get buffer of external file - InsetCommand const & inset - = static_cast(*iit->inset); - InsetCommandParams const & ip = inset.params(); + InsetInclude const & inset = + static_cast(*iit->inset); d->macro_lock = true; - Buffer * child = loadIfNeeded(*this, ip); + Buffer * child = inset.getChildBuffer(); d->macro_lock = false; if (!child) continue; // register its position, but only when it is // included first in the buffer - if (d->children_positions.find(child) - == d->children_positions.end()) - d->children_positions[child] = it; + if (d->children_positions.find(child) == + d->children_positions.end()) + d->children_positions[child] = it; // register child with its scope d->position_to_children[it] = Impl::ScopeBuffer(scope, child); @@ -1896,8 +1988,8 @@ void Buffer::updateMacros(DocIterator & it, DocIterator & scope) const continue; // get macro data - MathMacroTemplate & macroTemplate - = static_cast(*iit->inset); + MathMacroTemplate & macroTemplate = + static_cast(*iit->inset); MacroContext mc(*this, it); macroTemplate.updateToContext(mc); @@ -1948,8 +2040,8 @@ void Buffer::updateMacroInstances() const { LYXERR(Debug::MACROS, "updateMacroInstances for " << d->filename.onlyFileName()); - DocIterator it = doc_iterator_begin(inset()); - DocIterator end = doc_iterator_end(inset()); + DocIterator it = doc_iterator_begin(this); + DocIterator end = doc_iterator_end(this); for (; it != end; it.forwardPos()) { // look for MathData cells in InsetMathNest insets Inset * inset = it.nextInset(); @@ -2100,7 +2192,7 @@ void Buffer::changeRefsIfUnique(docstring const & from, docstring const & to, void Buffer::getSourceCode(odocstream & os, pit_type par_begin, - pit_type par_end, bool full_source) + pit_type par_end, bool full_source) const { OutputParams runparams(¶ms().encoding()); runparams.nice = true; @@ -2114,10 +2206,11 @@ void Buffer::getSourceCode(odocstream & os, pit_type par_begin, os << "% " << _("Preview source code") << "\n\n"; d->texrow.newline(); d->texrow.newline(); - if (isLatex()) - writeLaTeXSource(os, filePath(), runparams, true, true); - else + if (isDocBook()) writeDocBookSource(os, absFileName(), runparams, false); + else + // latex or literate + writeLaTeXSource(os, string(), runparams, true, true); } else { runparams.par_begin = par_begin; runparams.par_end = par_end; @@ -2135,11 +2228,11 @@ void Buffer::getSourceCode(odocstream & os, pit_type par_begin, d->texrow.newline(); d->texrow.newline(); // output paragraphs - if (isLatex()) - latexParagraphs(*this, text(), os, d->texrow, runparams); - else - // DocBook + if (isDocBook()) docbookParagraphs(paragraphs(), *this, os, runparams); + else + // latex or literate + latexParagraphs(*this, text(), os, d->texrow, runparams); } } @@ -2155,6 +2248,14 @@ ErrorList & Buffer::errorList(string const & type) const } +void Buffer::updateTocItem(std::string const & type, + DocIterator const & dit) const +{ + if (gui_) + gui_->updateTocItem(type, dit); +} + + void Buffer::structureChanged() const { if (gui_) @@ -2204,6 +2305,12 @@ void Buffer::resetAutosaveTimers() const } +bool Buffer::hasGuiDelegate() const +{ + return gui_; +} + + void Buffer::setGuiDelegate(frontend::GuiBufferDelegate * gui) { gui_ = gui; @@ -2621,4 +2728,315 @@ void Buffer::bufferErrors(TeXErrors const & terr, ErrorList & errorList) const } +void Buffer::setBuffersForInsets() const +{ + inset().setBuffer(const_cast(*this)); +} + + +void Buffer::updateLabels(UpdateScope scope) const +{ + // Use the master text class also for child documents + Buffer const * const master = masterBuffer(); + DocumentClass const & textclass = master->params().documentClass(); + + // keep the buffers to be children in this set. If the call from the + // master comes back we can see which of them were actually seen (i.e. + // via an InsetInclude). The remaining ones in the set need still be updated. + static std::set bufToUpdate; + if (scope == UpdateMaster) { + // If this is a child document start with the master + if (master != this) { + bufToUpdate.insert(this); + master->updateLabels(); + // Do this here in case the master has no gui associated with it. Then, + // the TocModel is not updated and TocModel::toc_ is invalid (bug 5699). + if (!master->gui_) + structureChanged(); + + // was buf referenced from the master (i.e. not in bufToUpdate anymore)? + if (bufToUpdate.find(this) == bufToUpdate.end()) + return; + } + + // start over the counters in the master + textclass.counters().reset(); + } + + // update will be done below for this buffer + bufToUpdate.erase(this); + + // update all caches + clearReferenceCache(); + updateMacros(); + + Buffer & cbuf = const_cast(*this); + + LASSERT(!text().paragraphs().empty(), /**/); + + // do the real work + ParIterator parit = cbuf.par_iterator_begin(); + updateLabels(parit); + + if (master != this) + // TocBackend update will be done later. + return; + + cbuf.tocBackend().update(); + if (scope == UpdateMaster) + 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