X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fcursor_slice.h;h=3ba4dfb0587ba56d276f79488690535f2f864bc0;hb=9ee46b846e5e84ad40ceda4f4af94aeb86cd90a2;hp=48a850b98f48345763d5ec001e866fc74540f27f;hpb=55ee6cb34695c044d986988328e8f0fb1f03d407;p=lyx.git diff --git a/src/cursor_slice.h b/src/cursor_slice.h index 48a850b98f..3ba4dfb058 100644 --- a/src/cursor_slice.h +++ b/src/cursor_slice.h @@ -17,22 +17,23 @@ #ifndef CURSORSLICE_H #define CURSORSLICE_H -#include -#include - +#include "insets/insetbase.h" #include "support/types.h" +#include +#include + +class BufferView; class InsetBase; -class UpdatableInset; class MathInset; -class LyXText; class MathArray; - +class LyXText; +class Paragraph; /// This encapsulates a single slice of a document iterator as used e.g. /// for cursors. -// After IU, the distinction of MathInset and UpdatableInset as well as +// After IU, the distinction of MathInset and InsetOld as well as // that of MathArray and LyXText should vanish. They are conceptually the // same (now...) @@ -41,81 +42,105 @@ public: /// type for cell number in inset typedef size_t idx_type; /// type for paragraph numbers positions within a cell - typedef lyx::paroffset_type par_type; + typedef lyx::pit_type pit_type; /// type for cursor positions within a cell typedef lyx::pos_type pos_type; + /// type for row indices + typedef size_t row_type; + /// type for col indices + typedef size_t col_type; /// CursorSlice(); /// - explicit CursorSlice(InsetBase *); - - /// set the paragraph that contains this cursor - void idx(idx_type idx); - /// return the paragraph this cursor is in - idx_type idx() const; - /// set the paragraph that contains this cursor - void par(par_type par); - /// return the paragraph this cursor is in - par_type par() const; - /// set the position within the paragraph - void pos(pos_type pos); + explicit CursorSlice(InsetBase &); + + /// the current inset + InsetBase & inset() const { return *inset_; } + /// return the cell this cursor is in + idx_type idx() const { return idx_; } + /// return the cell this cursor is in + idx_type & idx() { return idx_; } + /// return the last cell in this inset + idx_type lastidx() const { return nargs() - 1; } + /// return the offset of the paragraph this cursor is in + pit_type pit() const { return pit_; } + /// set the offset of the paragraph this cursor is in + pit_type & pit() { return pit_; } + /// increments the paragraph this cursor is in + void incrementPar(); + /// decrements the paragraph this cursor is in + void decrementPar(); /// return the position within the paragraph - pos_type pos() const; + pos_type pos() const { return pos_; } + /// return the position within the paragraph + pos_type & pos() { return pos_; } + /// return the last position within the paragraph + pos_type lastpos() const; + /// return the number of embedded cells + size_t nargs() const { return inset_->nargs(); } + /// return the number of columns (1 in non-grid-like insets) + size_t ncols() const { return inset_->ncols(); } + /// return the number of rows (1 in non-grid-like insets) + size_t nrows() const { return inset_->nrows(); } + /*! + * \return the grid row of the current cell. + * This does only make sense in grid like insets. + */ + row_type row() const; + /*! + * \return the grid column of the current cell. + * This does only make sense in grid like insets. + */ + col_type col() const; - /// FIXME - void boundary(bool b); - /// FIXME - bool boundary() const; /// /// texted specific stuff /// - /// - LyXText * text() const; - /// - UpdatableInset * asUpdatableInset() const; + /// returns text corresponding to this position + LyXText * text() { return inset_->getText(idx_); } + /// returns text corresponding to this position + LyXText const * text() const { return inset_->getText(idx_); } + /// paragraph in this cell + Paragraph & paragraph(); + /// paragraph in this cell + Paragraph const & paragraph() const; /// /// mathed specific stuff /// + /// returns the owning inset if it is a MathInset, else 0 + MathInset * asMathInset() const { return inset_->asMathInset(); } /// returns cell corresponding to this position MathArray & cell() const; - /// returns cell corresponding to this position - MathArray & cell(idx_type idx) const; - /// gets screen position of the thing - void getPos(int & x, int & y) const; - /// set position - void setPos(int pos); - /// - MathInset * asMathInset() const; - /// + /// write some debug information to \p os friend std::ostream & operator<<(std::ostream &, CursorSlice const &); public: - /// pointer to an inset + /// pointer to 'owning' inset. This is some kind of cache. InsetBase * inset_; - /// cell index of a position in this inset +private: + /*! + * Cell index of a position in this inset. + * This is the primary cell information also for grid like insets, + * although we have the convenience functions row() and col() for + * those * and column changes every time the number of columns ornumber + * of rows changes. Normally the cursor should stay in the same cell, + * so these changes should typically be performed like the following: + * \code + * row_type const r = cur.row(); + * col_type const c = cur.col(); + * // change nrows() and/or ncols() + * cur.idx = index(r, c); + * \endcode + */ idx_type idx_; /// paragraph in this cell (used by texted) - par_type par_; + pit_type pit_; + /// true if 'pit' was properly initialized + bool pit_valid_; /// position in this cell 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_; }; /// test for equality @@ -126,18 +151,7 @@ bool operator!=(CursorSlice const &, CursorSlice const &); bool operator<(CursorSlice const &, CursorSlice const &); /// test for order bool operator>(CursorSlice const &, CursorSlice const &); - -#include - - -// this is used for traversing math insets -typedef std::vector CursorBase; -/// move on one step -void increment(CursorBase &); -/// -CursorBase ibegin(InsetBase * p); -/// -CursorBase iend(InsetBase * p); - +/// test for order +bool operator<=(CursorSlice const &, CursorSlice const &); #endif