X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FDocIterator.h;h=8b23312b2e451020e503246475f783c8213e0da9;hb=2455bc258f3b62c29ec4a41cb88070ff8518e842;hp=e36092af748f1697f4b823d9b217c05022fc517d;hpb=57d2f9c0ad96baca7675e1c22e4f1349f849cca7;p=lyx.git

diff --git a/src/DocIterator.h b/src/DocIterator.h
index e36092af74..8b23312b2e 100644
--- 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
@@ -211,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_;
 	///