X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fcursor.h;h=1ec6255b0b8ee38b220ec36607e04eead5e542d3;hb=9ee46b846e5e84ad40ceda4f4af94aeb86cd90a2;hp=d6537ffd5214b09da720ca6a638fb5d01ce10fd2;hpb=ccc5d5576437a7615f54bf1ed6e83e05bfbaaf78;p=lyx.git diff --git a/src/cursor.h b/src/cursor.h index d6537ffd52..1ec6255b0b 100644 --- a/src/cursor.h +++ b/src/cursor.h @@ -12,65 +12,51 @@ #ifndef CURSOR_H #define CURSOR_H -#include "cursor_slice.h" +#include "dispatchresult.h" +#include "dociterator.h" #include #include +class Buffer; class BufferView; -class UpdatableInset; -class MathAtom; -class DispatchResult; +class FuncStatus; class FuncRequest; -class InsetTabular; -class LyXText; -class Paragraph; +class Point; +class LyXFont; +// these should go +class MathUnknownInset; +class Encoding; -// 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); +/// The cursor class describes the position of a cursor within a document. - -/** - * The cursor class describes the position of a cursor within a document. - */ - -class LCursor { +// The public inheritance should go in favour of a suitable data member +// (or maybe private inheritance) at some point of time. +class LCursor : public DocIterator { public: - /// type for cell number in inset - typedef CursorSlice::idx_type idx_type; - /// type for paragraph numbers positions within a cell - typedef CursorSlice::par_type par_type; - /// type for cursor positions within a cell - typedef CursorSlice::pos_type pos_type; - /// type for row indices - typedef CursorSlice::row_type row_type; - /// type for col indices - typedef CursorSlice::col_type col_type; - /// create the cursor of a BufferView explicit LCursor(BufferView & bv); + /// dispatch from innermost inset upwards - DispatchResult dispatch(FuncRequest const & cmd); - /// - void push(InsetBase * inset); - /// restrict cursor nesting to given size - void pop(int depth); + void dispatch(FuncRequest const & cmd); + /// get the resut of the last dispatch + DispatchResult result() const; + /// add a new cursor slice + void push(InsetBase & inset); + /// add a new cursor slice, place cursor on left end + void pushLeft(InsetBase & inset); /// pop one level off the cursor void pop(); - /// access to current cursor slice - CursorSlice & current(); - /// access to current cursor slice - CursorSlice const & current() const; - /// how many nested insets do we have? - size_t depth() const { return cursor_.size(); } + /// pop one slice off the cursor stack and go left + bool popLeft(); + /// pop one slice off the cursor stack and go right + bool popRight(); + /// make sure we are outside of given inset + void leaveInset(InsetBase const & inset); + /// sets cursor part + void setCursor(DocIterator const & it); // // selection @@ -85,62 +71,27 @@ public: bool & mark() { return mark_; } /// void setSelection(); + /// set selection at given position + void setSelection(DocIterator const & where, size_t 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 start of selection + DocIterator selectionEnd() const; /// - CursorSlice & selStart(); - /// - CursorSlice const & selStart() const; + void selHandle(bool selecting); + // + std::string selectionAsString(bool label) const; /// - CursorSlice & selEnd(); + void paste(std::string const & data); /// - CursorSlice const & selEnd() const; - - // - // access to the 'current' cursor slice - // - /// the current inset - InsetBase * inset() const { return current().inset(); } - /// return the text-ed cell this cursor is in - idx_type idx() const { return current().idx(); } - /// return the text-ed cell this cursor is in - idx_type & idx() { return current().idx(); } - /// return the paragraph this cursor is in - par_type par() const { return current().par(); } - /// return the paragraph this cursor is in - par_type & par() { return current().par(); } - /// return the position within the paragraph - pos_type pos() const { return current().pos(); } - /// return the position within the paragraph - pos_type & pos() { return current().pos(); } - /// return the last position within the paragraph - pos_type lastpos() const; - /// return the number of embedded cells - size_t nargs() const; - /// return the number of embedded cells - size_t ncols() const; - /// return the number of embedded cells - size_t nrows() const; - /// return the grid row of the current cell - row_type row() const; - /// return the grid row of the current cell - col_type col() const; + std::string currentState(); - // - // math-specific part - // - /// return the mathed cell this cursor is in - MathArray const & cell() const; - /// return the mathed cell this cursor is in - MathArray & cell(); - /// the mathatom left of the cursor - MathAtom const & prevAtom() const; - /// the mathatom left of the cursor - MathAtom & prevAtom(); - /// the mathatom right of the cursor - MathAtom const & nextAtom() const; - /// the mathatom right of the cursor - MathAtom & nextAtom(); /// auto-correct mode bool autocorrect() const { return autocorrect_; } /// auto-correct mode @@ -149,25 +100,8 @@ public: bool macromode() const { return macromode_; } /// are we entering a macro name? bool & macromode() { return macromode_; } - - // - // text-specific part - /// - bool boundary() const { return current().boundary(); } - /// - Paragraph & paragraph(); - /// - Paragraph const & paragraph() const; - /// - InsetBase * innerInsetOfType(int code) const; - /// - InsetTabular * innerInsetTabular() const; - /// - LyXText * innerText() const; /// returns x,y position void getPos(int & x, int & y) const; - /// returns cursor dimension - void getDim(int & asc, int & desc) const; // // common part @@ -177,45 +111,84 @@ public: /// move one step to the right bool posRight(); - /// set target x position of cursor - void x_target(int x); + /// insert an inset + void insert(InsetBase *); + /// insert a single char + void insert(char c); + /// insert a string + void insert(std::string const & str); + + /// in pixels from left of screen + int targetX() const; + /// write acess to target x position of cursor + int & x_target(); /// return target x position of cursor int x_target() const; + /// set targetX in current position + void setTargetX(); + /// clear target x position of cursor + void clearTargetX(); - /// access to selection anchor - CursorSlice & anchor(); - /// access to selection anchor - CursorSlice const & anchor() const; - /// cache the absolute coordinate from the top inset - void updatePos(); + /// access to normalized selection anchor + CursorSlice anchor() const; /// sets anchor to cursor position - void resetAnchor(); + void resetAnchor(); /// access to owning BufferView - BufferView & bv() const; - /// get some interesting description of current position - void info(std::ostream & os); + BufferView & bv() const; + /// access to owning Buffer + Buffer & buffer() const; + /// get some interesting description of top position + void info(std::ostream & 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 + // (sort of 'chroot' environment...) + void reset(InsetBase &); + /// for spellchecking + void replaceWord(std::string const & replacestring); + /** + * the event was not (yet) dispatched. + * + * Should only be called by an inset's doDispatch() method. It means: + * I, the doDispatch() method of InsetFoo, hereby declare that I am + * not able to handle that request and trust my parent will do the + * 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(); + /// the event was already dispatched + void dispatched(); + /// call update() when done + void needsUpdate(); + /** + * don't call update() when done + * + * Should only be called by an inset's doDispatch() method. It means: + * I handled that request and I can reassure you that the screen does + * 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. + */ + void noUpdate(); + /// fix cursor in circumstances that should never happen + void fixIfBroken(); /// output friend std::ostream & operator<<(std::ostream & os, LCursor const & cur); + public: + /// + BufferView * bv_; //private: - /// mainly used as stack, but wee need random access - std::vector cursor_; /// the anchor position - std::vector anchor_; - -private: - /// don't implement this - void operator=(LCursor const &); - /// don't implement this - LCursor(LCursor const &); + DocIterator anchor_; /// - BufferView * const bv_; - /// current slice - int current_; - /// - int cached_y_; + DispatchResult disp_; + + +private: /** * The target x position of the cursor. This is used for when * we have text like : @@ -229,10 +202,17 @@ private: * shorter than x() */ int x_target_; - // do we have a selection? + /// do we have a selection? bool selection_; - // are we on the way to get one? + /// are we on the way to get one? bool mark_; + /// 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_; + +private: // // math specific stuff that could be promoted to "global" later @@ -241,6 +221,90 @@ private: bool autocorrect_; /// are we entering a macro name? bool macromode_; + + +/////////////////////////////////////////////////////////////////// +// +// The part below is the non-integrated rest of the original math +// cursor. This should be either generalized for texted or moved +// back to the math insets. +// +/////////////////////////////////////////////////////////////////// + +public: + /// + void insert(MathAtom const &); + /// + void insert(MathArray const &); + /// return false for empty math insets + bool erase(); + /// return false for empty math insets + bool backspace(); + /// called for LFUN_UP etc + bool up(); + /// called for LFUN_DOWN etc + bool down(); + /// + void plainErase(); + /// + void plainInsert(MathAtom const & at); + /// + void niceInsert(MathAtom const & at); + /// + void niceInsert(std::string const & str); + + /// 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. + bool macroModeClose(); + /// are we currently typing the name of a macro? + bool inMacroMode() const; + /// get access to the macro we are currently typing + MathUnknownInset * activeMacro(); + + /// replace selected stuff with at, placing the former + // selection in given cell of atom + void handleNest(MathAtom const & at, int cell = 0); + /// + bool isInside(InsetBase const *); + + /// make sure cursor position is valid + 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(std::string const & msg) const; + /// display an error message + void errorMessage(std::string const & msg) const; + /// + std::string getPossibleLabel(); + + /// moves position somehow up or down + bool goUpDown(bool up); + + /// the name of the macro we are currently inputting + std::string 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 + LyXFont getFont() const; }; + #endif // LYXCURSOR_H