X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxtext.h;h=646f736ffa41fe01a6f04a3917197b0633064486;hb=98c966c64594611e469313314abd1e59524adb4a;hp=c500764c22c0ad158aaae2b23f4b9f08c2847875;hpb=82fa210ea8d38d51aafb131f10d843e27e056429;p=lyx.git diff --git a/src/lyxtext.h b/src/lyxtext.h index c500764c22..646f736ffa 100644 --- a/src/lyxtext.h +++ b/src/lyxtext.h @@ -1,11 +1,11 @@ // -*- C++ -*- /* This file is part of - * ====================================================== - * + * ====================================================== + * * LyX, The Document Processor - * + * * Copyright 1995 Matthias Ettrich - * Copyright 1995-2000 The LyX Team. + * Copyright 1995-2001 The LyX Team. * * ====================================================== */ @@ -17,15 +17,20 @@ #endif #include "lyxfont.h" -#include "undo.h" #include "lyxcursor.h" -#include "lyxparagraph.h" #include "layout.h" +#include "LColor.h" +#include "insets/inset.h" class Buffer; class BufferParams; -class Row; class BufferView; +class InsetText; +class Paragraph; +class Row; +class Spacing; +class UpdatableInset; +class VSpace; /** @@ -36,123 +41,150 @@ public: /// enum text_status { /// - UNCHANGED, + UNCHANGED = 0, + /// + CHANGED_IN_DRAW = 1, /// - NEED_MORE_REFRESH, + NEED_VERY_LITTLE_REFRESH = 2, /// - NEED_VERY_LITTLE_REFRESH + NEED_MORE_REFRESH = 3 }; - - enum Letter_Form { - FORM_ISOLATED, - FORM_INITIAL, - FORM_MEDIAL, - FORM_FINAL + /// + enum word_location { + // the word around the cursor, only if the cursor is + //not at a boundary + WHOLE_WORD_STRICT, + // the word around the cursor + WHOLE_WORD, + /// the word begining from the cursor position + PARTIAL_WORD, + /// the word around the cursor or before the cursor + PREVIOUS_WORD, + /// the next word (not yet used) + NEXT_WORD }; /// Constructor - LyXText(BufferView *, int paperwidth, Buffer *); - + LyXText(BufferView *); + /// + LyXText(InsetText *); + /// Destructor ~LyXText(); - /// points to Buffer.params - //BufferParams * bparams; - /// points to Buffer - Buffer * buffer; + void init(BufferView *, bool reinit = false); /// mutable int number_of_rows; /// - mutable long height; + mutable int height; + /// + mutable unsigned int width; /// the current font settings mutable LyXFont current_font; /// the current font mutable LyXFont real_current_font; + /// first visible pixel-row is set from LyXScreen!!! + // unsigned is wrong here for text-insets! + int first_y; + /// + BufferView * bv_owner; + /// + InsetText * inset_owner; + /// + UpdatableInset * the_locking_inset; /// - void owner(BufferView *); - + int getRealCursorX(BufferView *) const; + /// + LyXFont const getFont(Buffer const *, Paragraph * par, + lyx::pos_type pos) const; /// - LyXFont GetFont(LyXParagraph * par, - LyXParagraph::size_type pos) const; + LyXFont const getLayoutFont(Buffer const *, Paragraph * par) const; /// - void SetCharFont(LyXParagraph * par, - LyXParagraph::size_type pos, - LyXFont const & font); - /// returns a pointer to the very first LyXParagraph - LyXParagraph * FirstParagraph() const; - + LyXFont const getLabelFont(Buffer const *, Paragraph * par) const; + /// + void setCharFont(Buffer const *, Paragraph * par, + lyx::pos_type pos, LyXFont const & font); + void setCharFont(BufferView *, Paragraph * par, + lyx::pos_type pos, LyXFont const & font, bool toggleall); + /// what you expect when pressing at cursor position - void BreakParagraph(char keep_layout = 0); + void breakParagraph(BufferView *, char keep_layout = 0); /** set layout over selection and make a total rebreak of those paragraphs */ - void SetLayout(LyXTextClass::size_type layout); - + Paragraph * setLayout(BufferView *, LyXCursor & actual_cursor, + LyXCursor & selection_start, + LyXCursor & selection_end, + string const & layout); + /// + void setLayout(BufferView *, string const & layout); + /// used in setlayout - void MakeFontEntriesLayoutSpecific(LyXParagraph * par); - - /** increment depth over selection and make a total rebreak of those + void makeFontEntriesLayoutSpecific(Buffer const *, Paragraph * par); + + /** increment depth over selection and make a total rebreak of those paragraphs */ - void IncDepth(); - - /** decrement depth over selection and make a total rebreak of those + void incDepth(BufferView *); + + /** decrement depth over selection and make a total rebreak of those paragraphs */ - void DecDepth(); + 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(LyXFont const & font, bool toggleall = 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(LyXCursor const & cursor, - LyXParagraph const * end_par) const; + void redoParagraphs(BufferView *, LyXCursor const & cursor, + Paragraph const * end_par) const; /// - void RedoParagraph() const; - + void redoParagraph(BufferView *) const; + + /// + void toggleFree(BufferView *, LyXFont const &, bool toggleall = false); + /// - void ToggleFree(LyXFont const & font, 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(LyXCursor const & cursor); - - /** forces the redrawing of a paragraph. Needed when manipulating a + void redoHeightOfParagraph(BufferView *, LyXCursor const & cursor); + + /** forces the redrawing of a paragraph. Needed when manipulating a right address box - */ - void RedoDrawingOfParagraph(LyXCursor const & cursor); - - /** insert a character, moves all the following breaks in the + */ + void redoDrawingOfParagraph(BufferView *, LyXCursor const & cursor); + + /** insert a character, moves all the following breaks in the same Paragraph one to the right and make a little rebreak */ - void InsertChar(char c); + void insertChar(BufferView *, char c); /// - void InsertInset(Inset * inset); - + void insertInset(BufferView *, Inset * inset); + /** Completes the insertion with a full rebreak. Returns true if something was broken. */ - bool FullRebreak(); + bool fullRebreak(BufferView *); /// - LyXParagraph::footnote_flag GetFootnoteFlag(int row); - /// - Row * need_break_row; + mutable Row * need_break_row; /// - mutable long refresh_y; + mutable int refresh_y; /// int refresh_height; /// @@ -162,33 +194,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: /** wether the screen needs a refresh, starting with refresh_y */ - mutable text_status status; - + 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(long & y) const; - - /** returns the column near the specified x-coordinate of the row + */ + Row * getRowNearY(int & y) const; + + /** returns the column near the specified x-coordinate of the row x is set to the real beginning of this column - */ - int GetColumnNearX(Row * row, int & x) 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(LyXParagraph * par, - LyXParagraph::size_type pos, long & y) const; + Row * getRow(Paragraph * par, + 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; - + 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 @@ -198,460 +244,500 @@ 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; - - /* the selection cursor */ - /// - mutable bool selection; - /// - mutable bool mark_set; + mutable LyXCursor cursor; // actual cursor position + + /** The structure that keeps track of the selections set. */ + struct Selection { + Selection() + : set_(false), mark_(false) + {} + bool set() const { + return set_; + } + void set(bool s) { + set_ = s; + } + bool mark() const { + return mark_; + } + void mark(bool m) { + mark_ = m; + } + 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; + + /// need the selection cursor: + void setSelection(BufferView *); /// - mutable LyXCursor sel_cursor; + void clearSelection() const; /// - LyXCursor sel_start_cursor; + string const selectionAsString(Buffer const *, bool label) const; + + /// select the word we need depending on word_location + 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. + With SelectSelectedWord can this be highlighted really + */ + string const selectNextWordToSpellcheck(BufferView *, float & value) const; /// - mutable LyXCursor sel_end_cursor; - /// needed for the toggling - LyXCursor last_sel_cursor; + void selectSelectedWord(BufferView *); + /// 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; /// - LyXCursor toggle_cursor; + void setCursor(BufferView *, LyXCursor &, Paragraph * par, + lyx::pos_type pos, + bool boundary = false) const; /// - LyXCursor toggle_end_cursor; - - /// need the selection cursor: - void SetSelection(); + void setCursorIntern(BufferView *, Paragraph * par, + lyx::pos_type pos, + bool setfont = true, + bool boundary = false) const; /// - void ClearSelection() const; + void setCurrentFont(BufferView *) const; - /// just selects the word the cursor is in - void SelectWord(); + /// + bool isBoundary(Buffer const *, Paragraph * par, + lyx::pos_type pos) const; + /// + bool isBoundary(Buffer const *, Paragraph * par, + lyx::pos_type pos, + LyXFont const & font) 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. - With SelectSelectedWord can this be highlighted really - */ - char * SelectNextWord(float & value); /// - void SelectSelectedWord(); + void setCursorFromCoordinates(BufferView *, int x, int y) const; /// - void SetCursor(LyXParagraph * par, - LyXParagraph::size_type pos, - bool setfont = true) const; - void SetCursor(LyXCursor &, LyXParagraph * par, - LyXParagraph::size_type pos) const; + void setCursorFromCoordinates(BufferView *, LyXCursor &, + int x, int y) const; /// - void SetCursorIntern(LyXParagraph * par, - LyXParagraph::size_type pos, - bool setfont = true) const; + void cursorUp(BufferView *) const; /// - void SetCursorFromCoordinates(int x, long y) const; - void SetCursorFromCoordinates(LyXCursor &, int x, long y) const; + void cursorDown(BufferView *) const; /// - void CursorUp() const; + void cursorLeft(BufferView *, bool internal = true) const; /// - void CursorDown() const; + void cursorRight(BufferView *, bool internal = true) const; /// - void CursorLeft() const; + void cursorLeftOneWord(BufferView *) const; /// - void CursorRight() const; + void cursorLeftOneWord(LyXCursor &) const; /// - void CursorLeftOneWord() const; + void cursorRightOneWord(BufferView *) const; /// - void CursorRightOneWord() const; + void cursorUpParagraph(BufferView *) const; /// - void CursorUpParagraph() const; + void cursorDownParagraph(BufferView *) const; /// - void CursorDownParagraph() const; + void cursorHome(BufferView *) const; /// - void CursorHome() const; + void cursorEnd(BufferView *) const; /// - void CursorEnd() const; + void cursorTab(BufferView *) const; /// - void CursorTab() const; + void cursorTop(BufferView *) const; /// - void CursorTop() const; + void cursorBottom(BufferView *) const; /// - void CursorBottom() const; + void Delete(BufferView *); /// - void Delete(); + void backspace(BufferView *); /// - void Backspace(); + void deleteWordForward(BufferView *); /// - void DeleteWordForward(); + void deleteWordBackward(BufferView *); /// - void DeleteWordBackward(); + void deleteLineForward(BufferView *); /// - void DeleteLineForward(); + bool selectWordWhenUnderCursor(BufferView *, + word_location const); /// - bool SelectWordWhenUnderCursor(); - enum TextCase { + /// text_lowercase = 0, + /// text_capitalization = 1, + /// text_uppercase = 2 }; /// Change the case of the word at cursor position. - void ChangeWordCase(TextCase action); + void changeCase(BufferView *, TextCase action); + /// + void changeRegionCase(BufferView * bview, + LyXCursor const & from, + LyXCursor const & to, + 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. */ - void GetVisibleRow(int offset, Row * row_ptr, long y); + void getVisibleRow(BufferView *, int y_offset, int x_offset, + Row * row_ptr, int y, bool cleared=false); - /* footnotes: */ /// - void ToggleFootnote(); + void toggleInset(BufferView *); /// - void OpenStuff(); + void cutSelection(BufferView *, bool doclear = true, bool realcut = true); /// - void OpenFootnotes(); + void copySelection(BufferView *); /// - void OpenFootnote(); - /// - void CloseFootnotes(); - /// - void CloseFootnote(); - - /** turn the selection into a new environment. If there is no - selection, create an empty environment - */ - void InsertFootnoteEnvironment(LyXParagraph::footnote_kind kind); - /// - void MeltFootnoteEnvironment(); - /// - void CutSelection(bool = true); - /// - void CopySelection(); - /// - void PasteSelection(); + void pasteSelection(BufferView *); /// void copyEnvironmentType(); /// - void pasteEnvironmentType(); - /// - void InsertFootnote(); - /// - void InsertMarginpar(); - /// - void InsertFigure(); - /// - void InsertTabular(); + void pasteEnvironmentType(BufferView *); /** 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(bool line_top, bool line_bottom, + */ + 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); - void SetParagraphExtraOpt(int type, - char const * width, - char const * widthp, - int alignment, bool hfill, - bool start_minipage); /* these things are for search and replace */ - /** returns true if the specified string is at the specified - position - */ - bool IsStringInText(LyXParagraph * par, - LyXParagraph::size_type pos, - char const * str) const; /** sets the selection over the number of characters of string, no check!! */ - void SetSelectionOverString(char const * str); + void setSelectionOverString(BufferView *, string const & str); /** simple replacing. The font of the first selected character is used */ - void ReplaceSelectionWithString(char const * str); - - /** if the string can be found: return true and set the cursor to - the new position */ - bool SearchForward(char const * str) const; - bool SearchBackward(char const * str) const; + void replaceSelectionWithString(BufferView *, string const & str); /// needed to insert the selection - void InsertStringA(string const & str); + void insertStringAsLines(BufferView *, string const & str); /// needed to insert the selection - void InsertStringB(string const & str); - - /// usefull when texing from within LyX - bool GotoNextError() const; - - /// just another feature :) - bool GotoNextNote() const; + void insertStringAsParagraphs(BufferView *, string const & str); - /* for the greater insets */ - - /// returns 0 if inset wasn't found - int UpdateInset(Inset * inset); - /// - void CheckParagraph(LyXParagraph * par, - LyXParagraph::size_type pos); + /// Find next inset of some specified type. + bool gotoNextInset(BufferView *, std::vector const & codes, + string const & contents = string()) const; /// - int NumberOfCell(LyXParagraph * par, - LyXParagraph::size_type pos) const; - /* table stuff -- begin*/ - /** all table features of the text-class are put together in - this function. Possible values of feature are defined in table.h - */ - void TableFeatures(int feature, string const & val) const; - /// - void TableFeatures(int feature) const; + /* for the greater insets */ - /** pos points at the beginning of the next cell (if there is one) - */ - int WidthOfCell(LyXParagraph * par, - LyXParagraph::size_type & pos) const; + /// returns false if inset wasn't found + bool updateInset(BufferView *, Inset *); /// - void CheckParagraphInTable(LyXParagraph * par, - LyXParagraph::size_type pos); + void checkParagraph(BufferView *, Paragraph * par, lyx::pos_type pos); /// - void InsertCharInTable(char c); + int numberOfCell(Paragraph * par, lyx::pos_type pos) const; /// - void BackspaceInTable(); + void removeTableRow(LyXCursor & cursor) const; /// - bool HitInTable(Row * row, int x) const; + bool isEmptyTableCell() const; /// - bool MouseHitInTable(int x, long y) const; - /* table stuff -- end*/ - /// - LyXParagraph * GetParFromID(int id); - - // undo functions - /// returns false if no undo possible - bool TextUndo(); - /// returns false if no redo possible - bool TextRedo(); - /// used by TextUndo/TextRedo - bool TextHandleUndo(Undo * undo); - /// makes sure the next operation will be stored - void FinishUndo(); - /// this is dangerous and for internal use only - void FreezeUndo(); - /// this is dangerous and for internal use only - void UnFreezeUndo(); - /// the flag used by FinishUndo(); - mutable bool undo_finished; - /// a flag - bool undo_frozen; + void toggleAppendix(BufferView *); /// - void SetUndo(Undo::undo_kind kind, - LyXParagraph const * before, - LyXParagraph const * end) const; + int workWidth(BufferView *) const; /// - void SetRedo(Undo::undo_kind kind, - LyXParagraph const * before, - LyXParagraph const * end); + int workWidth(BufferView *, Inset * inset) const; /// - Undo * CreateUndo(Undo::undo_kind kind, - LyXParagraph const * before, - LyXParagraph const * end) const; - /// for external use in lyx_cb.C - void SetCursorParUndo(); - /// - void CursorLeftIntern() const; - /// - void CursorRightIntern() const; - /// - void RemoveTableRow(LyXCursor * cursor) const; - /// - bool IsEmptyTableCell() const; + void computeBidiTables(Buffer const *, Row * row) const; + + /// Maps positions in the visual string to positions in logical string. + inline + lyx::pos_type log2vis(lyx::pos_type pos) const { + if (bidi_start == -1) + return pos; + else + return log2vis_list[pos-bidi_start]; + } + + /// Maps positions in the logical string to positions in visual string. + inline + lyx::pos_type vis2log(lyx::pos_type pos) const { + if (bidi_start == -1) + return pos; + else + return vis2log_list[pos-bidi_start]; + } /// - void toggleAppendix(); + inline + lyx::pos_type bidi_level(lyx::pos_type pos) const { + if (bidi_start == -1) + return 0; + else + return bidi_levels[pos-bidi_start]; + } /// - unsigned short paperWidth() const { return paperwidth; } + inline + bool bidi_InRange(lyx::pos_type pos) const { + return bidi_start == -1 || + (bidi_start <= pos && pos <= bidi_end); + } private: - /// - BufferView * owner_; - - /// width of the paper - unsigned short paperwidth; - /// mutable Row * firstrow; + /// mutable Row * lastrow; - /** Copybuffer for copy environment type + /** Copybuffer for copy environment type. 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, LyXParagraph * par, - LyXParagraph::size_type pos) const; + the touched counters */ + void insertRow(Row * row, Paragraph * par, lyx::pos_type pos) const; /** removes the row and reset the touched counters */ - void RemoveRow(Row * row) const; + void removeRow(Row * row) const; /** remove all following rows of the paragraph of the specified row. */ - void RemoveParagraph(Row * row) const; + void removeParagraph(Row * row) const; /** insert the specified paragraph behind the specified row */ - void InsertParagraph(LyXParagraph * par, Row * row) const; + void insertParagraph(BufferView *, + Paragraph * par, Row * row) const; /** appends the implizit specified paragraph behind the specified row, * start at the implizit given position */ - void AppendParagraph(Row * row) const; - + void appendParagraph(BufferView *, Row * row) const; + /// - void BreakAgain(Row * row) const; + void breakAgain(BufferView *, Row * row) const; /// - void BreakAgainOneRow(Row * row); + void breakAgainOneRow(BufferView *, Row * row); /// Calculate and set the height of the row - void SetHeightOfRow(Row * row_ptr) const; + void setHeightOfRow(BufferView *, Row * row_ptr) const; /** this calculates the specified parameters. needed when setting - * the cursor and when creating a visible row */ - void PrepareToPrint(Row * row, float & x, - float & fill_separator, + * the cursor and when creating a visible row */ + void prepareToPrint(BufferView *, Row * row, float & x, + float & fill_separator, float & fill_hfill, float & fill_label_hfill, bool bidi = true) const; - /// - void DeleteEmptyParagraphMechanism(LyXCursor const & old_cursor) const; + /// 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 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. */ - void UpdateCounters(Row * row) const; + * with a dynamic left margin will be rebroken. */ + void updateCounters(BufferView *, Row * row) const; +private: /// - void SetCounter(LyXParagraph * par) const; - + void setCounter(Buffer const *, Paragraph * par) const; + /* * some low level functions */ - - /// - int SingleWidth(LyXParagraph * par, - LyXParagraph::size_type pos) const; + /// - int SingleWidth(LyXParagraph * par, - LyXParagraph::size_type pos, char c) const; + int singleWidth(BufferView *, Paragraph * par, + lyx::pos_type pos) const; /// - void draw(Row const * row, - LyXParagraph::size_type & pos, - int offset, float & x); + int singleWidth(BufferView *, Paragraph * par, + 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 + void drawInset(DrawRowParams & p, lyx::pos_type const pos); + /// draw new line marker + void drawNewline(DrawRowParams & p, lyx::pos_type const pos); + /// draw text + void draw(DrawRowParams & p, lyx::pos_type & vpos); /// get the next breakpoint in a given paragraph - LyXParagraph::size_type NextBreakPoint(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(Row const * row, int paperwidth) const; - + int fill(BufferView *, Row * row, int workwidth) const; + /** returns the minimum space a manual label needs on the - screen in pixel */ - int LabelFill(Row const * row) const; + screen in pixel */ + int labelFill(BufferView *, Row const * row) const; /// - LyXParagraph::size_type BeginningOfMainBody(LyXParagraph * par) const; - + lyx::pos_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. */ - int LeftMargin(Row const * row) const; + int leftMargin(BufferView *, Row const * row) const; /// - int RightMargin(Row const * row) const; + int rightMargin(Buffer const *, Row const * row) const; /// - int LabelEnd (Row const * row) const; + int labelEnd (BufferView *, Row const * row) const; /** returns the number of separators in the specified row. The separator on the very last column doesnt count - */ - int NumberOfSeparators(Row const * row) const; + */ + int numberOfSeparators(Buffer const *, Row const * row) const; /** returns the number of hfills in the specified row. The LyX-Hfill is a LaTeX \hfill so that the hfills at the beginning and at the end were ignored. This is {\em MUCH} more usefull than not to ignore! */ - int NumberOfHfills(Row const * row) const; - + int numberOfHfills(Buffer const *, Row const * row) const; + /// like NumberOfHfills, but only those in the manual label! - int NumberOfLabelHfills(Row const * row) const; - /** returns true, if a expansion is needed. Rules are given by + int numberOfLabelHfills(Buffer const *, Row const * row) const; + /** returns true, if a expansion is needed. Rules are given by LaTeX */ - bool HfillExpansion(Row const * row_ptr, - LyXParagraph::size_type pos) const; - - + bool hfillExpansion(Buffer const *, Row const * row_ptr, + lyx::pos_type pos) const; /// - mutable std::vector log2vis_list; + LColor::color backgroundColor(); - /// - mutable std::vector vis2log_list; /// - mutable std::vector bidi_levels; + mutable std::vector log2vis_list; /// - mutable LyXParagraph::size_type bidi_start; + mutable std::vector vis2log_list; /// - mutable bool bidi_same_direction; + mutable std::vector bidi_levels; /// - void ComputeBidiTables(Row *row) const; + mutable lyx::pos_type bidi_start; - /// Maps positions in the visual string to positions in logical string. - inline - LyXParagraph::size_type log2vis(LyXParagraph::size_type pos) const { - if (bidi_start == -1) - return pos; - else - return log2vis_list[pos-bidi_start]; - } - - /// Maps positions in the logical string to positions in visual string. - inline - LyXParagraph::size_type vis2log(LyXParagraph::size_type pos) const { - if (bidi_start == -1) - return pos; - else - return vis2log_list[pos-bidi_start]; - } - - inline - int bidi_level(LyXParagraph::size_type pos) const { - if (bidi_start == -1) - return 0; - else - return bidi_levels[pos-bidi_start]; - } + /// + mutable lyx::pos_type bidi_end; /// - unsigned char TransformChar(unsigned char c, Letter_Form form) const; + mutable bool bidi_same_direction; /// - unsigned char TransformChar(unsigned char c, LyXParagraph * par, - LyXParagraph::size_type pos) const; + unsigned char transformChar(unsigned char c, Paragraph * par, + 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 */ - LyXParagraph::size_type RowLast(Row const * row) const; + lyx::pos_type rowLast(Row const * row) const; /// - LyXParagraph::size_type RowLastPrintable(Row const * row) const; + lyx::pos_type rowLastPrintable(Row const * row) const; /// void charInserted(); +public: + // + // special owner functions + /// + Paragraph * ownerParagraph() const; + // + void ownerParagraph(Paragraph *) const; + // set it searching first for the right owner using the paragraph id + void ownerParagraph(int id, Paragraph *) const; }; #endif