// these should go
class InsetMathUnknown;
-class Encoding;
/**
* This class describes the position of a cursor within a document,
friend std::ostream & operator<<(std::ostream & os, CursorData const & cur);
friend LyXErr & operator<<(LyXErr & os, CursorData const & cur);
+ /// reset cursor bottom to the beginning of the top inset
+ // (sort of 'chroot' environment...)
+ void reset();
+ /// 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
+ //
+ /// selection active?
+ bool selection() const { return selection_; }
+ /// 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
+ { return selection_ && selBegin().idx() != selEnd().idx(); }
+ /// do we have a multiline selection?
+ bool selIsMultiLine() const
+ { return selection_ && selBegin().pit() != selEnd().pit(); }
+ ///
+ void setWordSelection(bool set) { word_selection_ = set; }
+ ///
+ bool wordSelection() { return word_selection_; }
+ /// did we place the anchor?
+ bool mark() const { return mark_; }
+ /// did we place the anchor?
+ void setMark(bool mark) { mark_ = mark; }
+ ///
+ void setSelection();
+ /// set selection at given position
+ void setSelection(DocIterator const & where, int n);
+ ///
+ void clearSelection();
+
+ /// access to normalized selection anchor
+ CursorSlice normalAnchor() const;
+ /// access to real selection anchor
+ DocIterator const & realAnchor() const { return anchor_; }
+ DocIterator & realAnchor() { return anchor_; }
+ /// sets anchor to cursor position
+ void resetAnchor();
+ /// access to owning BufferView
+
+ /// access start of selection
+ CursorSlice selBegin() const;
+ /// access end of selection
+ CursorSlice selEnd() const;
+ /// access start of selection
+ DocIterator selectionBegin() const;
+ /// access end of selection
+ DocIterator selectionEnd() const;
+
+ ///
+ docstring selectionAsString(bool with_label) const;
+ /// get some interesting description of top position
+ void info(odocstream & os, bool devel_mode) const;
+ ///
+ docstring currentState(bool devel_mode) const;
+
+ /// auto-correct mode
+ bool autocorrect() const { return autocorrect_; }
+ /// auto-correct mode
+ bool & autocorrect() { return autocorrect_; }
+
+ /// fix cursor in circumstances that should never happen.
+ /// \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();
+ ///
+ bool isInside(Inset const *) const;
+ /// make sure we are outside of given inset
+ void leaveInset(Inset const & inset);
+
+ ///
+ bool textUndo();
+ ///
+ bool textRedo();
+
+ /// makes sure the next operation will be stored
+ void finishUndo() const;
+ /// open a new group of undo operations. Groups can be nested.
+ void beginUndoGroup() const;
+ /// end the current undo group
+ void endUndoGroup() const;
+
+ /// The general case: prepare undo for an arbitrary range.
+ void recordUndo(pit_type from, pit_type to) const;
+ /// Convenience: prepare undo for the range between 'from' and cursor.
+ 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(Inset const * inset = 0) const;
+ /// Convenience: prepare undo for the whole buffer
+ void recordUndoFullBuffer() const;
+ /// Convenience: prepare undo for buffer parameters
+ void recordUndoBufferParams() const;
+ /// Convenience: prepare undo for the selected paragraphs or cells
+ void recordUndoSelection() const;
+
+ /// hook for text input to maintain the "new born word"
+ void markNewWordPosition();
+ /// The position of the new born word
+ /// As the user is entering a word without leaving it
+ /// the result is not empty. When not in text mode
+ /// and after leaving the word the result is empty.
+ DocIterator newWord() const { return new_word_; }
+
+ /// are we in math mode (2), text mode (1) or unsure (0)?
+ int currentMode();
+
+ /// 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;
+
protected:
+ /// validate the "new born word" position
+ void checkNewWordPosition();
+ /// clear the "new born word" position
+ void clearNewWordPosition();
+
/// the anchor position
DocIterator anchor_;
/// do we have a selection?
protected:
+ /// the start of the new born word
+ DocIterator new_word_;
//
// math specific stuff that could be promoted to "global" later
//
/// do we allow autocorrection
bool autocorrect_;
- /// are we entering a macro name?
- bool macromode_;
};
/// create the cursor of a BufferView
explicit Cursor(BufferView & bv);
- /// returns true if we made a decision
- bool getStatus(FuncRequest const & cmd, FuncStatus & flag) const;
- /// dispatch from innermost inset upwards
- void dispatch(FuncRequest const & cmd);
- /// get the resut of the last dispatch
- DispatchResult const & result() const;
/// add a new cursor slice
void push(Inset & inset);
/// add a new cursor slice, place cursor at front (move backwards)
bool popBackward();
/// pop one slice off the cursor stack and go forward
bool popForward();
- /// make sure we are outside of given inset
- void leaveInset(Inset const & inset);
/// 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();
+
+ /// returns true if we made a decision
+ bool getStatus(FuncRequest const & cmd, FuncStatus & flag) const;
+ /// dispatch from innermost inset upwards
+ void dispatch(FuncRequest const & cmd);
+ /// display a message
+ void message(docstring const & msg) const;
+ /// display an error message
+ void errorMessage(docstring const & msg) const;
+ /// get the resut of the last dispatch
+ DispatchResult const & result() const;
///
void setCurrentFont();
- //
- // selection
- //
- /// selection active?
- bool selection() const { return selection_; }
- /// 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
- { return selection_ && selBegin().idx() != selEnd().idx(); }
- /// do we have a multiline selection?
- bool selIsMultiLine() const
- { return selection_ && selBegin().pit() != selEnd().pit(); }
- ///
- void setWordSelection(bool set) { word_selection_ = set; }
- ///
- bool wordSelection() { return word_selection_; }
- /// did we place the anchor?
- bool mark() const { return mark_; }
- /// did we place the anchor?
- void setMark(bool mark) { mark_ = mark; }
- ///
- void setSelection();
- /// set selection at given position
- void setSelection(DocIterator const & where, int n);
- ///
- void clearSelection();
- /// access start of selection
- CursorSlice selBegin() const;
- /// access end of selection
- CursorSlice selEnd() const;
- /// access start of selection
- DocIterator selectionBegin() const;
- /// access end of selection
- DocIterator selectionEnd() const;
/**
* Update the selection status and save permanent
* selection if needed.
* @return whether the selection status has changed
*/
bool selHandle(bool selecting);
- ///
- docstring selectionAsString(bool with_label) const;
- ///
- docstring currentState(bool devel_mode) const;
-
- /// auto-correct mode
- bool autocorrect() const { return autocorrect_; }
- /// auto-correct mode
- bool & autocorrect() { return autocorrect_; }
- /// are we entering a macro name?
- 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;
/// Should interpretation of the arrow keys be reversed?
bool reverseDirectionNeeded() const;
- /// insert an inset
- void insert(Inset *);
+ ///
+ /// Insertion (mathed and texted)
+ ///
/// insert a single char
void insert(char_type c);
/// insert a string
void insert(docstring const & str);
+ /// insert an inset
+ void insert(Inset *);
+ ///
+ /// Insertion (mathed only)
+ ///
+ /// insert a math atom
+ void insert(MathAtom const &);
+ /// insert a string of atoms
+ void insert(MathData const &);
+ /// Like insert, but moves the selection inside the inset if possible
+ void niceInsert(MathAtom const & at);
+ /// return the number of inserted array items
+ /// FIXME: document properly
+ int niceInsert(docstring const & str, Parse::flags f = Parse::NORMAL,
+ bool enter = true);
/// FIXME: rename to something sensible showing difference to x_target()
/// in pixels from left of screen, set to current position if unset
/// distance between actual and targeted position during last up/down in text
int textTargetOffset() const;
- /// access to normalized selection anchor
- CursorSlice normalAnchor() const;
- /// access to real selection anchor
- 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, 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
// (sort of 'chroot' environment...)
void reset();
- /// for spellchecking
- void replaceWord(std::string const & replacestring);
+
/**
* the event was not (yet) dispatched.
*
* Not using noScreenUpdate() should never be wrong.
*/
void noScreenUpdate() const;
- /// fix cursor in circumstances that should never happen.
- /// \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();
- ///
- bool textUndo();
- ///
- bool textRedo();
-
- /// makes sure the next operation will be stored
- void finishUndo() const;
-
- /// open a new group of undo operations. Groups can be nested.
- void beginUndoGroup() const;
-
- /// end the current undo group
- void endUndoGroup() const;
-
- /// The general case: prepare undo for an arbitrary range.
- void recordUndo(pit_type from, pit_type to) const;
-
- /// Convenience: prepare undo for the range between 'from' and cursor.
- 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(Inset const * inset = 0) const;
-
- /// Convenience: prepare undo for the whole buffer
- void recordUndoFullBuffer() const;
-
- /// Convenience: prepare undo for buffer parameters
- void recordUndoBufferParams() const;
-
- /// Convenience: prepare undo for the selected paragraphs or cells
- void recordUndoSelection() const;
-
///
void checkBufferStructure();
- /// hook for text input to maintain the "new born word"
- void markNewWordPosition();
-
- /// The position of the new born word
- /// As the user is entering a word without leaving it
- /// the result is not empty. When not in text mode
- /// 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);
+ /// whether the cursor is either at the first or last row
+ bool atFirstOrLastRow(bool up);
+
public:
//private:
///
void saveBeforeDispatchPosXY();
-private:
- /// validate the "new born word" position
- void checkNewWordPosition();
- /// clear the "new born word" position
- void clearNewWordPosition();
-
private:
///
BufferView * bv_;
int x_target_;
/// if a x_target cannot be hit exactly in a text, put the difference here
int textTargetOffset_;
- /// the start of the new born word
- DocIterator new_word_;
/// position before dispatch started
DocIterator beforeDispatchCursor_;
/// cursor screen coordinates before dispatch started
///////////////////////////////////////////////////////////////////
public:
- ///
- void insert(MathAtom const &);
- ///
- void insert(MathData const &);
/// return false for empty math insets
/// Use force to skip the confirmDeletion check.
bool erase(bool force = false);
/// move the cursor up by sending an internal LFUN_DOWN,
/// return true if fullscreen update is needed
bool down();
- /// whether the cursor is either at the first or last row
- bool atFirstOrLastRow(bool up);
/// move up/down in a text inset, called for LFUN_UP/DOWN,
/// return true if successful, updateNeeded set to true if fullscreen
/// update is needed, otherwise it's not touched
/// move up/down in math or any non text inset, call for LFUN_UP/DOWN
/// 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);
void plainErase();
///
void plainInsert(MathAtom const & at);
- ///
- void niceInsert(MathAtom const & at);
- /// return the number of inserted array items
- int niceInsert(docstring const & str, Parse::flags f = Parse::NORMAL,
- bool enter = true);
- /// in pixels from top of screen
- 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.
+ /// interpret name of a macro. Returns true if something got
+ /// inserted.
bool macroModeClose();
/// are we currently typing the name of a macro?
bool inMacroMode() const;
InsetMathUnknown * activeMacro();
/// get access to the macro we are currently typing
InsetMathUnknown const * activeMacro() const;
+ /// the name of the macro we are currently inputting
+ docstring macroName();
+
/// replace selected stuff with at, placing the former
// selection in given cell of atom
void handleNest(MathAtom const & at, int cell = 0);
- ///
- bool isInside(Inset const *) const;
/// make sure cursor position is valid
/// FIXME: It does a subset of fixIfBroken. Maybe merge them?
void normalize();
- /// mark current cursor trace for redraw
- void touch();
- /// hack for reveal codes
- void markInsert();
- void markErase();
/// injects content of a cell into parent
void pullArg();
/// split font inset etc
void handleFont(std::string const & font);
- /// display a message
- void message(docstring const & msg) const;
- /// display an error message
- void errorMessage(docstring const & msg) const;
- ///
- docstring getPossibleLabel() const;
-
- /// the name of the macro we are currently inputting
- docstring macroName();
- /// where in the curent cell does the macro name start?
- int macroNamePos();
/// can we enter the inset?
bool openable(MathAtom const &) const;
- ///
- Encoding const * getEncoding() const;
/// font at cursor position
Font getFont() const;
};
projects / lyx.git / blobdiff