X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FDocIterator.cpp;h=fe1250ff335bf5d91330d12c79ca7bf5c60f241a;hb=28be7d552f62cc02fa86d7f79201d089bfb2d7b5;hp=3ef66b46c705307d2ea416bf93df8d05d5d4df56;hpb=7930b9e5b6b3796eba60ccfa474a772b1ccf9248;p=lyx.git diff --git a/src/DocIterator.cpp b/src/DocIterator.cpp index 3ef66b46c7..fe1250ff33 100644 --- a/src/DocIterator.cpp +++ b/src/DocIterator.cpp @@ -3,7 +3,8 @@ * 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. */ @@ -13,187 +14,233 @@ #include "DocIterator.h" -#include "debug.h" -#include "Text.h" +#include "Buffer.h" +#include "InsetList.h" #include "Paragraph.h" +#include "LyXRC.h" +#include "Text.h" #include "mathed/MathData.h" #include "mathed/InsetMath.h" +#include "mathed/InsetMathHull.h" #include "insets/InsetTabular.h" -#include -#include +#include "support/convert.h" +#include "support/debug.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 { -using std::endl; + +DocIterator::DocIterator() + : boundary_(false), inset_(0), buffer_(0) +{} // 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::DocIterator(Buffer * buf) + : boundary_(false), inset_(0), buffer_(buf) {} -DocIterator::DocIterator(Inset & inset) - : boundary_(false), inset_(&inset) +DocIterator::DocIterator(Buffer * buf, Inset * inset) + : boundary_(false), inset_(inset), buffer_(buf) {} -DocIterator doc_iterator_begin(Inset & inset) +DocIterator doc_iterator_begin(const Buffer * buf0, const Inset * inset0) { - DocIterator dit(inset); + Buffer * buf = const_cast(buf0); + Inset * inset = const_cast(inset0); + DocIterator dit(buf, inset ? inset : &buf->inset()); dit.forwardPos(); return dit; } -DocIterator doc_iterator_end(Inset & inset) +DocIterator doc_iterator_end(const Buffer * buf0, const Inset * inset0) { - return DocIterator(inset); + Buffer * buf = const_cast(buf0); + Inset * inset = const_cast(inset0); + return DocIterator(buf, inset ? inset : &buf->inset()); } -Inset * DocIterator::nextInset() +DocIterator DocIterator::clone(Buffer * buffer) const { - BOOST_ASSERT(!empty()); - if (pos() == lastpos()) - return 0; - if (pos() > lastpos()) { - lyxerr << "Should not happen, but it does. " << endl; - return 0; + 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(); } - if (inMathed()) - return nextAtom().nucleus(); - return paragraph().isInset(pos()) ? paragraph().getInset(pos()) : 0; + return dit; } -Inset * DocIterator::prevInset() +bool DocIterator::inRegexped() const { - BOOST_ASSERT(!empty()); - if (pos() == 0) + InsetMath * im = inset().asInsetMath(); + if (!im) + return false; + InsetMathHull * hull = im->asHullInset(); + return hull && hull->getType() == hullRegexp; +} + + +LyXErr & operator<<(LyXErr & os, DocIterator const & it) +{ + os.stream() << it; + return os; +} + + +Inset * DocIterator::nextInset() const +{ + LASSERT(!empty(), return 0); + if (pos() == lastpos()) return 0; + if (pos() > lastpos()) { + LYXERR0("Should not happen, but it does: pos() = " + << pos() << ", lastpos() = " << lastpos()); + return 0; + } 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; - else - return prevAtom().nucleus(); - return paragraph().isInset(pos() - 1) ? paragraph().getInset(pos() - 1) : 0; + return nextAtom().nucleus(); + return paragraph().getInset(pos()); } -Inset const * DocIterator::prevInset() const +Inset * DocIterator::prevInset() const { - BOOST_ASSERT(!empty()); + LASSERT(!empty(), return 0); if (pos() == 0) return 0; - if (inMathed()) + 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 + // http://www.lyx.org/trac/ticket/3189 return 0; else return prevAtom().nucleus(); - return paragraph().isInset(pos() - 1) ? paragraph().getInset(pos() - 1) : 0; + } + return paragraph().getInset(pos() - 1); } Inset * DocIterator::realInset() const { - BOOST_ASSERT(inTexted()); + LASSERT(inTexted(), return 0); // if we are in a tabular, we need the cell - if (inset().lyxCode() == Inset::TABULAR_CODE) { - InsetTabular & tabular = static_cast(inset()); - return tabular.cell(idx()).get(); + if (inset().lyxCode() == TABULAR_CODE) { + InsetTabular * tabular = inset().asInsetTabular(); + return tabular->cell(idx()).get(); } return &inset(); } -MathAtom const & DocIterator::prevAtom() const -{ - BOOST_ASSERT(!empty()); - BOOST_ASSERT(pos() > 0); - return cell()[pos() - 1]; -} - - -MathAtom & DocIterator::prevAtom() +MathAtom & DocIterator::prevAtom() const { - BOOST_ASSERT(!empty()); - BOOST_ASSERT(pos() > 0); + LASSERT(!empty(), /**/); + LASSERT(pos() > 0, /**/); return cell()[pos() - 1]; } -MathAtom const & DocIterator::nextAtom() const +MathAtom & DocIterator::nextAtom() const { - BOOST_ASSERT(!empty()); + LASSERT(!empty(), /**/); //lyxerr << "lastpos: " << lastpos() << " next atom:\n" << *this << endl; - BOOST_ASSERT(pos() < lastpos()); + LASSERT(pos() < lastpos(), /**/); return cell()[pos()]; } -MathAtom & DocIterator::nextAtom() +Text * DocIterator::text() const { - BOOST_ASSERT(!empty()); - //lyxerr << "lastpos: " << lastpos() << " next atom:\n" << *this << endl; - BOOST_ASSERT(pos() < lastpos()); - return cell()[pos()]; -} - - -Text * DocIterator::text() -{ - BOOST_ASSERT(!empty()); + LASSERT(!empty(), return 0); return top().text(); } -Text const * DocIterator::text() const + +Paragraph & DocIterator::paragraph() const { - BOOST_ASSERT(!empty()); - return top().text(); + if (!inTexted()) { + LYXERR0(*this); + LBUFERR(false); + } + return top().paragraph(); } -Paragraph & DocIterator::paragraph() +Paragraph & DocIterator::innerParagraph() const { - if (!inTexted()) - lyxerr << *this << endl; - BOOST_ASSERT(inTexted()); - return top().paragraph(); + LBUFERR(!empty()); + return innerTextSlice().paragraph(); } -Paragraph const & DocIterator::paragraph() const +FontSpan DocIterator::locateWord(word_location const loc) const { - BOOST_ASSERT(inTexted()); - return top().paragraph(); + FontSpan f = FontSpan(); + + if (!top().text()->empty()) { + f.first = pos(); + top().paragraph().locateWord(f.first, f.last, loc); + } + return f; } -Paragraph const & DocIterator::innerParagraph() const +CursorSlice const & DocIterator::innerTextSlice() const { - BOOST_ASSERT(!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].paragraph(); + return slices_[i]; + + // This case is in principle not possible. We _must_ + // be inside a Text. + 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()); +} + - // This case is in principe not possible. We _must_ - // be inside a Paragraph. - BOOST_ASSERT(false); - return paragraph(); +DocIterator DocIterator::getInnerText() const +{ + DocIterator texted = *this; + while (!texted.inTexted()) + texted.pop_back(); + return texted; } @@ -248,167 +295,100 @@ DocIterator::col_type DocIterator::col() const } -MathData const & DocIterator::cell() const +MathData & DocIterator::cell() const { -// BOOST_ASSERT(inMathed()); +// LASSERT(inMathed(), /**/); return top().cell(); } -MathData & DocIterator::cell() +Text * DocIterator::innerText() const { -// BOOST_ASSERT(inMathed()); - return top().cell(); + LASSERT(!empty(), return 0); + return innerTextSlice().text(); } -Text * DocIterator::innerText() +Inset * DocIterator::innerInsetOfType(int code) const { - BOOST_ASSERT(!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(); + if (slices_[i].inset_->lyxCode() == code) + return slices_[i].inset_; return 0; } -Text const * DocIterator::innerText() const + +bool DocIterator::posBackward() { - BOOST_ASSERT(!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; + if (pos() == 0) + return false; + --pos(); + return true; } -Inset * DocIterator::innerInsetOfType(int code) const +bool DocIterator::posForward() { - for (int i = depth() - 1; i >= 0; --i) - if (slices_[i].inset_->lyxCode() == code) - return slices_[i].inset_; - return 0; + if (pos() == lastpos()) + return false; + ++pos(); + return true; } -void DocIterator::forwardPos(bool ignorecollapsed) +// This duplicates code above, but is in the critical path. +// So please think twice before adding stuff +void DocIterator::forwardPos() { - //this dog bites his tail + // this dog bites his tail if (empty()) { push_back(CursorSlice(*inset_)); return; } - Inset * const nextinset = nextInset(); - // jump over collapsables if they are collapsed - // FIXME: the check for asInsetMath() shouldn't be necessary - // but math insets do not return a sensible editable() state yet. - if (ignorecollapsed && nextinset && (!nextinset->asInsetMath() - && nextinset->editable() != Inset::HIGHLY_EDITABLE)) { - ++top().pos(); - return; - } - CursorSlice & tip = top(); //lyxerr << "XXX\n" << *this << endl; - // this is used twice and shows up in the profiler! - pos_type const lastp = lastpos(); - - // move into an inset to the right if possible - Inset * n = 0; - - if (tip.pos() != lastp) { - // this is impossible for pos() == size() - if (inMathed()) { + // not at cell/paragraph end? + if (tip.pos() != tip.lastpos()) { + // move into an inset to the right if possible + Inset * n = 0; + if (inMathed()) n = (tip.cell().begin() + tip.pos())->nucleus(); - } else { - if (paragraph().isInset(tip.pos())) - n = paragraph().getInset(tip.pos()); + else + n = paragraph().getInset(tip.pos()); + if (n && n->isActive()) { + //lyxerr << "... descend" << endl; + push_back(CursorSlice(*n)); + return; } } - if (n && n->isActive()) { - //lyxerr << "... descend" << endl; - push_back(CursorSlice(*n)); + // jump to the next cell/paragraph if possible + if (!tip.at_end()) { + tip.forwardPos(); return; } - // otherwise move on one position if possible - if (tip.pos() < lastp) { - //lyxerr << "... next pos" << endl; - ++tip.pos(); - return; - } - //lyxerr << "... no next pos" << endl; - - // otherwise move on one paragraph if possible - if (tip.pit() < lastpit()) { - //lyxerr << "... next par" << endl; - ++tip.pit(); - tip.pos() = 0; - return; - } - //lyxerr << "... no next pit" << endl; - - // otherwise try to move on one cell if possible - if (tip.idx() < lastidx()) { - //lyxerr << "... next idx" << endl; - ++tip.idx(); - tip.pit() = 0; - tip.pos() = 0; - return; - } - //lyxerr << "... no next idx" << endl; - // otherwise leave inset and jump over inset as a whole pop_back(); - // 'top' is invalid now... + // 'tip' is invalid now... if (!empty()) ++top().pos(); } -void DocIterator::forwardPosNoDescend() +void DocIterator::forwardPosIgnoreCollapsed() { - CursorSlice & tip = top(); - pos_type const lastp = lastpos(); - - // move on one position if possible - if (tip.pos() < lastp) { - //lyxerr << "... next pos" << endl; - ++tip.pos(); - return; - } - //lyxerr << "... no next pos" << endl; - - // otherwise move on one paragraph if possible - if (tip.pit() < lastpit()) { - //lyxerr << "... next par" << endl; - ++tip.pit(); - tip.pos() = 0; - return; - } - //lyxerr << "... no next pit" << endl; - - // otherwise try to move on one cell if possible - if (tip.idx() < lastidx()) { - //lyxerr << "... next idx" << endl; - ++tip.idx(); - tip.pit() = 0; - tip.pos() = 0; + Inset * const nextinset = nextInset(); + // 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()) { + ++top().pos(); return; } - //lyxerr << "... no next idx" << endl; - - // otherwise leave inset and jump over inset as a whole - pop_back(); - // 'top' is invalid now... - if (!empty()) - ++top().pos(); + forwardPos(); } @@ -421,7 +401,7 @@ void DocIterator::forwardPar() pos_type const lastp = lastpos(); Paragraph const & par = paragraph(); pos_type & pos = top().pos(); - if (par.insetlist.empty()) + if (par.insetList().empty()) pos = lastp; else while (pos < lastp && !par.isInset(pos)) @@ -432,19 +412,6 @@ void DocIterator::forwardPar() } -void DocIterator::forwardIdx() -{ - CursorSlice & tip = top(); - - //prevent endless loops - BOOST_ASSERT(tip.idx() < lastidx()); - - ++tip.idx(); - tip.pit() = 0; - tip.pos() = 0; -} - - void DocIterator::forwardChar() { forwardPos(); @@ -491,34 +458,24 @@ void DocIterator::backwardPos() return; } - CursorSlice & tip = top(); - - if (tip.pos() != 0) { - --tip.pos(); - } else if (tip.pit() != 0) { - --tip.pit(); - tip.pos() = lastpos(); - return; - } else if (tip.idx() != 0) { - --tip.idx(); - tip.pit() = lastpit(); - tip.pos() = lastpos(); - return; - } else { + // at inset beginning? + if (top().at_begin()) { pop_back(); return; } - // move into an inset to the left if possible - Inset * n = 0; + top().backwardPos(); - if (inMathed()) { - n = (tip.cell().begin() + tip.pos())->nucleus(); - } else { - if (paragraph().isInset(tip.pos())) - n = paragraph().getInset(tip.pos()); - } + // entered another cell/paragraph from the right? + if (top().pos() == top().lastpos()) + return; + // move into an inset to the left if possible + Inset * n = 0; + if (inMathed()) + n = (top().cell().begin() + top().pos())->nucleus(); + else + n = paragraph().getInset(top().pos()); if (n && n->isActive()) { push_back(CursorSlice(*n)); top().idx() = lastidx(); @@ -528,6 +485,28 @@ void DocIterator::backwardPos() } +#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 @@ -539,92 +518,204 @@ 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. - // code taken in part from StableDocIterator::asDocIterator. //lyxerr << "converting:\n" << *this << endl; - DocIterator dit = DocIterator(*inset); + DocIterator dit = *this; size_t const n = slices_.size(); + slices_.resize(0); for (size_t i = 0 ; i < n; ++i) { - BOOST_ASSERT(inset); - dit.push_back(slices_[i]); - dit.top().inset_ = inset; + LBUFERR(inset); + push_back(dit[i]); + top().inset_ = inset; if (i + 1 != n) - inset = dit.nextInset(); + inset = nextInset(); } //lyxerr << "converted:\n" << *this << endl; - operator=(dit); } -std::ostream & operator<<(std::ostream & os, DocIterator const & dit) +bool DocIterator::fixIfBroken() { - for (size_t i = 0, n = dit.depth(); i != n; ++i) - os << " " << dit[i] << "\n"; - return os; + if (empty()) + return false; + + // 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(); + size_t i = 0; + size_t n = slices_.size(); + for (; i != n; ++i) { + CursorSlice & cs = slices_[i]; + if (&cs.inset() != inset || cs.nargs() == 0) { + // the whole slice is wrong, chop off this as well + --i; + LYXERR(Debug::DEBUG, "fixIfBroken(): inset changed"); + break; + } else if (cs.idx() > cs.lastidx()) { + cs.idx() = cs.lastidx(); + cs.pit() = cs.lastpit(); + cs.pos() = cs.lastpos(); + LYXERR(Debug::DEBUG, "fixIfBroken(): idx fixed"); + break; + } else if (cs.pit() > cs.lastpit()) { + cs.pit() = cs.lastpit(); + cs.pos() = cs.lastpos(); + LYXERR(Debug::DEBUG, "fixIfBroken(): pit fixed"); + break; + } else if (cs.pos() > cs.lastpos()) { + cs.pos() = cs.lastpos(); + LYXERR(Debug::DEBUG, "fixIfBroken(): pos fixed"); + break; + } else if (i != n - 1 && cs.pos() != cs.lastpos()) { + // get inset which is supposed to be in the next slice + if (cs.inset().inMathed()) + inset = (cs.cell().begin() + cs.pos())->nucleus(); + else if (Inset * csInset = cs.paragraph().getInset(cs.pos())) + inset = csInset; + else { + // there are slices left, so there must be another inset + break; + } + } + } + + // Did we make it through the whole slice stack? Otherwise there + // was a problem at slice i, and we have to chop off above + if (i < n) { + LYXERR(Debug::DEBUG, "fixIfBroken(): cursor chopped at " << i); + resize(i + 1); + return true; + } else + return false; +} + + +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 == 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: " << *this << '\n' + << " lastpos: " << slices_[i].lastpos()); + 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 operator<(DocIterator const & p, DocIterator const & q) +int DocIterator::find(MathData const & cell) const { - size_t depth = std::min(p.depth(), q.depth()); - for (size_t i = 0 ; i < depth ; ++i) { - if (p[i] != q[i]) - return p[i] < q[i]; + for (size_t l = 0; l != slices_.size(); ++l) { + if (slices_[l].asInsetMath() && &slices_[l].cell() == &cell) + return l; } - return p.depth() < q.depth(); + return -1; } -bool operator>(DocIterator const & p, DocIterator const & q) +int DocIterator::find(Inset const * inset) const { - return q < p; + for (size_t l = 0; l != slices_.size(); ++l) { + if (&slices_[l].inset() == inset) + return l; + } + return -1; } -bool operator<=(DocIterator const & p, DocIterator const & q) +void DocIterator::cutOff(int above, vector & cut) { - return !(q < p); + cut = vector(slices_.begin() + above + 1, slices_.end()); + slices_.resize(above + 1); +} + + +void DocIterator::cutOff(int above) +{ + slices_.resize(above + 1); +} + + +void DocIterator::append(vector const & x) +{ + slices_.insert(slices_.end(), x.begin(), x.end()); +} + + +void DocIterator::append(DocIterator::idx_type idx, pos_type pos) +{ + slices_.push_back(CursorSlice()); + top().idx() = idx; + top().pos() = pos; +} + + +ostream & operator<<(ostream & os, DocIterator const & dit) +{ + for (size_t i = 0, n = dit.depth(); i != n; ++i) + os << " " << dit[i] << "\n"; + return os; } /////////////////////////////////////////////////////// -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; } -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 - lyxerr << BOOST_CURRENT_FUNCTION - << " Should not happen, but does e.g. after C-n C-l C-z S-C-z" - << '\n' << "dit: " << dit << '\n' - << " lastpos: " << dit.lastpos() << endl; - //break; - BOOST_ASSERT(false); - } - dit.push_back(data_[i]); - dit.top().inset_ = inset; - 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; } -std::ostream & operator<<(std::ostream & os, StableDocIterator const & dit) +ostream & operator<<(ostream & os, StableDocIterator const & dit) { for (size_t i = 0, n = dit.data_.size(); i != n; ++i) os << " " << dit.data_[i] << "\n";