]> git.lyx.org Git - lyx.git/blob - src/cursor.h
the Buffer::text -> inset change
[lyx.git] / 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 "dispatchresult.h"
16 #include "dociterator.h"
17
18 #include <iosfwd>
19 #include <vector>
20
21 class BufferView;
22 class FuncStatus;
23 class FuncRequest;
24
25 // these should go
26 class MathHullInset;
27 class MathUnknownInset;
28 class MathGridInset;
29 class Encoding;
30
31
32 /// The cursor class describes the position of a cursor within a document.
33
34 // The public inheritance should go in favour of a suitable data member
35 // (or maybe private inheritance) at some point of time.
36 class LCursor : public DocumentIterator {
37 public:
38         /// create the cursor of a BufferView
39         explicit LCursor(BufferView & bv);
40
41         /// dispatch from innermost inset upwards
42         DispatchResult dispatch(FuncRequest const & cmd);
43         /// are we willing to handle this event?
44         bool getStatus(FuncRequest const & cmd, FuncStatus & flag);
45
46         /// add a new cursor slice
47         void push(InsetBase & inset);
48         /// add a new cursor slice, place cursor on left end
49         void pushLeft(InsetBase & inset);
50         /// pop one level off the cursor
51         void pop();
52         /// pop one slice off the cursor stack and go left
53         bool popLeft();
54         /// pop one slice off the cursor stack and go right
55         bool popRight();
56         /// sets cursor part
57         void setCursor(DocumentIterator const & it, bool sel);
58
59         //
60         // selection
61         //
62         /// selection active?
63         bool selection() const { return selection_; }
64         /// selection active?
65         bool & selection() { return selection_; }
66         /// did we place the anchor?
67         bool mark() const { return mark_; }
68         /// did we place the anchor?
69         bool & mark() { return mark_; }
70         ///
71         void setSelection();
72         /// set selection at given position
73         void setSelection(DocumentIterator const & where, size_t n);
74         ///
75         void clearSelection();
76         /// access start of selection
77         CursorSlice & selBegin();
78         /// access start of selection
79         CursorSlice const & selBegin() const;
80         /// access end of selection
81         CursorSlice & selEnd();
82         /// access end of selection
83         CursorSlice const & selEnd() const;
84         ///
85         std::string grabSelection();
86         ///
87         void eraseSelection();
88         ///
89         std::string grabAndEraseSelection();
90         // other selection methods
91         ///
92         void selCopy();
93         ///
94         void selCut();
95         ///
96         void selDel();
97         /// pastes n-th element of cut buffer
98         void selPaste(size_t n);
99         ///
100         void selHandle(bool selecting);
101         /// start selection
102         void selStart();
103         /// clear selection
104         void selClear();
105         /// clears or deletes selection depending on lyxrc setting
106         void selClearOrDel();
107         //
108         std::string selectionAsString(bool label) const;
109         ///
110         void paste(std::string const & data);
111         ///
112         std::string currentState();
113
114         /// auto-correct mode
115         bool autocorrect() const { return autocorrect_; }
116         /// auto-correct mode
117         bool & autocorrect() { return autocorrect_; }
118         /// are we entering a macro name?
119         bool macromode() const { return macromode_; }
120         /// are we entering a macro name?
121         bool & macromode() { return macromode_; }
122         /// returns x,y position
123         void getPos(int & x, int & y) const;
124         /// returns cursor dimension
125         void getDim(int & asc, int & desc) const;
126
127         //
128         // common part
129         //
130         /// move one step to the left
131         bool posLeft();
132         /// move one step to the right
133         bool posRight();
134
135         /// insert an inset
136         void insert(InsetBase *);
137         /// insert a single char
138         void insert(char c);
139         /// insert a string
140         void insert(std::string const & str);
141
142         /// write acess to target x position of cursor
143         int & x_target();
144         /// return target x position of cursor
145         int x_target() const;
146         /// clear target x position of cursor
147         void clearTargetX();
148
149         /// access to selection anchor
150         CursorSlice & anchor();
151         /// access to selection anchor
152         CursorSlice const & anchor() const;
153         /// cache the absolute coordinate from the top inset
154         void updatePos();
155         /// sets anchor to cursor position
156         void resetAnchor(); 
157         /// access to owning BufferView
158         BufferView & bv() const; 
159         /// get some interesting description of top position
160         void info(std::ostream & os) const;
161         /// are we in math mode (2), text mode (1) or unsure (0)?
162         int currentMode();
163         /// reset cursor
164         void reset();
165         /// for spellchecking
166         void replaceWord(std::string const & replacestring);
167         /// update our view
168         void update();
169         /// set dispatch result
170         void dispatched(dispatch_result_t res);
171         /// assume event was not (yet) dispatched
172         void undispatched();
173         /// don't call update() when done
174         void noUpdate();
175         /// don't pop cursor to the level where the LFUN was handled
176         void noPop();
177
178         /// output
179         friend std::ostream & operator<<(std::ostream & os, LCursor const & cur);
180
181 public:
182         ///
183         BufferView * bv_;
184 //private:
185         /// the anchor position
186         DocumentIterator anchor_;
187         
188         /// 
189         DispatchResult disp_;
190
191 private:
192         ///
193         int cached_y_;
194         /**
195          * The target x position of the cursor. This is used for when
196          * we have text like :
197          *
198          * blah blah blah blah| blah blah blah
199          * blah blah blah
200          * blah blah blah blah blah blah
201          *
202          * When we move onto row 3, we would like to be vertically aligned
203          * with where we were in row 1, despite the fact that row 2 is
204          * shorter than x()
205          */
206         int x_target_;
207         // do we have a selection?
208         bool selection_;
209         // are we on the way to get one?
210         bool mark_;
211         ///
212         bool nopop_;
213
214         //
215         // math specific stuff that could be promoted to "global" later
216         //
217         /// do we allow autocorrection
218         bool autocorrect_;
219         /// are we entering a macro name?
220         bool macromode_;
221
222
223 ///////////////////////////////////////////////////////////////////
224 //
225 // The part below is the non-integrated rest of the original math
226 // cursor. This should be either generalized for texted or moved
227 // back to the math insets.
228 //
229 ///////////////////////////////////////////////////////////////////
230
231 public:
232         ///
233         void insert(MathAtom const &);
234         ///
235         void insert(MathArray const &);
236         /// return false for empty math insets
237         bool erase();
238         /// return false for empty math insets
239         bool backspace();
240         /// called for LFUN_UP etc
241         bool up();
242         /// called for LFUN_DOWN etc
243         bool down();
244         ///
245         void plainErase();
246         ///
247         void plainInsert(MathAtom const & at);
248         ///
249         void niceInsert(MathAtom const & at);
250         ///
251         void niceInsert(std::string const & str);
252
253         /// in pixels from top of screen
254         void setScreenPos(int x, int y);
255         /// in pixels from left of screen
256         int targetX() const;
257         /// return the next enclosing grid inset and the cursor's index in it
258         MathGridInset * enclosingGrid(idx_type & idx) const;
259         /// adjust anchor position after deletions/insertions
260         void adjust(pos_type from, int diff);
261         ///
262         MathHullInset * formula() const;
263         /// current offset in the top cell
264         /// interpret name a name of a macro
265         void macroModeClose();
266         /// are we currently typing the name of a macro?
267         bool inMacroMode() const;
268         /// get access to the macro we are currently typing
269         MathUnknownInset * activeMacro();
270         /// are we currently typing '#1' or '#2' or...?
271         bool inMacroArgMode() const;
272
273         /// replace selected stuff with at, placing the former
274         // selection in given cell of atom
275         void handleNest(MathAtom const & at, int cell = 0);
276         /// remove this as soon as LyXFunc::getStatus is "localized"
277         //inline std::string getLastCode() { return "mathnormal"; }
278         ///
279         bool isInside(InsetBase const *);
280         ///
281         char valign();
282         ///
283         char halign();
284
285         /// make sure cursor position is valid
286         void normalize();
287         /// mark current cursor trace for redraw
288         void touch();
289
290         /// returns the normalized anchor of the selection
291         CursorSlice normalAnchor();
292
293         /// hack for reveal codes
294         void markInsert();
295         void markErase();
296         /// injects content of a cell into parent
297         void pullArg();
298         /// split font inset etc
299         void handleFont(std::string const & font);
300
301         /// display a message
302         void message(std::string const & msg) const;
303         /// display an error message
304         void errorMessage(std::string const & msg) const;
305         ///
306         std::string getPossibleLabel();
307
308         /// moves position somehow up or down
309         bool goUpDown(bool up);
310         /// moves position closest to (x, y) in given box
311         bool bruteFind(int x, int y, int xlow, int xhigh, int ylow, int yhigh);
312         /// moves position closest to (x, y) in current cell
313         void bruteFind2(int x, int y);
314
315         /// the name of the macro we are currently inputting
316         std::string macroName();
317         /// where in the curent cell does the macro name start?
318         int macroNamePos();
319         /// can we enter the inset?
320         bool openable(MathAtom const &) const;
321         ///
322         Encoding const * getEncoding() const;
323 };
324
325 #endif // LYXCURSOR_H