src/cursor.h

   1 // -*- C++ -*-
   2 /**
   3  * \file cursor.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author André Pönitz
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #ifndef CURSOR_H
  13 #define CURSOR_H
  14
  15 #include "cursor_slice.h"
  16
  17 #include <iosfwd>
  18 #include <vector>
  19
  20 class BufferView;
  21 class UpdatableInset;
  22 class MathAtom;
  23 class DispatchResult;
  24 class FuncRequest;
  25 class InsetTabular;
  26 class LyXText;
  27 class Paragraph;
  28
  29
  30 // these should go
  31 class MathHullInset;
  32 class PainterInfo;
  33 class MathUnknownInset;
  34 class MathGridInset;
  35
  36
  37 // only needed for gcc 2.95, remove when support terminated
  38
  39
  40 template <typename A, typename B>
  41 bool ptr_cmp(A const * a, B const * b)
  42 {
  43 return a == b;
  44 }
  45
  46
  47 // this is used for traversing math insets
  48 typedef std::vector<CursorSlice> CursorBase;
  49 /// move on one step
  50 void increment(CursorBase &);
  51 ///
  52 CursorBase ibegin(InsetBase * p);
  53 ///
  54 CursorBase iend(InsetBase * p);
  55
  56
  57 /**
  58  * The cursor class describes the position of a cursor within a document.
  59  */
  60
  61 class LCursor {
  62 public:
  63         /// type for cell number in inset
  64         typedef CursorSlice::idx_type idx_type;
  65         /// type for paragraph numbers positions within a cell
  66         typedef CursorSlice::par_type par_type;
  67         /// type for cursor positions within a cell
  68         typedef CursorSlice::pos_type pos_type;
  69         /// type for row indices
  70         typedef CursorSlice::row_type row_type;
  71         /// type for col indices
  72         typedef CursorSlice::col_type col_type;
  73
  74         /// create the cursor of a BufferView
  75         explicit LCursor(BufferView & bv);
  76         /// dispatch from innermost inset upwards
  77         DispatchResult dispatch(FuncRequest const & cmd);
  78         /// add a new cursor slice
  79         void push(InsetBase * inset);
  80         /// add a new cursor slice, place cursor on left end
  81         void pushLeft(InsetBase * inset);
  82         /// pop one level off the cursor
  83         void pop();
  84         /// pop one slice off the cursor stack and go left
  85         bool popLeft();
  86         /// pop one slice off the cursor stack and go right
  87         bool popRight();
  88         /// restrict cursor nesting to given size
  89         void pop(int depth);
  90         /// access to current cursor slice
  91         CursorSlice & current();
  92         /// access to current cursor slice
  93         CursorSlice const & current() const;
  94         /// how many nested insets do we have?
  95         size_t depth() const { return cursor_.size(); }
  96         /// depth of current slice
  97         int currentDepth() const { return current_; }
  98
  99         //
 100         // selection
 101         //
 102         /// selection active?
 103         bool selection() const { return selection_; }
 104         /// selection active?
 105         bool & selection() { return selection_; }
 106         /// did we place the anchor?
 107         bool mark() const { return mark_; }
 108         /// did we place the anchor?
 109         bool & mark() { return mark_; }
 110         ///
 111         void setSelection();
 112         /// set selection at given position
 113         void setSelection(CursorBase const & where, size_t n);
 114         ///
 115         void clearSelection();
 116         /// access start of selection
 117         CursorSlice & selBegin();
 118         /// access start of selection
 119         CursorSlice const & selBegin() const;
 120         /// access end of selection
 121         CursorSlice & selEnd();
 122         /// access end of selection
 123         CursorSlice const & selEnd() const;
 124         ///
 125         std::string grabSelection();
 126         ///
 127         void eraseSelection();
 128         ///
 129         std::string grabAndEraseSelection();
 130         // other selection methods
 131         ///
 132         void selCopy();
 133         ///
 134         void selCut();
 135         ///
 136         void selDel();
 137         /// pastes n-th element of cut buffer
 138         void selPaste(size_t n);
 139         ///
 140         void selHandle(bool selecting);
 141         /// start selection
 142         void selStart();
 143         /// clear selection
 144         void selClear();
 145         /// clears or deletes selection depending on lyxrc setting
 146         void selClearOrDel();
 147         ///
 148         void paste(std::string const & data);
 149
 150         //
 151         // access to the 'current' cursor slice
 152         //
 153         /// the containing inset
 154         InsetBase * inset() const { return current().inset(); }
 155         /// return the cell of the inset this cursor is in
 156         idx_type idx() const { return current().idx(); }
 157         /// return the cell of the inset this cursor is in
 158         idx_type & idx() { return current().idx(); }
 159         /// return the last possible cell in this inset
 160         idx_type lastidx() const { return current().lastidx(); }
 161         /// return the paragraph this cursor is in
 162         par_type par() const { return current().par(); }
 163         /// return the paragraph this cursor is in
 164         par_type & par() { return current().par(); }
 165         /// return the last possible paragraph in this inset
 166         par_type lastpar() const;
 167         /// return the position within the paragraph
 168         pos_type pos() const { return current().pos(); }
 169         /// return the position within the paragraph
 170         pos_type & pos() { return current().pos(); }
 171         /// return the last position within the paragraph
 172         pos_type lastpos() const;
 173         /// return the display row of the cursor with in the current par
 174         row_type crow() const;
 175         /// return the display row of the cursor with in the current par
 176         row_type lastcrow() const;
 177
 178         /// return the number of embedded cells
 179         size_t nargs() const;
 180         /// return the number of embedded cells
 181         size_t ncols() const;
 182         /// return the number of embedded cells
 183         size_t nrows() const;
 184         /// return the grid row of the current cell
 185         row_type row() const;
 186         /// return the grid row of the current cell
 187         col_type col() const;
 188         /// the inset just behind the cursor
 189         InsetBase * nextInset();
 190         /// the inset just in front of the cursor
 191         InsetBase * prevInset();
 192
 193         //
 194         // math-specific part
 195         //
 196         /// return the mathed cell this cursor is in
 197         MathArray const & cell() const;
 198         /// return the mathed cell this cursor is in
 199         MathArray & cell();
 200         /// the mathatom left of the cursor
 201         MathAtom const & prevAtom() const;
 202         /// the mathatom left of the cursor
 203         MathAtom & prevAtom();
 204         /// the mathatom right of the cursor
 205         MathAtom const & nextAtom() const;
 206         /// the mathatom right of the cursor
 207         MathAtom & nextAtom();
 208         /// auto-correct mode
 209         bool autocorrect() const { return autocorrect_; }
 210         /// auto-correct mode
 211         bool & autocorrect() { return autocorrect_; }
 212         /// are we entering a macro name?
 213         bool macromode() const { return macromode_; }
 214         /// are we entering a macro name?
 215         bool & macromode() { return macromode_; }
 216
 217         //
 218         // text-specific part
 219         ///
 220         bool boundary() const { return current().boundary(); }
 221         ///
 222         bool & boundary() { return current().boundary(); }
 223         ///
 224         Paragraph & paragraph();
 225         ///
 226         Paragraph const & paragraph() const;
 227         ///
 228         LyXText * text() const;
 229         ///
 230         InsetBase * innerInsetOfType(int code) const;
 231         ///
 232         InsetTabular * innerInsetTabular() const;
 233         ///
 234         LyXText * innerText() const;
 235         ///
 236         CursorSlice const & innerTextSlice() const;
 237         /// returns x,y position
 238         void getPos(int & x, int & y) const;
 239         /// returns cursor dimension
 240         void getDim(int & asc, int & desc) const;
 241
 242         //
 243         // common part
 244         //
 245         /// move one step to the left
 246         bool posLeft();
 247         /// move one step to the right
 248         bool posRight();
 249
 250         /// write acess to target x position of cursor
 251         int & x_target();
 252         /// return target x position of cursor
 253         int x_target() const;
 254         /// clear target x position of cursor
 255         void clearTargetX();
 256
 257         /// access to selection anchor
 258         CursorSlice & anchor();
 259         /// access to selection anchor
 260         CursorSlice const & anchor() const;
 261         /// cache the absolute coordinate from the top inset
 262         void updatePos();
 263         /// sets anchor to cursor position
 264         void resetAnchor();
 265         /// access to owning BufferView
 266         BufferView & bv() const;
 267         /// get some interesting description of current position
 268         void info(std::ostream & os);
 269         /// are we in math mode (2), text mode (1) or unsure (0)?
 270         int currentMode();
 271         /// reset cursor
 272         void reset();
 273
 274         /// output
 275         friend std::ostream & operator<<(std::ostream & os, LCursor const & cur);
 276 public:
 277 //private:
 278         /// mainly used as stack, but wee need random access
 279         std::vector<CursorSlice> cursor_;
 280         /// the anchor position
 281         std::vector<CursorSlice> anchor_;
 282
 283 private:
 284         ///
 285         BufferView * bv_;
 286         /// current slice
 287         int current_;
 288         ///
 289         int cached_y_;
 290         /**
 291          * The target x position of the cursor. This is used for when
 292          * we have text like :
 293          *
 294          * blah blah blah blah| blah blah blah
 295          * blah blah blah
 296          * blah blah blah blah blah blah
 297          *
 298          * When we move onto row 3, we would like to be vertically aligned
 299          * with where we were in row 1, despite the fact that row 2 is
 300          * shorter than x()
 301          */
 302         int x_target_;
 303         // do we have a selection?
 304         bool selection_;
 305         // are we on the way to get one?
 306         bool mark_;
 307
 308         //
 309         // math specific stuff that could be promoted to "global" later
 310         //
 311         /// do we allow autocorrection
 312         bool autocorrect_;
 313         /// are we entering a macro name?
 314         bool macromode_;
 315
 316
 317 ///////////////////////////////////////////////////////////////////
 318 //
 319 // The part below is the non-integrated rest of the original math
 320 // cursor. This should be either generalized for texted or moved
 321 // back to the math insets.
 322 //
 323 ///////////////////////////////////////////////////////////////////
 324
 325 public:
 326         ///
 327         void insert(MathAtom const &);
 328         ///
 329         void insert(MathArray const &);
 330         ///
 331         void insert2(std::string const &);
 332         /// return false for empty math insets
 333         bool erase();
 334         /// return false for empty math insets
 335         bool backspace();
 336         /// called for LFUN_HOME etc
 337         bool home();
 338         /// called for LFUN_END etc
 339         bool end();
 340         /// called for LFUN_RIGHT and LFUN_RIGHTSEL
 341         bool right();
 342         /// called for LFUN_LEFT etc
 343         bool left();
 344         /// called for LFUN_UP etc
 345         bool up();
 346         /// called for LFUN_DOWN etc
 347         bool down();
 348         ///
 349         void plainErase();
 350         ///
 351         void plainInsert(MathAtom const & at);
 352         ///
 353         void niceInsert(MathAtom const & at);
 354         ///
 355         void niceInsert(std::string const & str);
 356
 357         /// in pixels from top of screen
 358         void setScreenPos(int x, int y);
 359         /// in pixels from left of screen
 360         int targetX() const;
 361         /// return the next enclosing grid inset and the cursor's index in it
 362         MathGridInset * enclosingGrid(idx_type & idx) const;
 363         /// adjust anchor position after deletions/insertions
 364         void adjust(pos_type from, int diff);
 365         ///
 366         MathHullInset * formula() const;
 367         /// current offset in the current cell
 368         ///
 369         bool script(bool);
 370         ///
 371         bool interpret(char);
 372         /// interpret name a name of a macro
 373         void macroModeClose();
 374         /// are we currently typing the name of a macro?
 375         bool inMacroMode() const;
 376         /// get access to the macro we are currently typing
 377         MathUnknownInset * activeMacro();
 378         /// are we currently typing '#1' or '#2' or...?
 379         bool inMacroArgMode() const;
 380
 381         /// replace selected stuff with at, placing the former
 382         // selection in given cell of atom
 383         void handleNest(MathAtom const & at, int cell = 0);
 384         /// remove this as soon as LyXFunc::getStatus is "localized"
 385         //inline std::string getLastCode() { return "mathnormal"; }
 386         ///
 387         bool isInside(InsetBase const *);
 388         ///
 389         char valign();
 390         ///
 391         char halign();
 392
 393         /// make sure cursor position is valid
 394         void normalize();
 395         /// mark current cursor trace for redraw
 396         void touch();
 397
 398         /// returns the normalized anchor of the selection
 399         CursorSlice normalAnchor();
 400
 401         ///
 402         void insert(char c);
 403         ///
 404         void insert(std::string const & str);
 405         /// lock/unlock inset
 406         void lockToggle();
 407
 408         /// hack for reveal codes
 409         void markInsert();
 410         void markErase();
 411         /// injects content of a cell into parent
 412         void pullArg();
 413         /// split font inset etc
 414         void handleFont(std::string const & font);
 415
 416         void releaseMathCursor();
 417         /// are we in mathed?
 418         bool inMathed() const;
 419         /// are we in texted?
 420         bool inTexted() const;
 421
 422         /// display a message
 423         void message(std::string const & msg) const;
 424         /// display an error message
 425         void errorMessage(std::string const & msg) const;
 426
 427 private:
 428         /// moves cursor index one cell to the left
 429         bool idxLeft();
 430         /// moves cursor index one cell to the right
 431         bool idxRight();
 432         /// moves cursor to end of last cell of current line
 433         bool idxLineLast();
 434         /// moves position somehow up or down
 435         bool goUpDown(bool up);
 436         /// moves position closest to (x, y) in given box
 437         bool bruteFind(int x, int y, int xlow, int xhigh, int ylow, int yhigh);
 438         /// moves position closest to (x, y) in current cell
 439         void bruteFind2(int x, int y);
 440         /// are we in a nucleus of a script inset?
 441         bool inNucleus();
 442
 443         /// the name of the macro we are currently inputting
 444         std::string macroName();
 445         /// where in the curent cell does the macro name start?
 446         int macroNamePos();
 447         /// can we enter the inset?
 448         bool openable(MathAtom const &);
 449 };
 450
 451 #endif // LYXCURSOR_H