X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FDocIterator.h;h=8b23312b2e451020e503246475f783c8213e0da9;hb=2455bc258f3b62c29ec4a41cb88070ff8518e842;hp=fd4050cec8c40e23bb70b1621d3ff279392070b8;hpb=76dec26fec47df5b828973554b85dc91f3b564d1;p=lyx.git diff --git a/src/DocIterator.h b/src/DocIterator.h index fd4050cec8..8b23312b2e 100644 --- a/src/DocIterator.h +++ b/src/DocIterator.h @@ -15,22 +15,15 @@ #include "CursorSlice.h" #include -#include namespace lyx { -class LyXText; +class LyXErr; class MathAtom; class Paragraph; - - -// only needed for gcc 2.95, remove when support terminated -template -bool ptr_cmp(A const * a, B const * b) -{ - return a == b; -} +class Text; +class InsetIterator; // The public inheritance should go in favour of a suitable data member @@ -48,8 +41,6 @@ public: public: /// DocIterator(); - /// - explicit DocIterator(InsetBase & inset); /// access slice at position \p i CursorSlice const & operator[](size_t i) const { return slices_[i]; } @@ -65,6 +56,8 @@ public: /// does this iterator have any content? bool empty() const { return slices_.empty(); } + /// is this the end position? + bool atEnd() const { return slices_.empty(); } // // access to slice at tip @@ -80,7 +73,7 @@ public: /// how many nested insets do we have? size_t depth() const { return slices_.size(); } /// the containing inset - InsetBase & inset() const { return top().inset(); } + Inset & inset() const { return top().inset(); } /// return the cell of the inset this cursor is in idx_type idx() const { return top().idx(); } /// return the cell of the inset this cursor is in @@ -115,11 +108,9 @@ public: /// return the last column of the top grid col_type lastcol() const { return ncols() - 1; } /// the inset just behind the cursor - InsetBase * nextInset(); + Inset * nextInset() const; /// the inset just in front of the cursor - InsetBase * prevInset(); - /// the inset just in front of the cursor - InsetBase const * prevInset() const; + Inset * prevInset() const; /// bool boundary() const { return boundary_; } /// @@ -138,54 +129,49 @@ public: // math-specific part // /// return the mathed cell this cursor is in - MathData const & cell() const; - /// return the mathed cell this cursor is in - MathData & cell(); + MathData & cell() const; /// the mathatom left of the cursor - MathAtom const & prevAtom() const; - /// the mathatom left of the cursor - MathAtom & prevAtom(); - /// the mathatom right of the cursor - MathAtom const & nextAtom() const; + MathAtom & prevAtom() const; /// the mathatom right of the cursor - MathAtom & nextAtom(); + MathAtom & nextAtom() const; - // // text-specific part // - /// the paragraph we're in - Paragraph & paragraph(); - /// the paragraph we're in - Paragraph const & paragraph() const; - /// - LyXText * text(); + /// the paragraph we're in in text mode. + /// \warning only works within text! + Paragraph & paragraph() const; + /// the paragraph we're in in any case. + /// This method will give the containing paragraph even + /// if not in text mode (ex: in mathed). + Paragraph & innerParagraph() const; + /// return the inner text slice. + CursorSlice const & innerTextSlice() const; /// - LyXText const * text() const; + Text * text() const; /// the containing inset or the cell, respectively - InsetBase * realInset() const; + Inset * realInset() const; /// - InsetBase * innerInsetOfType(int code) const; + Inset * innerInsetOfType(int code) const; /// - LyXText * innerText(); - /// - LyXText const * innerText() const; + Text * innerText() const; // // elementary moving // - /// move on one logical position, do not descend into nested insets - void forwardPosNoDescend(); /** * move on one logical position, descend into nested insets - * skip collapsed insets if \p ignorecollapsed is true + * including collapsed insets + */ + void forwardPos(); + /** + * move on one logical position, descend into nested insets + * skip collapsed insets */ - void forwardPos(bool ignorecollapsed = false); + void forwardPosIgnoreCollapsed(); /// move on one physical character or inset void forwardChar(); /// move on one paragraph void forwardPar(); - /// move on one cell - void forwardIdx(); /// move on one inset void forwardInset(); /// move backward one logical position @@ -194,8 +180,6 @@ public: void backwardChar(); /// move backward one paragraph void backwardPar(); - /// move backward one cell - void backwardIdx(); /// move backward one inset /// FIXME: This is not implemented! //void backwardInset(); @@ -206,8 +190,12 @@ 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 &); + friend bool operator>(DocIterator const &, DocIterator const &); + friend bool operator<=(DocIterator const &, DocIterator const &); /// friend class StableDocIterator; //protected: @@ -218,23 +206,54 @@ public: /// void pop_back() { slices_.pop_back(); } /// recompute the inset parts of the cursor from the document data - void updateInsets(InsetBase * inset); + void updateInsets(Inset * inset); + /// fix DocIterator in circumstances that should never happen. + /// \return true if the DocIterator was fixed. + bool fixIfBroken(); + + /// find index of CursorSlice with &cell() == &cell (or -1 if not found) + int find(MathData const & cell) const; + /// find index of CursorSlice with inset() == inset (or -1 of not found) + 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(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(Inset & inset); + friend DocIterator doc_iterator_end(Inset & inset); + /// + explicit DocIterator(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_; /// @@ -244,28 +263,52 @@ private: /// std::vector slices_; /// - InsetBase * inset_; + Inset * inset_; }; -DocIterator doc_iterator_begin(InsetBase & inset); -DocIterator doc_iterator_end(InsetBase & inset); +DocIterator doc_iterator_begin(Inset & inset); +DocIterator doc_iterator_end(Inset & inset); -inline -bool operator==(DocIterator const & di1, DocIterator const & di2) +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 == di2); } +inline +bool operator<(DocIterator const & p, DocIterator const & q) +{ + 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); +} + + // The difference to a ('non stable') DocIterator is the removed // (overwritten by 0...) part of the CursorSlice data items. So this thing // is suitable for external storage, but not for iteration as such. @@ -277,7 +320,7 @@ public: /// non-explicit intended StableDocIterator(const DocIterator & it); /// - DocIterator asDocIterator(InsetBase * start) const; + DocIterator asDocIterator(Inset * start) const; /// size_t size() const { return data_.size(); } /// return the position within the paragraph