*/
/*
-First some explanation about what a Cursor really is. I try to go from
-more local to general.
+First some explanation about what a Cursor really is, from local to
+global.
* a CursorSlice indicates the position of the cursor at local level.
-It contains in particular:
+ It contains in particular:
* idx(): the cell that contains the cursor (for Tabular or math
arrays). Always 0 for 'plain' insets
- * pit(): the index of the current paragraph (only for Texted)
+ * pit(): the index of the current paragraph (only for text)
* pos(): the position in the current paragraph (or in the math
- equation in Mathed).
- * inset(): the inset in which the cursor is.
+ equation in mathed).
+ * inset(): the inset in which the cursor is. For a InsetTabular,
+ this is the tabular itself, not the cell inset (which is an
+ InsetTableCell).
* a DocIterator indicated the position of the cursor in the document.
It knows about the current buffer (buffer() method) and contains a
* innerTextSlice() returns the deepest slice that is text (useful
when one is in a math equation and looks for the enclosing text)
-* A CursorData is a descendent of Dociterator that contains
+* A CursorData is a descendant of Dociterator that contains
* a second DocIterator object, the anchor, that is useful when
selecting.
- * some other data not interesting here
-This class is used only for undo and contains the Cursor element that
-are not GUI-related. In LyX 2.0, Cursor was directly deriving from
-DocIterator
+ * some other data that describes current selection, cursor font, etc.
+
+ This class is mostly used only for undo and contains the Cursor
+ elements that are not GUI-related. In LyX 2.0, Cursor was directly
+ deriving from DocIterator
* A Cursor is a descendant of CursorData that contains interesting
display-related information, in particular targetX(), the horizontal
position of the cursor in pixels.
- * one interesting method for what you want to do is textRow(), that
- returns the inner Row object that contains the cursor
*/
#ifndef LCURSOR_H
// these should go
class InsetMathUnknown;
-class Encoding;
/**
* This class describes the position of a cursor within a document,
explicit CursorData(Buffer * buffer);
///
explicit CursorData(DocIterator const & dit);
+ /// output
+ friend std::ostream & operator<<(std::ostream & os, CursorData const & cur);
+ friend LyXErr & operator<<(LyXErr & os, CursorData const & cur);
+
protected:
/// the anchor position
DocIterator anchor_;
- ///
- mutable DispatchResult disp_;
/// do we have a selection?
bool selection_;
/// are we on the way to get one?
bool mark_;
/// are we in word-selection mode? This is set when double clicking.
bool word_selection_;
- /// If true, we are behind the previous char, otherwise we are in front
- // of the next char. This only make a difference when we are in front
- // of a big inset spanning a whole row and computing coordinates for
- // displaying the cursor.
- bool logicalpos_;
// FIXME: make them protected.
public:
/// set the cursor data
void setCursorData(CursorData const & data);
/// sets cursor part
+ /// this (intentionally) does neither touch anchor nor selection status
void setCursor(DocIterator const & it);
+ /// set the cursor to dit normalised against the anchor, and set selection.
+ void setCursorSelectionTo(DocIterator dit);
/// sets the cursor to the normalized selection anchor
void setCursorToAnchor();
//
/// selection active?
bool selection() const { return selection_; }
- /// set selection;
- void setSelection(bool sel) { selection_ = sel; }
+ /// set selection; this is lower level than (set|clear)Selection
+ void selection(bool sel) { selection_ = sel; }
/// do we have a multicell selection?
- bool selIsMultiCell() const
+ bool selIsMultiCell() const
{ return selection_ && selBegin().idx() != selEnd().idx(); }
/// do we have a multiline selection?
- bool selIsMultiLine() const
+ bool selIsMultiLine() const
{ return selection_ && selBegin().pit() != selEnd().pit(); }
- ///
+ ///
void setWordSelection(bool set) { word_selection_ = set; }
///
bool wordSelection() { return word_selection_; }
void setSelection(DocIterator const & where, int n);
///
void clearSelection();
+ /// check whether selection contains specific type of inset
+ /// returns 0 if no selection was made
+ bool insetInSelection(InsetCode const & inset);
+ /// count occurences of specific inset type in the selection
+ /// returns 0 if no selection was made
+ int countInsetsInSelection(InsetCode const & inset);
/// access start of selection
CursorSlice selBegin() const;
/// access end of selection
///
docstring selectionAsString(bool with_label) const;
///
- docstring currentState() const;
+ docstring currentState(bool devel_mode) const;
/// auto-correct mode
bool autocorrect() const { return autocorrect_; }
bool macromode() const { return macromode_; }
/// are we entering a macro name?
bool & macromode() { return macromode_; }
+
/// returns x,y position
void getPos(int & x, int & y) const;
/// return logical positions between which the cursor is situated
/**
- * If the cursor is at the edge of a row, the position which is "over the
+ * If the cursor is at the edge of a row, the position which is "over the
* edge" will be returned as -1.
*/
- void getSurroundingPos(pos_type & left_pos, pos_type & right_pos);
+ void getSurroundingPos(pos_type & left_pos, pos_type & right_pos) const;
/// the row in the paragraph we're in
Row const & textRow() const;
//
// common part
//
- /// move one step backwards
- bool posBackward();
- /// move one step forward
- bool posForward();
/// move visually one step to the right
/**
* @note: This method may move into an inset unless skip_inset == true.
/// move visually to next/previous row
/**
* Assuming we were to keep moving left (right) from the current cursor
- * position, place the cursor at the rightmost (leftmost) edge of the
+ * position, place the cursor at the rightmost (leftmost) edge of the
* new row to which we would move according to visual-mode cursor movement.
* This could be either the next or the previous row, depending on the
- * direction in which we're moving, and whether we're in an LTR or RTL
- * paragraph.
+ * direction in which we're moving, and whether we're in an LTR or RTL
+ * paragraph.
* @note: The new position may even be in a new paragraph.
* @note: This method will not move out of the current slice.
* @return: false if not moved (no more rows to move to in given direction)
bool posVisToNewRow(bool movingLeft);
/// move to right or left extremity of the current row
void posVisToRowExtremity(bool left);
+ /// Should interpretation of the arrow keys be reversed?
+ bool reverseDirectionNeeded() const;
/// insert an inset
void insert(Inset *);
/// access to normalized selection anchor
CursorSlice normalAnchor() const;
- // FIXME: this can't be a const & and a const function because
- // LFUN_TAB_* wants to move the real anchor.
/// access to real selection anchor
- DocIterator & realAnchor();
+ DocIterator const & realAnchor() const { return anchor_; }
+ DocIterator & realAnchor() { return anchor_; }
/// sets anchor to cursor position
void resetAnchor();
/// access to owning BufferView
BufferView & bv() const;
/// get some interesting description of top position
- void info(odocstream & os) const;
+ void info(odocstream & os, bool devel_mode) const;
/// are we in math mode (2), text mode (1) or unsure (0)?
int currentMode();
/// reset cursor bottom to the beginning of the top inset
*/
void noScreenUpdate() const;
/// fix cursor in circumstances that should never happen.
- /// \retval true if a fix occured.
+ /// \retval true if a fix occurred.
bool fixIfBroken();
/// Repopulate the slices insets from bottom to top. Useful
/// for stable iterators or Undo data.
void sanitize();
- /// output
- friend std::ostream & operator<<(std::ostream & os, Cursor const & cur);
- friend LyXErr & operator<<(LyXErr & os, Cursor const & cur);
-
///
bool textUndo();
///
void endUndoGroup() const;
/// The general case: prepare undo for an arbitrary range.
- void recordUndo(UndoKind kind, pit_type from, pit_type to) const;
+ void recordUndo(pit_type from, pit_type to) const;
/// Convenience: prepare undo for the range between 'from' and cursor.
- void recordUndo(UndoKind kind, pit_type from) const;
+ void recordUndo(pit_type from) const;
/// Convenience: prepare undo for the single paragraph or cell
/// containing the cursor
void recordUndo(UndoKind kind = ATOMIC_UNDO) const;
/// Convenience: prepare undo for the inset containing the cursor
- void recordUndoInset(UndoKind kind = ATOMIC_UNDO,
- Inset const * inset = 0) const;
+ void recordUndoInset(Inset const * inset = 0) const;
/// Convenience: prepare undo for the whole buffer
void recordUndoFullBuffer() const;
/// and after leaving the word the result is empty.
DocIterator newWord() const { return new_word_; }
+ /// Return true if the next or previous inset has confirmDeletion depending
+ /// on the boolean before. If there is a selection, return true if at least
+ /// one inset in the selection has confirmDeletion.
+ bool confirmDeletion(bool before = false) const;
+
+ /// Determine if x falls to the left or to the side of the middle of the
+ /// inset, and advance the cursor to match this position. If edit is true,
+ /// keep the cursor in front of the inset if it matter for dialogs.
+ /// Note: it does not handle RTL text yet, and is only used in math for now.
+ void moveToClosestEdge(int x, bool edit = false);
+
public:
//private:
-
+
///
DocIterator const & beforeDispatchCursor() const { return beforeDispatchCursor_; }
///
///
void insert(MathData const &);
/// return false for empty math insets
- bool erase();
- /// return false for empty math insets
- bool backspace();
+ /// Use force to skip the confirmDeletion check.
+ bool erase(bool force = false);
+ bool backspace(bool force = false);
+
/// move the cursor up by sending an internal LFUN_UP
/// return true if fullscreen update is needed
bool up();
/// return true if successful
bool upDownInMath(bool up);
///
+ InsetMath & nextMath();
+ ///
+ InsetMath & prevMath();
+ /// move forward in math. word: whether to skip a whole "word" (insets with
+ /// the same mathclass)
+ bool mathForward(bool word);
+ ///
+ bool mathBackward(bool word);
+ ///
void plainErase();
///
void plainInsert(MathAtom const & at);
void setScreenPos(int x, int y);
/// current offset in the top cell
- /// interpret name a name of a macro. Returns true if
- /// something got inserted.
- bool macroModeClose();
+ /// interpret name of a macro or ditch it if \c cancel is true.
+ /// Returns true if something got inserted.
+ bool macroModeClose(bool cancel = false);
/// are we currently typing the name of a macro?
bool inMacroMode() const;
/// get access to the macro we are currently typing
int macroNamePos();
/// can we enter the inset?
bool openable(MathAtom const &) const;
- ///
- Encoding const * getEncoding() const;
/// font at cursor position
Font getFont() const;
};
/**
- * Notifies all insets which appear in old, but not in cur. And then
- * notify all insets which appear in cur, but not in old.
- * Make sure that the cursor old is valid, i.e. all inset pointers
- * point to valid insets! Use Cursor::fixIfBroken if necessary.
+ * Notifies all insets which appear in \c old, but not in \c cur. And then
+ * notify all insets which appear in \c cur, but not in \c old.
+ * \returns true if cursor is now invalid, e.g. if some insets in
+ * higher cursor slices of \c old do not exist anymore. In this case
+ * it may be necessary to use Use Cursor::fixIfBroken.
*/
bool notifyCursorLeavesOrEnters(Cursor const & old, Cursor & cur);
projects / lyx.git / blobdiff