split LyXText::rowlist_ into individual Paragraph::rows_ chunks

[lyx.git] / src / lyxcursor.h

diff --git a/src/lyxcursor.h b/src/lyxcursor.h
index a6ffefc9adbbe45f281fa2c4c2cb5a38abf0e616..8cbea6ce3d223b5c0e61dc5e41316bb0b7eb687d 100644 (file)
--- a/src/lyxcursor.h
+++ b/src/lyxcursor.h
@@ -1,93 +1,119 @@
 // -*- C++ -*-
-/* This file is part of
- * ====================================================== 
- * 
- *           LyX, The Document Processor
- *      
- *           Copyright 1995 Matthias Ettrich
- *           Copyright 1995-2000 The LyX Team.
+/**
+ * \file lyxcursor.h
+ * Copyright 1995-2001 the LyX Team
+ * Read the file COPYING
  *
- * ====================================================== */
+ * \author Matthias Ettrich
+ */
 
 #ifndef LYXCURSOR_H
 #define LYXCURSOR_H
 
-#ifdef __GNUG__
-#pragma interface
-#endif
-
-#include "lyxparagraph.h"
-
-struct Row;
+#include "ParagraphList.h"
+#include "support/types.h"
 
-/** All these variables should be explained. Matthias?
+/**
+ * The cursor class describes the position of a cursor within a document.
+ * Several cursors exist within LyX; for example, when locking an inset,
+ * the position of the cursor in the containing inset is stored.
+ *
+ * FIXME: true ?
  */
 class LyXCursor {
 public:
        LyXCursor();
-       ///
-       void par(LyXParagraph * p);
-       ///
-       LyXParagraph * par();
-       ///
-       LyXParagraph * par() const;
-       ///
-       void pos(LyXParagraph::size_type p);
-       ///
-       LyXParagraph::size_type pos() const;
-       ///
+       /// set the paragraph that contains this cursor
+       void par(ParagraphList::iterator pit);
+       /// return the paragraph this cursor is in
+       ParagraphList::iterator par() const;
+       /// set the position within the paragraph
+       void pos(lyx::pos_type p);
+       /// return the position within the paragraph
+       lyx::pos_type pos() const;
+       /// FIXME
        void boundary(bool b);
-       ///
+       /// FIXME
        bool boundary() const;
-       ///
+       /// set the x position in pixels
        void x(int i);
-       ///
+       /// return the x position in pixels
        int x() const;
-       ///
+       /// set the stored next-line position when at the end of a row
+       void ix(int i);
+       /**
+        * Return the x position of the start of the next row, when this
+        * cursor is at the end of the previous row, for insets that take
+        * a full row.
+        *
+        * FIXME: explain why we need this ?
+        */
+       int ix() const;
+       /// set the cached x position
        void x_fix(int i);
-       ///
+       /**
+        * Return the cached x position of the cursor. This is used for when
+        * we have text like :
+        *
+        * blah blah blah blah| blah blah blah
+        * blah blah blah
+        * blah blah blah blah blah blah
+        *
+        * When we move onto row 3, we would like to be vertically aligned
+        * with where we were in row 1, despite the fact that row 2 is
+        * shorter than x()
+        */
        int x_fix() const;
-       ///
+       /// set the y position in pixels
        void y(int i);
-       ///
+       /// return the y position in pixels
        int y() const;
-       ///
-       void row(Row * r);
-       ///
-       Row * row();
-       ///
-       Row * row() const;
+       /// set the stored next-line y position when at the end of a row
+       void iy(int i);
+       /**
+        * Return the y position of the start of the next row, when this
+        * cursor is at the end of the previous row, for insets that take
+        * a full row.
+        *
+        * FIXME: explain why we need this ? especially for y...
+        */
+       int iy() const;
 private:
        /// The paragraph the cursor is in.
-       LyXParagraph * par_;
+       ParagraphList::iterator par_;
        /// The position inside the paragraph
-       LyXParagraph::size_type pos_;
-       ///
+       lyx::pos_type pos_;
+       /**
+        * When the cursor position is i, is the cursor is 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_;
-       ///
+       /// the pixel x position
        int x_;
-       ///
+       /// the stored next-row x position
+       int ix_;
+       /// the cached x position
        int x_fix_;
-       ///
+       /// the pixel y position
        int y_;
-       ///
-       Row * row_;
+       /// the stored next-row y position
+       int iy_;
 };
 
+/// 
+bool operator==(LyXCursor const & a, LyXCursor const & b);
 ///
-inline
-bool operator==(LyXCursor const & a, LyXCursor const & b)
-{
-       return (a.par() == b.par())
-               && (a.pos() == b.pos())
-               && a.boundary() == b.boundary();
-}
-
-///
-inline
-bool operator!=(LyXCursor const & a, LyXCursor const & b)
-{
-       return !(a == b);
-}
+bool operator!=(LyXCursor const & a, LyXCursor const & b);
 
-#endif
+#endif // LYXCURSOR_H