X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FDocIterator.cpp;h=31a5bffcafe0f47630b2da56ce009df69c61b6ef;hb=b198a36a363bb6a084407d476942d68ef5fb5e86;hp=2a3b60c101991f1c8ddf7d26c8d04114df16679c;hpb=7f461f4392a19cf488dec005d2f12cfea83655d9;p=lyx.git diff --git a/src/DocIterator.cpp b/src/DocIterator.cpp index 2a3b60c101..31a5bffcaf 100644 --- a/src/DocIterator.cpp +++ b/src/DocIterator.cpp @@ -3,7 +3,7 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author André Pönitz + * \author André Pönitz * \author Alfredo Braunstein * * Full author contact details are available in file CREDITS. @@ -14,49 +14,78 @@ #include "DocIterator.h" +#include "Buffer.h" +#include "BufferParams.h" +#include "Encoding.h" +#include "Font.h" #include "InsetList.h" +#include "Language.h" #include "Paragraph.h" #include "Text.h" #include "mathed/MathData.h" #include "mathed/InsetMath.h" +#include "mathed/InsetMathHull.h" #include "insets/InsetTabular.h" +#include "support/convert.h" #include "support/debug.h" - -#include "support/assert.h" +#include "support/ExceptionMessage.h" +#include "support/gettext.h" +#include "support/lassert.h" +#include "support/lstrings.h" #include using namespace std; +using namespace lyx::support; namespace lyx { -// We could be able to get rid of this if only every BufferView were -// associated to a buffer on construction. -DocIterator::DocIterator() - : boundary_(false), inset_(0) -{} +DocIterator doc_iterator_begin(const Buffer * buf0, const Inset * inset0) +{ + Buffer * buf = const_cast(buf0); + Inset * inset = const_cast(inset0); + DocIterator dit(buf, inset ? inset : &buf->inset()); + dit.forwardPos(); + return dit; +} -DocIterator::DocIterator(Inset & inset) - : boundary_(false), inset_(&inset) -{} +DocIterator doc_iterator_end(const Buffer * buf0, const Inset * inset0) +{ + Buffer * buf = const_cast(buf0); + Inset * inset = const_cast(inset0); + return DocIterator(buf, inset ? inset : &buf->inset()); +} -DocIterator doc_iterator_begin(Inset & inset) +DocIterator DocIterator::clone(Buffer * buffer) const { - DocIterator dit(inset); - dit.forwardPos(); + LASSERT(buffer->isClone(), return DocIterator()); + Inset * inset = &buffer->inset(); + DocIterator dit(buffer); + size_t const n = slices_.size(); + for (size_t i = 0 ; i != n; ++i) { + LBUFERR(inset); + dit.push_back(slices_[i]); + dit.top().inset_ = inset; + if (i + 1 != n) + inset = dit.nextInset(); + } return dit; } -DocIterator doc_iterator_end(Inset & inset) +bool DocIterator::inRegexped() const { - return DocIterator(inset); + InsetMath * im = inset().asInsetMath(); + if (!im) + return false; + InsetMathHull * hull = im->asHullInset(); + return hull && hull->getType() == hullRegexp; } @@ -69,12 +98,13 @@ LyXErr & operator<<(LyXErr & os, DocIterator const & it) Inset * DocIterator::nextInset() const { - LASSERT(!empty(), /**/); + LASSERT(!empty(), return nullptr); if (pos() == lastpos()) - return 0; + return nullptr; if (pos() > lastpos()) { - LYXERR0("Should not happen, but it does. "); - return 0; + LYXERR0("Should not happen, but it does: pos() = " + << pos() << ", lastpos() = " << lastpos()); + return nullptr; } if (inMathed()) return nextAtom().nucleus(); @@ -84,15 +114,15 @@ Inset * DocIterator::nextInset() const Inset * DocIterator::prevInset() const { - LASSERT(!empty(), /**/); + LASSERT(!empty(), return nullptr); if (pos() == 0) - return 0; + return nullptr; if (inMathed()) { if (cell().empty()) // FIXME: this should not happen but it does. // See bug 3189 - // http://bugzilla.lyx.org/show_bug.cgi?id=3189 - return 0; + // http://www.lyx.org/trac/ticket/3189 + return nullptr; else return prevAtom().nucleus(); } @@ -102,16 +132,28 @@ Inset * DocIterator::prevInset() const Inset * DocIterator::realInset() const { - LASSERT(inTexted(), /**/); + LASSERT(inTexted(), return nullptr); // if we are in a tabular, we need the cell if (inset().lyxCode() == TABULAR_CODE) { - InsetTabular & tabular = static_cast(inset()); - return tabular.cell(idx()).get(); + InsetTabular * tabular = inset().asInsetTabular(); + return tabular->cell(idx()).get(); } return &inset(); } +InsetMath & DocIterator::nextMath() +{ + return *nextAtom().nucleus(); +} + + +InsetMath & DocIterator::prevMath() +{ + return *prevAtom().nucleus(); +} + + MathAtom & DocIterator::prevAtom() const { LASSERT(!empty(), /**/); @@ -131,41 +173,72 @@ MathAtom & DocIterator::nextAtom() const Text * DocIterator::text() const { - LASSERT(!empty(), /**/); + LASSERT(!empty(), return nullptr); return top().text(); } Paragraph & DocIterator::paragraph() const { - if (!inTexted()) + if (!inTexted()) { LYXERR0(*this); - LASSERT(inTexted(), /**/); + LBUFERR(false); + } return top().paragraph(); } Paragraph & DocIterator::innerParagraph() const { - LASSERT(!empty(), /**/); + LBUFERR(!empty()); return innerTextSlice().paragraph(); } +FontSpan DocIterator::locateWord(word_location const loc) const +{ + FontSpan f = FontSpan(); + + if (!top().text()->empty()) { + f.first = pos(); + top().paragraph().locateWord(f.first, f.last, loc); + } + return f; +} + + CursorSlice const & DocIterator::innerTextSlice() const { - LASSERT(!empty(), /**/); + LBUFERR(!empty()); // go up until first non-0 text is hit // (innermost text is 0 in mathed) for (int i = depth() - 1; i >= 0; --i) if (slices_[i].text()) return slices_[i]; - // This case is in principe not possible. We _must_ + // This case is in principle not possible. We _must_ // be inside a Text. - LASSERT(false, /**/); - static CursorSlice dummy; - return dummy; + LBUFERR(false); + // Squash warning + static const CursorSlice c; + return c; +} + + +docstring DocIterator::paragraphGotoArgument() const +{ + CursorSlice const & s = innerTextSlice(); + return convert(s.paragraph().id()) + ' ' + + convert(s.pos()); +} + + +DocIterator DocIterator::getInnerText() const +{ + DocIterator texted = *this; + while (!texted.inTexted()) + texted.pop_back(); + return texted; } @@ -181,7 +254,7 @@ pos_type DocIterator::lastpos() const } -DocIterator::idx_type DocIterator::lastidx() const +idx_type DocIterator::lastidx() const { return top().lastidx(); } @@ -208,13 +281,13 @@ size_t DocIterator::nrows() const } -DocIterator::row_type DocIterator::row() const +row_type DocIterator::row() const { return top().row(); } -DocIterator::col_type DocIterator::col() const +col_type DocIterator::col() const { return top().col(); } @@ -229,13 +302,8 @@ MathData & DocIterator::cell() const Text * DocIterator::innerText() const { - LASSERT(!empty(), /**/); - // go up until first non-0 text is hit - // (innermost text is 0 in mathed) - for (int i = depth() - 1; i >= 0; --i) - if (slices_[i].text()) - return slices_[i].text(); - return 0; + LASSERT(!empty(), return nullptr); + return innerTextSlice().text(); } @@ -244,7 +312,25 @@ Inset * DocIterator::innerInsetOfType(int code) const for (int i = depth() - 1; i >= 0; --i) if (slices_[i].inset_->lyxCode() == code) return slices_[i].inset_; - return 0; + return nullptr; +} + + +bool DocIterator::posBackward() +{ + if (pos() == 0) + return false; + --pos(); + return true; +} + + +bool DocIterator::posForward() +{ + if (pos() == lastpos()) + return false; + ++pos(); + return true; } @@ -264,7 +350,7 @@ void DocIterator::forwardPos() // not at cell/paragraph end? if (tip.pos() != tip.lastpos()) { // move into an inset to the right if possible - Inset * n = 0; + Inset * n = nullptr; if (inMathed()) n = (tip.cell().begin() + tip.pos())->nucleus(); else @@ -296,7 +382,7 @@ void DocIterator::forwardPosIgnoreCollapsed() // FIXME: the check for asInsetMath() shouldn't be necessary // but math insets do not return a sensible editable() state yet. if (nextinset && !nextinset->asInsetMath() - && nextinset->editable() != Inset::HIGHLY_EDITABLE) { + && !nextinset->editable()) { ++top().pos(); return; } @@ -383,7 +469,7 @@ void DocIterator::backwardPos() return; // move into an inset to the left if possible - Inset * n = 0; + Inset * n = nullptr; if (inMathed()) n = (top().cell().begin() + top().pos())->nucleus(); else @@ -397,6 +483,40 @@ void DocIterator::backwardPos() } +void DocIterator::backwardPosIgnoreCollapsed() +{ + backwardPos(); + if (inTexted()) { + Inset const * ins = realInset(); + if (ins && !ins->editable()) { + pop_back(); // move out of collapsed inset + } + } +} + + +#if 0 +// works, but currently not needed +void DocIterator::backwardInset() +{ + backwardPos(); + + while (!empty() && !nextInset()) { + if (inTexted()) { + pos_type const lastp = lastpos(); + Paragraph const & par = paragraph(); + pos_type & pos = top().pos(); + while (pos > 0 && (pos == lastp || !par.isInset(pos))) + --pos; + if (pos > 0) + break; + } + backwardPos(); + } +} +#endif + + bool DocIterator::hasPart(DocIterator const & it) const { // it can't be a part if it is larger @@ -408,6 +528,19 @@ bool DocIterator::hasPart(DocIterator const & it) const } +bool DocIterator::allowSpellCheck() const +{ + /// spell check is disabled if the iterator position + /// is inside of an inset which disables the spell checker + size_t const n = depth(); + for (size_t i = 0; i < n; ++i) { + if (!slices_[i].inset_->allowSpellCheck()) + return false; + } + return true; +} + + void DocIterator::updateInsets(Inset * inset) { // this function re-creates the cache of inset pointers. @@ -416,7 +549,12 @@ void DocIterator::updateInsets(Inset * inset) size_t const n = slices_.size(); slices_.resize(0); for (size_t i = 0 ; i < n; ++i) { - LASSERT(inset, /**/); + if (dit[i].empty() && pos() > 0 && prevMath().lyxCode() == MATH_SCRIPT_CODE) + // Workaround: With empty optional argument and a trailing script, + // we have empty slices in math macro args (#11676) + // FIXME: Find real cause! + continue; + LBUFERR(inset); push_back(dit[i]); top().inset_ = inset; if (i + 1 != n) @@ -431,7 +569,7 @@ bool DocIterator::fixIfBroken() if (empty()) return false; - // Go through the slice stack from the bottom. + // Go through the slice stack from the bottom. // Check that all coordinates (idx, pit, pos) are correct and // that the inset is the one which is claimed to be there Inset * inset = &slices_[0].inset(); @@ -439,7 +577,7 @@ bool DocIterator::fixIfBroken() size_t n = slices_.size(); for (; i != n; ++i) { CursorSlice & cs = slices_[i]; - if (&cs.inset() != inset) { + if (&cs.inset() != inset || ! cs.inset().isActive()) { // the whole slice is wrong, chop off this as well --i; LYXERR(Debug::DEBUG, "fixIfBroken(): inset changed"); @@ -483,6 +621,57 @@ bool DocIterator::fixIfBroken() } +void DocIterator::sanitize() +{ + // keep a copy of the slices + vector const sl = slices_; + slices_.clear(); + if (buffer_) + inset_ = &buffer_->inset(); + Inset * inset = inset_; + // re-add the slices one by one, and adjust the inset pointer. + for (size_t i = 0, n = sl.size(); i != n; ++i) { + if (inset == nullptr) { + // FIXME + LYXERR0("Null inset on cursor stack."); + fixIfBroken(); + break; + } + if (!inset->isActive()) { + LYXERR0("Inset found on cursor stack is not active."); + fixIfBroken(); + break; + } + push_back(sl[i]); + top().inset_ = inset; + if (fixIfBroken()) + break; + if (i + 1 != n) + inset = nextInset(); + } +} + + +bool DocIterator::isInside(Inset const * p) const +{ + for (CursorSlice const & sl : slices_) + if (&sl.inset() == p) + return true; + return false; +} + + +void DocIterator::leaveInset(Inset const & inset) +{ + for (size_t i = 0; i != slices_.size(); ++i) { + if (&slices_[i].inset() == &inset) { + resize(i); + return; + } + } +} + + int DocIterator::find(MathData const & cell) const { for (size_t l = 0; l != slices_.size(); ++l) { @@ -493,7 +682,7 @@ int DocIterator::find(MathData const & cell) const } -int DocIterator::find(Inset const * inset) const +int DocIterator::find(Inset const * inset) const { for (size_t l = 0; l != slices_.size(); ++l) { if (&slices_[l].inset() == inset) @@ -516,13 +705,13 @@ void DocIterator::cutOff(int above) } -void DocIterator::append(vector const & x) +void DocIterator::append(vector const & x) { slices_.insert(slices_.end(), x.begin(), x.end()); } -void DocIterator::append(DocIterator::idx_type idx, pos_type pos) +void DocIterator::append(idx_type idx, pos_type pos) { slices_.push_back(CursorSlice()); top().idx() = idx; @@ -530,6 +719,73 @@ void DocIterator::append(DocIterator::idx_type idx, pos_type pos) } +docstring DocIterator::getPossibleLabel() const +{ + return inMathed() ? from_ascii("eq:") : text()->getPossibleLabel(*this); +} + + +Encoding const * DocIterator::getEncoding() const +{ + if (empty()) + return nullptr; + + BufferParams const & bp = buffer()->params(); + if (bp.useNonTeXFonts) + return encodings.fromLyXName("utf8-plain"); + + // With platex, we don't switch encodings (not even if forced). + if (bp.encoding().package() == Encoding::japanese) + return &bp.encoding(); + + CursorSlice const & sl = innerTextSlice(); + Text const & text = *sl.text(); + Language const * lang = + text.getPar(sl.pit()).getFont(bp, sl.pos(), text.outerFont(sl.pit())).language(); + // If we have a custom encoding for the buffer, we don't switch + // encodings (see output_latex::switchEncoding()) + bool const customenc = bp.inputenc != "auto-legacy" && bp.inputenc != "auto-legacy-plain"; + Encoding const * enc = customenc ? &bp.encoding() : lang->encoding(); + + // Some insets force specific encodings sometimes (e.g., listings in + // multibyte context forces singlebyte). + if (inset().forcedEncoding(enc, encodings.fromLyXName("iso8859-1"))) { + // Get the language outside the inset + size_t const n = depth(); + for (size_t i = 0; i < n; ++i) { + Text const & otext = *slices_[i].text(); + Language const * olang = + otext.getPar(slices_[i].pit()).getFont(bp, slices_[i].pos(), + otext.outerFont(slices_[i].pit())).language(); + Encoding const * oenc = olang->encoding(); + if (oenc->name() != "inherit") + return inset().forcedEncoding(enc, oenc); + } + // Fall back to buffer encoding if no outer lang was found. + return inset().forcedEncoding(enc, &bp.encoding()); + } + + // Inherited encoding (latex_language) is determined by the context + // Look for the first outer encoding that is not itself "inherit" + if (lang->encoding()->name() == "inherit") { + size_t const n = depth(); + for (size_t i = 0; i < n; ++i) { + Text const & otext = *slices_[i].text(); + Language const * olang = + otext.getPar(slices_[i].pit()).getFont(bp, slices_[i].pos(), + otext.outerFont(slices_[i].pit())).language(); + // Again, if we have a custom encoding, this is used + // instead of the language's. + Encoding const * oenc = customenc ? &bp.encoding() : olang->encoding(); + if (olang->encoding()->name() != "inherit") + return oenc; + } + } + + return enc; +} + + ostream & operator<<(ostream & os, DocIterator const & dit) { for (size_t i = 0, n = dit.depth(); i != n; ++i) @@ -540,38 +796,19 @@ ostream & operator<<(ostream & os, DocIterator const & dit) /////////////////////////////////////////////////////// -StableDocIterator::StableDocIterator(DocIterator const & dit) +StableDocIterator::StableDocIterator(DocIterator const & dit) : + data_(dit.internalData()) { - data_ = dit.internalData(); for (size_t i = 0, n = data_.size(); i != n; ++i) - data_[i].inset_ = 0; + data_[i].inset_ = nullptr; } -DocIterator StableDocIterator::asDocIterator(Inset * inset) const +DocIterator StableDocIterator::asDocIterator(Buffer * buf) const { - // this function re-creates the cache of inset pointers - //lyxerr << "converting:\n" << *this << endl; - DocIterator dit = DocIterator(*inset); - for (size_t i = 0, n = data_.size(); i != n; ++i) { - if (inset == 0) { - // FIXME - LYXERR0(" Should not happen, but does e.g. after " - "C-n C-l C-z S-C-z\n" - << " or when a Buffer has been concurrently edited by two views" - << '\n' << "dit: " << dit << '\n' - << " lastpos: " << dit.lastpos()); - dit.fixIfBroken(); - break; - } - dit.push_back(data_[i]); - dit.top().inset_ = inset; - if (dit.fixIfBroken()) - break; - if (i + 1 != n) - inset = dit.nextInset(); - } - //lyxerr << "convert:\n" << *this << " to:\n" << dit << endl; + DocIterator dit(buf); + dit.slices_ = data_; + dit.sanitize(); return dit; }