X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fdociterator.h;h=7d4c4439681589200460d00067e4be9548204599;hb=35204f8f33d7400a5fefeffea533fb4cb4097211;hp=22e49c8b455ecf6d9c2bbf8eaf82dd473c0a89e3;hpb=ec4ab8ce18418999b547368d1d2bbf546bec1e7b;p=lyx.git diff --git a/src/dociterator.h b/src/dociterator.h index 22e49c8b45..7d4c443968 100644 --- a/src/dociterator.h +++ b/src/dociterator.h @@ -17,14 +17,15 @@ #include #include -class BufferView; -class MathAtom; + +namespace lyx { + class LyXText; +class MathAtom; class Paragraph; class Row; - // only needed for gcc 2.95, remove when support terminated template bool ptr_cmp(A const * a, B const * b) @@ -35,15 +36,11 @@ bool ptr_cmp(A const * a, B const * b) // The public inheritance should go in favour of a suitable data member // (or maybe private inheritance) at some point of time. -class DocumentIterator : public std::vector +class DocIterator // : public std::vector { public: /// type for cell number in inset typedef CursorSlice::idx_type idx_type; - /// type for paragraph numbers positions within a cell - typedef CursorSlice::par_type par_type; - /// type for cursor positions within a cell - typedef CursorSlice::pos_type pos_type; /// type for row indices typedef CursorSlice::row_type row_type; /// type for col indices @@ -51,45 +48,58 @@ public: public: /// - DocumentIterator(); - /// - explicit DocumentIterator(BufferView & bv); + DocIterator(); /// - BufferView & bv() const { return *bv_; } + explicit DocIterator(InsetBase & inset); + + /// access slice at position \p i + CursorSlice const & operator[](size_t i) const { return slices_[i]; } + /// access slice at position \p i + CursorSlice & operator[](size_t i) { return slices_[i]; } + /// chop a few slices from the iterator + void resize(size_t i) { slices_.resize(i); } + + /// is the iterator valid? + operator const void*() const { return empty() ? 0 : this; } + /// is this iterator invalid? + bool operator!() const { return empty(); } + + /// does this iterator have any content? + bool empty() const { return slices_.empty(); } // // access to slice at tip // /// access to tip - CursorSlice & top() { return back(); } + CursorSlice & top() { return slices_.back(); } /// access to tip - CursorSlice const & top() const { return back(); } + CursorSlice const & top() const { return slices_.back(); } + /// access to outermost slice + CursorSlice & bottom() { return slices_.front(); } + /// access to outermost slice + CursorSlice const & bottom() const { return slices_.front(); } /// how many nested insets do we have? - size_t depth() const { return size(); } + size_t depth() const { return slices_.size(); } /// the containing inset - InsetBase * inset() const { return back().inset(); } + InsetBase & inset() const { return top().inset(); } /// return the cell of the inset this cursor is in - idx_type idx() const { return back().idx(); } + idx_type idx() const { return top().idx(); } /// return the cell of the inset this cursor is in - idx_type & idx() { return back().idx(); } + idx_type & idx() { return top().idx(); } /// return the last possible cell in this inset idx_type lastidx() const; /// return the paragraph this cursor is in - par_type par() const { return back().par(); } + pit_type pit() const { return top().pit(); } /// return the paragraph this cursor is in - par_type & par() { return back().par(); } + pit_type & pit() { return top().pit(); } /// return the last possible paragraph in this inset - par_type lastpar() const; + pit_type lastpit() const; /// return the position within the paragraph - pos_type pos() const { return back().pos(); } + pos_type pos() const { return top().pos(); } /// return the position within the paragraph - pos_type & pos() { return back().pos(); } + pos_type & pos() { return top().pos(); } /// return the last position within the paragraph pos_type lastpos() const; - /// return the display row of the cursor with in the top par - row_type crow() const; - /// return the display row of the cursor with in the top par - row_type lastcrow() const; /// return the number of embedded cells size_t nargs() const; @@ -111,6 +121,10 @@ public: InsetBase * prevInset(); /// the inset just in front of the cursor InsetBase const * prevInset() const; + /// + bool boundary() const { return boundary_; } + /// + void boundary(bool b) { boundary_ = b; } /// are we in mathed? bool inMathed() const; @@ -136,10 +150,6 @@ public: // // text-specific part // - /// see comment for boundary_ below - bool boundary() const { return top().boundary(); } - /// see comment for boundary_ below - bool & boundary() { return top().boundary(); } /// the paragraph we're in Paragraph & paragraph(); /// the paragraph we're in @@ -149,69 +159,145 @@ public: /// the row in the paragraph we're in Row const & textRow() const; /// - LyXText * text() const; + LyXText * text(); /// - CursorSlice const & innerTextSlice() const; + LyXText const * text() const; + /// the containing inset or the cell, respectively + InsetBase * realInset() const; /// InsetBase * innerInsetOfType(int code) const; /// - LyXText * innerText() const; + LyXText * innerText(); + /// + LyXText const * innerText() const; // // elementary moving // - /// move on one position - void forwardPos(); + /// 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 + */ + void forwardPos(bool ignorecollapsed = false); + /// 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 + void backwardPos(); + /// move backward one physical character or inset + void backwardChar(); + /// move backward one paragraph + void backwardPar(); + /// move backward one cell + void backwardIdx(); + /// move backward one inset + void backwardInset(); + + /// are we some 'extension' (i.e. deeper nested) of the given iterator + bool hasPart(DocIterator const & it) const; + /// output friend std::ostream & - operator<<(std::ostream & os, DocumentIterator const & cur); + operator<<(std::ostream & os, DocIterator const & cur); + /// + friend bool operator==(DocIterator const &, DocIterator const &); + /// + friend class StableDocIterator; +//protected: + /// + void clear() { slices_.clear(); } + /// + void push_back(CursorSlice const & sl) { slices_.push_back(sl); } + /// + void pop_back() { slices_.pop_back(); } + /// recompute the inset parts of the cursor from the document data + void updateInsets(InsetBase * inset); private: + /** + * 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. + * + * 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. + */ + bool boundary_; + /// + std::vector const & internalData() const { + return slices_; + } /// - BufferView * bv_; + std::vector slices_; + /// + InsetBase * inset_; }; -/// -DocumentIterator bufferBegin(BufferView & bv); -/// -DocumentIterator bufferEnd(); -/// -DocumentIterator insetBegin(BufferView & bv, InsetBase * inset); -/// -DocumentIterator insetEnd(); +DocIterator doc_iterator_begin(InsetBase & inset); +DocIterator doc_iterator_end(InsetBase & inset); + +inline +bool operator==(DocIterator const & di1, DocIterator const & di2) +{ + return di1.slices_ == di2.slices_; +} -// The difference to a ('non stable') DocumentIterator is the removed + +inline +bool operator!=(DocIterator const & di1, DocIterator const & di2) +{ + return !(di1 == di2); +} + + +// The difference to a ('non stable') DocIterator is the removed // (overwritte by 0...) part of the CursorSlice data items. So this thing // is suitable for external storage, but not for iteration as such. -class StableDocumentIterator { +class StableDocIterator { public: /// - StableDocumentIterator() {} + StableDocIterator() {} /// non-explicit intended - StableDocumentIterator(const DocumentIterator & it); + StableDocIterator(const DocIterator & it); /// - DocumentIterator asDocumentIterator(BufferView & bv) const; + DocIterator asDocIterator(InsetBase * start) const; /// size_t size() const { return data_.size(); } + /// return the position within the paragraph + pos_type pos() const { return data_.back().pos(); } + /// return the position within the paragraph + pos_type & pos() { return data_.back().pos(); } /// friend std::ostream & - operator<<(std::ostream & os, StableDocumentIterator const & cur); + operator<<(std::ostream & os, StableDocIterator const & cur); /// friend std::istream & - operator>>(std::istream & is, StableDocumentIterator & cur); + operator>>(std::istream & is, StableDocIterator & cur); + /// + friend bool + operator==(StableDocIterator const &, StableDocIterator const &); private: std::vector data_; }; -bool operator==(StableDocumentIterator const &, StableDocumentIterator const &); + +} // namespace lyx #endif