X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FDocIterator.h;h=471f52d4be18079a6638682a540efff7fb99f7fe;hb=27f1f8a94857b147fcd5097351ec2fb070c2966e;hp=1ffc262a4e49194a596c879751b94a1c3c25cab5;hpb=6fa7710506497fb65a0fd3d6eb4942f6041be85f;p=lyx.git diff --git a/src/DocIterator.h b/src/DocIterator.h index 1ffc262a4e..471f52d4be 100644 --- a/src/DocIterator.h +++ b/src/DocIterator.h @@ -4,7 +4,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 * * Full author contact details are available in file CREDITS. */ @@ -15,27 +15,23 @@ #include "CursorSlice.h" #include -#include - +#include namespace lyx { -class Text; +class DocIterator; +class LyXErr; class MathAtom; class Paragraph; +class Text; +class InsetIterator; +class FontSpan; - -// only needed for gcc 2.95, remove when support terminated -template -bool ptr_cmp(A const * a, B const * b) -{ - return a == b; -} +DocIterator doc_iterator_begin(Buffer const * buf, Inset const * inset = 0); +DocIterator doc_iterator_end(Buffer const * buf, Inset const * inset = 0); -// The public inheritance should go in favour of a suitable data member -// (or maybe private inheritance) at some point of time. -class DocIterator // : public std::vector +class DocIterator { public: /// type for cell number in inset @@ -49,7 +45,16 @@ public: /// DocIterator(); /// - explicit DocIterator(Inset & inset); + explicit DocIterator(Buffer *buf); + + /// access to owning buffer + Buffer * buffer() const { return buffer_; } + /// access to owning buffer + void setBuffer(Buffer * buf) { buffer_ = buf; } + + /// Clone this for given \p buffer. + /// \p buffer must be a clone of buffer_. + DocIterator clone(Buffer * buffer) const; /// access slice at position \p i CursorSlice const & operator[](size_t i) const { return slices_[i]; } @@ -65,6 +70,13 @@ public: /// does this iterator have any content? bool empty() const { return slices_.empty(); } + /// is this the end position? + bool atEnd() const { return slices_.empty(); } + /// is this the last possible position? + bool atLastPos() const { return pit() == lastpit() && pos() == lastpos(); } + + /// checks the cursor slices for disabled spell checker insets + bool allowSpellCheck() const; // // access to slice at tip @@ -131,6 +143,8 @@ public: /// are we in texted?. bool inTexted() const { return !empty() && !inset().inMathed(); } + /// are we in regexp-mode ? + bool inRegexped() const; // // math-specific part @@ -153,6 +167,11 @@ public: Paragraph & innerParagraph() const; /// return the inner text slice. CursorSlice const & innerTextSlice() const; + /// returns a DocIterator for the containing text inset + DocIterator getInnerText() const; + /// the first and last positions of a word at top cursor slice + /// \warning only works within text! + FontSpan locateWord(word_location const loc) const; /// Text * text() const; /// the containing inset or the cell, respectively @@ -167,9 +186,14 @@ public: // /** * move on one logical position, descend into nested insets - * skip collapsed insets if \p ignorecollapsed is true + * including collapsed insets */ - void forwardPos(bool ignorecollapsed = false); + void forwardPos(); + /** + * move on one logical position, descend into nested insets + * skip collapsed insets + */ + void forwardPosIgnoreCollapsed(); /// move on one physical character or inset void forwardChar(); /// move on one paragraph @@ -183,7 +207,7 @@ public: /// move backward one paragraph void backwardPar(); /// move backward one inset - /// FIXME: This is not implemented! + /// not used currently, uncomment if you need it //void backwardInset(); /// are we some 'extension' (i.e. deeper nested) of the given iterator @@ -192,6 +216,7 @@ public: /// output friend std::ostream & operator<<(std::ostream & os, DocIterator const & cur); + friend LyXErr & operator<<(LyXErr & os, DocIterator const & it); /// friend bool operator==(DocIterator const &, DocIterator const &); friend bool operator<(DocIterator const &, DocIterator const &); @@ -211,63 +236,108 @@ public: /// fix DocIterator in circumstances that should never happen. /// \return true if the DocIterator was fixed. bool fixIfBroken(); + /// Repopulate the slices insets from bottom to top. Useful + /// for stable iterators or Undo data. + void sanitize(); /// find index of CursorSlice with &cell() == &cell (or -1 if not found) - idx_type find(MathData const & cell) const; + int find(MathData const & cell) const; /// find index of CursorSlice with inset() == inset (or -1 of not found) - idx_type find(InsetMath const * inset) const; - /// cut off CursorSlices with index > above and store cut off slices in cut - void cutOff(idx_type above, std::vector & cut); + int find(Inset const * inset) const; + /// cut off CursorSlices with index > above and store cut off slices in cut. + void cutOff(int above, std::vector & cut); /// cut off CursorSlices with index > above - void cutOff(idx_type above); + void cutOff(int above); /// push CursorSlices on top void append(std::vector const & x); /// push one CursorSlice on top and set its index and position void append(idx_type idx, pos_type pos); private: + friend class InsetIterator; + friend DocIterator doc_iterator_begin(Buffer const * buf, Inset const * inset); + friend DocIterator doc_iterator_end(Buffer const * buf, Inset const * inset); + /// + explicit DocIterator(Buffer * buf, Inset * inset); /** - * When the cursor position is i, is the cursor after the i-th char - * or before the i+1-th char ? Normally, these two interpretations are - * equivalent, except when the fonts of the i-th and i+1-th char - * differ. - * We use boundary_ to distinguish between the two options: - * If boundary_=true, then the cursor is after the i-th char - * and if boundary_=false, then the cursor is before the i+1-th char. + * Normally, when the cursor is at position i, it is painted *before* + * the character at position i. However, what if we want the cursor + * painted *after* position i? That's what boundary_ is for: if + * boundary_==true, the cursor is painted *after* position i-1, instead + * of before position i. + * + * Note 1: Usually, after i-1 or before i are actually the same place! + * However, this is not the case when i-1 and i are not painted + * contiguously, and in these cases we sometimes do want to have control + * over whether to paint before i or after i-1. + * Some concrete examples of where this happens: + * a. i-1 at the end of one row, i at the beginning of next row + * b. in bidi text, at transitions between RTL and LTR or vice versa * - * We currently use the boundary only when the language direction of - * the i-th char is different than the one of the i+1-th char. - * In this case it is important to distinguish between the two - * cursor interpretations, in order to give a reasonable behavior to - * the user. + * Note 2: Why i and i-1? Why, if boundary_==false means: *before* i, + * couldn't boundary_==true mean: *after* i? + * Well, the reason is this: cursor position is not used only for + * painting the cursor, but it also affects other things, for example: + * where the next insertion will be placed (it is inserted at the current + * position, pushing anything at the current position and beyond forward). + * Now, when the current position is i and boundary_==true, insertion would + * happen *before* i. If the cursor, however, were painted *after* i, that + * would be very unnatural... */ bool boundary_; /// - std::vector const & internalData() const { - return slices_; - } + std::vector const & internalData() const { return slices_; } /// std::vector slices_; /// Inset * inset_; + /// + Buffer * buffer_; }; -DocIterator doc_iterator_begin(Inset & inset); -DocIterator doc_iterator_end(Inset & inset); +inline bool operator==(DocIterator const & di1, DocIterator const & di2) +{ + return di1.slices_ == di2.slices_; +} -inline -bool operator==(DocIterator const & di1, DocIterator const & di2) +inline bool operator!=(DocIterator const & di1, DocIterator const & di2) { - return di1.slices_ == di2.slices_; + return !(di1 == di2); } inline -bool operator!=(DocIterator const & di1, DocIterator const & di2) +bool operator<(DocIterator const & p, DocIterator const & q) { - return !(di1 == di2); + 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]; + } + return p.depth() < q.depth(); +} + + +inline +bool operator>(DocIterator const & p, DocIterator const & q) +{ + return q < p; +} + + +inline +bool operator<=(DocIterator const & p, DocIterator const & q) +{ + return !(q < p); +} + + +inline +bool operator>=(DocIterator const & p, DocIterator const & q) +{ + return !(p < q); } @@ -275,14 +345,15 @@ bool operator!=(DocIterator const & di1, DocIterator const & di2) // (overwritten by 0...) part of the CursorSlice data items. So this thing // is suitable for external storage, but not for iteration as such. -class StableDocIterator { +class StableDocIterator +{ public: /// StableDocIterator() {} /// non-explicit intended StableDocIterator(const DocIterator & it); /// - DocIterator asDocIterator(Inset * start) const; + DocIterator asDocIterator(Buffer * buf) const; /// size_t size() const { return data_.size(); } /// return the position within the paragraph @@ -302,7 +373,6 @@ private: std::vector data_; }; - } // namespace lyx -#endif +#endif // DOCITERATOR_H