* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
- * \author André Pönitz
+ * \author André Pönitz
*
* Full author contact details are available in file CREDITS.
*/
#include "Font.h"
#include "Undo.h"
+#include "mathed/MathParser_flags.h"
+
#include <vector>
/// The cursor class describes the position of a cursor within a document.
-
-// The public inheritance should go in favour of a suitable data member
-// (or maybe private inheritance) at some point of time.
-class Cursor : public DocIterator {
+class Cursor : public DocIterator
+{
public:
/// 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 result() const;
+ DispatchResult const & result() const;
/// add a new cursor slice
void push(Inset & inset);
/// add a new cursor slice, place cursor at front (move backwards)
void leaveInset(Inset const & inset);
/// sets cursor part
void setCursor(DocIterator const & it);
+ /// sets the cursor to the normalized selection anchor
+ void setCursorToAnchor();
///
void setCurrentFont();
//
/// selection active?
bool selection() const { return selection_; }
- /// selection active?
- bool & selection() { return selection_; }
+ /// set selection;
+ void setSelection(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?
- bool & mark() { return mark_; }
+ void setMark(bool mark) { mark_ = mark; }
///
void setSelection();
/// set selection at given position
DocIterator selectionBegin() const;
/// access start of selection
DocIterator selectionEnd() const;
- /// FIXME: document this
+ /**
+ * Update the selection status and save permanent
+ * selection if needed.
+ * @param selecting the new selection status
+ * @return whether the selection status has changed
+ */
bool selHandle(bool selecting);
///
- docstring selectionAsString(bool label) const;
+ docstring selectionAsString(bool with_label) const;
///
- docstring currentState();
+ docstring currentState() const;
/// auto-correct mode
bool autocorrect() const { return autocorrect_; }
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
+ * edge" will be returned as -1.
+ */
+ void getSurroundingPos(pos_type & left_pos, pos_type & right_pos);
/// the row in the paragraph we're in
Row const & textRow() const;
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.
+ * @note: This method may move into a new paragraph.
+ * @note: This method may move out of the current slice.
+ * @return: true if moved, false if not moved
+ */
+ bool posVisRight(bool skip_inset = false);
+ /// move visually one step to the left
+ /**
+ * @note: This method may move into an inset unless skip_inset == true.
+ * @note: This method may move into a new paragraph.
+ * @note: This method may move out of the current slice.
+ * @return: true if moved, false if not moved
+ */
+ bool posVisLeft(bool skip_inset = false);
+ /// 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
+ * 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.
+ * @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)
+ * @return: true if moved
+ */
+ bool posVisToNewRow(bool movingLeft);
+ /// move to right or left extremity of the current row
+ void posVisToRowExtremity(bool left);
/// insert an inset
void insert(Inset *);
int textTargetOffset() const;
/// access to normalized selection anchor
- CursorSlice anchor() const;
+ 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();
/// sets anchor to cursor position
void resetAnchor();
/// access to owning BufferView
BufferView & bv() const;
- /// access to owning Buffer
- Buffer & buffer() const;
/// get some interesting description of top position
void info(odocstream & os) const;
/// are we in math mode (2), text mode (1) or unsure (0)?
int currentMode();
- /// reset cursor bottom to the beginning of the given inset
+ /// reset cursor bottom to the beginning of the top inset
// (sort of 'chroot' environment...)
- void reset(Inset &);
+ void reset();
/// for spellchecking
void replaceWord(std::string const & replacestring);
/**
* Right Thing (even if my getStatus partner said that I can do it).
* It is sort of a kludge that should be used only rarely...
*/
- void undispatched();
+ void undispatched() const;
/// the event was already dispatched
- void dispatched();
- /// Set which update should be done
- void updateFlags(Update::flags f);
+ void dispatched() const;
+ /// Set which screen update should be done
+ void screenUpdateFlags(Update::flags f) const;
+ /// Forces an updateBuffer() call
+ void forceBufferUpdate() const;
+ /// Removes any pending updateBuffer() call
+ void clearBufferUpdate() const;
+ /// Do we need to call updateBuffer()?
+ bool needBufferUpdate() const;
/**
* don't call update() when done
*
* not need to be re-drawn and all entries in the coord cache stay
* valid (and there are no other things to put in the coord cache).
* This is a fairly rare event as well and only some optimization.
- * Not using noUpdate() should never be wrong.
+ * Not using noScreenUpdate() should never be wrong.
*/
- void noUpdate();
+ void noScreenUpdate() const;
+ ///
+ Update::flags screenUpdate() const { return disp_.screenUpdate(); }
/// fix cursor in circumstances that should never happen.
/// \retval true if a fix occured.
bool fixIfBroken();
bool textRedo();
/// makes sure the next operation will be stored
- void finishUndo();
+ 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(UndoKind kind, pit_type from, pit_type to);
+ void recordUndo(UndoKind kind, pit_type from, pit_type to) const;
/// Convenience: prepare undo for the range between 'from' and cursor.
- void recordUndo(UndoKind kind, pit_type from);
+ void recordUndo(UndoKind kind, pit_type from) const;
/// Convenience: prepare undo for the single paragraph or cell
/// containing the cursor
- void recordUndo(UndoKind kind = ATOMIC_UNDO);
+ void recordUndo(UndoKind kind = ATOMIC_UNDO) const;
/// Convenience: prepare undo for the inset containing the cursor
- void recordUndoInset(UndoKind kind = ATOMIC_UNDO);
+ void recordUndoInset(UndoKind kind = ATOMIC_UNDO,
+ Inset const * inset = 0) const;
/// Convenience: prepare undo for the whole buffer
- void recordUndoFullDocument();
+ void recordUndoFullDocument() const;
- /// Convenience: prepare undo for the selected paragraphs
- void recordUndoSelection();
+ /// Convenience: prepare undo for the selected paragraphs or cells
+ void recordUndoSelection() const;
-public:
///
- BufferView * bv_;
+ 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_; }
+
+public:
//private:
- /// the anchor position
- DocIterator anchor_;
///
- DispatchResult disp_;
+ DocIterator const & beforeDispatchCursor() const { return beforeDispatchCursor_; }
///
- DocIterator const & beforeDispatchCursor() { return beforeDispatchCursor_; }
-
+ void saveBeforeDispatchPosXY();
+
+private:
+ /// validate the "new born word" position
+ void checkNewWordPosition();
+ /// clear the "new born word" position
+ void clearNewWordPosition();
+
private:
+ ///
+ BufferView * bv_;
+ /// the anchor position
+ DocIterator anchor_;
+ /// the start of the new born word
+ DocIterator new_word_;
+ ///
+ mutable DispatchResult disp_;
/**
* The target x position of the cursor. This is used for when
* we have text like :
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
bool logicalpos_;
/// position before dispatch started
DocIterator beforeDispatchCursor_;
+ /// cursor screen coordinates before dispatch started
+ int beforeDispatchPosX_;
+ int beforeDispatchPosY_;
+
// FIXME: make them private.
public:
/// 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
void plainInsert(MathAtom const & at);
///
void niceInsert(MathAtom const & at);
- ///
- void niceInsert(docstring const & str);
+ /// 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);
bool inMacroMode() const;
/// get access to the macro we are currently typing
InsetMathUnknown * activeMacro();
+ /// get access to the macro we are currently typing
+ InsetMathUnknown const * activeMacro() const;
/// replace selected stuff with at, placing the former
// selection in given cell of atom
/// display an error message
void errorMessage(docstring const & msg) const;
///
- docstring getPossibleLabel();
+ docstring getPossibleLabel() const;
/// the name of the macro we are currently inputting
docstring macroName();
/**
- * Notifies all insets which appear in old, but not in cur. Make
- * Sure that the cursor old is valid, i.e. als inset pointer
+ * 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.
*/
-bool notifyCursorLeaves(DocIterator const & old, Cursor & cur);
+bool notifyCursorLeavesOrEnters(Cursor const & old, Cursor & cur);
} // namespace lyx
projects / lyx.git / blobdiff