X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxtext.h;h=949681298d438d1d5ea0ea6f641dec19c55121cc;hb=acb4e0a1d39ad697fdfcc7f2d66be2bc6b82e2d1;hp=e446658a6dbcdb8376728cb27e4166a7f5262a9b;hpb=bdba99dcf94c7e12f34add5050416fd7632650a6;p=lyx.git diff --git a/src/lyxtext.h b/src/lyxtext.h index e446658a6d..949681298d 100644 --- a/src/lyxtext.h +++ b/src/lyxtext.h @@ -1,9 +1,9 @@ // -*- C++ -*- /* This file is part of - * ====================================================== - * + * ====================================================== + * * LyX, The Document Processor - * + * * Copyright 1995 Matthias Ettrich * Copyright 1995-2001 The LyX Team. * @@ -18,16 +18,19 @@ #include "lyxfont.h" #include "lyxcursor.h" -#include "paragraph.h" #include "layout.h" -#include "lyxrow.h" -#include "vspace.h" #include "LColor.h" +#include "insets/inset.h" class Buffer; class BufferParams; class BufferView; class InsetText; +class Paragraph; +class Row; +class Spacing; +class UpdatableInset; +class VSpace; /** @@ -65,7 +68,7 @@ public: LyXText(BufferView *); /// LyXText(InsetText *); - + /// Destructor ~LyXText(); @@ -82,7 +85,7 @@ public: mutable LyXFont real_current_font; /// first visible pixel-row is set from LyXScreen!!! // unsigned is wrong here for text-insets! - int first; + int first_y; /// BufferView * bv_owner; /// @@ -94,16 +97,17 @@ public: int getRealCursorX(BufferView *) const; /// LyXFont const getFont(Buffer const *, Paragraph * par, - Paragraph::size_type pos) const; + lyx::pos_type pos) const; + /// + LyXFont const getLayoutFont(Buffer const *, Paragraph * par) const; + /// + LyXFont const getLabelFont(Buffer const *, Paragraph * par) const; /// void setCharFont(Buffer const *, Paragraph * par, - Paragraph::size_type pos, LyXFont const & font); + lyx::pos_type pos, LyXFont const & font); void setCharFont(BufferView *, Paragraph * par, - Paragraph::size_type pos, - LyXFont const & font, bool toggleall); - /// returns a pointer to the very first Paragraph - Paragraph * firstParagraph() const; - + lyx::pos_type pos, LyXFont const & font, bool toggleall); + /// what you expect when pressing at cursor position void breakParagraph(BufferView *, char keep_layout = 0); @@ -111,70 +115,73 @@ public: those paragraphs */ Paragraph * setLayout(BufferView *, LyXCursor & actual_cursor, - LyXCursor & selection_start, - LyXCursor & selection_end, - LyXTextClass::size_type layout); - void setLayout(BufferView *, LyXTextClass::size_type layout); - + LyXCursor & selection_start, + LyXCursor & selection_end, + string const & layout); + /// + void setLayout(BufferView *, string const & layout); + /// used in setlayout void makeFontEntriesLayoutSpecific(Buffer const *, Paragraph * par); - - /** increment depth over selection and make a total rebreak of those + + /** increment depth over selection and make a total rebreak of those paragraphs */ void incDepth(BufferView *); - - /** decrement depth over selection and make a total rebreak of those + + /** decrement depth over selection and make a total rebreak of those paragraphs */ void decDepth(BufferView *); /** Get the depth at current cursor position */ - int getDepth() const { return cursor.par()->getDepth(); } - + int getDepth() const; + /** set font over selection and make a total rebreak of those paragraphs. toggleall defaults to false. */ void setFont(BufferView *, LyXFont const &, bool toggleall = false); - + /** deletes and inserts again all paragaphs between the cursor and the specified par. The Cursor is needed to set the refreshing - parameters. + parameters. This function is needed after SetLayout and SetFont etc. */ void redoParagraphs(BufferView *, LyXCursor const & cursor, Paragraph const * end_par) const; /// void redoParagraph(BufferView *) const; - + /// void toggleFree(BufferView *, LyXFont const &, bool toggleall = false); - + + /// + string getStringToIndex(BufferView *); + /** recalculates the heights of all previous rows of the specified paragraph. needed, if the last characters font - has changed. + has changed. */ void redoHeightOfParagraph(BufferView *, LyXCursor const & cursor); - - /** forces the redrawing of a paragraph. Needed when manipulating a + + /** forces the redrawing of a paragraph. Needed when manipulating a right address box - */ + */ void redoDrawingOfParagraph(BufferView *, LyXCursor const & cursor); - - /** insert a character, moves all the following breaks in the + + /** insert a character, moves all the following breaks in the same Paragraph one to the right and make a little rebreak */ void insertChar(BufferView *, char c); /// void insertInset(BufferView *, Inset * inset); - - /** Completes the insertion with a full rebreak. - Returns true if something was broken. */ - bool fullRebreak(BufferView *); + + /** Completes the insertion with a full rebreak. */ + void fullRebreak(BufferView *); /// - Row * need_break_row; + mutable Row * need_break_row; /// mutable int refresh_y; /// @@ -186,41 +193,47 @@ public: /// mutable Row * refresh_row; /// - int refresh_pos; + lyx::pos_type refresh_pos; /// give and set the LyXText status text_status status() const; + /// void status(BufferView *, text_status) const; -private: +private: /** wether the screen needs a refresh, starting with refresh_y */ mutable text_status status_; - + public: /** returns a pointer to the row near the specified y-coordinate (relative to the whole text). y is set to the real beginning of this row - */ + */ Row * getRowNearY(int & y) const; - - /** returns the column near the specified x-coordinate of the row + + /** returns the column near the specified x-coordinate of the row x is set to the real beginning of this column - */ - int getColumnNearX(BufferView *, Row * row, - int & x, bool & boundary) const; - + */ + lyx::pos_type getColumnNearX(BufferView *, Row * row, + int & x, bool & boundary) const; + /** returns a pointer to a specified row. y is set to the beginning of the row */ Row * getRow(Paragraph * par, - Paragraph::size_type pos, int & y) const; + lyx::pos_type pos, int & y) const; + /** returns the firstrow, this could be done with the above too but + IMO it's stupid to have to allocate a dummy y all the time I need + the first row + */ + Row * firstRow() { return firstrow; } /** returns the height of a default row, needed for scrollbar */ int defaultHeight() const; - + /** The cursor. Later this variable has to be removed. There should be now internal cursor in a text (and thus not in a buffer). By keeping this it is @@ -230,11 +243,11 @@ public: Since the LyXText now has been moved from Buffer to BufferView it should not be absolutely needed to move the cursor... */ - mutable LyXCursor cursor; + mutable LyXCursor cursor; // actual cursor position - /** The structrue that keeps track of the selections set. */ + /** The structure that keeps track of the selections set. */ struct Selection { - Selection() + Selection() : set_(false), mark_(false) {} bool set() const { @@ -249,69 +262,75 @@ public: void mark(bool m) { mark_ = m; } - LyXCursor cursor; - LyXCursor start; - LyXCursor end; + LyXCursor cursor; // temporary cursor to hold a cursor position + // until setSelection is called! + LyXCursor start; // start of a REAL selection + LyXCursor end; // end of a REAL selection private: bool set_; // former selection bool mark_; // former mark_set - + }; mutable Selection selection; + // this is used to handle XSelection events in the right manner + mutable Selection xsel_cache; + + /// needed for the toggling (cursor position on last selection made) + mutable LyXCursor last_sel_cursor; + /// needed for toggling the selection in screen.C + mutable LyXCursor toggle_cursor; + /// needed for toggling the selection in screen.C + mutable LyXCursor toggle_end_cursor; - /// needed for the toggling - LyXCursor last_sel_cursor; - /// - LyXCursor toggle_cursor; - /// - LyXCursor toggle_end_cursor; - /// need the selection cursor: void setSelection(BufferView *); /// - void clearSelection(BufferView *) const; + void clearSelection() const; /// - string const selectionAsString(Buffer const *) const; - + string const selectionAsString(Buffer const *, bool label) const; + /// select the word we need depending on word_location - void getWord(LyXCursor & from, LyXCursor & to, + void getWord(LyXCursor & from, LyXCursor & to, word_location const) const; /// just selects the word the cursor is in void selectWord(BufferView *, word_location const); /// returns the inset at cursor (if it exists), 0 otherwise Inset * getInset() const; - /** 'selects" the next word, where the cursor is not in - and returns this word as string. THe cursor will be moved - to the beginning of this word. + /** 'selects" the next word, where the cursor is not in + and returns this word as string. THe cursor will be moved + to the beginning of this word. With SelectSelectedWord can this be highlighted really - */ - string const selectNextWord(BufferView *, float & value) const; + */ + string const selectNextWordToSpellcheck(BufferView *, float & value) const; /// void selectSelectedWord(BufferView *); - /// - void setCursor(BufferView *, Paragraph * par, - Paragraph::size_type pos, + /// returns true if par was empty and was removed + bool setCursor(BufferView *, Paragraph * par, + lyx::pos_type pos, bool setfont = true, bool boundary = false) const; /// void setCursor(BufferView *, LyXCursor &, Paragraph * par, - Paragraph::size_type pos, + lyx::pos_type pos, bool boundary = false) const; /// void setCursorIntern(BufferView *, Paragraph * par, - Paragraph::size_type pos, + lyx::pos_type pos, bool setfont = true, bool boundary = false) const; /// + float getCursorX(BufferView *, Row *, lyx::pos_type pos, + lyx::pos_type last, bool boundary) const; + /// void setCurrentFont(BufferView *) const; /// bool isBoundary(Buffer const *, Paragraph * par, - Paragraph::size_type pos) const; + lyx::pos_type pos) const; /// bool isBoundary(Buffer const *, Paragraph * par, - Paragraph::size_type pos, + lyx::pos_type pos, LyXFont const & font) const; /// @@ -320,9 +339,9 @@ public: void setCursorFromCoordinates(BufferView *, LyXCursor &, int x, int y) const; /// - void cursorUp(BufferView *) const; + void cursorUp(BufferView *, bool selecting = false) const; /// - void cursorDown(BufferView *) const; + void cursorDown(BufferView *, bool selecting = false) const; /// void cursorLeft(BufferView *, bool internal = true) const; /// @@ -358,7 +377,7 @@ public: /// void deleteLineForward(BufferView *); /// - bool selectWordWhenUnderCursor(BufferView *, + bool selectWordWhenUnderCursor(BufferView *, word_location const); /// enum TextCase { @@ -378,7 +397,7 @@ public: LyXText::TextCase action); /// void transposeChars(BufferView &); - + /** returns a printed row in a pixmap. The y value is needed to decide, wether it is selected text or not. This is a strange solution but faster. @@ -386,10 +405,10 @@ public: void getVisibleRow(BufferView *, int y_offset, int x_offset, Row * row_ptr, int y, bool cleared=false); - /// + /// void toggleInset(BufferView *); /// - void cutSelection(BufferView *, bool = true); + void cutSelection(BufferView *, bool doclear = true, bool realcut = true); /// void copySelection(BufferView *); /// @@ -401,16 +420,17 @@ public: /** the DTP switches for paragraphs. LyX will store the top settings always in the first physical paragraph, the bottom settings in the - last. When a paragraph is broken, the top settings rest, the bottom + last. When a paragraph is broken, the top settings rest, the bottom settings are given to the new one. So I can make shure, they do not duplicate themself (and you cannnot make dirty things with them! ) - */ + */ void setParagraph(BufferView *, bool line_top, bool line_bottom, bool pagebreak_top, bool pagebreak_bottom, VSpace const & space_top, VSpace const & space_bottom, - LyXAlignment align, + Spacing const & spacing, + LyXAlignment align, string labelwidthstring, bool noindent); @@ -437,15 +457,13 @@ public: /// /* for the greater insets */ - + /// returns false if inset wasn't found bool updateInset(BufferView *, Inset *); /// - void checkParagraph(BufferView *, Paragraph * par, - Paragraph::size_type pos); + void checkParagraph(BufferView *, Paragraph * par, lyx::pos_type pos); /// - int numberOfCell(Paragraph * par, - Paragraph::size_type pos) const; + int numberOfCell(Paragraph * par, lyx::pos_type pos) const; /// void removeTableRow(LyXCursor & cursor) const; /// @@ -455,11 +473,13 @@ public: /// int workWidth(BufferView *) const; /// + int workWidth(BufferView *, Inset * inset) const; + /// void computeBidiTables(Buffer const *, Row * row) const; /// Maps positions in the visual string to positions in logical string. inline - Paragraph::size_type log2vis(Paragraph::size_type pos) const { + lyx::pos_type log2vis(lyx::pos_type pos) const { if (bidi_start == -1) return pos; else @@ -468,7 +488,7 @@ public: /// Maps positions in the logical string to positions in visual string. inline - Paragraph::size_type vis2log(Paragraph::size_type pos) const { + lyx::pos_type vis2log(lyx::pos_type pos) const { if (bidi_start == -1) return pos; else @@ -476,21 +496,22 @@ public: } /// inline - Paragraph::size_type bidi_level(Paragraph::size_type pos) const { + lyx::pos_type bidi_level(lyx::pos_type pos) const { if (bidi_start == -1) return 0; else return bidi_levels[pos-bidi_start]; - } + } /// inline - bool bidi_InRange(Paragraph::size_type pos) const { + bool bidi_InRange(lyx::pos_type pos) const { return bidi_start == -1 || (bidi_start <= pos && pos <= bidi_end); } private: /// mutable Row * firstrow; + /// mutable Row * lastrow; @@ -498,12 +519,10 @@ private: Asger has learned that this should be a buffer-property instead Lgb has learned that 'char' is a lousy type for non-characters */ - LyXTextClass::size_type copylayouttype; - + string copylayouttype; /** inserts a new row behind the specified row, increments the touched counters */ - void insertRow(Row * row, Paragraph * par, - Paragraph::size_type pos) const; + void insertRow(Row * row, Paragraph * par, lyx::pos_type pos) const; /** removes the row and reset the touched counters */ void removeRow(Row * row) const; @@ -517,7 +536,7 @@ private: /** appends the implizit specified paragraph behind the specified row, * start at the implizit given position */ void appendParagraph(BufferView *, Row * row) const; - + /// void breakAgain(BufferView *, Row * row) const; /// @@ -526,59 +545,136 @@ private: void setHeightOfRow(BufferView *, Row * row_ptr) const; /** this calculates the specified parameters. needed when setting - * the cursor and when creating a visible row */ + * the cursor and when creating a visible row */ void prepareToPrint(BufferView *, Row * row, float & x, - float & fill_separator, + float & fill_separator, float & fill_hfill, float & fill_label_hfill, bool bidi = true) const; - /// - void deleteEmptyParagraphMechanism(BufferView *, + /// A struct used for drawing routines + struct DrawRowParams { + // the bufferview + BufferView * bv; + // the row + Row * row; + // the painter to use + Painter * pain; + // has the background been cleared + bool cleared; + /// x offset (e.g. for insets) + int xo; + /// y offset (e.g. for insets) + int yo; + /// FIXME + float x; + /// FIXME + int y; + /// the inset/view full width + int width; + /// hfill size + float hfill; + /// label hfill size + float label_hfill; + /// fill separator size + float separator; + }; + + /// paint the background + bool paintRowBackground(DrawRowParams & p); + + /// paint the selection background + void paintRowSelection(DrawRowParams & p); + + /// paint appendix marker + void paintRowAppendix(DrawRowParams & p); + + /// paint page break marker. Returns its height. + int paintPageBreak(string const & label, int y, DrawRowParams & p); + + /// paint env depth bar + void paintRowDepthBar(DrawRowParams & p); + + /// get the on-screen size of the length marker + int getLengthMarkerHeight(BufferView * bv, VSpace const & vsp) const; + + /// paint an added space marker + int drawLengthMarker(DrawRowParams & p, string const & str, + VSpace const & vsp, int start); + + /// paint a first row in a paragraph + void paintFirstRow(DrawRowParams & p); + + /// paint a last row in a paragraph + void paintLastRow(DrawRowParams & p); + + /// paint text + void paintRowText(DrawRowParams & p); + + // fix the cursor `cur' after a characters has been deleted at `where' + // position. Called by deleteEmptyParagraphMechanism + void fixCursorAfterDelete(BufferView * bview, + LyXCursor & cur, + LyXCursor const & where) const; + + /// delete double space (false) or empty paragraphs (true) around old_cursor + bool deleteEmptyParagraphMechanism(BufferView *, LyXCursor const & old_cursor) const; public: /** Updates all counters starting BEHIND the row. Changed paragraphs - * with a dynamic left margin will be rebroken. */ + * with a dynamic left margin will be rebroken. */ void updateCounters(BufferView *, Row * row) const; private: /// void setCounter(Buffer const *, Paragraph * par) const; - + /* * some low level functions */ - + /// int singleWidth(BufferView *, Paragraph * par, - Paragraph::size_type pos) const; + lyx::pos_type pos) const; /// int singleWidth(BufferView *, Paragraph * par, - Paragraph::size_type pos, char c) const; - /// - void draw(BufferView *, Row const * row, - Paragraph::size_type & pos, - int offset, float & x, bool cleared); + lyx::pos_type pos, char c) const; + + + /// draw normal chars + void drawChars(DrawRowParams & p, lyx::pos_type & vpos, + bool hebrew, bool arabic); + /// draw from arabic composed char + void drawArabicComposeChar(DrawRowParams & p, lyx::pos_type & vpos); + /// draw from hebrew composed char + void drawHebrewComposeChar(DrawRowParams & p, lyx::pos_type & vpos); + /// draw a mark for foreign language, starting from orig_x + void drawForeignMark(DrawRowParams & p, float const orig_x, LyXFont const & orig_font); + /// draw an inset + bool drawInset(DrawRowParams & p, lyx::pos_type const pos); + /// draw new line marker + void drawNewline(DrawRowParams & p, lyx::pos_type const pos); + /// draw text + bool draw(DrawRowParams & p, lyx::pos_type & vpos); /// get the next breakpoint in a given paragraph - Paragraph::size_type nextBreakPoint(BufferView *, Row const * row, - int width) const; + lyx::pos_type nextBreakPoint(BufferView *, Row const * row, int width) const; /// returns the minimum space a row needs on the screen in pixel int fill(BufferView *, Row * row, int workwidth) const; - + /** returns the minimum space a manual label needs on the - screen in pixel */ + screen in pixel */ int labelFill(BufferView *, Row const * row) const; /// - Paragraph::size_type - beginningOfMainBody(Buffer const *, Paragraph const * par) const; - - /** Returns the left beginning of the text. - This information cannot be taken from the layouts-objekt, because - in LaTeX the beginning of the text fits in some cases - (for example sections) exactly the label-width. - */ + lyx::pos_type beginningOfMainBody(Buffer const *, Paragraph const * par) const; + + /** + * Returns the left beginning of the text. + * This information cannot be taken from the layout object, because + * in LaTeX the beginning of the text fits in some cases + * (for example sections) exactly the label-width. + */ int leftMargin(BufferView *, Row const * row) const; /// int rightMargin(Buffer const *, Row const * row) const; @@ -587,7 +683,7 @@ private: /** returns the number of separators in the specified row. The separator on the very last column doesnt count - */ + */ int numberOfSeparators(Buffer const *, Row const * row) const; /** returns the number of hfills in the specified row. The @@ -596,46 +692,46 @@ private: more usefull than not to ignore! */ int numberOfHfills(Buffer const *, Row const * row) const; - + /// like NumberOfHfills, but only those in the manual label! int numberOfLabelHfills(Buffer const *, Row const * row) const; - /** returns true, if a expansion is needed. Rules are given by + /** returns true, if a expansion is needed. Rules are given by LaTeX */ bool hfillExpansion(Buffer const *, Row const * row_ptr, - Paragraph::size_type pos) const; - /// + lyx::pos_type pos) const; + /// LColor::color backgroundColor(); /// - mutable std::vector log2vis_list; + mutable std::vector log2vis_list; /// - mutable std::vector vis2log_list; + mutable std::vector vis2log_list; /// - mutable std::vector bidi_levels; + mutable std::vector bidi_levels; /// - mutable Paragraph::size_type bidi_start; + mutable lyx::pos_type bidi_start; /// - mutable Paragraph::size_type bidi_end; + mutable lyx::pos_type bidi_end; /// mutable bool bidi_same_direction; /// unsigned char transformChar(unsigned char c, Paragraph * par, - Paragraph::size_type pos) const; + lyx::pos_type pos) const; - /** returns the paragraph position of the last character in the + /** returns the paragraph position of the last character in the specified row */ - Paragraph::size_type rowLast(Row const * row) const; + lyx::pos_type rowLast(Row const * row) const; /// - Paragraph::size_type rowLastPrintable(Row const * row) const; + lyx::pos_type rowLastPrintable(Row const * row) const; /// void charInserted(); @@ -645,28 +741,9 @@ public: /// Paragraph * ownerParagraph() const; // - Paragraph * ownerParagraph(Paragraph *) const; + void ownerParagraph(Paragraph *) const; // set it searching first for the right owner using the paragraph id - Paragraph * ownerParagraph(int id, Paragraph *) const; + void ownerParagraph(int id, Paragraph *) const; }; - -/* returns a pointer to the row near the specified y-coordinate - * (relative to the whole text). y is set to the real beginning - * of this row */ -inline -Row * LyXText::getRowNearY(int & y) const -{ - // If possible we should optimize this method. (Lgb) - Row * tmprow = firstrow; - int tmpy = 0; - - while (tmprow->next() && tmpy + tmprow->height() <= y) { - tmpy += tmprow->height(); - tmprow = tmprow->next(); - } - - y = tmpy; // return the real y - return tmprow; -} #endif