src/lyxtext.h

   1 // -*- C++ -*-
   2 /* This file is part of
   3  * ======================================================
   4  *
   5  *           LyX, The Document Processor
   6  *
   7  *           Copyright 1995 Matthias Ettrich
   8  *           Copyright 1995-2000 The LyX Team.
   9  *
  10  * ====================================================== */
  11
  12 #ifndef LYXTEXT_H
  13 #define LYXTEXT_H
  14
  15 #ifdef __GNUG__
  16 #pragma interface
  17 #endif
  18
  19 #include "lyxfont.h"
  20 #include "undo.h"
  21 #include "lyxcursor.h"
  22 #include "lyxparagraph.h"
  23 #include "layout.h"
  24
  25 class Buffer;
  26 class BufferParams;
  27 class Row;
  28 class BufferView;
  29 class InsetText;
  30
  31
  32 /**
  33   This class holds the mapping between buffer paragraphs and screen rows.
  34   */
  35 class LyXText {
  36 public:
  37         ///
  38         enum text_status {
  39                 ///
  40                 UNCHANGED,
  41                 ///
  42                 NEED_MORE_REFRESH,
  43                 ///
  44                 NEED_VERY_LITTLE_REFRESH,
  45                 ///
  46                 CHANGED_IN_DRAW
  47         };
  48
  49         /// Constructor
  50         LyXText(BufferView *);
  51         ///
  52         LyXText(InsetText *);
  53
  54         /// Destructor
  55         ~LyXText();
  56
  57         void init(BufferView *);
  58         ///
  59         mutable int number_of_rows;
  60         ///
  61         mutable int height;
  62         ///
  63         mutable unsigned int width;
  64         /// the current font settings
  65         mutable LyXFont current_font;
  66         /// the current font
  67         mutable LyXFont real_current_font;
  68         /// first visible pixel-row is set from LyXScreen!!!
  69         // unsigned is wrong here for text-insets!
  70         int first;
  71         ///
  72         BufferView * bv_owner;
  73         ///
  74         InsetText * inset_owner;
  75         ///
  76         UpdatableInset * the_locking_inset;
  77
  78         ///
  79         int GetRealCursorX(BufferView *) const;
  80         ///
  81         LyXFont const GetFont(Buffer const *, LyXParagraph * par,
  82                         LyXParagraph::size_type pos) const;
  83         ///
  84         void SetCharFont(Buffer const *, LyXParagraph * par,
  85                          LyXParagraph::size_type pos,
  86                          LyXFont const & font);
  87         /// returns a pointer to the very first LyXParagraph
  88         LyXParagraph * FirstParagraph() const;
  89
  90         /// what you expect when pressing <enter> at cursor position
  91         void BreakParagraph(BufferView *, char keep_layout = 0);
  92
  93         /** set layout over selection and make a total rebreak of
  94           those paragraphs
  95           */
  96         LyXParagraph * SetLayout(BufferView *, LyXCursor & actual_cursor,
  97                                  LyXCursor & selection_start,
  98                                  LyXCursor & selection_end,
  99                                  LyXTextClass::size_type layout);
 100         void SetLayout(BufferView *, LyXTextClass::size_type layout);
 101
 102         /// used in setlayout
 103         void MakeFontEntriesLayoutSpecific(Buffer const *, LyXParagraph * par);
 104
 105         /** increment depth over selection and make a total rebreak of those
 106           paragraphs
 107           */
 108         void IncDepth(BufferView *);
 109
 110         /** decrement depth over selection and make a total rebreak of those
 111           paragraphs */
 112         void DecDepth(BufferView *);
 113
 114         /** Get the depth at current cursor position
 115          */
 116         int GetDepth() const { return cursor.par()->GetDepth(); }
 117
 118         /** set font over selection and make a total rebreak of those
 119           paragraphs.
 120           toggleall defaults to false.
 121           */
 122         void SetFont(BufferView *, LyXFont const &, bool toggleall = false);
 123
 124         /** deletes and inserts again all paragaphs between the cursor
 125           and the specified par. The Cursor is needed to set the refreshing
 126           parameters.
 127           This function is needed after SetLayout and SetFont etc.
 128           */
 129         void RedoParagraphs(BufferView *, LyXCursor const & cursor,
 130                             LyXParagraph const * end_par) const;
 131         ///
 132         void RedoParagraph(BufferView *) const;
 133
 134         ///
 135         void ToggleFree(BufferView *, LyXFont const &, bool toggleall = false);
 136
 137         /** recalculates the heights of all previous rows of the
 138             specified paragraph.  needed, if the last characters font
 139             has changed.
 140             */
 141         void RedoHeightOfParagraph(BufferView *, LyXCursor const & cursor);
 142
 143         /** forces the redrawing of a paragraph. Needed when manipulating a
 144             right address box
 145             */
 146         void RedoDrawingOfParagraph(BufferView *, LyXCursor const & cursor);
 147
 148         /** insert a character, moves all the following breaks in the
 149           same Paragraph one to the right and make a little rebreak
 150           */
 151         void InsertChar(BufferView *, char c);
 152         ///
 153         void InsertInset(BufferView *, Inset * inset);
 154
 155         /** Completes the insertion with a full rebreak.
 156             Returns true if something was broken. */
 157         bool FullRebreak(BufferView *);
 158
 159 #ifndef NEW_INSETS
 160         ///
 161         LyXParagraph::footnote_flag GetFootnoteFlag(int row);
 162 #endif
 163         ///
 164         Row * need_break_row;
 165         ///
 166         mutable int refresh_y;
 167         ///
 168         int refresh_height;
 169         ///
 170         int refresh_width;
 171         ///
 172         int refresh_x;
 173         ///
 174         mutable Row * refresh_row;
 175         ///
 176         int refresh_pos;
 177
 178         /** wether the screen needs a refresh,
 179            starting with refresh_y
 180            */
 181         mutable text_status status;
 182
 183         /** returns a pointer to the row near the specified y-coordinate
 184           (relative to the whole text). y is set to the real beginning
 185           of this row
 186           */
 187         Row * GetRowNearY(int & y) const;
 188
 189         /** returns the column near the specified x-coordinate of the row
 190          x is set to the real beginning of this column
 191          */
 192         int GetColumnNearX(BufferView *, Row * row,
 193                            int & x, bool & boundary) const;
 194
 195         /** returns a pointer to a specified row. y is set to the beginning
 196          of the row
 197          */
 198         Row * GetRow(LyXParagraph * par,
 199                      LyXParagraph::size_type pos, int & y) const;
 200
 201         /** returns the height of a default row, needed  for scrollbar
 202          */
 203         int DefaultHeight() const;
 204
 205         /** The cursor.
 206           Later this variable has to be removed. There should be now internal
 207           cursor in a text (and thus not in a buffer). By keeping this it is
 208           (I think) impossible to have several views with the same buffer, but
 209           the cursor placed at different places.
 210           [later]
 211           Since the LyXText now has been moved from Buffer to BufferView
 212           it should not be absolutely needed to move the cursor...
 213           */
 214         mutable LyXCursor cursor;
 215
 216         /* the selection cursor */
 217         ///
 218         mutable bool selection;
 219         ///
 220         mutable bool mark_set;
 221
 222         ///
 223         mutable LyXCursor sel_cursor;
 224         ///
 225         LyXCursor sel_start_cursor;
 226         ///
 227         mutable LyXCursor sel_end_cursor;
 228         /// needed for the toggling
 229         LyXCursor last_sel_cursor;
 230         ///
 231         LyXCursor toggle_cursor;
 232         ///
 233         LyXCursor toggle_end_cursor;
 234
 235         /// need the selection cursor:
 236         void SetSelection(BufferView *);
 237         ///
 238         void ClearSelection() const;
 239         ///
 240         string const selectionAsString(Buffer const *) const;
 241
 242         /// just selects the word the cursor is in
 243         void SelectWord(BufferView *);
 244
 245         /** 'selects" the next word, where the cursor is not in
 246          and returns this word as string. THe cursor will be moved
 247          to the beginning of this word.
 248          With SelectSelectedWord can this be highlighted really
 249          */
 250         string const SelectNextWord(BufferView *, float & value) const;
 251         ///
 252         void SelectSelectedWord(BufferView *);
 253         ///
 254         void SetCursor(BufferView *, LyXParagraph * par,
 255                        LyXParagraph::size_type pos,
 256                        bool setfont = true,
 257                        bool boundary = false) const;
 258         ///
 259         void SetCursor(BufferView *, LyXCursor &, LyXParagraph * par,
 260                        LyXParagraph::size_type pos,
 261                        bool boundary = false) const;
 262         ///
 263         void SetCursorIntern(BufferView *, LyXParagraph * par,
 264                              LyXParagraph::size_type pos,
 265                              bool setfont = true,
 266                              bool boundary = false) const;
 267         ///
 268         void SetCurrentFont(BufferView *) const;
 269
 270         ///
 271         bool IsBoundary(Buffer const *, LyXParagraph * par,
 272                         LyXParagraph::size_type pos) const;
 273         ///
 274         bool IsBoundary(Buffer const *, LyXParagraph * par,
 275                          LyXParagraph::size_type pos,
 276                          LyXFont const & font) const;
 277
 278         ///
 279         void SetCursorFromCoordinates(BufferView *, int x, int y) const;
 280         ///
 281         void SetCursorFromCoordinates(BufferView *, LyXCursor &,
 282                                       int x, int y) const;
 283         ///
 284         void CursorUp(BufferView *) const;
 285         ///
 286         void CursorDown(BufferView *) const;
 287         ///
 288         void CursorLeft(BufferView *, bool internal = true) const;
 289         ///
 290         void CursorRight(BufferView *, bool internal = true) const;
 291         ///
 292         void CursorLeftOneWord(BufferView *) const;
 293         ///
 294         void CursorRightOneWord(BufferView *) const;
 295         ///
 296         void CursorUpParagraph(BufferView *) const;
 297         ///
 298         void CursorDownParagraph(BufferView *) const;
 299         ///
 300         void CursorHome(BufferView *) const;
 301         ///
 302         void CursorEnd(BufferView *) const;
 303         ///
 304         void CursorTab(BufferView *) const;
 305         ///
 306         void CursorTop(BufferView *) const;
 307         ///
 308         void CursorBottom(BufferView *) const;
 309         ///
 310         void Delete(BufferView *);
 311         ///
 312         void Backspace(BufferView *);
 313         ///
 314         void DeleteWordForward(BufferView *);
 315         ///
 316         void DeleteWordBackward(BufferView *);
 317         ///
 318         void DeleteLineForward(BufferView *);
 319         ///
 320         bool SelectWordWhenUnderCursor(BufferView *);
 321         ///
 322         enum TextCase {
 323                 ///
 324                 text_lowercase = 0,
 325                 ///
 326                 text_capitalization = 1,
 327                 ///
 328                 text_uppercase = 2
 329         };
 330         /// Change the case of the word at cursor position.
 331         void ChangeWordCase(BufferView *, TextCase action);
 332
 333         /** returns a printed row in a pixmap. The y value is needed to
 334           decide, wether it is selected text or not. This is a strange
 335           solution but faster.
 336          */
 337         void GetVisibleRow(BufferView *, int y_offset, int x_offset,
 338                            Row * row_ptr, int y, bool cleared=false);
 339
 340 #ifndef NEW_INSETS
 341         /* footnotes: */
 342         ///
 343         void ToggleFootnote(BufferView *);
 344         ///
 345         void OpenStuff(BufferView *);
 346         ///
 347         void OpenFootnotes();
 348         ///
 349         void OpenFootnote(BufferView *);
 350         ///
 351         void CloseFootnotes();
 352         ///
 353         void CloseFootnote(BufferView *);
 354
 355         /** turn the selection into a new environment. If there is no
 356           selection, create an empty environment
 357          */
 358         void InsertFootnoteEnvironment(BufferView *,
 359                                        LyXParagraph::footnote_kind kind);
 360         ///
 361         void MeltFootnoteEnvironment(BufferView *);
 362 #endif
 363         ///
 364         void CutSelection(BufferView *, bool = true);
 365         ///
 366         void CopySelection(BufferView *);
 367         ///
 368         void PasteSelection(BufferView *);
 369         ///
 370         void copyEnvironmentType();
 371         ///
 372         void pasteEnvironmentType(BufferView *);
 373         ///
 374         void InsertFootnote();
 375         ///
 376         void InsertMarginpar();
 377         ///
 378         void InsertFigure();
 379         ///
 380         void InsertTabular();
 381
 382         /** the DTP switches for paragraphs. LyX will store the top settings
 383          always in the first physical paragraph, the bottom settings in the
 384          last. When a paragraph is broken, the top settings rest, the bottom
 385          settings are given to the new one. So I can make shure, they do not
 386          duplicate themself (and you cannnot make dirty things with them! )
 387          */
 388         void SetParagraph(BufferView *,
 389                           bool line_top, bool line_bottom,
 390                           bool pagebreak_top, bool pagebreak_bottom,
 391                           VSpace const & space_top,
 392                           VSpace const & space_bottom,
 393                           LyXAlignment align,
 394                           string labelwidthstring,
 395                           bool noindent);
 396         ///
 397         void SetParagraphExtraOpt(BufferView *, int type,
 398                                   string const & width,
 399                                   string const & widthp,
 400                                   int alignment, bool hfill,
 401                                   bool start_minipage);
 402
 403         /* these things are for search and replace */
 404
 405         /** returns true if the specified string is at the specified
 406           position
 407           */
 408         bool IsStringInText(LyXParagraph * par,
 409                             LyXParagraph::size_type pos,
 410                             string const & str) const;
 411         /** sets the selection over the number of characters of string,
 412           no check!!
 413           */
 414         void SetSelectionOverString(BufferView *, string const & str);
 415
 416         /** simple replacing. The font of the first selected character
 417           is used
 418           */
 419         void ReplaceSelectionWithString(BufferView *, string const & str);
 420
 421         /** if the string can be found: return true and set the cursor to
 422           the new position */
 423         bool SearchForward(BufferView *, string const & str) const;
 424         ///
 425         bool SearchBackward(BufferView *, string const & str) const;
 426
 427         /// needed to insert the selection
 428         void InsertStringA(BufferView *, string const & str);
 429         /// needed to insert the selection
 430         void InsertStringB(BufferView *, string const & str);
 431
 432         /// Find next inset of some specified type.
 433         bool GotoNextInset(BufferView *, std::vector<Inset::Code> const & codes,
 434                            string const & contents = string()) const;
 435         ///
 436
 437         /* for the greater insets */
 438
 439         /// returns false if inset wasn't found
 440         bool UpdateInset(BufferView *, Inset *);
 441         ///
 442         void CheckParagraph(BufferView *, LyXParagraph * par,
 443                             LyXParagraph::size_type pos);
 444         ///
 445         int NumberOfCell(LyXParagraph * par,
 446                          LyXParagraph::size_type pos) const;
 447         ///
 448         LyXParagraph * GetParFromID(int id);
 449
 450         // undo functions
 451         /// returns false if no undo possible
 452         bool TextUndo(BufferView *);
 453         /// returns false if no redo possible
 454         bool TextRedo(BufferView *);
 455         /// used by TextUndo/TextRedo
 456         bool TextHandleUndo(BufferView *, Undo * undo);
 457         /// makes sure the next operation will be stored
 458         void FinishUndo();
 459         /// this is dangerous and for internal use only
 460         void FreezeUndo();
 461         /// this is dangerous and for internal use only
 462         void UnFreezeUndo();
 463         /// the flag used by FinishUndo();
 464         mutable bool undo_finished;
 465         /// a flag
 466         bool undo_frozen;
 467         ///
 468         void SetUndo(Buffer *, Undo::undo_kind kind,
 469                      LyXParagraph const * before,
 470                      LyXParagraph const * end) const;
 471         ///
 472         void SetRedo(Buffer *, Undo::undo_kind kind,
 473                      LyXParagraph const * before,
 474                      LyXParagraph const * end);
 475         ///
 476         Undo * CreateUndo(Buffer *, Undo::undo_kind kind,
 477                           LyXParagraph const * before,
 478                           LyXParagraph const * end) const;
 479         /// for external use in lyx_cb.C
 480         void SetCursorParUndo(Buffer *);
 481         ///
 482         void RemoveTableRow(LyXCursor & cursor) const;
 483         ///
 484         bool IsEmptyTableCell() const;
 485         ///
 486         void toggleAppendix(BufferView *);
 487         ///
 488         int workWidth(BufferView *) const;
 489         ///
 490         void ComputeBidiTables(Buffer const *, Row * row) const;
 491
 492         /// Maps positions in the visual string to positions in logical string.
 493         inline
 494         LyXParagraph::size_type log2vis(LyXParagraph::size_type pos) const {
 495                 if (bidi_start == -1)
 496                         return pos;
 497                 else
 498                         return log2vis_list[pos-bidi_start];
 499         }
 500
 501         /// Maps positions in the logical string to positions in visual string.
 502         inline
 503         LyXParagraph::size_type vis2log(LyXParagraph::size_type pos) const {
 504                 if (bidi_start == -1)
 505                         return pos;
 506                 else
 507                         return vis2log_list[pos-bidi_start];
 508         }
 509         ///
 510         inline
 511         LyXParagraph::size_type bidi_level(LyXParagraph::size_type pos) const {
 512                 if (bidi_start == -1)
 513                         return 0;
 514                 else
 515                         return bidi_levels[pos-bidi_start];
 516         }
 517         ///
 518         inline
 519         bool bidi_InRange(LyXParagraph::size_type pos) const {
 520                 return bidi_start == -1 ||
 521                         (bidi_start <= pos && pos <= bidi_end);
 522         }
 523 private:
 524         ///
 525         void init();
 526         ///
 527         mutable Row * firstrow;
 528         ///
 529         mutable Row * lastrow;
 530
 531         /** Copybuffer for copy environment type.
 532           Asger has learned that this should be a buffer-property instead
 533           Lgb has learned that 'char' is a lousy type for non-characters
 534           */
 535         LyXTextClass::size_type copylayouttype;
 536
 537         /** inserts a new row behind the specified row, increments
 538             the touched counters */
 539         void InsertRow(Row * row, LyXParagraph * par,
 540                        LyXParagraph::size_type pos) const;
 541         /** removes the row and reset the touched counters */
 542         void RemoveRow(Row * row) const;
 543
 544         /** remove all following rows of the paragraph of the specified row. */
 545         void RemoveParagraph(Row * row) const;
 546
 547         /** insert the specified paragraph behind the specified row */
 548         void InsertParagraph(BufferView *,
 549                              LyXParagraph * par, Row * row) const;
 550
 551         /** appends  the implizit specified paragraph behind the specified row,
 552          * start at the implizit given position */
 553         void AppendParagraph(BufferView *, Row * row) const;
 554
 555         ///
 556         void BreakAgain(BufferView *, Row * row) const;
 557         ///
 558         void BreakAgainOneRow(BufferView *, Row * row);
 559         /// Calculate and set the height of the row
 560         void SetHeightOfRow(BufferView *, Row * row_ptr) const;
 561
 562         /** this calculates the specified parameters. needed when setting
 563          * the cursor and when creating a visible row */
 564         void PrepareToPrint(BufferView *, Row * row, float & x,
 565                             float & fill_separator,
 566                             float & fill_hfill,
 567                             float & fill_label_hfill,
 568                             bool bidi = true) const;
 569
 570         ///
 571         void DeleteEmptyParagraphMechanism(BufferView *,
 572                                            LyXCursor const & old_cursor) const;
 573
 574         /** Updates all counters starting BEHIND the row. Changed paragraphs
 575          * with a dynamic left margin will be rebroken. */
 576         void UpdateCounters(BufferView *, Row * row) const;
 577         ///
 578         void SetCounter(Buffer const *, LyXParagraph * par) const;
 579
 580         /*
 581          * some low level functions
 582          */
 583
 584         ///
 585         int SingleWidth(BufferView *, LyXParagraph * par,
 586                         LyXParagraph::size_type pos) const;
 587         ///
 588         int SingleWidth(BufferView *, LyXParagraph * par,
 589                         LyXParagraph::size_type pos, char c) const;
 590         ///
 591         void draw(BufferView *, Row const * row,
 592                   LyXParagraph::size_type & pos,
 593                   int offset, float & x, bool cleared);
 594
 595         /// get the next breakpoint in a given paragraph
 596         LyXParagraph::size_type NextBreakPoint(BufferView *, Row const * row,
 597                                                int width) const;
 598         /// returns the minimum space a row needs on the screen in pixel
 599         int Fill(BufferView *, Row * row, int workwidth) const;
 600
 601         /** returns the minimum space a manual label needs on the
 602           screen in pixel */
 603         int LabelFill(BufferView *, Row const * row) const;
 604
 605         ///
 606         LyXParagraph::size_type
 607         BeginningOfMainBody(Buffer const *, LyXParagraph const * par) const;
 608
 609         /** Returns the left beginning of the text.
 610           This information cannot be taken from the layouts-objekt, because
 611           in LaTeX the beginning of the text fits in some cases
 612           (for example sections) exactly the label-width.
 613           */
 614         int LeftMargin(BufferView *, Row const * row) const;
 615         ///
 616         int RightMargin(Buffer const *, Row const * row) const;
 617         ///
 618         int LabelEnd (BufferView *, Row const * row) const;
 619
 620         /** returns the number of separators in the specified row.
 621           The separator on the very last column doesnt count
 622           */
 623         int NumberOfSeparators(Buffer const *, Row const * row) const;
 624
 625         /** returns the number of hfills in the specified row. The
 626           LyX-Hfill is a LaTeX \hfill so that the hfills at the
 627           beginning and at the end were ignored. This is {\em MUCH}
 628           more usefull than not to ignore!
 629           */
 630         int NumberOfHfills(Buffer const *, Row const * row) const;
 631
 632         /// like NumberOfHfills, but only those in the manual label!
 633         int NumberOfLabelHfills(Buffer const *, Row const * row) const;
 634         /** returns true, if a expansion is needed. Rules are given by
 635           LaTeX
 636           */
 637         bool HfillExpansion(Buffer const *, Row const * row_ptr,
 638                             LyXParagraph::size_type pos) const;
 639
 640
 641         ///
 642         mutable std::vector<LyXParagraph::size_type> log2vis_list;
 643
 644         ///
 645         mutable std::vector<LyXParagraph::size_type> vis2log_list;
 646
 647         ///
 648         mutable std::vector<LyXParagraph::size_type> bidi_levels;
 649
 650         ///
 651         mutable LyXParagraph::size_type bidi_start;
 652
 653         ///
 654         mutable LyXParagraph::size_type bidi_end;
 655
 656         ///
 657         mutable bool bidi_same_direction;
 658
 659         ///
 660         unsigned char TransformChar(unsigned char c, LyXParagraph * par,
 661                                 LyXParagraph::size_type pos) const;
 662
 663         /** returns the paragraph position of the last character in the
 664           specified row
 665           */
 666         LyXParagraph::size_type RowLast(Row const * row) const;
 667         ///
 668         LyXParagraph::size_type RowLastPrintable(Row const * row) const;
 669
 670         ///
 671         void charInserted();
 672         //
 673         // special owner functions
 674         ///
 675         LyXParagraph * OwnerParagraph() const;
 676         //
 677         LyXParagraph * OwnerParagraph(LyXParagraph *) const;
 678 };
 679
 680 #endif