class InsetMathUnknown;
class Encoding;
+/**
+ * This class describes the position of a cursor within a document,
+ * but does not contain any detail about the view. It is currently
+ * only used to save cursor position in Undo, but culd be extended to
+ * handle the methods that only need this data.
+ **/
+class CursorData : public DocIterator
+{
+public:
+ ///
+ CursorData();
+ ///
+ explicit CursorData(Buffer * buffer);
+ ///
+ explicit CursorData(DocIterator const & dit);
+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:
+ /// the current font settings
+ Font current_font;
+ /// the current font
+ Font real_current_font;
+
+protected:
+
+ //
+ // math specific stuff that could be promoted to "global" later
+ //
+ /// do we allow autocorrection
+ bool autocorrect_;
+ /// are we entering a macro name?
+ bool macromode_;
+};
+
/// The cursor class describes the position of a cursor within a document.
-class Cursor : public DocIterator
+class Cursor : public CursorData
{
public:
/// create the cursor of a BufferView
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
void setCursor(DocIterator const & it);
/// sets the cursor to the normalized selection anchor
*/
bool selHandle(bool selecting);
///
- docstring selectionAsString(bool label) const;
+ docstring selectionAsString(bool with_label) const;
///
docstring currentState() const;
* 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 screenUpdateFlags(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
*
* This is a fairly rare event as well and only some optimization.
* Not using noScreenUpdate() should never be wrong.
*/
- void noScreenUpdate();
+ 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();
+ /// 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);
void recordUndo(UndoKind kind = ATOMIC_UNDO) const;
/// Convenience: prepare undo for the inset containing the cursor
- void recordUndoInset(UndoKind kind = ATOMIC_UNDO) const;
+ void recordUndoInset(UndoKind kind = ATOMIC_UNDO,
+ Inset const * inset = 0) const;
/// Convenience: prepare undo for the whole buffer
void recordUndoFullDocument() 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_; }
+
public:
//private:
///
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_;
///
mutable DispatchResult disp_;
/**
int x_target_;
/// if a x_target cannot be hit exactly in a text, put the difference here
int textTargetOffset_;
- /// 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_;
+ /// the start of the new born word
+ DocIterator new_word_;
/// position before dispatch started
DocIterator beforeDispatchCursor_;
/// cursor screen coordinates before dispatch started
int beforeDispatchPosX_;
int beforeDispatchPosY_;
-
-// FIXME: make them private.
-public:
- /// the current font settings
- Font current_font;
- /// the current font
- Font real_current_font;
-
-private:
-
- //
- // math specific stuff that could be promoted to "global" later
- //
- /// do we allow autocorrection
- bool autocorrect_;
- /// are we entering a macro name?
- bool macromode_;
-
-
///////////////////////////////////////////////////////////////////
//
// The part below is the non-integrated rest of the original math
void plainInsert(MathAtom const & at);
///
void niceInsert(MathAtom const & at);
- ///
- void niceInsert(docstring const & str, Parse::flags f = Parse::NORMAL,
+ /// 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