X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fcursor.h;h=1ec6255b0b8ee38b220ec36607e04eead5e542d3;hb=9ee46b846e5e84ad40ceda4f4af94aeb86cd90a2;hp=35f858f09c5ae67592240b594c87d648cd18bfc3;hpb=335e83b1a8919c441872da0d2fccce24146cb715;p=lyx.git diff --git a/src/cursor.h b/src/cursor.h index 35f858f09c..1ec6255b0b 100644 --- a/src/cursor.h +++ b/src/cursor.h @@ -12,114 +12,96 @@ #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 LyXText; -class InsetTabular; +class Point; +class LyXFont; +// these should go +class MathUnknownInset; +class Encoding; -/** - * The cursor class describes the position of a cursor within a document. - */ -class LCursor { +/// 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 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 'empty' cursor. REMOVE ME - LCursor(); /// 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 cursor 'tip' - CursorSlice & top() { return cursor_.back(); } - /// access to cursor 'tip' - CursorSlice const & top() const { return cursor_.back(); } - /// how many nested insets do we have? - size_t depth() const { return cursor_.size(); } - - /// access to the topmost slice - /// the current inset - InsetBase * inset() const { return top().inset(); } - /// return the text-ed cell this cursor is in - idx_type idx() const { return top().idx(); } - /// return the text-ed cell this cursor is in - idx_type & idx() { return top().idx(); } - /// return the paragraph this cursor is in - par_type par() const { return top().par(); } - /// return the paragraph this cursor is in - par_type & par() { return top().par(); } - /// return the position within the paragraph - pos_type pos() const { return top().pos(); } - /// return the position within the paragraph - pos_type & pos() { return top().pos(); } - /// return the last position within the paragraph - pos_type lastpos() const { return top().lastpos(); } - /// return the number of embedded cells - size_t nargs() const { return top().nargs(); } - /// return the number of embedded cells - size_t ncols() const { return top().ncols(); } - /// return the number of embedded cells - size_t nrows() const { return top().nrows(); } - /// return the grid row of the current cell - row_type row() const { return top().row(); } - /// return the grid row of the current cell - col_type col() const { return top().col(); } + /// 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); // - // math-specific part - // - /// return the mathed cell this cursor is in - MathArray const & cell() const { return top().cell(); } - /// return the mathed cell this cursor is in - MathArray & cell() { return top().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(); - + // selection // - // text-specific part + /// selection active? + bool selection() const { return selection_; } + /// selection active? + bool & selection() { return selection_; } + /// did we place the anchor? + bool mark() const { return mark_; } + /// did we place the anchor? + bool & mark() { return mark_; } + /// + void setSelection(); + /// set selection at given position + void setSelection(DocIterator const & where, size_t n); /// - UpdatableInset * innerInset() const; + 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; /// - UpdatableInset * innerInsetOfType(int code) const; + void selHandle(bool selecting); + // + std::string selectionAsString(bool label) const; /// - InsetTabular * innerInsetTabular() const; + void paste(std::string const & data); /// - LyXText * innerText() const; + std::string currentState(); + + /// 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; - /// returns cursor dimension - void getDim(int & asc, int & desc) const; // // common part @@ -129,24 +111,200 @@ public: /// move one step to the right bool posRight(); - /// cache the absolute coordinate from the top inset - void updatePos(); + /// 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 normalized selection anchor + CursorSlice anchor() const; /// sets anchor to cursor position - void resetAnchor(); + void resetAnchor(); /// access to owning BufferView - BufferView & bv() const; - /// - friend std::ostream & operator<<(std::ostream &, LCursor const &); + 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: - /// mainly used as stack, but wee need random access - std::vector cursor_; - /// The - std::vector anchor_; /// BufferView * bv_; +//private: + /// the anchor position + DocIterator anchor_; + + /// + DispatchResult disp_; + + +private: + /** + * The target x position of the cursor. This is used for when + * we have text like : + * + * blah blah blah blah| blah blah blah + * blah blah blah + * blah blah blah blah blah blah + * + * When we move onto row 3, we would like to be vertically aligned + * with where we were in row 1, despite the fact that row 2 is + * shorter than x() + */ + int x_target_; + /// do we have a selection? + bool selection_; + /// 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 + // + /// 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 +// 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); /// - int cached_y_; + 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