4 * This file is part of LyX, the document processor.
5 * Licence details can be found in the file COPYING.
8 * \author Lars Gullik Bjønnes
11 * Full author contact details are available in file CREDITS
18 #include "lyxcursor.h"
21 #include "insets/inset.h"
23 #include "bufferview_funcs.h"
39 This class holds the mapping between buffer paragraphs and screen rows.
43 /// what repainting is needed
45 /// no repaint is needed
47 /// the refresh_row needs repainting
49 /// everything from refresh_y downwards needs repainting
55 // the word around the cursor, only if the cursor is
58 // the word around the cursor
60 /// the word begining from the cursor position
62 /// the word around the cursor or before the cursor
64 /// the next word (not yet used)
69 LyXText(BufferView *);
70 /// sets inset as owner
71 LyXText(BufferView *, InsetText *);
73 void init(BufferView *, bool reinit = false);
78 /// the current font settings
81 LyXFont real_current_font;
83 /** the 'anchor' row: the position of this row remains constant
84 * with respect to the top of the screen
86 RowList::iterator anchor_row_;
87 /** the pixel offset with respect to this row of top_y
89 int anchor_row_offset_;
91 /// get the y coord. of the top of the screen (relative to doc start)
93 /// set the y coord. of the top of the screen (relative to doc start)
95 /// set the anchoring row. top_y will be computed relative to this
96 void anchor_row(RowList::iterator rit);
98 InsetText * inset_owner;
100 UpdatableInset * the_locking_inset;
103 int getRealCursorX() const;
105 LyXFont const getFont(Buffer const *, Paragraph * par,
106 lyx::pos_type pos) const;
108 LyXFont const getLayoutFont(Buffer const *, Paragraph * par) const;
110 LyXFont const getLabelFont(Buffer const *, Paragraph * par) const;
112 void setCharFont(Buffer const *, Paragraph * par,
113 lyx::pos_type pos, LyXFont const & font);
114 void setCharFont(Paragraph * par,
115 lyx::pos_type pos, LyXFont const & font, bool toggleall);
118 void breakAgainOneRow(RowList::iterator rit);
119 /// what you expect when pressing <enter> at cursor position
120 void breakParagraph(ParagraphList & paragraphs, char keep_layout = 0);
122 /** set layout over selection and make a total rebreak of
125 Paragraph * setLayout(LyXCursor & actual_cursor,
126 LyXCursor & selection_start,
127 LyXCursor & selection_end,
128 string const & layout);
130 void setLayout(string const & layout);
132 /// increase or decrease the nesting depth of the selected paragraph(s)
133 void changeDepth(bv_funcs::DEPTH_CHANGE type);
135 /// get the depth at current cursor position
136 int getDepth() const;
138 /** set font over selection and make a total rebreak of those
140 toggleall defaults to false.
142 void setFont(LyXFont const &, bool toggleall = false);
144 /** deletes and inserts again all paragaphs between the cursor
145 and the specified par. The Cursor is needed to set the refreshing
147 This function is needed after SetLayout and SetFont etc.
149 void redoParagraphs(LyXCursor const & cursor,
150 Paragraph const * end_par);
152 void redoParagraph();
155 void toggleFree(LyXFont const &, bool toggleall = false);
158 string getStringToIndex();
160 /** recalculates the heights of all previous rows of the
161 specified paragraph. needed, if the last characters font
164 void redoHeightOfParagraph();
166 /** insert a character, moves all the following breaks in the
167 same Paragraph one to the right and make a little rebreak
169 void insertChar(char c);
171 void insertInset(Inset * inset);
173 /// Completes the insertion with a full rebreak
177 RowList::iterator need_break_row;
179 /// clear any pending paints
183 * Mark position y as the starting point for a repaint
185 void postPaint(int start_y);
188 * Mark the given row at position y as needing a repaint.
190 void postRowPaint(RowList::iterator rit, int start_y);
193 Inset::RESULT dispatch(FuncRequest const & cmd);
197 BufferView * bv() const;
199 friend class LyXScreen;
202 * Return the status. This represents what repaints are
203 * pending after some operation (e.g. inserting a char).
205 refresh_status refreshStatus() const;
209 * The pixel y position from which to repaint the screen.
210 * The position is absolute along the height of outermost
211 * lyxtext (I think). REFRESH_AREA and REFRESH_ROW
212 * repaints both use this as a starting point (if it's within
213 * the viewable portion of the lyxtext).
217 * The row from which to repaint the screen, used by screen.c.
218 * This must be set if the pending update is REFRESH_ROW.
219 * It doesn't make any difference for REFRESH_AREA.
221 RowList::iterator refresh_row;
223 refresh_status refresh_status_;
225 /// only the top-level LyXText has this non-zero
226 BufferView * bv_owner;
229 /** returns a pointer to the row near the specified y-coordinate
230 (relative to the whole text). y is set to the real beginning
233 RowList::iterator getRowNearY(int & y) const;
235 /** returns the column near the specified x-coordinate of the row
236 x is set to the real beginning of this column
238 lyx::pos_type getColumnNearX(RowList::iterator rit,
239 int & x, bool & boundary) const;
241 /** returns a pointer to a specified row. y is set to the beginning
245 getRow(Paragraph * par, lyx::pos_type pos, int & y) const;
247 RowList & rows() const {
252 Later this variable has to be removed. There should be now internal
253 cursor in a text (and thus not in a buffer). By keeping this it is
254 (I think) impossible to have several views with the same buffer, but
255 the cursor placed at different places.
257 Since the LyXText now has been moved from Buffer to BufferView
258 it should not be absolutely needed to move the cursor...
260 LyXCursor cursor; // actual cursor position
262 /** The structure that keeps track of the selections set. */
265 : set_(false), mark_(false)
279 LyXCursor cursor; // temporary cursor to hold a cursor position
280 // until setSelection is called!
281 LyXCursor start; // start of a REAL selection
282 LyXCursor end; // end of a REAL selection
284 bool set_; // former selection
285 bool mark_; // former mark_set
289 // this is used to handle XSelection events in the right manner
290 Selection xsel_cache;
292 /// needed for the toggling (cursor position on last selection made)
293 LyXCursor last_sel_cursor;
294 /// needed for toggling the selection in screen.C
295 LyXCursor toggle_cursor;
296 /// needed for toggling the selection in screen.C
297 LyXCursor toggle_end_cursor;
299 /// need the selection cursor:
302 void clearSelection();
304 string const selectionAsString(Buffer const *, bool label) const;
306 /// select the word we need depending on word_location
307 void getWord(LyXCursor & from, LyXCursor & to,
308 word_location const);
309 /// just selects the word the cursor is in
310 void selectWord(word_location const);
311 /// returns the inset at cursor (if it exists), 0 otherwise
312 Inset * getInset() const;
314 /// accept selected change
317 /// reject selected change
320 /** 'selects" the next word, where the cursor is not in
321 and returns this word as string. THe cursor will be moved
322 to the beginning of this word.
323 With SelectSelectedWord can this be highlighted really
325 WordLangTuple const selectNextWordToSpellcheck(float & value);
327 void selectSelectedWord();
328 /// returns true if par was empty and was removed
329 bool setCursor(Paragraph * par,
332 bool boundary = false);
334 void setCursor(LyXCursor &, Paragraph * par,
336 bool boundary = false);
338 void setCursorIntern(Paragraph * par,
341 bool boundary = false);
343 void setCurrentFont();
346 bool isBoundary(Buffer const *, Paragraph * par,
347 lyx::pos_type pos) const;
349 bool isBoundary(Buffer const *, Paragraph * par,
351 LyXFont const & font) const;
354 void setCursorFromCoordinates(int x, int y);
356 void setCursorFromCoordinates(LyXCursor &,
359 void cursorUp(bool selecting = false);
361 void cursorDown(bool selecting = false);
363 void cursorLeft(bool internal = true);
365 void cursorRight(bool internal = true);
367 void cursorLeftOneWord();
369 void cursorRightOneWord();
371 void cursorUpParagraph();
373 void cursorDownParagraph();
379 void cursorPrevious();
391 bool selectWordWhenUnderCursor(word_location);
397 text_capitalization = 1,
401 /// Change the case of the word at cursor position.
402 void changeCase(TextCase action);
407 void cutSelection(bool doclear = true, bool realcut = true);
409 void copySelection();
411 void pasteSelection();
413 void copyEnvironmentType();
415 void pasteEnvironmentType();
417 /** the DTP switches for paragraphs. LyX will store the top settings
418 always in the first physical paragraph, the bottom settings in the
419 last. When a paragraph is broken, the top settings rest, the bottom
420 settings are given to the new one. So I can make shure, they do not
421 duplicate themself (and you cannnot make dirty things with them! )
423 void setParagraph(bool line_top, bool line_bottom,
424 bool pagebreak_top, bool pagebreak_bottom,
425 VSpace const & space_top,
426 VSpace const & space_bottom,
427 Spacing const & spacing,
429 string const & labelwidthstring,
432 /* these things are for search and replace */
435 * Sets the selection from the current cursor position to length
436 * characters to the right. No safety checks.
438 void setSelectionRange(lyx::pos_type length);
440 /** simple replacing. The font of the first selected character
443 void replaceSelectionWithString(string const & str);
445 /// needed to insert the selection
446 void insertStringAsLines(string const & str);
447 /// needed to insert the selection
448 void insertStringAsParagraphs(string const & str);
450 /// Find next inset of some specified type.
451 bool gotoNextInset(std::vector<Inset::Code> const & codes,
452 string const & contents = string());
454 void gotoInset(std::vector<Inset::Code> const & codes,
457 void gotoInset(Inset::Code code, bool same_content);
460 /* for the greater insets */
462 /// returns false if inset wasn't found
463 bool updateInset(Inset *);
465 void checkParagraph(Paragraph * par, lyx::pos_type pos);
467 int workWidth() const;
469 int workWidth(Inset * inset) const;
472 void computeBidiTables(Buffer const *, RowList::iterator row) const;
473 /// Maps positions in the visual string to positions in logical string.
474 lyx::pos_type log2vis(lyx::pos_type pos) const;
475 /// Maps positions in the logical string to positions in visual string.
476 lyx::pos_type vis2log(lyx::pos_type pos) const;
478 lyx::pos_type bidi_level(lyx::pos_type pos) const;
480 bool bidi_InRange(lyx::pos_type pos) const;
483 mutable RowList rowlist_;
485 void cursorLeftOneWord(LyXCursor &);
488 float getCursorX(RowList::iterator rit, lyx::pos_type pos,
489 lyx::pos_type last, bool boundary) const;
490 /// used in setlayout
491 void makeFontEntriesLayoutSpecific(Buffer const &, Paragraph & par);
493 /** forces the redrawing of a paragraph. Needed when manipulating a
496 void redoDrawingOfParagraph(LyXCursor const & cursor);
498 /** Copybuffer for copy environment type.
499 Asger has learned that this should be a buffer-property instead
500 Lgb has learned that 'char' is a lousy type for non-characters
502 string copylayouttype;
504 /// removes the row and reset the touched counters
505 void removeRow(RowList::iterator rit);
507 /// remove all following rows of the paragraph of the specified row.
508 void removeParagraph(RowList::iterator rit);
510 /// insert the specified paragraph behind the specified row
511 void insertParagraph(Paragraph * par, RowList::iterator rowit);
513 /** appends the implizit specified paragraph behind the specified row,
514 * start at the implizit given position */
515 void appendParagraph(RowList::iterator rowit);
518 void breakAgain(RowList::iterator rit);
519 /// Calculate and set the height of the row
520 void setHeightOfRow(RowList::iterator rit);
522 // fix the cursor `cur' after a characters has been deleted at `where'
523 // position. Called by deleteEmptyParagraphMechanism
524 void fixCursorAfterDelete(LyXCursor & cur,
525 LyXCursor const & where);
527 /// delete double space (false) or empty paragraphs (true) around old_cursor
528 bool deleteEmptyParagraphMechanism(LyXCursor const & old_cursor);
531 /** Updates all counters starting BEHIND the row. Changed paragraphs
532 * with a dynamic left margin will be rebroken. */
533 void updateCounters();
537 * Returns an inset if inset was hit, or 0 if not.
538 * If hit, the coordinates are changed relative to the inset.
540 Inset * checkInsetHit(int & x, int & y);
543 int singleWidth(Paragraph * par,
544 lyx::pos_type pos) const;
546 int singleWidth(Paragraph * par,
547 lyx::pos_type pos, char c) const;
549 /// return the color of the canvas
550 LColor::color backgroundColor() const;
553 mutable bool bidi_same_direction;
555 unsigned char transformChar(unsigned char c, Paragraph * par,
556 lyx::pos_type pos) const;
559 * Returns the left beginning of the text.
560 * This information cannot be taken from the layout object, because
561 * in LaTeX the beginning of the text fits in some cases
562 * (for example sections) exactly the label-width.
564 int leftMargin(Row const & row) const;
566 int rightMargin(Buffer const &, Row const & row) const;
568 /** this calculates the specified parameters. needed when setting
569 * the cursor and when creating a visible row */
570 void prepareToPrint(RowList::iterator row, float & x,
571 float & fill_separator,
573 float & fill_label_hfill,
574 bool bidi = true) const;
578 void setCounter(Buffer const *, Paragraph * par);
580 void deleteWordForward();
582 void deleteWordBackward();
584 void deleteLineForward();
587 * some low level functions
591 /// return the pos value *before* which a row should break.
592 /// for example, the pos at which IsNewLine(pos) == true
593 lyx::pos_type rowBreakPoint(Row const & row) const;
595 /// returns the minimum space a row needs on the screen in pixel
596 int fill(RowList::iterator row, int workwidth) const;
599 * returns the minimum space a manual label needs on the
602 int labelFill(Row const & row) const;
605 int labelEnd(Row const & row) const;
608 mutable std::vector<lyx::pos_type> log2vis_list;
610 mutable std::vector<lyx::pos_type> vis2log_list;
612 mutable std::vector<lyx::pos_type> bidi_levels;
614 mutable lyx::pos_type bidi_start;
616 mutable lyx::pos_type bidi_end;
622 // special owner functions
624 ParagraphList & ownerParagraphs() const;
626 void ownerParagraph(Paragraph *) const;
627 // set it searching first for the right owner using the paragraph id
628 void ownerParagraph(int id, Paragraph *) const;
630 /// return true if this is owned by an inset.
631 bool isInInset() const;
634 /// return the default height of a row in pixels, considering font zoom
635 extern int defaultRowHeight();