Continue to improve GtkLengthEntry

[lyx.git] / src / dociterator.h

diff --git a/src/dociterator.h b/src/dociterator.h
index 9fc912ec0792ef0b8d36c93709758cd0371314db..f8f4b490f52cb6c2bc82dc74c534bf9770402141 100644 (file)
--- a/src/dociterator.h
+++ b/src/dociterator.h
@@ -54,15 +54,11 @@ public:
        ///
        explicit DocIterator(InsetBase & inset);
 
-       CursorSlice const & operator[](size_t i) const {
-               return slices_[i];
-       }
-
-       CursorSlice & operator[](size_t i) {
-               return slices_[i];
-       }
-
-       // What is the point of this function?
+       /// 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?
@@ -70,6 +66,7 @@ public:
        /// is this iterator invalid?
        bool operator!() const { return empty(); }
 
+       /// does this iterator have any content?
        bool empty() const { return slices_.empty(); }
 
        //
@@ -81,7 +78,7 @@ public:
        CursorSlice const & top() const { return slices_.back(); }
        /// access to outermost slice
        CursorSlice & bottom() { return slices_.front(); }
-       /// access to  outermost slicetip
+       /// access to outermost slice
        CursorSlice const & bottom() const { return slices_.front(); }
        /// how many nested insets do we have?
        size_t depth() const { return slices_.size(); }
@@ -126,6 +123,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;
@@ -151,10 +152,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
@@ -167,6 +164,8 @@ public:
        LyXText * text();
        ///
        LyXText const * text() const;
+       /// the containing inset or the cell, respectively
+       InsetBase * realInset() const;
        ///
        InsetBase * innerInsetOfType(int code) const;
        ///
@@ -179,8 +178,11 @@ public:
        //
        /// move on one logical position, do not descend into nested insets
        void forwardPosNoDescend();
-       /// move on one logical position, descend into nested insets
-       void forwardPos();
+       /**
+        * 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
@@ -206,21 +208,44 @@ public:
        /// output
        friend std::ostream &
        operator<<(std::ostream & os, DocIterator const & cur);
+       ///
        friend bool operator==(DocIterator const &, DocIterator const &);
+       ///
        friend class StableDocIterator;
-protected:
+//protected:
+       ///
        void clear() { slices_.clear(); }
-       void push_back(CursorSlice const & sl) {
-               slices_.push_back(sl);
-       }
-       void pop_back() {
-               slices_.pop_back();
-       }
+       ///
+       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<CursorSlice> const & internalData() const {
                return slices_;
        }
+       ///
        std::vector<CursorSlice> slices_;
+       ///
        InsetBase * inset_;
 };
 
@@ -257,16 +282,23 @@ public:
        DocIterator asDocIterator(InsetBase * start) const;
        ///
        size_t size() const { return data_.size(); }
+       /// type for cursor positions within a cell
+       typedef CursorSlice::pos_type pos_type;
+       ///  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, StableDocIterator const & cur);
        ///
        friend std::istream &
        operator>>(std::istream & is, StableDocIterator & cur);
+       ///
+       friend bool
+       operator==(StableDocIterator const &, StableDocIterator const &);
 private:
        std::vector<CursorSlice> data_;
 };
 
-bool operator==(StableDocIterator const &, StableDocIterator const &);
-
 #endif