Fix layout bug. Pasting text into a cell tried to set Standard layout, because

[lyx.git] / src / DocIterator.h

diff --git a/src/DocIterator.h b/src/DocIterator.h
index 6e730ea685018f6b85116c6adbdffdb07469b39e..8b23312b2e451020e503246475f783c8213e0da9 100644 (file)
--- a/src/DocIterator.h
+++ b/src/DocIterator.h
@@ -23,6 +23,7 @@ class LyXErr;
 class MathAtom;
 class Paragraph;
 class Text;
+class InsetIterator;
 
 
 // The public inheritance should go in favour of a suitable data member
@@ -40,8 +41,6 @@ public:
 public:
        ///
        DocIterator();
-       ///
-       explicit DocIterator(Inset & inset);
 
        /// access slice at position \p i
        CursorSlice const & operator[](size_t i) const { return slices_[i]; }
@@ -57,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
@@ -159,9 +160,14 @@ public:
        //
        /**
         * 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
@@ -206,33 +212,48 @@ public:
        bool fixIfBroken();
 
        /// 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<CursorSlice> & 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<CursorSlice> & cut);
        /// cut off CursorSlices with index > above
-       void cutOff(idx_type above);
+       void cutOff(int above);
        /// push CursorSlices on top
        void append(std::vector<CursorSlice> 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_;
        ///