From 38dcb5a463e0b41e220c79ee85b5fd9cd2318c33 Mon Sep 17 00:00:00 2001 From: Matthias Melcher Date: Thu, 4 Nov 2010 21:53:56 +0000 Subject: [PATCH] Starting to rework Fl_Text_Display from scratch to make wrapping work correctly. Fixed a few issues that made wrapping crash. Using ASCII range only with fixed character sizes should still wrap as expected?! git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3@7794 ea41ed52-d2ee-0310-a9c1-e6b18d33e121 --- FL/Fl_Text_Buffer.H | 14 +- FL/Fl_Text_Display.H | 576 +++++---- src/Fl_Text_Buffer.cxx | 13 +- src/Fl_Text_Display.cxx | 2641 ++++++++++++++++++++------------------- test/editor.cxx | 2 + 5 files changed, 1649 insertions(+), 1597 deletions(-) diff --git a/FL/Fl_Text_Buffer.H b/FL/Fl_Text_Buffer.H index 1b31d14cf..ae9f78d44 100644 --- a/FL/Fl_Text_Buffer.H +++ b/FL/Fl_Text_Buffer.H @@ -39,7 +39,7 @@ ?? "length" is the number of characters in a string ?? "size" is the number of bytes ?? "index" is the position in a string in number of characters - ?? "offset" is the position in a strin in bytes (and must be kept on a charater boundary) + ?? "offset" is the position in a string in bytes (and must be kept on a charater boundary) (there seems to be no standard in Uncode documents, howevere "length" is commonly referencing the number of bytes. Maybe "bytes" and "glyphs" would be the most obvious way to describe sizes?) @@ -154,6 +154,11 @@ typedef void (*Fl_Text_Predelete_Cb)(int pos, int nDeleted, void* cbArg); /** \brief This class manages unicode displayed in one or more Fl_Text_Display widgets. + All text in Fl_Text_Buffermust be encoded in UTF-8. All indices used in the + function calls must be aligned to the start of a UTF-8 sequence. All indices + and pointers returned will be aligned. All functions that return a single + character will return that in an unsiged int in UCS-4 encoding. + The Fl_Text_Buffer class is used by the Fl_Text_Display and Fl_Text_Editor to manage complex text data and is based upon the excellent NEdit text editor engine - see http://www.nedit.org/. @@ -193,7 +198,7 @@ public: /** Replaces the entire contents of the text buffer. - Text must be valid utf8. + \param text Text must be valid utf8. \todo unicode check */ void text(const char* text); @@ -228,12 +233,16 @@ public: /** Convert a byte offset in buffer into a memory address. + \param pos byte offset into buffer + \return byte offset converted to a memory address */ const char *address(int pos) const { return (pos < mGapStart) ? mBuf+pos : mBuf+pos+mGapEnd-mGapStart; } /** Convert a byte offset in buffer into a memory address. + \param pos byte offset into buffer + \return byte offset converted to a memory address */ char *address(int pos) { return (pos < mGapStart) ? mBuf+pos : mBuf+pos+mGapEnd-mGapStart; } @@ -748,6 +757,7 @@ protected: expensive and the length will be required by any caller who will continue on to call redisplay). \p pos must be contiguous with the existing text in the buffer (i.e. not past the end). + \return the number of bytes inserted \todo unicode check */ int insert_(int pos, const char* text); diff --git a/FL/Fl_Text_Display.H b/FL/Fl_Text_Display.H index c033d5221..f6e103a34 100644 --- a/FL/Fl_Text_Display.H +++ b/FL/Fl_Text_Display.H @@ -28,7 +28,7 @@ // /* \file - Fl_Text_Display widget . */ + Fl_Text_Display widget . */ #ifndef FL_TEXT_DISPLAY_H #define FL_TEXT_DISPLAY_H @@ -40,377 +40,405 @@ #include "Fl_Text_Buffer.H" /** - This is the FLTK text display widget. It allows the user to - view multiple lines of text and supports highlighting and - scrolling. The buffer that is displayed in the widget is managed - by the Fl_Text_Buffer - class. -*/ + \brief Rich text display widget. + + This is the FLTK text display widget. It allows the user to view multiple lines + of text and supports highlighting and scrolling. The buffer that is displayed + in the widget is managed by the Fl_Text_Buffer class. A single Text Buffer + can be displayed by multiple Text Displays. + */ class FL_EXPORT Fl_Text_Display: public Fl_Group { - public: +public: /** text display cursor shapes enumeration */ - enum { - NORMAL_CURSOR, CARET_CURSOR, DIM_CURSOR, - BLOCK_CURSOR, HEAVY_CURSOR - }; - + enum { + NORMAL_CURSOR, /**< I-beam */ + CARET_CURSOR, /**< caret under the text */ + DIM_CURSOR, /**< dim I-beam */ + BLOCK_CURSOR, /**< unfille box under the current character */ + HEAVY_CURSOR /**< thick I-beam */ + }; + /** the character position is the left edge of a character wheras the cursor is thought to be between the centers of to consecutive characters. */ - enum { - CURSOR_POS, CHARACTER_POS - }; - - /** - drag types- they match Fl::event_clicks() so that single clicking to - start a collection selects by character, double clicking selects by - word and triple clicking selects by line. - */ - enum { - DRAG_CHAR = 0, DRAG_WORD = 1, DRAG_LINE = 2 - }; - - friend void fl_text_drag_me(int pos, Fl_Text_Display* d); - - typedef void (*Unfinished_Style_Cb)(int, void *); - + enum { + CURSOR_POS, + CHARACTER_POS + }; + /** - style attributes - currently not implemented! + drag types - they match Fl::event_clicks() so that single clicking to + start a collection selects by character, double clicking selects by + word and triple clicking selects by line. */ - enum { - ATTR_NONE = 0, - ATTR_UNDERLINE = 1, - ATTR_HIDDEN = 2 - }; + enum { + DRAG_CHAR = 0, + DRAG_WORD = 1, + DRAG_LINE = 2 + }; + + friend void fl_text_drag_me(int pos, Fl_Text_Display* d); + + typedef void (*Unfinished_Style_Cb)(int, void *); /** This structure associates the color,font,size of a string to draw with an attribute mask matching attr */ - struct Style_Table_Entry { - Fl_Color color; - Fl_Font font; - int size; - unsigned attr; - }; - - Fl_Text_Display(int X, int Y, int W, int H, const char *l = 0); - ~Fl_Text_Display(); - - virtual int handle(int e); - void buffer(Fl_Text_Buffer* buf); + struct Style_Table_Entry { + Fl_Color color; + Fl_Font font; + Fl_Fontsize size; + unsigned attr; + }; + + Fl_Text_Display(int X, int Y, int W, int H, const char *l = 0); + ~Fl_Text_Display(); + + virtual int handle(int e); + + void buffer(Fl_Text_Buffer* buf); /** - Sets or gets the current text buffer associated with the text widget. - Multiple text widgets can be associated with the same text buffer. - */ - void buffer(Fl_Text_Buffer& buf) { buffer(&buf); } - - /** - Gets the current text buffer associated with the text widget. - Multiple text widgets can be associated with the same text buffer. - */ - Fl_Text_Buffer* buffer() const { return mBuffer; } - - void redisplay_range(int start, int end); - void scroll(int topLineNum, int horizOffset); - void insert(const char* text); - void overstrike(const char* text); - void insert_position(int newPos); + Sets the current text buffer associated with the text widget. + Multiple text widgets can be associated with the same text buffer. + \param buf new text buffer + */ + void buffer(Fl_Text_Buffer& buf) { buffer(&buf); } + + /** + Gets the current text buffer associated with the text widget. + Multiple text widgets can be associated with the same text buffer. + \return current text buffer + */ + Fl_Text_Buffer* buffer() const { return mBuffer; } + + void redisplay_range(int start, int end); + void scroll(int topLineNum, int horizOffset); + void insert(const char* text); + void overstrike(const char* text); + void insert_position(int newPos); /** Gets the position of the text insertion cursor for text display + \return insert position index into text buffer */ - int insert_position() const { return mCursorPos; } - - int in_selection(int x, int y) const; - void show_insert_position(); - int move_right(); - int move_left(); - int move_up(); - int move_down(); - int count_lines(int start, int end, bool start_pos_is_line_start) const; - int line_start(int pos) const; - int line_end(int pos, bool start_pos_is_line_start) const; - int skip_lines(int startPos, int nLines, bool startPosIsLineStart); - int rewind_lines(int startPos, int nLines); - void next_word(void); - void previous_word(void); - void show_cursor(int b = 1); + int insert_position() const { return mCursorPos; } + + int in_selection(int x, int y) const; + void show_insert_position(); + + int move_right(); + int move_left(); + int move_up(); + int move_down(); + int count_lines(int start, int end, bool start_pos_is_line_start) const; + int line_start(int pos) const; + int line_end(int pos, bool start_pos_is_line_start) const; + int skip_lines(int startPos, int nLines, bool startPosIsLineStart); + int rewind_lines(int startPos, int nLines); + void next_word(void); + void previous_word(void); + + void show_cursor(int b = 1); /** Hides the text cursor */ - void hide_cursor() { show_cursor(0); } + void hide_cursor() { show_cursor(0); } - void cursor_style(int style); + void cursor_style(int style); /** - Sets or gets the text cursor color. + Gets the text cursor color. + \return cursor color */ - Fl_Color cursor_color() const {return mCursor_color;} + Fl_Color cursor_color() const {return mCursor_color;} /** - Sets or gets the text cursor color. + Sets the text cursor color. + \param n new cursor color */ - void cursor_color(Fl_Color n) {mCursor_color = n;} + void cursor_color(Fl_Color n) {mCursor_color = n;} /** - Sets or gets the width/height of the scrollbars. + Gets the width/height of the scrollbars. + /return width of scrollbars */ - int scrollbar_width() const { return scrollbar_width_; } + int scrollbar_width() const { return scrollbar_width_; } /** - Sets or gets the width/height of the scrollbars. + Sets the width/height of the scrollbars. + \param W width of scrollbars */ - void scrollbar_width(int W) { scrollbar_width_ = W; } + void scrollbar_width(int W) { scrollbar_width_ = W; } /** Gets the scrollbar alignment type + \return scrollbar alignment */ - Fl_Align scrollbar_align() const { return scrollbar_align_; } + Fl_Align scrollbar_align() const { return scrollbar_align_; } /** Sets the scrollbar alignment type + \param a new scrollbar alignment */ - void scrollbar_align(Fl_Align a) { scrollbar_align_ = a; } + void scrollbar_align(Fl_Align a) { scrollbar_align_ = a; } /** Moves the insert position to the beginning of the current word. + \param pos start calculation at this index + \return beginning of the wors */ - int word_start(int pos) const { return buffer()->word_start(pos); } + int word_start(int pos) const { return buffer()->word_start(pos); } - /** - Moves the insert position to the end of the current word. + /** + Moves the insert position to the end of the current word. + \param pos start calculation at this index + \return index of first character after the end of the word */ - int word_end(int pos) const { return buffer()->word_end(pos); } - - - void highlight_data(Fl_Text_Buffer *styleBuffer, - const Style_Table_Entry *styleTable, - int nStyles, char unfinishedStyle, - Unfinished_Style_Cb unfinishedHighlightCB, - void *cbArg); - + int word_end(int pos) const { return buffer()->word_end(pos); } + + + void highlight_data(Fl_Text_Buffer *styleBuffer, + const Style_Table_Entry *styleTable, + int nStyles, char unfinishedStyle, + Unfinished_Style_Cb unfinishedHighlightCB, + void *cbArg); + int position_style(int lineStartPos, int lineLen, int lineIndex) const; /** \todo FIXME : get set methods pointing on shortcut_ have no effects as shortcut_ is unused in this class and derived! + \return the current shortcut key */ - int shortcut() const {return shortcut_;} + int shortcut() const {return shortcut_;} /** \todo FIXME : get set methods pointing on shortcut_ have no effects as shortcut_ is unused in this class and derived! + \param s the new shortcut key */ - void shortcut(int s) {shortcut_ = s;} - + void shortcut(int s) {shortcut_ = s;} + /** - Gets the default font used when drawing text in the widget. + Gets the default font used when drawing text in the widget. + \return current text font face unless overriden by a style */ - Fl_Font textfont() const {return textfont_;} + Fl_Font textfont() const {return textfont_;} /** Sets the default font used when drawing text in the widget. + \param s default text font face */ - void textfont(Fl_Font s) {textfont_ = s;} + void textfont(Fl_Font s) {textfont_ = s;} /** Gets the default size of text in the widget. + \return current text height unless overriden by a style */ - Fl_Fontsize textsize() const {return textsize_;} + Fl_Fontsize textsize() const {return textsize_;} /** Sets the default size of text in the widget. + \param s new text size */ - void textsize(Fl_Fontsize s) {textsize_ = s;} + void textsize(Fl_Fontsize s) {textsize_ = s;} /** Gets the default color of text in the widget. + \return text color unless overriden by a style */ - Fl_Color textcolor() const {return textcolor_;} + Fl_Color textcolor() const {return textcolor_;} /** Sets the default color of text in the widget. + \param n new text color */ - void textcolor(Fl_Color n) {textcolor_ = n;} - - int wrapped_column(int row, int column) const; - int wrapped_row(int row) const; - void wrap_mode(int wrap, int wrap_margin); - - virtual void resize(int X, int Y, int W, int H); - - protected: - // Most (all?) of this stuff should only be called from resize() or - // draw(). - // Anything with "vline" indicates thats it deals with currently - // visible lines. - - virtual void draw(); - void draw_text(int X, int Y, int W, int H); - void draw_range(int start, int end); - void draw_cursor(int, int); - - void draw_string(int style, int x, int y, int toX, const char *string, + void textcolor(Fl_Color n) {textcolor_ = n;} + + int wrapped_column(int row, int column) const; + int wrapped_row(int row) const; + void wrap_mode(int wrap, int wrap_margin); + + virtual void resize(int X, int Y, int W, int H); + +protected: + // Most (all?) of this stuff should only be called from resize() or + // draw(). + // Anything with "vline" indicates thats it deals with currently + // visible lines. + + virtual void draw(); + void draw_text(int X, int Y, int W, int H); + void draw_range(int start, int end); + void draw_cursor(int, int); + + void draw_string(int style, int x, int y, int toX, const char *string, int nChars) const; - - void draw_vline(int visLineNum, int leftClip, int rightClip, - int leftCharIndex, int rightCharIndex); - + + void draw_vline(int visLineNum, int leftClip, int rightClip, + int leftCharIndex, int rightCharIndex); + int find_x(const char *s, int len, int style, int x) const; - enum { DRAW_LINE, FIND_INDEX, GET_WIDTH }; + + enum { + DRAW_LINE, + FIND_INDEX, + GET_WIDTH + }; + int handle_vline(int mode, int lineStart, int lineLen, int leftChar, int rightChar, int topClip, int bottomClip, int leftClip, int rightClip) const; - void draw_line_numbers(bool clearAll); - + void draw_line_numbers(bool clearAll); + void clear_rect(int style, int x, int y, int width, int height) const; - void display_insert(); - - void offset_line_starts(int newTopLineNum); - - void calc_line_starts(int startLine, int endLine); - - void update_line_starts(int pos, int charsInserted, int charsDeleted, - int linesInserted, int linesDeleted, int *scrolled); - - void calc_last_char(); - - int position_to_line( int pos, int* lineNum ) const; - int string_width(const char* string, int length, int style) const; - - static void scroll_timer_cb(void*); - - static void buffer_predelete_cb(int pos, int nDeleted, void* cbArg); - static void buffer_modified_cb(int pos, int nInserted, int nDeleted, - int nRestyled, const char* deletedText, - void* cbArg); - - static void h_scrollbar_cb(Fl_Scrollbar* w, Fl_Text_Display* d); - static void v_scrollbar_cb( Fl_Scrollbar* w, Fl_Text_Display* d); - void update_v_scrollbar(); - void update_h_scrollbar(); - int measure_vline(int visLineNum) const; - int longest_vline() const; - int empty_vlines() const; - int vline_length(int visLineNum) const; - int xy_to_position(int x, int y, int PosType = CHARACTER_POS) const; - - void xy_to_rowcol(int x, int y, int* row, int* column, - int PosType = CHARACTER_POS) const; - - int position_to_xy(int pos, int* x, int* y) const; - void maintain_absolute_top_line_number(int state); - int get_absolute_top_line_number() const; - void absolute_top_line_number(int oldFirstChar); - int maintaining_absolute_top_line_number() const; - void reset_absolute_top_line_number(); - int position_to_linecol(int pos, int* lineNum, int* column) const; - void scroll_(int topLineNum, int horizOffset); - - void extend_range_for_styles(int* start, int* end); - - void find_wrap_range(const char *deletedText, int pos, int nInserted, - int nDeleted, int *modRangeStart, int *modRangeEnd, - int *linesInserted, int *linesDeleted); - void measure_deleted_lines(int pos, int nDeleted); - void wrapped_line_counter(Fl_Text_Buffer *buf, int startPos, int maxPos, - int maxLines, bool startPosIsLineStart, - int styleBufOffset, int *retPos, int *retLines, - int *retLineStart, int *retLineEnd, - bool countLastLineMissingNewLine = true) const; - void find_line_end(int pos, bool start_pos_is_line_start, int *lineEnd, - int *nextLineStart) const; - int measure_proportional_character(const char *s, int colNum, int pos) const; - int wrap_uses_character(int lineEndPos) const; - - int damage_range1_start, damage_range1_end; - int damage_range2_start, damage_range2_end; - int mCursorPos; - int mCursorOn; - int mCursorOldY; /* Y pos. of cursor for blanking */ - int mCursorToHint; /* Tells the buffer modified callback - where to move the cursor, to reduce - the number of redraw calls */ - int mCursorStyle; /* One of enum cursorStyles above */ - int mCursorPreferredCol; /* Column for vert. cursor movement */ - int mNVisibleLines; /* # of visible (displayed) lines */ - int mNBufferLines; /* # of newlines in the buffer */ - Fl_Text_Buffer* mBuffer; /* Contains text to be displayed */ - Fl_Text_Buffer* mStyleBuffer; /* Optional parallel buffer containing - color and font information */ - int mFirstChar, mLastChar; /* Buffer positions of first and last - displayed character (lastChar points - either to a newline or one character - beyond the end of the buffer) */ - int mContinuousWrap; /* Wrap long lines when displaying */ - int mWrapMargin; /* Margin in # of char positions for - wrapping in continuousWrap mode */ - int* mLineStarts; - int mTopLineNum; /* Line number of top displayed line - of file (first line of file is 1) */ - int mAbsTopLineNum; /* In continuous wrap mode, the line - number of the top line if the text - were not wrapped (note that this is - only maintained as needed). */ - int mNeedAbsTopLineNum; /* Externally settable flag to continue - maintaining absTopLineNum even if - it isn't needed for line # display */ - int mHorizOffset; /* Horizontal scroll pos. in pixels */ - int mTopLineNumHint; /* Line number of top displayed line - of file (first line of file is 1) */ - int mHorizOffsetHint; /* Horizontal scroll pos. in pixels */ - int mNStyles; /* Number of entries in styleTable */ - const Style_Table_Entry *mStyleTable; /* Table of fonts and colors for - coloring/syntax-highlighting */ - char mUnfinishedStyle; /* Style buffer entry which triggers - on-the-fly reparsing of region */ - Unfinished_Style_Cb mUnfinishedHighlightCB; /* Callback to parse "unfinished" */ - /* regions */ - void* mHighlightCBArg; /* Arg to unfinishedHighlightCB */ - - int mMaxsize; - - int mSuppressResync; /* Suppress resynchronization of line - starts during buffer updates */ - int mNLinesDeleted; /* Number of lines deleted during - buffer modification (only used - when resynchronization is suppressed) */ - int mModifyingTabDistance; /* Whether tab distance is being - modified */ - - Fl_Color mCursor_color; - - Fl_Scrollbar* mHScrollBar; - Fl_Scrollbar* mVScrollBar; - int scrollbar_width_; - Fl_Align scrollbar_align_; - int dragPos, dragType, dragging; - int display_insert_position_hint; - struct { int x, y, w, h; } text_area; - - int shortcut_; - - Fl_Font textfont_; - Fl_Fontsize textsize_; - Fl_Color textcolor_; - - // The following are not presently used from the original NEdit code, - // but are being put here so that future versions of Fl_Text_Display - // can implement line numbers without breaking binary compatibility. + void display_insert(); + + void offset_line_starts(int newTopLineNum); + + void calc_line_starts(int startLine, int endLine); + + void update_line_starts(int pos, int charsInserted, int charsDeleted, + int linesInserted, int linesDeleted, int *scrolled); + + void calc_last_char(); + + int position_to_line( int pos, int* lineNum ) const; + int string_width(const char* string, int length, int style) const; + + static void scroll_timer_cb(void*); + + static void buffer_predelete_cb(int pos, int nDeleted, void* cbArg); + static void buffer_modified_cb(int pos, int nInserted, int nDeleted, + int nRestyled, const char* deletedText, + void* cbArg); + + static void h_scrollbar_cb(Fl_Scrollbar* w, Fl_Text_Display* d); + static void v_scrollbar_cb( Fl_Scrollbar* w, Fl_Text_Display* d); + void update_v_scrollbar(); + void update_h_scrollbar(); + int measure_vline(int visLineNum) const; + int longest_vline() const; + int empty_vlines() const; + int vline_length(int visLineNum) const; + int xy_to_position(int x, int y, int PosType = CHARACTER_POS) const; + + void xy_to_rowcol(int x, int y, int* row, int* column, + int PosType = CHARACTER_POS) const; + + int position_to_xy(int pos, int* x, int* y) const; + void maintain_absolute_top_line_number(int state); + int get_absolute_top_line_number() const; + void absolute_top_line_number(int oldFirstChar); + int maintaining_absolute_top_line_number() const; + void reset_absolute_top_line_number(); + int position_to_linecol(int pos, int* lineNum, int* column) const; + void scroll_(int topLineNum, int horizOffset); + + void extend_range_for_styles(int* start, int* end); + + void find_wrap_range(const char *deletedText, int pos, int nInserted, + int nDeleted, int *modRangeStart, int *modRangeEnd, + int *linesInserted, int *linesDeleted); + void measure_deleted_lines(int pos, int nDeleted); + void wrapped_line_counter(Fl_Text_Buffer *buf, int startPos, int maxPos, + int maxLines, bool startPosIsLineStart, + int styleBufOffset, int *retPos, int *retLines, + int *retLineStart, int *retLineEnd, + bool countLastLineMissingNewLine = true) const; + void find_line_end(int pos, bool start_pos_is_line_start, int *lineEnd, + int *nextLineStart) const; + int measure_proportional_character(const char *s, int colNum, int pos) const; + int wrap_uses_character(int lineEndPos) const; + + int damage_range1_start, damage_range1_end; + int damage_range2_start, damage_range2_end; + int mCursorPos; + int mCursorOn; + int mCursorOldY; /* Y pos. of cursor for blanking */ + int mCursorToHint; /* Tells the buffer modified callback + where to move the cursor, to reduce + the number of redraw calls */ + int mCursorStyle; /* One of enum cursorStyles above */ + int mCursorPreferredCol; /* Column for vert. cursor movement */ + int mNVisibleLines; /* # of visible (displayed) lines */ + int mNBufferLines; /* # of newlines in the buffer */ + Fl_Text_Buffer* mBuffer; /* Contains text to be displayed */ + Fl_Text_Buffer* mStyleBuffer; /* Optional parallel buffer containing + color and font information */ + int mFirstChar, mLastChar; /* Buffer positions of first and last + displayed character (lastChar points + either to a newline or one character + beyond the end of the buffer) */ + int mContinuousWrap; /* Wrap long lines when displaying */ + int mWrapMargin; /* Margin in # of char positions for + wrapping in continuousWrap mode */ + int* mLineStarts; + int mTopLineNum; /* Line number of top displayed line + of file (first line of file is 1) */ + int mAbsTopLineNum; /* In continuous wrap mode, the line + number of the top line if the text + were not wrapped (note that this is + only maintained as needed). */ + int mNeedAbsTopLineNum; /* Externally settable flag to continue + maintaining absTopLineNum even if + it isn't needed for line # display */ + int mHorizOffset; /* Horizontal scroll pos. in pixels */ + int mTopLineNumHint; /* Line number of top displayed line + of file (first line of file is 1) */ + int mHorizOffsetHint; /* Horizontal scroll pos. in pixels */ + int mNStyles; /* Number of entries in styleTable */ + const Style_Table_Entry *mStyleTable; /* Table of fonts and colors for + coloring/syntax-highlighting */ + char mUnfinishedStyle; /* Style buffer entry which triggers + on-the-fly reparsing of region */ + Unfinished_Style_Cb mUnfinishedHighlightCB; /* Callback to parse "unfinished" */ + /* regions */ + void* mHighlightCBArg; /* Arg to unfinishedHighlightCB */ + + int mMaxsize; + + int mSuppressResync; /* Suppress resynchronization of line + starts during buffer updates */ + int mNLinesDeleted; /* Number of lines deleted during + buffer modification (only used + when resynchronization is suppressed) */ + int mModifyingTabDistance; /* Whether tab distance is being + modified */ + + Fl_Color mCursor_color; + + Fl_Scrollbar* mHScrollBar; + Fl_Scrollbar* mVScrollBar; + int scrollbar_width_; + Fl_Align scrollbar_align_; + int dragPos, dragType, dragging; + int display_insert_position_hint; + struct { int x, y, w, h; } text_area; + + int shortcut_; + + Fl_Font textfont_; + Fl_Fontsize textsize_; + Fl_Color textcolor_; + + // The following are not presently used from the original NEdit code, + // but are being put here so that future versions of Fl_Text_Display + // can implement line numbers without breaking binary compatibility. /* Line number margin and width */ - int mLineNumLeft, mLineNumWidth; + int mLineNumLeft, mLineNumWidth; }; #endif diff --git a/src/Fl_Text_Buffer.cxx b/src/Fl_Text_Buffer.cxx index cdd43e491..622ccd1ee 100644 --- a/src/Fl_Text_Buffer.cxx +++ b/src/Fl_Text_Buffer.cxx @@ -270,6 +270,10 @@ char Fl_Text_Buffer::byte_at(int pos) const { */ void Fl_Text_Buffer::insert(int pos, const char *text) { + /* check if there is actually any text */ + if (!text || !*text) + return; + /* if pos is not contiguous to existing text, make it */ if (pos > mLength) pos = mLength; @@ -1010,7 +1014,7 @@ int Fl_Text_Buffer::search_forward(int startPos, const char *searchString, return 1; } // FIXME: character is ucs-4 - } while ((matchCase ? char_at(bp++) == *sp++ : + } while ((matchCase ? char_at(bp++) == (unsigned int)*sp++ : toupper(char_at(bp++)) == toupper(*sp++)) && bp < length()); startPos++; @@ -1040,7 +1044,7 @@ int Fl_Text_Buffer::search_backward(int startPos, const char *searchString, return 1; } // FIXME: character is ucs-4 - } while ((matchCase ? char_at(bp--) == *sp-- : + } while ((matchCase ? char_at(bp--) == (unsigned int)*sp-- : toupper(char_at(bp--)) == toupper(*sp--)) && bp >= 0); startPos--; @@ -1128,6 +1132,9 @@ int Fl_Text_Buffer::findchars_backward(int startPos, const char *searchChars, */ int Fl_Text_Buffer::insert_(int pos, const char *text) { + if (!text || !*text) + return 0; + int insertedLength = strlen(text); /* Prepare the buffer to receive the new text. If the new text fits in @@ -1246,7 +1253,7 @@ int Fl_Text_Selection::position(int *startpos, int *endpos) const { */ int Fl_Text_Selection::includes(int pos) const { return (selected() && pos >= start() && pos < end() ); - } +} /* diff --git a/src/Fl_Text_Display.cxx b/src/Fl_Text_Display.cxx index e4303957e..cc2be8a69 100644 --- a/src/Fl_Text_Display.cxx +++ b/src/Fl_Text_Display.cxx @@ -25,6 +25,8 @@ // http://www.fltk.org/str.php // +// TODO: check all functions for UTF-8/UCS-4 compatibility! + #include #include #include @@ -49,7 +51,7 @@ #define NO_HINT -1 /* Masks for text drawing methods. These are or'd together to form an - integer which describes what drawing calls to use to draw a string */ + integer which describes what drawing calls to use to draw a string */ #define FILL_MASK 0x0100 #define SECONDARY_MASK 0x0200 #define PRIMARY_MASK 0x0400 @@ -59,8 +61,8 @@ #define STYLE_LOOKUP_MASK 0xff /* Maximum displayable line length (how many characters will fit across the - widest window). This amount of memory is temporarily allocated from the - stack in the draw_vline() method for drawing strings */ + widest window). This amount of memory is temporarily allocated from the + stack in the draw_vline() method for drawing strings */ #define MAX_DISP_LINE_LEN 1000 static int max( int i1, int i2 ); @@ -68,7 +70,7 @@ static int min( int i1, int i2 ); static int countlines( const char *string ); /* The variables below are used in a timer event to allow smooth - scrolling of the text area when the pointer has left the area. */ + scrolling of the text area when the pointer has left the area. */ static int scroll_direction = 0; static int scroll_amount = 0; static int scroll_y = 0; @@ -79,39 +81,39 @@ static int scroll_x = 0; /** Creates a new text display widget.*/ Fl_Text_Display::Fl_Text_Display(int X, int Y, int W, int H, const char* l) - : Fl_Group(X, Y, W, H, l) { +: Fl_Group(X, Y, W, H, l) { int i; - + mMaxsize = 0; damage_range1_start = damage_range1_end = -1; damage_range2_start = damage_range2_end = -1; dragPos = dragType = dragging = 0; display_insert_position_hint = 0; shortcut_ = 0; - + color(FL_BACKGROUND2_COLOR, FL_SELECTION_COLOR); box(FL_DOWN_FRAME); textsize(FL_NORMAL_SIZE); textcolor(FL_FOREGROUND_COLOR); textfont(FL_HELVETICA); set_flag(SHORTCUT_LABEL); - + text_area.x = 0; text_area.y = 0; text_area.w = 0; text_area.h = 0; - + mVScrollBar = new Fl_Scrollbar(0,0,1,1); mVScrollBar->callback((Fl_Callback*)v_scrollbar_cb, this); mHScrollBar = new Fl_Scrollbar(0,0,1,1); mHScrollBar->callback((Fl_Callback*)h_scrollbar_cb, this); mHScrollBar->type(FL_HORIZONTAL); - + end(); - + scrollbar_width(Fl::scrollbar_size()); scrollbar_align(FL_ALIGN_BOTTOM_RIGHT); - + mCursorOn = 0; mCursorPos = 0; mCursorOldY = -100; @@ -126,9 +128,9 @@ Fl_Text_Display::Fl_Text_Display(int X, int Y, int W, int H, const char* l) mAbsTopLineNum = 1; mNeedAbsTopLineNum = 0; mHorizOffset = mHorizOffsetHint = 0; - + mCursor_color = FL_FOREGROUND_COLOR; - + mStyleBuffer = 0; mStyleTable = 0; mNStyles = 0; @@ -140,11 +142,11 @@ Fl_Text_Display::Fl_Text_Display(int X, int Y, int W, int H, const char* l) mSuppressResync = 0; mNLinesDeleted = 0; mModifyingTabDistance = 0; - + mUnfinishedStyle = 0; mUnfinishedHighlightCB = 0; mHighlightCBArg = 0; - + mLineNumLeft = mLineNumWidth = 0; mContinuousWrap = 0; mWrapMargin = 0; @@ -152,11 +154,11 @@ Fl_Text_Display::Fl_Text_Display(int X, int Y, int W, int H, const char* l) } /** - Free a text display and release its associated memory. - - Note, the text BUFFER that the text display displays is a separate - entity and is not freed, nor are the style buffer or style table. -*/ + Free a text display and release its associated memory. + + Note, the text BUFFER that the text display displays is a separate + entity and is not freed, nor are the style buffer or style table. + */ Fl_Text_Display::~Fl_Text_Display() { if (scroll_direction) { Fl::remove_timeout(scroll_timer_cb, this); @@ -169,62 +171,64 @@ Fl_Text_Display::~Fl_Text_Display() { if (mLineStarts) delete[] mLineStarts; } + /** - Attach a text buffer to display, replacing the current buffer (if any) -*/ + Attach a text buffer to display, replacing the current buffer (if any) + \param buf attach this text buffer + */ void Fl_Text_Display::buffer( Fl_Text_Buffer *buf ) { /* If the text display is already displaying a buffer, clear it off - of the display and remove our callback from it */ + of the display and remove our callback from it */ if ( buf == mBuffer) return; if ( mBuffer != 0 ) { buffer_modified_cb( 0, 0, mBuffer->length(), 0, 0, this ); - mNBufferLines = 0; + mNBufferLines = 0; mBuffer->remove_modify_callback( buffer_modified_cb, this ); mBuffer->remove_predelete_callback( buffer_predelete_cb, this ); } - + /* Add the buffer to the display, and attach a callback to the buffer for - receiving modification information when the buffer contents change */ + receiving modification information when the buffer contents change */ mBuffer = buf; if (mBuffer) { mBuffer->add_modify_callback( buffer_modified_cb, this ); mBuffer->add_predelete_callback( buffer_predelete_cb, this ); - + /* Update the display */ buffer_modified_cb( 0, buf->length(), 0, 0, 0, this ); } - + /* Resize the widget to update the screen... */ resize(x(), y(), w(), h()); } /** - Attach (or remove) highlight information in text display and redisplay. - Highlighting information consists of a style buffer which parallels the - normal text buffer, but codes font and color information for the display; - a style table which translates style buffer codes (indexed by buffer - character - 'A') into fonts and colors; and a callback mechanism for - as-needed highlighting, triggered by a style buffer entry of - "unfinishedStyle". Style buffer can trigger additional redisplay during - a normal buffer modification if the buffer contains a primary Fl_Text_Selection - (see extendRangeForStyleMods for more information on this protocol). - - Style buffers, tables and their associated memory are managed by the caller. + Attach (or remove) highlight information in text display and redisplay. + Highlighting information consists of a style buffer which parallels the + normal text buffer, but codes font and color information for the display; + a style table which translates style buffer codes (indexed by buffer + character - 'A') into fonts and colors; and a callback mechanism for + as-needed highlighting, triggered by a style buffer entry of + "unfinishedStyle". Style buffer can trigger additional redisplay during + a normal buffer modification if the buffer contains a primary Fl_Text_Selection + (see extendRangeForStyleMods for more information on this protocol). + + Style buffers, tables and their associated memory are managed by the caller. Styles are ranged from 65 ('A') to 126. -*/ + */ void Fl_Text_Display::highlight_data(Fl_Text_Buffer *styleBuffer, - const Style_Table_Entry *styleTable, - int nStyles, char unfinishedStyle, - Unfinished_Style_Cb unfinishedHighlightCB, - void *cbArg ) { + const Style_Table_Entry *styleTable, + int nStyles, char unfinishedStyle, + Unfinished_Style_Cb unfinishedHighlightCB, + void *cbArg ) { mStyleBuffer = styleBuffer; mStyleTable = styleTable; mNStyles = nStyles; mUnfinishedStyle = unfinishedStyle; mUnfinishedHighlightCB = unfinishedHighlightCB; mHighlightCBArg = cbArg; - + mStyleBuffer->canUndo(0); damage(FL_DAMAGE_EXPOSE); } @@ -237,8 +241,8 @@ int Fl_Text_Display::longest_vline() const { } /** - Change the size of the displayed text area -*/ + Change the size of the displayed text area + */ void Fl_Text_Display::resize(int X, int Y, int W, int H) { #ifdef DEBUG printf("Fl_Text_Display::resize(X=%d, Y=%d, W=%d, H=%d)\n", X, Y, W, H); @@ -254,44 +258,44 @@ void Fl_Text_Display::resize(int X, int Y, int W, int H) { Y += Fl::box_dy(box()); W -= Fl::box_dw(box()); H -= Fl::box_dh(box()); - + text_area.x = X+LEFT_MARGIN; text_area.y = Y+TOP_MARGIN; text_area.w = W-LEFT_MARGIN-RIGHT_MARGIN; text_area.h = H-TOP_MARGIN-BOTTOM_MARGIN; int i; - + /* Find the new maximum font height for this text display */ for (i = 0, mMaxsize = fl_height(textfont(), textsize()); i < mNStyles; i++) mMaxsize = max(mMaxsize, fl_height(mStyleTable[i].font, mStyleTable[i].size)); - + // did we have scrollbars initially? unsigned int hscrollbarvisible = mHScrollBar->visible(); unsigned int vscrollbarvisible = mVScrollBar->visible(); - + // try without scrollbars first mVScrollBar->clear_visible(); mHScrollBar->clear_visible(); - + for (int again = 1; again;) { - again = 0; + again = 0; /* In continuous wrap mode, a change in width affects the total number of - lines in the buffer, and can leave the top line number incorrect, and - the top character no longer pointing at a valid line start */ + lines in the buffer, and can leave the top line number incorrect, and + the top character no longer pointing at a valid line start */ if (mContinuousWrap && !mWrapMargin && W!=oldWidth) { int oldFirstChar = mFirstChar; mNBufferLines = count_lines(0, buffer()->length(), true); mFirstChar = line_start(mFirstChar); mTopLineNum = count_lines(0, mFirstChar, true)+1; absolute_top_line_number(oldFirstChar); - + #ifdef DEBUG printf(" mNBufferLines=%d\n", mNBufferLines); #endif // DEBUG } - + /* reallocate and update the line starts array, which may have changed - size and / or contents. */ + size and / or contents. */ int nvlines = (text_area.h + mMaxsize - 1) / mMaxsize; if (nvlines < 1) nvlines = 1; if (mNVisibleLines != nvlines) { @@ -299,10 +303,10 @@ void Fl_Text_Display::resize(int X, int Y, int W, int H) { if (mLineStarts) delete[] mLineStarts; mLineStarts = new int [mNVisibleLines]; } - + calc_line_starts(0, mNVisibleLines); calc_last_char(); - + // figure the scrollbars if (scrollbar_width()) { /* Decide if the vertical scroll bar needs to be visible */ @@ -322,28 +326,28 @@ void Fl_Text_Display::resize(int X, int Y, int W, int H) { scrollbar_width(), text_area.h+TOP_MARGIN+BOTTOM_MARGIN); } } - + /* - Decide if the horizontal scroll bar needs to be visible. If there - is a vertical scrollbar, a horizontal is always created too. This - is because the alternatives are unatractive: - * Dynamically creating a horizontal scrollbar based on the currently - visible lines is what the original nedit does, but it always wastes - space for the scrollbar even when it's not used. Since the FLTK - widget dynamically allocates the space for the scrollbar and - rearranges the widget to make room for it, this would create a very - visually displeasing "bounce" effect when the vertical scrollbar is - dragged. Trust me, I tried it and it looks really bad. - * The other alternative would be to keep track of what the longest - line in the entire buffer is and base the scrollbar on that. I - didn't do this because I didn't see any easy way to do that using - the nedit code and this could involve a lengthy calculation for - large buffers. If an efficient and non-costly way of doing this - can be found, this might be a way to go. - */ + Decide if the horizontal scroll bar needs to be visible. If there + is a vertical scrollbar, a horizontal is always created too. This + is because the alternatives are unatractive: + * Dynamically creating a horizontal scrollbar based on the currently + visible lines is what the original nedit does, but it always wastes + space for the scrollbar even when it's not used. Since the FLTK + widget dynamically allocates the space for the scrollbar and + rearranges the widget to make room for it, this would create a very + visually displeasing "bounce" effect when the vertical scrollbar is + dragged. Trust me, I tried it and it looks really bad. + * The other alternative would be to keep track of what the longest + line in the entire buffer is and base the scrollbar on that. I + didn't do this because I didn't see any easy way to do that using + the nedit code and this could involve a lengthy calculation for + large buffers. If an efficient and non-costly way of doing this + can be found, this might be a way to go. + */ /* WAS: Suggestion: Try turning the horizontal scrollbar on when - you first see a line that is too wide in the window, but then - don't turn it off (ie mix both of your solutions). */ + you first see a line that is too wide in the window, but then + don't turn it off (ie mix both of your solutions). */ if (scrollbar_align() & (FL_ALIGN_TOP|FL_ALIGN_BOTTOM) && (mVScrollBar->visible() || longest_vline() > text_area.w)) { @@ -365,63 +369,63 @@ void Fl_Text_Display::resize(int X, int Y, int W, int H) { } } } - + // user request to change viewport if (mTopLineNumHint != mTopLineNum || mHorizOffsetHint != mHorizOffset) scroll_(mTopLineNumHint, mHorizOffsetHint); - + // everything will fit in the viewport if (mNBufferLines < mNVisibleLines || mBuffer == NULL || mBuffer->length() == 0) scroll_(1, mHorizOffset); /* if empty lines become visible, there may be an opportunity to - display more text by scrolling down */ + display more text by scrolling down */ else while (mLineStarts[mNVisibleLines-2] == -1) scroll_(mTopLineNum-1, mHorizOffset); - + // user request to display insert position if (display_insert_position_hint) display_insert(); - + // in case horizontal offset is now greater than longest line int maxhoffset = max(0, longest_vline()-text_area.w); if (mHorizOffset > maxhoffset) scroll_(mTopLineNumHint, maxhoffset); - + mTopLineNumHint = mTopLineNum; mHorizOffsetHint = mHorizOffset; display_insert_position_hint = 0; - + if (mContinuousWrap || hscrollbarvisible != mHScrollBar->visible() || vscrollbarvisible != mVScrollBar->visible()) redraw(); - + update_v_scrollbar(); update_h_scrollbar(); } /** - Refresh a rectangle of the text display. left and top are in coordinates of - the text drawing window -*/ + Refresh a rectangle of the text display. left and top are in coordinates of + the text drawing window + */ void Fl_Text_Display::draw_text( int left, int top, int width, int height ) { int fontHeight, firstLine, lastLine, line; - + /* find the line number range of the display */ fontHeight = mMaxsize ? mMaxsize : textsize_; firstLine = ( top - text_area.y - fontHeight + 1 ) / fontHeight; lastLine = ( top + height - text_area.y ) / fontHeight + 1; - + fl_push_clip( left, top, width, height ); - + /* draw the lines */ for ( line = firstLine; line <= lastLine; line++ ) draw_vline( line, left, left + width, 0, INT_MAX ); - - /* draw the line numbers if exposed area includes them */ - if (mLineNumWidth != 0 && left <= mLineNumLeft + mLineNumWidth) - draw_line_numbers(false); - + + /* draw the line numbers if exposed area includes them */ + if (mLineNumWidth != 0 && left <= mLineNumLeft + mLineNumWidth) + draw_line_numbers(false); + fl_pop_clip(); } @@ -463,25 +467,25 @@ void Fl_Text_Display::redisplay_range(int startpos, int endpos) { damage(FL_DAMAGE_SCROLL); } /** - Refresh all of the text between buffer positions "start" and "end" - not including the character at the position "end". - If end points beyond the end of the buffer, refresh the whole display - after pos, including blank lines which are not technically part of - any range of characters. -*/ + Refresh all of the text between buffer positions "start" and "end" + not including the character at the position "end". + If end points beyond the end of the buffer, refresh the whole display + after pos, including blank lines which are not technically part of + any range of characters. + */ void Fl_Text_Display::draw_range(int startpos, int endpos) { int i, startLine, lastLine, startIndex, endIndex; - + /* If the range is outside of the displayed text, just return */ if ( endpos < mFirstChar || ( startpos > mLastChar && - !empty_vlines() ) ) return; - + !empty_vlines() ) ) return; + /* Clean up the starting and ending values */ if ( startpos < 0 ) startpos = 0; if ( startpos > mBuffer->length() ) startpos = mBuffer->length(); if ( endpos < 0 ) endpos = 0; if ( endpos > mBuffer->length() ) endpos = mBuffer->length(); - + /* Get the starting and ending lines */ if ( startpos < mFirstChar ) startpos = mFirstChar; @@ -495,31 +499,31 @@ void Fl_Text_Display::draw_range(int startpos, int endpos) { lastLine = mNVisibleLines - 1; } } - + /* Get the starting and ending positions within the lines */ startIndex = mLineStarts[ startLine ] == -1 ? 0 : - startpos - mLineStarts[ startLine ]; + startpos - mLineStarts[ startLine ]; if ( endpos >= mLastChar ) endIndex = INT_MAX; else if ( mLineStarts[ lastLine ] == -1 ) endIndex = 0; else endIndex = endpos - mLineStarts[ lastLine ]; - + /* If the starting and ending lines are the same, redisplay the single - line between "start" and "end" */ + line between "start" and "end" */ if ( startLine == lastLine ) { draw_vline( startLine, 0, INT_MAX, startIndex, endIndex ); return; } - + /* Redisplay the first line from "start" */ draw_vline( startLine, 0, INT_MAX, startIndex, INT_MAX ); - + /* Redisplay the lines in between at their full width */ for ( i = startLine + 1; i < lastLine; i++ ) draw_vline( i, 0, INT_MAX, 0, INT_MAX ); - + /* Redisplay the last line to "end" */ draw_vline( lastLine, 0, INT_MAX, 0, endIndex ); } @@ -531,15 +535,15 @@ void Fl_Text_Display::insert_position( int newPos ) { return; if ( newPos < 0 ) newPos = 0; if ( newPos > mBuffer->length() ) newPos = mBuffer->length(); - + /* cursor movement cancels vertical cursor motion column */ mCursorPreferredCol = -1; - + /* erase the cursor at it's previous position */ redisplay_range(mCursorPos - 1, mCursorPos + 1); // FIXME utf8 - + mCursorPos = newPos; - + /* draw cursor at its new position */ redisplay_range(mCursorPos - 1, mCursorPos + 1); // FIXME utf8 } @@ -551,40 +555,40 @@ void Fl_Text_Display::show_cursor(int b) { } /** - Sets the text cursor style to one of the following: - - \li Fl_Text_Display::NORMAL_CURSOR - Shows an I beam. - \li Fl_Text_Display::CARET_CURSOR - Shows a caret under the text. - \li Fl_Text_Display::DIM_CURSOR - Shows a dimmed I beam. - \li Fl_Text_Display::BLOCK_CURSOR - Shows an unfilled box around the current - character. - \li Fl_Text_Display::HEAVY_CURSOR - Shows a thick I beam. -*/ + Sets the text cursor style to one of the following: + + \li Fl_Text_Display::NORMAL_CURSOR - Shows an I beam. + \li Fl_Text_Display::CARET_CURSOR - Shows a caret under the text. + \li Fl_Text_Display::DIM_CURSOR - Shows a dimmed I beam. + \li Fl_Text_Display::BLOCK_CURSOR - Shows an unfilled box around the current + character. + \li Fl_Text_Display::HEAVY_CURSOR - Shows a thick I beam. + */ void Fl_Text_Display::cursor_style(int style) { mCursorStyle = style; if (mCursorOn) show_cursor(); } /** - If mode is not zero, this call enables automatic word wrapping at column pos. - Word-wrapping does not change the text buffer itself, only the way that the text is displayed. -*/ + If mode is not zero, this call enables automatic word wrapping at column pos. + Word-wrapping does not change the text buffer itself, only the way that the text is displayed. + */ void Fl_Text_Display::wrap_mode(int wrap, int wrapMargin) { mWrapMargin = wrapMargin; mContinuousWrap = wrap; - + if (buffer()) { /* wrapping can change the total number of lines, re-count */ mNBufferLines = count_lines(0, buffer()->length(), true); - + /* changing wrap margins or changing from wrapped mode to non-wrapped - can leave the character at the top no longer at a line start, and/or - change the line number */ + can leave the character at the top no longer at a line start, and/or + change the line number */ mFirstChar = line_start(mFirstChar); mTopLineNum = count_lines(0, mFirstChar, true) + 1; - + reset_absolute_top_line_number(); - + /* update the line starts array */ calc_line_starts(0, mNVisibleLines); calc_last_char(); @@ -595,19 +599,19 @@ void Fl_Text_Display::wrap_mode(int wrap, int wrapMargin) { mTopLineNum = 1; mAbsTopLineNum = 0; } - + resize(x(), y(), w(), h()); } /** - Inserts "text" at the current cursor location. This has the same - effect as inserting the text into the buffer using BufInsert and - then moving the insert position after the newly inserted text, except - that it's optimized to do less redrawing. -*/ + Inserts "text" at the current cursor location. This has the same + effect as inserting the text into the buffer using BufInsert and + then moving the insert position after the newly inserted text, except + that it's optimized to do less redrawing. + */ void Fl_Text_Display::insert(const char* text) { int pos = mCursorPos; - + mCursorToHint = pos + strlen( text ); mBuffer->insert( pos, text ); mCursorToHint = NO_HINT; @@ -622,16 +626,16 @@ void Fl_Text_Display::overstrike(const char* text) { int i, p, endPos, indent, startIndent, endIndent; const char *c; char ch, *paddedText = NULL; - + /* determine how many displayed character positions are covered */ startIndent = mBuffer->count_displayed_characters( lineStart, startPos ); indent = startIndent; for ( c = text; *c != '\0'; c++ ) indent++; endIndent = indent; - + /* find which characters to remove, and if necessary generate additional - padding to make up for removed control characters at the end */ + padding to make up for removed control characters at the end */ indent = startIndent; for ( p = startPos; ; p++ ) { if ( p == buf->length() ) @@ -657,7 +661,7 @@ void Fl_Text_Display::overstrike(const char* text) { } } endPos = p; - + mCursorToHint = startPos + textLen; buf->replace( startPos, endPos, paddedText == NULL ? text : paddedText ); mCursorToHint = NO_HINT; @@ -666,22 +670,22 @@ void Fl_Text_Display::overstrike(const char* text) { } /** - Translate a buffer text position to the XY location where the top left - of the cursor would be positioned to point to that character. Returns - 0 if the position is not displayed because it is VERTICALLY out - of view. If the position is horizontally out of view, returns the - X coordinate where the position would be if it were visible. -*/ + Translate a buffer text position to the XY location where the top left + of the cursor would be positioned to point to that character. Returns + 0 if the position is not displayed because it is VERTICALLY out + of view. If the position is horizontally out of view, returns the + X coordinate where the position would be if it were visible. + */ int Fl_Text_Display::position_to_xy( int pos, int* X, int* Y ) const { int lineStartPos, fontHeight, lineLen; int visLineNum; - + /* If position is not displayed, return false */ if (pos < mFirstChar || (pos > mLastChar && !empty_vlines())) { return 0; } - + /* Calculate Y coordinate */ if (!position_to_line(pos, &visLineNum)) { return 0; @@ -689,13 +693,13 @@ int Fl_Text_Display::position_to_xy( int pos, int* X, int* Y ) const { if (visLineNum < 0 || visLineNum > mNBufferLines) { return 0; } - + fontHeight = mMaxsize; *Y = text_area.y + visLineNum * fontHeight; - + /* Get the text, length, and buffer position of the line. If the position - is beyond the end of the buffer and should be at the first position on - the first empty line, don't try to get or scan the text */ + is beyond the end of the buffer and should be at the first position on + the first empty line, don't try to get or scan the text */ lineStartPos = mLineStarts[visLineNum]; if ( lineStartPos == -1 ) { *X = text_area.x - mHorizOffset; @@ -707,118 +711,116 @@ int Fl_Text_Display::position_to_xy( int pos, int* X, int* Y ) const { } /** - Find the line number of position "pos". Note: this only works for - displayed lines. If the line is not displayed, the function returns - 0 (without the mLineStarts array it could turn in to very long - calculation involving scanning large amounts of text in the buffer). - If continuous wrap mode is on, returns the absolute line number (as opposed - to the wrapped line number which is used for scrolling). -*/ + Find the line number of position "pos". Note: this only works for + displayed lines. If the line is not displayed, the function returns + 0 (without the mLineStarts array it could turn in to very long + calculation involving scanning large amounts of text in the buffer). + If continuous wrap mode is on, returns the absolute line number (as opposed + to the wrapped line number which is used for scrolling). + */ int Fl_Text_Display::position_to_linecol( int pos, int* lineNum, int* column ) const { int retVal; - - /* In continuous wrap mode, the absolute (non-wrapped) line count is - maintained separately, as needed. Only return it if we're actually - keeping track of it and pos is in the displayed text */ - if (mContinuousWrap) { - if (!maintaining_absolute_top_line_number() || - pos < mFirstChar || pos > mLastChar) - return 0; - *lineNum = mAbsTopLineNum + buffer()->count_lines(mFirstChar, pos); - *column - = buffer()->count_displayed_characters(buffer()->line_start(pos), pos); - return 1; - } - + + /* In continuous wrap mode, the absolute (non-wrapped) line count is + maintained separately, as needed. Only return it if we're actually + keeping track of it and pos is in the displayed text */ + if (mContinuousWrap) { + if (!maintaining_absolute_top_line_number() || + pos < mFirstChar || pos > mLastChar) + return 0; + *lineNum = mAbsTopLineNum + buffer()->count_lines(mFirstChar, pos); + *column = buffer()->count_displayed_characters(buffer()->line_start(pos), pos); + return 1; + } + retVal = position_to_line( pos, lineNum ); if ( retVal ) { - *column = mBuffer->count_displayed_characters( - mLineStarts[ *lineNum ], pos ); + *column = mBuffer->count_displayed_characters( mLineStarts[ *lineNum ], pos ); *lineNum += mTopLineNum; } return retVal; } /** - Return 1 if position (X, Y) is inside of the primary Fl_Text_Selection -*/ + Return 1 if position (X, Y) is inside of the primary Fl_Text_Selection + */ int Fl_Text_Display::in_selection( int X, int Y ) const { int pos = xy_to_position( X, Y, CHARACTER_POS ); Fl_Text_Buffer *buf = mBuffer; return buf->primary_selection()->includes(pos); - } +} /** - Correct a column number based on an unconstrained position (as returned by - TextDXYToUnconstrainedPosition) to be relative to the last actual newline - in the buffer before the row and column position given, rather than the - last line start created by line wrapping. This is an adapter - for rectangular selections and code written before continuous wrap mode, - which thinks that the unconstrained column is the number of characters - from the last newline. Obviously this is time consuming, because it - invloves character re-counting. -*/ + Correct a column number based on an unconstrained position (as returned by + TextDXYToUnconstrainedPosition) to be relative to the last actual newline + in the buffer before the row and column position given, rather than the + last line start created by line wrapping. This is an adapter + for rectangular selections and code written before continuous wrap mode, + which thinks that the unconstrained column is the number of characters + from the last newline. Obviously this is time consuming, because it + invloves character re-counting. + */ int Fl_Text_Display::wrapped_column(int row, int column) const { - int lineStart, dispLineStart; - - if (!mContinuousWrap || row < 0 || row > mNVisibleLines) - return column; - dispLineStart = mLineStarts[row]; - if (dispLineStart == -1) - return column; - lineStart = buffer()->line_start(dispLineStart); - return column - + buffer()->count_displayed_characters(lineStart, dispLineStart); + int lineStart, dispLineStart; + + if (!mContinuousWrap || row < 0 || row > mNVisibleLines) + return column; + dispLineStart = mLineStarts[row]; + if (dispLineStart == -1) + return column; + lineStart = buffer()->line_start(dispLineStart); + return column + + buffer()->count_displayed_characters(lineStart, dispLineStart); } /** - Correct a row number from an unconstrained position (as returned by - TextDXYToUnconstrainedPosition) to a straight number of newlines from the - top line of the display. Because rectangular selections are based on - newlines, rather than display wrapping, and anywhere a rectangular selection - needs a row, it needs it in terms of un-wrapped lines. -*/ + Correct a row number from an unconstrained position (as returned by + TextDXYToUnconstrainedPosition) to a straight number of newlines from the + top line of the display. Because rectangular selections are based on + newlines, rather than display wrapping, and anywhere a rectangular selection + needs a row, it needs it in terms of un-wrapped lines. + */ int Fl_Text_Display::wrapped_row(int row) const{ - if (!mContinuousWrap || row < 0 || row > mNVisibleLines) - return row; - return buffer()->count_lines(mFirstChar, mLineStarts[row]); + if (!mContinuousWrap || row < 0 || row > mNVisibleLines) + return row; + return buffer()->count_lines(mFirstChar, mLineStarts[row]); } /** - Scroll the display to bring insertion cursor into view. -** - Note: it would be nice to be able to do this without counting lines twice - (scroll_() counts them too) and/or to count from the most efficient - starting point, but the efficiency of this routine is not as important to - the overall performance of the text display. -*/ + Scroll the display to bring insertion cursor into view. + ** + Note: it would be nice to be able to do this without counting lines twice + (scroll_() counts them too) and/or to count from the most efficient + starting point, but the efficiency of this routine is not as important to + the overall performance of the text display. + */ void Fl_Text_Display::display_insert() { int hOffset, topLine, X, Y; hOffset = mHorizOffset; topLine = mTopLineNum; - -// FIXME: I don't understand this well enough to know if it is correct -// it is different than nedit 5.3 + + // FIXME: I don't understand this well enough to know if it is correct + // it is different than nedit 5.3 if (insert_position() < mFirstChar) { topLine -= count_lines(insert_position(), mFirstChar, false); } else if (mLineStarts[mNVisibleLines-2] != -1) { int lastChar = line_end(mLineStarts[mNVisibleLines-2],true); if (insert_position() >= lastChar) topLine - += count_lines(lastChar - (wrap_uses_character(mLastChar) ? 0 : 1), - insert_position(), false); + += count_lines(lastChar - (wrap_uses_character(mLastChar) ? 0 : 1), + insert_position(), false); } - + /* Find the new setting for horizontal offset (this is a bit ungraceful). - If the line is visible, just use PositionToXY to get the position - to scroll to, otherwise, do the vertical scrolling first, then the - horizontal */ + If the line is visible, just use PositionToXY to get the position + to scroll to, otherwise, do the vertical scrolling first, then the + horizontal */ if (!position_to_xy( mCursorPos, &X, &Y )) { scroll_(topLine, hOffset); if (!position_to_xy( mCursorPos, &X, &Y )) { - #ifdef DEBUG +#ifdef DEBUG printf ("*** display_insert/position_to_xy # GIVE UP !\n"); fflush(stdout); - #endif // DEBUG +#endif // DEBUG return; /* Give up, it's not worth it (but why does it fail?) */ } } @@ -826,7 +828,7 @@ void Fl_Text_Display::display_insert() { hOffset += X-(text_area.x + text_area.w); else if (X < text_area.x) hOffset += X-text_area.x; - + /* Do the scroll */ if (topLine != mTopLineNum || hOffset != mHorizOffset) scroll_(topLine, hOffset); @@ -839,16 +841,16 @@ void Fl_Text_Display::show_insert_position() { } /* - Cursor movement functions -*/ + Cursor movement functions + */ /** Moves the current insert position right one character. \return 1 if the cursor moved, 0 if the end of the text was reached */ int Fl_Text_Display::move_right() { - if ( mCursorPos >= mBuffer->length() ) - return 0; + if ( mCursorPos >= mBuffer->length() ) + return 0; int p = insert_position(); int q = buffer()->next_char(p); insert_position(q); @@ -860,8 +862,8 @@ int Fl_Text_Display::move_right() { \return 1 if the cursor moved, 0 if the beginning of the text was reached */ int Fl_Text_Display::move_left() { - if ( mCursorPos <= 0 ) - return 0; + if ( mCursorPos <= 0 ) + return 0; int p = insert_position(); int q = buffer()->prev_char(p); insert_position(q); @@ -871,9 +873,9 @@ int Fl_Text_Display::move_left() { /** Moves the current insert position up one line.*/ int Fl_Text_Display::move_up() { int lineStartPos, column, prevLineStartPos, newPos, visLineNum; - + /* Find the position of the start of the line. Use the line starts array - if possible */ + if possible */ if ( position_to_line( mCursorPos, &visLineNum ) ) lineStartPos = mLineStarts[ visLineNum ]; else { @@ -882,11 +884,11 @@ int Fl_Text_Display::move_up() { } if ( lineStartPos == 0 ) return 0; - + /* Decide what column to move to, if there's a preferred column use that */ column = mCursorPreferredCol >= 0 ? mCursorPreferredCol : - mBuffer->count_displayed_characters( lineStartPos, mCursorPos ); - + mBuffer->count_displayed_characters( lineStartPos, mCursorPos ); + /* count forward from the start of the previous line to reach the column */ if ( visLineNum != -1 && visLineNum != 0 ) prevLineStartPos = mLineStarts[ visLineNum - 1 ]; @@ -894,12 +896,12 @@ int Fl_Text_Display::move_up() { prevLineStartPos = rewind_lines( lineStartPos, 1 ); newPos = mBuffer->skip_displayed_characters( prevLineStartPos, column ); if (mContinuousWrap) - newPos = min(newPos, line_end(prevLineStartPos, true)); - + newPos = min(newPos, line_end(prevLineStartPos, true)); + /* move the cursor */ insert_position( newPos ); - - int ok = 0; + + int ok = 0; while (!ok) { int pos = insert_position(); // FIXME: character is ucs-4 @@ -910,7 +912,7 @@ int Fl_Text_Display::move_up() { insert_position( mCursorPos + 1 ); } } - + /* if a preferred column wasn't aleady established, establish it */ mCursorPreferredCol = column; return 1; @@ -919,7 +921,7 @@ int Fl_Text_Display::move_up() { /** Moves the current insert position down one line.*/ int Fl_Text_Display::move_down() { int lineStartPos, column, nextLineStartPos, newPos, visLineNum; - + if ( mCursorPos == mBuffer->length() ) return 0; if ( position_to_line( mCursorPos, &visLineNum ) ) @@ -929,12 +931,12 @@ int Fl_Text_Display::move_down() { visLineNum = -1; } column = mCursorPreferredCol >= 0 ? mCursorPreferredCol : - mBuffer->count_displayed_characters( lineStartPos, mCursorPos ); + mBuffer->count_displayed_characters( lineStartPos, mCursorPos ); nextLineStartPos = skip_lines( lineStartPos, 1, true ); newPos = mBuffer->skip_displayed_characters( nextLineStartPos, column ); if (mContinuousWrap) newPos = min(newPos, line_end(nextLineStartPos, true)); - + insert_position( newPos ); int ok = 0; while (!ok) { @@ -952,134 +954,134 @@ int Fl_Text_Display::move_down() { } /** - Same as BufCountLines, but takes in to account wrapping if wrapping is - turned on. If the caller knows that startPos is at a line start, it - can pass "startPosIsLineStart" as True to make the call more efficient - by avoiding the additional step of scanning back to the last newline. -*/ + Same as BufCountLines, but takes in to account wrapping if wrapping is + turned on. If the caller knows that startPos is at a line start, it + can pass "startPosIsLineStart" as True to make the call more efficient + by avoiding the additional step of scanning back to the last newline. + */ int Fl_Text_Display::count_lines(int startPos, int endPos, - bool startPosIsLineStart) const { - int retLines, retPos, retLineStart, retLineEnd; - + bool startPosIsLineStart) const { + int retLines, retPos, retLineStart, retLineEnd; + #ifdef DEBUG - printf("Fl_Text_Display::count_lines(startPos=%d, endPos=%d, startPosIsLineStart=%d\n", - startPos, endPos, startPosIsLineStart); + printf("Fl_Text_Display::count_lines(startPos=%d, endPos=%d, startPosIsLineStart=%d\n", + startPos, endPos, startPosIsLineStart); #endif // DEBUG - - /* If we're not wrapping use simple (and more efficient) BufCountLines */ - if (!mContinuousWrap) - return buffer()->count_lines(startPos, endPos); - - wrapped_line_counter(buffer(), startPos, endPos, INT_MAX, - startPosIsLineStart, 0, &retPos, &retLines, &retLineStart, - &retLineEnd); - + + /* If we're not wrapping use simple (and more efficient) BufCountLines */ + if (!mContinuousWrap) + return buffer()->count_lines(startPos, endPos); + + wrapped_line_counter(buffer(), startPos, endPos, INT_MAX, + startPosIsLineStart, 0, &retPos, &retLines, &retLineStart, + &retLineEnd); + #ifdef DEBUG - printf(" # after WLC: retPos=%d, retLines=%d, retLineStart=%d, retLineEnd=%d\n", - retPos, retLines, retLineStart, retLineEnd); + printf(" # after WLC: retPos=%d, retLines=%d, retLineStart=%d, retLineEnd=%d\n", + retPos, retLines, retLineStart, retLineEnd); #endif // DEBUG - - return retLines; + + return retLines; } /** - Same as BufCountForwardNLines, but takes in to account line breaks when - wrapping is turned on. If the caller knows that startPos is at a line start, - it can pass "startPosIsLineStart" as True to make the call more efficient - by avoiding the additional step of scanning back to the last newline. -*/ + Same as BufCountForwardNLines, but takes in to account line breaks when + wrapping is turned on. If the caller knows that startPos is at a line start, + it can pass "startPosIsLineStart" as True to make the call more efficient + by avoiding the additional step of scanning back to the last newline. + */ int Fl_Text_Display::skip_lines(int startPos, int nLines, - bool startPosIsLineStart) { - int retLines, retPos, retLineStart, retLineEnd; - - /* if we're not wrapping use more efficient BufCountForwardNLines */ - if (!mContinuousWrap) - return buffer()->skip_lines(startPos, nLines); - - /* wrappedLineCounter can't handle the 0 lines case */ - if (nLines == 0) - return startPos; - - /* use the common line counting routine to count forward */ - wrapped_line_counter(buffer(), startPos, buffer()->length(), - nLines, startPosIsLineStart, 0, &retPos, &retLines, &retLineStart, - &retLineEnd); - return retPos; + bool startPosIsLineStart) { + int retLines, retPos, retLineStart, retLineEnd; + + /* if we're not wrapping use more efficient BufCountForwardNLines */ + if (!mContinuousWrap) + return buffer()->skip_lines(startPos, nLines); + + /* wrappedLineCounter can't handle the 0 lines case */ + if (nLines == 0) + return startPos; + + /* use the common line counting routine to count forward */ + wrapped_line_counter(buffer(), startPos, buffer()->length(), + nLines, startPosIsLineStart, 0, &retPos, &retLines, &retLineStart, + &retLineEnd); + return retPos; } /** - Same as BufEndOfLine, but takes in to account line breaks when wrapping - is turned on. If the caller knows that startPos is at a line start, it - can pass "startPosIsLineStart" as True to make the call more efficient - by avoiding the additional step of scanning back to the last newline. -** - Note that the definition of the end of a line is less clear when continuous - wrap is on. With continuous wrap off, it's just a pointer to the newline - that ends the line. When it's on, it's the character beyond the last - DISPLAYABLE character on the line, where a whitespace character which has - been "converted" to a newline for wrapping is not considered displayable. - Also note that, a line can be wrapped at a non-whitespace character if the - line had no whitespace. In this case, this routine returns a pointer to - the start of the next line. This is also consistent with the model used by - visLineLength. -*/ + Same as BufEndOfLine, but takes in to account line breaks when wrapping + is turned on. If the caller knows that startPos is at a line start, it + can pass "startPosIsLineStart" as True to make the call more efficient + by avoiding the additional step of scanning back to the last newline. + ** + Note that the definition of the end of a line is less clear when continuous + wrap is on. With continuous wrap off, it's just a pointer to the newline + that ends the line. When it's on, it's the character beyond the last + DISPLAYABLE character on the line, where a whitespace character which has + been "converted" to a newline for wrapping is not considered displayable. + Also note that, a line can be wrapped at a non-whitespace character if the + line had no whitespace. In this case, this routine returns a pointer to + the start of the next line. This is also consistent with the model used by + visLineLength. + */ int Fl_Text_Display::line_end(int pos, bool startPosIsLineStart) const { - int retLines, retPos, retLineStart, retLineEnd; - - /* If we're not wrapping use more efficien BufEndOfLine */ - if (!mContinuousWrap) - return buffer()->line_end(pos); - - if (pos == buffer()->length()) - return pos; - wrapped_line_counter(buffer(), pos, buffer()->length(), 1, - startPosIsLineStart, 0, &retPos, &retLines, &retLineStart, - &retLineEnd); - return retLineEnd; + int retLines, retPos, retLineStart, retLineEnd; + + /* If we're not wrapping use more efficien BufEndOfLine */ + if (!mContinuousWrap) + return buffer()->line_end(pos); + + if (pos == buffer()->length()) + return pos; + wrapped_line_counter(buffer(), pos, buffer()->length(), 1, + startPosIsLineStart, 0, &retPos, &retLines, &retLineStart, + &retLineEnd); + return retLineEnd; } /** - Same as BufStartOfLine, but returns the character after last wrap point - rather than the last newline. -*/ + Same as BufStartOfLine, but returns the character after last wrap point + rather than the last newline. + */ int Fl_Text_Display::line_start(int pos) const { - int retLines, retPos, retLineStart, retLineEnd; - - /* If we're not wrapping, use the more efficient BufStartOfLine */ - if (!mContinuousWrap) - return buffer()->line_start(pos); - - wrapped_line_counter(buffer(), buffer()->line_start(pos), pos, INT_MAX, true, 0, - &retPos, &retLines, &retLineStart, &retLineEnd); - return retLineStart; + int retLines, retPos, retLineStart, retLineEnd; + + /* If we're not wrapping, use the more efficient BufStartOfLine */ + if (!mContinuousWrap) + return buffer()->line_start(pos); + + wrapped_line_counter(buffer(), buffer()->line_start(pos), pos, INT_MAX, true, 0, + &retPos, &retLines, &retLineStart, &retLineEnd); + return retLineStart; } /** - Same as BufCountBackwardNLines, but takes in to account line breaks when - wrapping is turned on. -*/ + Same as BufCountBackwardNLines, but takes in to account line breaks when + wrapping is turned on. + */ int Fl_Text_Display::rewind_lines(int startPos, int nLines) { - Fl_Text_Buffer *buf = buffer(); - int pos, lineStart, retLines, retPos, retLineStart, retLineEnd; - - /* If we're not wrapping, use the more efficient BufCountBackwardNLines */ - if (!mContinuousWrap) - return buf->rewind_lines(startPos, nLines); - - pos = startPos; - for (;;) { - lineStart = buf->line_start(pos); - wrapped_line_counter(buf, lineStart, pos, INT_MAX, - true, 0, &retPos, &retLines, &retLineStart, &retLineEnd, false); - if (retLines > nLines) - return skip_lines(lineStart, retLines-nLines, - true); - nLines -= retLines; - pos = lineStart - 1; - if (pos < 0) - return 0; - nLines -= 1; - } + Fl_Text_Buffer *buf = buffer(); + int pos, lineStart, retLines, retPos, retLineStart, retLineEnd; + + /* If we're not wrapping, use the more efficient BufCountBackwardNLines */ + if (!mContinuousWrap) + return buf->rewind_lines(startPos, nLines); + + pos = startPos; + for (;;) { + lineStart = buf->line_start(pos); + wrapped_line_counter(buf, lineStart, pos, INT_MAX, + true, 0, &retPos, &retLines, &retLineStart, &retLineEnd, false); + if (retLines > nLines) + return skip_lines(lineStart, retLines-nLines, + true); + nLines -= retLines; + pos = lineStart - 1; + if (pos < 0) + return 0; + nLines -= 1; + } } static inline int fl_isseparator(int c) { @@ -1097,7 +1099,7 @@ void Fl_Text_Display::next_word() { while (pos < buffer()->length() && fl_isseparator(buffer()->char_at(pos))) { pos++; } - + insert_position( pos ); } @@ -1116,84 +1118,84 @@ void Fl_Text_Display::previous_word() { } // FIXME: character is ucs-4 if (fl_isseparator(buffer()->char_at(pos))) pos++; - + insert_position( pos ); } /** - Callback attached to the text buffer to receive delete information before - the modifications are actually made. -*/ + Callback attached to the text buffer to receive delete information before + the modifications are actually made. + */ void Fl_Text_Display::buffer_predelete_cb(int pos, int nDeleted, void *cbArg) { - Fl_Text_Display *textD = (Fl_Text_Display *)cbArg; + Fl_Text_Display *textD = (Fl_Text_Display *)cbArg; if (textD->mContinuousWrap) - /* Note: we must perform this measurement, even if there is not a - single character deleted; the number of "deleted" lines is the - number of visual lines spanned by the real line in which the - modification takes place. - Also, a modification of the tab distance requires the same - kind of calculations in advance, even if the font width is "fixed", - because when the width of the tab characters changes, the layout - of the text may be completely different. */ - textD->measure_deleted_lines(pos, nDeleted); - else - textD->mSuppressResync = 0; /* Probably not needed, but just in case */ + /* Note: we must perform this measurement, even if there is not a + single character deleted; the number of "deleted" lines is the + number of visual lines spanned by the real line in which the + modification takes place. + Also, a modification of the tab distance requires the same + kind of calculations in advance, even if the font width is "fixed", + because when the width of the tab characters changes, the layout + of the text may be completely different. */ + textD->measure_deleted_lines(pos, nDeleted); + else + textD->mSuppressResync = 0; /* Probably not needed, but just in case */ } /** - Callback attached to the text buffer to receive modification information -*/ + Callback attached to the text buffer to receive modification information + */ void Fl_Text_Display::buffer_modified_cb( int pos, int nInserted, int nDeleted, - int nRestyled, const char *deletedText, void *cbArg ) { + int nRestyled, const char *deletedText, void *cbArg ) { int linesInserted, linesDeleted, startDispPos, endDispPos; Fl_Text_Display *textD = ( Fl_Text_Display * ) cbArg; Fl_Text_Buffer *buf = textD->mBuffer; int oldFirstChar = textD->mFirstChar; int scrolled, origCursorPos = textD->mCursorPos; int wrapModStart, wrapModEnd; - + /* buffer modification cancels vertical cursor motion column */ if ( nInserted != 0 || nDeleted != 0 ) textD->mCursorPreferredCol = -1; - - /* Count the number of lines inserted and deleted, and in the case - of continuous wrap mode, how much has changed */ + + /* Count the number of lines inserted and deleted, and in the case + of continuous wrap mode, how much has changed */ + if (textD->mContinuousWrap) { + textD->find_wrap_range(deletedText, pos, nInserted, nDeleted, + &wrapModStart, &wrapModEnd, &linesInserted, &linesDeleted); + } else { + linesInserted = nInserted == 0 ? 0 : + buf->count_lines( pos, pos + nInserted ); + linesDeleted = nDeleted == 0 ? 0 : countlines( deletedText ); + } + + /* Update the line starts and mTopLineNum */ + if ( nInserted != 0 || nDeleted != 0 ) { if (textD->mContinuousWrap) { - textD->find_wrap_range(deletedText, pos, nInserted, nDeleted, - &wrapModStart, &wrapModEnd, &linesInserted, &linesDeleted); + textD->update_line_starts( wrapModStart, wrapModEnd-wrapModStart, + nDeleted + pos-wrapModStart + (wrapModEnd-(pos+nInserted)), + linesInserted, linesDeleted, &scrolled ); } else { - linesInserted = nInserted == 0 ? 0 : - buf->count_lines( pos, pos + nInserted ); - linesDeleted = nDeleted == 0 ? 0 : countlines( deletedText ); + textD->update_line_starts( pos, nInserted, nDeleted, linesInserted, + linesDeleted, &scrolled ); } - - /* Update the line starts and mTopLineNum */ - if ( nInserted != 0 || nDeleted != 0 ) { - if (textD->mContinuousWrap) { - textD->update_line_starts( wrapModStart, wrapModEnd-wrapModStart, - nDeleted + pos-wrapModStart + (wrapModEnd-(pos+nInserted)), - linesInserted, linesDeleted, &scrolled ); - } else { - textD->update_line_starts( pos, nInserted, nDeleted, linesInserted, - linesDeleted, &scrolled ); - } } else scrolled = 0; - - /* If we're counting non-wrapped lines as well, maintain the absolute - (non-wrapped) line number of the text displayed */ - if (textD->maintaining_absolute_top_line_number() && - (nInserted != 0 || nDeleted != 0)) { - if (pos + nDeleted < oldFirstChar) - textD->mAbsTopLineNum += buf->count_lines(pos, pos + nInserted) - - countlines(deletedText); - else if (pos < oldFirstChar) - textD->reset_absolute_top_line_number(); - } - + + /* If we're counting non-wrapped lines as well, maintain the absolute + (non-wrapped) line number of the text displayed */ + if (textD->maintaining_absolute_top_line_number() && + (nInserted != 0 || nDeleted != 0)) { + if (pos + nDeleted < oldFirstChar) + textD->mAbsTopLineNum += buf->count_lines(pos, pos + nInserted) - + countlines(deletedText); + else if (pos < oldFirstChar) + textD->reset_absolute_top_line_number(); + } + /* Update the line count for the whole buffer */ textD->mNBufferLines += linesInserted - linesDeleted; - + /* Update the cursor position */ if ( textD->mCursorToHint != NO_HINT ) { textD->mCursorPos = textD->mCursorToHint; @@ -1204,13 +1206,13 @@ void Fl_Text_Display::buffer_modified_cb( int pos, int nInserted, int nDeleted, else textD->mCursorPos += nInserted - nDeleted; } - + // refigure scrollbars & stuff textD->resize(textD->x(), textD->y(), textD->w(), textD->h()); - + // don't need to do anything else if not visible? if (!textD->visible_r()) return; - + /* If the changes caused scrolling, re-paint everything and we're done. */ if ( scrolled ) { textD->damage(FL_DAMAGE_EXPOSE); @@ -1218,12 +1220,12 @@ void Fl_Text_Display::buffer_modified_cb( int pos, int nInserted, int nDeleted, textD->mStyleBuffer->primary_selection()->selected(0); return; } - + /* If the changes didn't cause scrolling, decide the range of characters - that need to be re-painted. Also if the cursor position moved, be - sure that the redisplay range covers the old cursor position so the - old cursor gets erased, and erase the bits of the cursor which extend - beyond the left and right edges of the text. */ + that need to be re-painted. Also if the cursor position moved, be + sure that the redisplay range covers the old cursor position so the + old cursor gets erased, and erase the bits of the cursor which extend + beyond the left and right edges of the text. */ startDispPos = textD->mContinuousWrap ? wrapModStart : pos; if ( origCursorPos == startDispPos && textD->mCursorPos != startDispPos ) startDispPos = min( startDispPos, origCursorPos - 1 ); @@ -1232,99 +1234,99 @@ void Fl_Text_Display::buffer_modified_cb( int pos, int nInserted, int nDeleted, endDispPos = pos + nRestyled; else { endDispPos = textD->mContinuousWrap ? wrapModEnd : - buf->line_end( pos + nInserted ) + 1; + buf->line_end( pos + nInserted ) + 1; // CET - FIXME if ( origCursorPos >= startDispPos && // ( origCursorPos <= endDispPos || endDispPos == buf->length() ) ) } - - if (linesInserted > 1) textD->draw_line_numbers(false); + + if (linesInserted > 1) textD->draw_line_numbers(false); } else { endDispPos = textD->mLastChar + 1; // CET - FIXME if ( origCursorPos >= pos ) - /* If more than one line is inserted/deleted, a line break may have - been inserted or removed in between, and the line numbers may - have changed. If only one line is altered, line numbers cannot - be affected (the insertion or removal of a line break always - results in at least two lines being redrawn). */ - textD->draw_line_numbers(false); + /* If more than one line is inserted/deleted, a line break may have + been inserted or removed in between, and the line numbers may + have changed. If only one line is altered, line numbers cannot + be affected (the insertion or removal of a line break always + results in at least two lines being redrawn). */ + textD->draw_line_numbers(false); } - + /* If there is a style buffer, check if the modification caused additional - changes that need to be redisplayed. (Redisplaying separately would - cause double-redraw on almost every modification involving styled - text). Extend the redraw range to incorporate style changes */ + changes that need to be redisplayed. (Redisplaying separately would + cause double-redraw on almost every modification involving styled + text). Extend the redraw range to incorporate style changes */ if ( textD->mStyleBuffer ) textD->extend_range_for_styles( &startDispPos, &endDispPos ); - + /* Redisplay computed range */ textD->redisplay_range( startDispPos, endDispPos ); // FIXME utf8 } /** - In continuous wrap mode, internal line numbers are calculated after - wrapping. A separate non-wrapped line count is maintained when line - numbering is turned on. There is some performance cost to maintaining this - line count, so normally absolute line numbers are not tracked if line - numbering is off. This routine allows callers to specify that they still - want this line count maintained (for use via TextDPosToLineAndCol). - More specifically, this allows the line number reported in the statistics - line to be calibrated in absolute lines, rather than post-wrapped lines. -*/ + In continuous wrap mode, internal line numbers are calculated after + wrapping. A separate non-wrapped line count is maintained when line + numbering is turned on. There is some performance cost to maintaining this + line count, so normally absolute line numbers are not tracked if line + numbering is off. This routine allows callers to specify that they still + want this line count maintained (for use via TextDPosToLineAndCol). + More specifically, this allows the line number reported in the statistics + line to be calibrated in absolute lines, rather than post-wrapped lines. + */ void Fl_Text_Display::maintain_absolute_top_line_number(int state) { - mNeedAbsTopLineNum = state; - reset_absolute_top_line_number(); + mNeedAbsTopLineNum = state; + reset_absolute_top_line_number(); } /** - Returns the absolute (non-wrapped) line number of the first line displayed. - Returns 0 if the absolute top line number is not being maintained. -*/ + Returns the absolute (non-wrapped) line number of the first line displayed. + Returns 0 if the absolute top line number is not being maintained. + */ int Fl_Text_Display::get_absolute_top_line_number() const { - if (!mContinuousWrap) - return mTopLineNum; - if (maintaining_absolute_top_line_number()) - return mAbsTopLineNum; - return 0; + if (!mContinuousWrap) + return mTopLineNum; + if (maintaining_absolute_top_line_number()) + return mAbsTopLineNum; + return 0; } /** - Re-calculate absolute top line number for a change in scroll position. -*/ + Re-calculate absolute top line number for a change in scroll position. + */ void Fl_Text_Display::absolute_top_line_number(int oldFirstChar) { - if (maintaining_absolute_top_line_number()) { - if (mFirstChar < oldFirstChar) - mAbsTopLineNum -= buffer()->count_lines(mFirstChar, oldFirstChar); - else - mAbsTopLineNum += buffer()->count_lines(oldFirstChar, mFirstChar); - } + if (maintaining_absolute_top_line_number()) { + if (mFirstChar < oldFirstChar) + mAbsTopLineNum -= buffer()->count_lines(mFirstChar, oldFirstChar); + else + mAbsTopLineNum += buffer()->count_lines(oldFirstChar, mFirstChar); + } } /** - Return true if a separate absolute top line number is being maintained - (for displaying line numbers or showing in the statistics line). -*/ + Return true if a separate absolute top line number is being maintained + (for displaying line numbers or showing in the statistics line). + */ int Fl_Text_Display::maintaining_absolute_top_line_number() const { - return mContinuousWrap && - (mLineNumWidth != 0 || mNeedAbsTopLineNum); + return mContinuousWrap && + (mLineNumWidth != 0 || mNeedAbsTopLineNum); } /** - Count lines from the beginning of the buffer to reestablish the - absolute (non-wrapped) top line number. If mode is not continuous wrap, - or the number is not being maintained, does nothing. -*/ + Count lines from the beginning of the buffer to reestablish the + absolute (non-wrapped) top line number. If mode is not continuous wrap, + or the number is not being maintained, does nothing. + */ void Fl_Text_Display::reset_absolute_top_line_number() { - mAbsTopLineNum = 1; - absolute_top_line_number(0); + mAbsTopLineNum = 1; + absolute_top_line_number(0); } /** - Find the line number of position "pos" relative to the first line of - displayed text. Returns 0 if the line is not displayed. -*/ + Find the line number of position "pos" relative to the first line of + displayed text. Returns 0 if the line is not displayed. + */ int Fl_Text_Display::position_to_line( int pos, int *lineNum ) const { int i; - + *lineNum = 0; if ( pos < mFirstChar ) return 0; if ( pos > mLastChar ) { @@ -1342,7 +1344,7 @@ int Fl_Text_Display::position_to_line( int pos, int *lineNum ) const { } return 0; } - + for ( i = mNVisibleLines - 1; i >= 0; i-- ) { if ( mLineStarts[ i ] != -1 && pos >= mLineStarts[ i ] ) { *lineNum = i; @@ -1431,6 +1433,10 @@ int Fl_Text_Display::handle_vline( startX += w; startIndex = i; } + if (len==-1) { + // FIXME: what happened? Is there an illegal charater, or an illegal index? + len = 1; + } i += len; } int w = string_width( lineStr+startIndex, i-startIndex, style ); @@ -1472,72 +1478,72 @@ int Fl_Text_Display::find_x(const char *s, int len, int style, int x) const { /** - Draw the text on a single line represented by "visLineNum" (the - number of lines down from the top of the display), limited by - "leftClip" and "rightClip" window coordinates and "leftCharIndex" and - "rightCharIndex" character positions (not including the character at - position "rightCharIndex"). -*/ + Draw the text on a single line represented by "visLineNum" (the + number of lines down from the top of the display), limited by + "leftClip" and "rightClip" window coordinates and "leftCharIndex" and + "rightCharIndex" character positions (not including the character at + position "rightCharIndex"). + */ void Fl_Text_Display::draw_vline(int visLineNum, int leftClip, int rightClip, int leftCharIndex, int rightCharIndex) { int Y, lineStartPos, lineLen, fontHeight; int stdCharWidth; - -// printf("draw_vline(visLineNum=%d, leftClip=%d, rightClip=%d, leftCharIndex=%d, rightCharIndex=%d)\n", -// visLineNum, leftClip, rightClip, leftCharIndex, rightCharIndex); -// printf("nNVisibleLines=%d\n", mNVisibleLines); - + + // printf("draw_vline(visLineNum=%d, leftClip=%d, rightClip=%d, leftCharIndex=%d, rightCharIndex=%d)\n", + // visLineNum, leftClip, rightClip, leftCharIndex, rightCharIndex); + // printf("nNVisibleLines=%d\n", mNVisibleLines); + /* If line is not displayed, skip it */ if ( visLineNum < 0 || visLineNum >= mNVisibleLines ) return; - + /* Calculate Y coordinate of the string to draw */ fontHeight = mMaxsize; Y = text_area.y + visLineNum * fontHeight; - + /* Get the text, length, and buffer position of the line to display */ lineStartPos = mLineStarts[ visLineNum ]; -// printf("lineStartPos=%d\n", lineStartPos); + // printf("lineStartPos=%d\n", lineStartPos); if ( lineStartPos == -1 ) { lineLen = 0; } else { lineLen = vline_length( visLineNum ); } - + /* Space beyond the end of the line is still counted in units of characters - of a standardized character width (this is done mostly because style - changes based on character position can still occur in this region due - to rectangular Fl_Text_Selections). stdCharWidth must be non-zero to - prevent a potential infinite loop if X does not advance */ + of a standardized character width (this is done mostly because style + changes based on character position can still occur in this region due + to rectangular Fl_Text_Selections). stdCharWidth must be non-zero to + prevent a potential infinite loop if X does not advance */ stdCharWidth = TMPFONTWIDTH; //mFontStruct->max_bounds.width; if ( stdCharWidth <= 0 ) { Fl::error("Fl_Text_Display::draw_vline(): bad font measurement"); return; } - + /* Shrink the clipping range to the active display area */ leftClip = max( text_area.x, leftClip ); rightClip = min( rightClip, text_area.x + text_area.w ); - + handle_vline(DRAW_LINE, lineStartPos, lineLen, leftCharIndex, rightCharIndex, Y, Y+fontHeight, leftClip, rightClip); return; - } +} /** - Draw a string or blank area according to parameter "style", using the - appropriate colors and drawing method for that style, with top left - corner at X, y. If style says to draw text, use "string" as source of - characters, and draw "nChars", if style is FILL, erase - rectangle where text would have drawn from X to toX and from Y to - the maximum Y extent of the current font(s). -*/ + Draw a string or blank area according to parameter "style", using the + appropriate colors and drawing method for that style, with top left + corner at X, y. If style says to draw text, use "string" as source of + characters, and draw "nChars", if style is FILL, erase + rectangle where text would have drawn from X to toX and from Y to + the maximum Y extent of the current font(s). + */ void Fl_Text_Display::draw_string(int style, int X, int Y, int toX, const char *string, int nChars) const { const Style_Table_Entry * styleRec; - + /* Draw blank area rather than text, if that was the request */ if ( style & FILL_MASK ) { if (style & TEXT_ONLY_MASK) return; @@ -1545,24 +1551,24 @@ void Fl_Text_Display::draw_string(int style, return; } /* Set font, color, and gc depending on style. For normal text, GCs - for normal drawing, or drawing within a Fl_Text_Selection or highlight are - pre-allocated and pre-configured. For syntax highlighting, GCs are - configured here, on the fly. */ - + for normal drawing, or drawing within a Fl_Text_Selection or highlight are + pre-allocated and pre-configured. For syntax highlighting, GCs are + configured here, on the fly. */ + Fl_Font font = textfont(); int fsize = textsize(); Fl_Color foreground; Fl_Color background; - + if ( style & STYLE_LOOKUP_MASK ) { int si = (style & STYLE_LOOKUP_MASK) - 'A'; if (si < 0) si = 0; else if (si >= mNStyles) si = mNStyles - 1; - + styleRec = mStyleTable + si; font = styleRec->font; fsize = styleRec->size; - + if (style & PRIMARY_MASK) { if (Fl::focus() == this) background = selection_color(); else background = fl_color_average(color(), selection_color(), 0.4f); @@ -1583,7 +1589,7 @@ void Fl_Text_Display::draw_string(int style, foreground = textcolor(); background = color(); } - + if (!(style & TEXT_ONLY_MASK)) { fl_color( background ); fl_rectf( X, Y, toX - X, mMaxsize ); @@ -1593,38 +1599,38 @@ void Fl_Text_Display::draw_string(int style, fl_font( font, fsize ); fl_draw( string, nChars, X, Y + mMaxsize - fl_descent()); } - + // CET - FIXME /* If any space around the character remains unfilled (due to use of - different sized fonts for highlighting), fill in above or below - to erase previously drawn characters */ + different sized fonts for highlighting), fill in above or below + to erase previously drawn characters */ /* - if (fs->ascent < mAscent) - clear_rect( style, X, Y, toX - X, mAscent - fs->ascent); - if (fs->descent < mDescent) - clear_rect( style, X, Y + mAscent + fs->descent, toX - x, - mDescent - fs->descent); - */ + if (fs->ascent < mAscent) + clear_rect( style, X, Y, toX - X, mAscent - fs->ascent); + if (fs->descent < mDescent) + clear_rect( style, X, Y + mAscent + fs->descent, toX - x, + mDescent - fs->descent); + */ /* Underline if style is secondary Fl_Text_Selection */ - + /* - if (style & SECONDARY_MASK) - XDrawLine(XtDisplay(mW), XtWindow(mW), gc, x, - y + mAscent, toX - 1, Y + fs->ascent); - */ + if (style & SECONDARY_MASK) + XDrawLine(XtDisplay(mW), XtWindow(mW), gc, x, + y + mAscent, toX - 1, Y + fs->ascent); + */ } /** - Clear a rectangle with the appropriate background color for "style" -*/ + Clear a rectangle with the appropriate background color for "style" + */ void Fl_Text_Display::clear_rect(int style, int X, int Y, int width, int height) const { /* A width of zero means "clear to end of window" to XClearArea */ if ( width == 0 ) return; - + if (style & PRIMARY_MASK) { if (Fl::focus()==this) { fl_color(selection_color()); @@ -1645,14 +1651,14 @@ void Fl_Text_Display::clear_rect(int style, /** - Draw a cursor with top center at X, y. -*/ + Draw a cursor with top center at X, y. + */ void Fl_Text_Display::draw_cursor( int X, int Y ) { typedef struct { int x1, y1, x2, y2; } Segment; - + Segment segs[ 5 ]; int left, right, cursorWidth, midY; // int fontWidth = mFontStruct->min_bounds.width, nSegs = 0; @@ -1660,17 +1666,17 @@ void Fl_Text_Display::draw_cursor( int X, int Y ) { int nSegs = 0; int fontHeight = mMaxsize; int bot = Y + fontHeight - 1; - + if ( X < text_area.x - 1 || X > text_area.x + text_area.w ) return; - + /* For cursors other than the block, make them around 2/3 of a character - width, rounded to an even number of pixels so that X will draw an - odd number centered on the stem at x. */ + width, rounded to an even number of pixels so that X will draw an + odd number centered on the stem at x. */ cursorWidth = 4; //(fontWidth/3) * 2; left = X - cursorWidth / 2; right = left + cursorWidth; - + /* Create segments and draw cursor */ if ( mCursorStyle == CARET_CURSOR ) { midY = bot - fontHeight / 5; @@ -1706,46 +1712,46 @@ void Fl_Text_Display::draw_cursor( int X, int Y ) { nSegs = 4; } fl_color( mCursor_color ); - + for ( int k = 0; k < nSegs; k++ ) { fl_line( segs[ k ].x1, segs[ k ].y1, segs[ k ].x2, segs[ k ].y2 ); } } /** - Determine the drawing method to use to draw a specific character from "buf". - "lineStartPos" gives the character index where the line begins, "lineIndex", - the number of characters past the beginning of the line, and "dispIndex", - the number of displayed characters past the beginning of the line. Passing - lineStartPos of -1 returns the drawing style for "no text". -** - Why not just: position_style(pos)? Because style applies to blank areas - of the window beyond the text boundaries, and because this routine must also - decide whether a position is inside of a rectangular Fl_Text_Selection, and do - so efficiently, without re-counting character positions from the start of the - line. -** - Note that style is a somewhat incorrect name, drawing method would - be more appropriate. -*/ + Determine the drawing method to use to draw a specific character from "buf". + "lineStartPos" gives the character index where the line begins, "lineIndex", + the number of characters past the beginning of the line, and "dispIndex", + the number of displayed characters past the beginning of the line. Passing + lineStartPos of -1 returns the drawing style for "no text". + ** + Why not just: position_style(pos)? Because style applies to blank areas + of the window beyond the text boundaries, and because this routine must also + decide whether a position is inside of a rectangular Fl_Text_Selection, and do + so efficiently, without re-counting character positions from the start of the + line. + ** + Note that style is a somewhat incorrect name, drawing method would + be more appropriate. + */ int Fl_Text_Display::position_style( int lineStartPos, int lineLen, int lineIndex) const { Fl_Text_Buffer * buf = mBuffer; Fl_Text_Buffer *styleBuf = mStyleBuffer; int pos, style = 0; - + if ( lineStartPos == -1 || buf == NULL ) return FILL_MASK; - + pos = lineStartPos + min( lineIndex, lineLen ); - + if ( lineIndex >= lineLen ) style = FILL_MASK; else if ( styleBuf != NULL ) { style = ( unsigned char ) styleBuf->byte_at( pos ); if (style == mUnfinishedStyle && mUnfinishedHighlightCB) { - /* encountered "unfinished" style, trigger parsing */ - (mUnfinishedHighlightCB)( pos, mHighlightCBArg); + /* encountered "unfinished" style, trigger parsing */ + (mUnfinishedHighlightCB)( pos, mHighlightCBArg); style = (unsigned char) styleBuf->byte_at( pos); } } @@ -1759,17 +1765,17 @@ int Fl_Text_Display::position_style( int lineStartPos, int lineLen, int lineInde } /** - Find the width of a string in the font of a particular style -*/ + Find the width of a string in the font of a particular style + */ int Fl_Text_Display::string_width( const char *string, int length, int style ) const { Fl_Font font; int fsize; - + if ( style & STYLE_LOOKUP_MASK ) { int si = (style & STYLE_LOOKUP_MASK) - 'A'; if (si < 0) si = 0; else if (si >= mNStyles) si = mNStyles - 1; - + font = mStyleTable[si].font; fsize = mStyleTable[si].size; } else { @@ -1777,21 +1783,21 @@ int Fl_Text_Display::string_width( const char *string, int length, int style ) c fsize = textsize(); } fl_font( font, fsize ); - + return ( int ) ( fl_width( string, length ) ); } /** - Translate window coordinates to the nearest (insert cursor or character - cell) text position. The parameter posType specifies how to interpret the - position: CURSOR_POS means translate the coordinates to the nearest cursor - position, and CHARACTER_POS means return the position of the character - closest to (X, Y). -*/ + Translate window coordinates to the nearest (insert cursor or character + cell) text position. The parameter posType specifies how to interpret the + position: CURSOR_POS means translate the coordinates to the nearest cursor + position, and CHARACTER_POS means return the position of the character + closest to (X, Y). + */ int Fl_Text_Display::xy_to_position( int X, int Y, int posType ) const { int lineStart, lineLen, fontHeight; int visLineNum; - + /* Find the visible line number corresponding to the Y coordinate */ fontHeight = mMaxsize; visLineNum = ( Y - text_area.y ) / fontHeight; @@ -1799,52 +1805,52 @@ int Fl_Text_Display::xy_to_position( int X, int Y, int posType ) const { return mFirstChar; if ( visLineNum >= mNVisibleLines ) visLineNum = mNVisibleLines - 1; - + /* Find the position at the start of the line */ lineStart = mLineStarts[ visLineNum ]; - + /* If the line start was empty, return the last position in the buffer */ if ( lineStart == -1 ) return mBuffer->length(); - + /* Get the line text and its length */ lineLen = vline_length( visLineNum ); - + return handle_vline(FIND_INDEX, lineStart, lineLen, 0, 0, 0, 0, text_area.x, X); - } +} /** - Translate window coordinates to the nearest row and column number for - positioning the cursor. This, of course, makes no sense when the font is - proportional, since there are no absolute columns. The parameter posType - specifies how to interpret the position: CURSOR_POS means translate the - coordinates to the nearest position between characters, and CHARACTER_POS - means translate the position to the nearest character cell. -*/ + Translate window coordinates to the nearest row and column number for + positioning the cursor. This, of course, makes no sense when the font is + proportional, since there are no absolute columns. The parameter posType + specifies how to interpret the position: CURSOR_POS means translate the + coordinates to the nearest position between characters, and CHARACTER_POS + means translate the position to the nearest character cell. + */ void Fl_Text_Display::xy_to_rowcol( int X, int Y, int *row, - int *column, int posType ) const { + int *column, int posType ) const { int fontHeight = mMaxsize; int fontWidth = TMPFONTWIDTH; //mFontStruct->max_bounds.width; - + /* Find the visible line number corresponding to the Y coordinate */ *row = ( Y - text_area.y ) / fontHeight; if ( *row < 0 ) * row = 0; if ( *row >= mNVisibleLines ) * row = mNVisibleLines - 1; *column = ( ( X - text_area.x ) + mHorizOffset + - ( posType == CURSOR_POS ? fontWidth / 2 : 0 ) ) / fontWidth; + ( posType == CURSOR_POS ? fontWidth / 2 : 0 ) ) / fontWidth; if ( *column < 0 ) * column = 0; } /** - Offset the line starts array, mTopLineNum, mFirstChar and lastChar, for a new - vertical scroll position given by newTopLineNum. If any currently displayed - lines will still be visible, salvage the line starts values, otherwise, - count lines from the nearest known line start (start or end of buffer, or - the closest value in the mLineStarts array) -*/ + Offset the line starts array, mTopLineNum, mFirstChar and lastChar, for a new + vertical scroll position given by newTopLineNum. If any currently displayed + lines will still be visible, salvage the line starts values, otherwise, + count lines from the nearest known line start (start or end of buffer, or + the closest value in the mLineStarts array) + */ void Fl_Text_Display::offset_line_starts( int newTopLineNum ) { int oldTopLineNum = mTopLineNum; int oldFirstChar = mFirstChar; @@ -1853,14 +1859,14 @@ void Fl_Text_Display::offset_line_starts( int newTopLineNum ) { int *lineStarts = mLineStarts; int i, lastLineNum; Fl_Text_Buffer *buf = mBuffer; - + /* If there was no offset, nothing needs to be changed */ if ( lineDelta == 0 ) return; - + /* Find the new value for mFirstChar by counting lines from the nearest - known line start (start or end of buffer, or the closest value in the - lineStarts array) */ + known line start (start or end of buffer, or the closest value in the + lineStarts array) */ lastLineNum = oldTopLineNum + nVisLines - 1; if ( newTopLineNum < oldTopLineNum && newTopLineNum < -lineDelta ) { mFirstChar = skip_lines( 0, newTopLineNum - 1, true ); @@ -1870,11 +1876,11 @@ void Fl_Text_Display::offset_line_starts( int newTopLineNum ) { mFirstChar = lineStarts[ newTopLineNum - oldTopLineNum ]; } else if ( newTopLineNum - lastLineNum < mNBufferLines - newTopLineNum ) { mFirstChar = skip_lines( lineStarts[ nVisLines - 1 ], - newTopLineNum - lastLineNum, true ); + newTopLineNum - lastLineNum, true ); } else { mFirstChar = rewind_lines( buf->length(), mNBufferLines - newTopLineNum + 1 ); } - + /* Fill in the line starts array */ if ( lineDelta < 0 && -lineDelta < nVisLines ) { for ( i = nVisLines - 1; i >= -lineDelta; i-- ) @@ -1886,32 +1892,32 @@ void Fl_Text_Display::offset_line_starts( int newTopLineNum ) { calc_line_starts( nVisLines - lineDelta, nVisLines - 1 ); } else calc_line_starts( 0, nVisLines ); - + /* Set lastChar and mTopLineNum */ calc_last_char(); mTopLineNum = newTopLineNum; - - /* If we're numbering lines or being asked to maintain an absolute line - number, re-calculate the absolute line number */ - absolute_top_line_number(oldFirstChar); + + /* If we're numbering lines or being asked to maintain an absolute line + number, re-calculate the absolute line number */ + absolute_top_line_number(oldFirstChar); } /** - Update the line starts array, mTopLineNum, mFirstChar and lastChar for text - display "textD" after a modification to the text buffer, given by the - position where the change began "pos", and the nmubers of characters - and lines inserted and deleted. -*/ + Update the line starts array, mTopLineNum, mFirstChar and lastChar for text + display "textD" after a modification to the text buffer, given by the + position where the change began "pos", and the nmubers of characters + and lines inserted and deleted. + */ void Fl_Text_Display::update_line_starts( int pos, int charsInserted, - int charsDeleted, int linesInserted, int linesDeleted, int *scrolled ) { + int charsDeleted, int linesInserted, int linesDeleted, int *scrolled ) { int * lineStarts = mLineStarts; int i, lineOfPos, lineOfEnd, nVisLines = mNVisibleLines; int charDelta = charsInserted - charsDeleted; int lineDelta = linesInserted - linesDeleted; - + /* If all of the changes were before the displayed text, the display - doesn't change, just update the top line num and offset the line - start entries and first and last characters */ + doesn't change, just update the top line num and offset the line + start entries and first and last characters */ if ( pos + charsDeleted < mFirstChar ) { mTopLineNum += lineDelta; for ( i = 0; i < nVisLines && lineStarts[i] != -1; i++ ) @@ -1921,16 +1927,16 @@ void Fl_Text_Display::update_line_starts( int pos, int charsInserted, *scrolled = 0; return; } - + /* The change began before the beginning of the displayed text, but - part or all of the displayed text was deleted */ + part or all of the displayed text was deleted */ if ( pos < mFirstChar ) { /* If some text remains in the window, anchor on that */ if ( position_to_line( pos + charsDeleted, &lineOfEnd ) && - ++lineOfEnd < nVisLines && lineStarts[ lineOfEnd ] != -1 ) { + ++lineOfEnd < nVisLines && lineStarts[ lineOfEnd ] != -1 ) { mTopLineNum = max( 1, mTopLineNum + lineDelta ); mFirstChar = rewind_lines( - lineStarts[ lineOfEnd ] + charDelta, lineOfEnd ); + lineStarts[ lineOfEnd ] + charDelta, lineOfEnd ); /* Otherwise anchor on original line number and recount everything */ } else { if ( mTopLineNum > mNBufferLines + lineDelta ) { @@ -1945,12 +1951,12 @@ void Fl_Text_Display::update_line_starts( int pos, int charsInserted, *scrolled = 1; return; } - + /* If the change was in the middle of the displayed text (it usually is), - salvage as much of the line starts array as possible by moving and - offsetting the entries after the changed area, and re-counting the - added lines or the lines beyond the salvaged part of the line starts - array */ + salvage as much of the line starts array as possible by moving and + offsetting the entries after the changed area, and re-counting the + added lines or the lines beyond the salvaged part of the line starts + array */ if ( pos <= mLastChar ) { /* find line on which the change began */ position_to_line( pos, &lineOfPos ); @@ -1961,11 +1967,11 @@ void Fl_Text_Display::update_line_starts( int pos, int charsInserted, } else if ( lineDelta > 0 ) { for ( i = nVisLines - 1; i >= lineOfPos + lineDelta + 1; i-- ) lineStarts[ i ] = lineStarts[ i - lineDelta ] + - ( lineStarts[ i - lineDelta ] == -1 ? 0 : charDelta ); + ( lineStarts[ i - lineDelta ] == -1 ? 0 : charDelta ); } else /* (lineDelta < 0) */ { for ( i = max( 0, lineOfPos + 1 ); i < nVisLines + lineDelta; i++ ) lineStarts[ i ] = lineStarts[ i - lineDelta ] + - ( lineStarts[ i - lineDelta ] == -1 ? 0 : charDelta ); + ( lineStarts[ i - lineDelta ] == -1 ? 0 : charDelta ); } /* fill in the missing line starts */ if ( linesInserted >= 0 ) @@ -1977,9 +1983,9 @@ void Fl_Text_Display::update_line_starts( int pos, int charsInserted, *scrolled = 0; return; } - + /* Change was past the end of the displayed text, but displayable by virtue - of being an insert at the end of the buffer into visible blank lines */ + of being an insert at the end of the buffer into visible blank lines */ if ( empty_vlines() ) { position_to_line( pos, &lineOfPos ); calc_line_starts( lineOfPos, lineOfPos + linesInserted ); @@ -1987,24 +1993,24 @@ void Fl_Text_Display::update_line_starts( int pos, int charsInserted, *scrolled = 0; return; } - + /* Change was beyond the end of the buffer and not visible, do nothing */ *scrolled = 0; } /** - Scan through the text in the "textD"'s buffer and recalculate the line - starts array values beginning at index "startLine" and continuing through - (including) "endLine". It assumes that the line starts entry preceding - "startLine" (or mFirstChar if startLine is 0) is good, and re-counts - newlines to fill in the requested entries. Out of range values for - "startLine" and "endLine" are acceptable. -*/ + Scan through the text in the "textD"'s buffer and recalculate the line + starts array values beginning at index "startLine" and continuing through + (including) "endLine". It assumes that the line starts entry preceding + "startLine" (or mFirstChar if startLine is 0) is good, and re-counts + newlines to fill in the requested entries. Out of range values for + "startLine" and "endLine" are acceptable. + */ void Fl_Text_Display::calc_line_starts( int startLine, int endLine ) { int startPos, bufLen = mBuffer->length(); int line, lineEnd, nextLineStart, nVis = mNVisibleLines; int *lineStarts = mLineStarts; - + /* Clean up (possibly) messy input parameters */ if ( endLine < 0 ) endLine = 0; if ( endLine >= nVis ) endLine = nVis - 1; @@ -2012,34 +2018,34 @@ void Fl_Text_Display::calc_line_starts( int startLine, int endLine ) { if ( startLine >= nVis ) startLine = nVis - 1; if ( startLine > endLine ) return; - + /* Find the last known good line number -> position mapping */ if ( startLine == 0 ) { lineStarts[ 0 ] = mFirstChar; startLine = 1; } startPos = lineStarts[ startLine - 1 ]; - + /* If the starting position is already past the end of the text, - fill in -1's (means no text on line) and return */ + fill in -1's (means no text on line) and return */ if ( startPos == -1 ) { for ( line = startLine; line <= endLine; line++ ) lineStarts[ line ] = -1; return; } - + /* Loop searching for ends of lines and storing the positions of the - start of the next line in lineStarts */ + start of the next line in lineStarts */ for ( line = startLine; line <= endLine; line++ ) { find_line_end(startPos, true, &lineEnd, &nextLineStart); startPos = nextLineStart; if ( startPos >= bufLen ) { /* If the buffer ends with a newline or line break, put - buf->length() in the next line start position (instead of - a -1 which is the normal marker for an empty line) to - indicate that the cursor may safely be displayed there */ + buf->length() in the next line start position (instead of + a -1 which is the normal marker for an empty line) to + indicate that the cursor may safely be displayed there */ if ( line == 0 || ( lineStarts[ line - 1 ] != bufLen && - lineEnd != nextLineStart ) ) { + lineEnd != nextLineStart ) ) { lineStarts[ line ] = bufLen; line++; } @@ -2047,16 +2053,16 @@ void Fl_Text_Display::calc_line_starts( int startLine, int endLine ) { } lineStarts[ line ] = startPos; } - + /* Set any entries beyond the end of the text to -1 */ for ( ; line <= endLine; line++ ) lineStarts[ line ] = -1; } /** - Given a Fl_Text_Display with a complete, up-to-date lineStarts array, update - the lastChar entry to point to the last buffer position displayed. -*/ + Given a Fl_Text_Display with a complete, up-to-date lineStarts array, update + the lastChar entry to point to the last buffer position displayed. + */ void Fl_Text_Display::calc_last_char() { int i; for (i = mNVisibleLines - 1; i >= 0 && mLineStarts[i] == -1; i--) ; @@ -2075,58 +2081,58 @@ void Fl_Text_Display::scroll_(int topLineNum, int horizOffset) { if (topLineNum > mNBufferLines + 3 - mNVisibleLines) topLineNum = mNBufferLines + 3 - mNVisibleLines; if (topLineNum < 1) topLineNum = 1; - + if (horizOffset > longest_vline() - text_area.w) horizOffset = longest_vline() - text_area.w; if (horizOffset < 0) horizOffset = 0; - + /* Do nothing if scroll position hasn't actually changed or there's no - window to draw in yet */ + window to draw in yet */ if (mHorizOffset == horizOffset && mTopLineNum == topLineNum) return; - + /* If the vertical scroll position has changed, update the line - starts array and related counters in the text display */ + starts array and related counters in the text display */ offset_line_starts(topLineNum); - + /* Just setting mHorizOffset is enough information for redisplay */ mHorizOffset = horizOffset; - + // redraw all text damage(FL_DAMAGE_EXPOSE); } /** - Update the minimum, maximum, slider size, page increment, and value - for vertical scroll bar. -*/ + Update the minimum, maximum, slider size, page increment, and value + for vertical scroll bar. + */ void Fl_Text_Display::update_v_scrollbar() { /* The Vert. scroll bar value and slider size directly represent the top - line number, and the number of visible lines respectively. The scroll - bar maximum value is chosen to generally represent the size of the whole - buffer, with minor adjustments to keep the scroll bar widget happy */ + line number, and the number of visible lines respectively. The scroll + bar maximum value is chosen to generally represent the size of the whole + buffer, with minor adjustments to keep the scroll bar widget happy */ #ifdef DEBUG printf("Fl_Text_Display::update_v_scrollbar():\n" " mTopLineNum=%d, mNVisibleLines=%d, mNBufferLines=%d\n", mTopLineNum, mNVisibleLines, mNBufferLines); #endif // DEBUG - + mVScrollBar->value(mTopLineNum, mNVisibleLines, 1, mNBufferLines+2); mVScrollBar->linesize(3); } /** - Update the minimum, maximum, slider size, page increment, and value - for the horizontal scroll bar. -*/ + Update the minimum, maximum, slider size, page increment, and value + for the horizontal scroll bar. + */ void Fl_Text_Display::update_h_scrollbar() { int sliderMax = max(longest_vline(), text_area.w + mHorizOffset); mHScrollBar->value( mHorizOffset, text_area.w, 0, sliderMax ); } /** - Callbacks for drag or valueChanged on scroll bars -*/ + Callbacks for drag or valueChanged on scroll bars + */ void Fl_Text_Display::v_scrollbar_cb(Fl_Scrollbar* b, Fl_Text_Display* textD) { if (b->value() == textD->mTopLineNum) return; textD->scroll(b->value(), textD->mHorizOffset); @@ -2138,62 +2144,62 @@ void Fl_Text_Display::h_scrollbar_cb(Fl_Scrollbar* b, Fl_Text_Display* textD) { } /** - Refresh the line number area. If clearAll is False, writes only over - the character cell areas. Setting clearAll to True will clear out any - stray marks outside of the character cell area, which might have been - left from before a resize or font change. -*/ + Refresh the line number area. If clearAll is False, writes only over + the character cell areas. Setting clearAll to True will clear out any + stray marks outside of the character cell area, which might have been + left from before a resize or font change. + */ void Fl_Text_Display::draw_line_numbers(bool /*clearAll*/) { #if 0 - // FIXME: don't want this yet, so will leave for another time - - int y, line, visLine, nCols, lineStart; - char lineNumString[12]; - int lineHeight = mMaxsize ? mMaxsize : textsize_; - int charWidth = TMPFONTWIDTH; //mFontStruct->max_bounds.width; - - /* Don't draw if mLineNumWidth == 0 (line numbers are hidden), or widget is - not yet realized */ - if (mLineNumWidth == 0 || visible_r()) - return; - - /* GC is allocated on demand, since not everyone will use line numbering */ - if (textD->lineNumGC == NULL) { - XGCValues values; - values.foreground = textD->lineNumFGPixel; - values.background = textD->bgPixel; - values.font = textD->fontStruct->fid; - textD->lineNumGC = XtGetGC(textD->w, - GCFont| GCForeground | GCBackground, &values); - } - - /* Erase the previous contents of the line number area, if requested */ - if (clearAll) - XClearArea(XtDisplay(textD->w), XtWindow(textD->w), textD->lineNumLeft, - textD->top, textD->lineNumWidth, textD->height, False); - - /* Draw the line numbers, aligned to the text */ - nCols = min(11, textD->lineNumWidth / charWidth); - y = textD->top; - line = getAbsTopLineNum(textD); - for (visLine=0; visLine < textD->nVisibleLines; visLine++) { - lineStart = textD->lineStarts[visLine]; - if (lineStart != -1 && (lineStart==0 || - BufGetCharacter(textD->buffer, lineStart-1)=='\n')) { - sprintf(lineNumString, "%*d", nCols, line); - XDrawImageString(XtDisplay(textD->w), XtWindow(textD->w), - textD->lineNumGC, textD->lineNumLeft, y + textD->ascent, - lineNumString, strlen(lineNumString)); - line++; - } else { - XClearArea(XtDisplay(textD->w), XtWindow(textD->w), - textD->lineNumLeft, y, textD->lineNumWidth, - textD->ascent + textD->descent, False); - if (visLine == 0) - line++; - } - y += lineHeight; + // FIXME: don't want this yet, so will leave for another time + + int y, line, visLine, nCols, lineStart; + char lineNumString[12]; + int lineHeight = mMaxsize ? mMaxsize : textsize_; + int charWidth = TMPFONTWIDTH; //mFontStruct->max_bounds.width; + + /* Don't draw if mLineNumWidth == 0 (line numbers are hidden), or widget is + not yet realized */ + if (mLineNumWidth == 0 || visible_r()) + return; + + /* GC is allocated on demand, since not everyone will use line numbering */ + if (textD->lineNumGC == NULL) { + XGCValues values; + values.foreground = textD->lineNumFGPixel; + values.background = textD->bgPixel; + values.font = textD->fontStruct->fid; + textD->lineNumGC = XtGetGC(textD->w, + GCFont| GCForeground | GCBackground, &values); + } + + /* Erase the previous contents of the line number area, if requested */ + if (clearAll) + XClearArea(XtDisplay(textD->w), XtWindow(textD->w), textD->lineNumLeft, + textD->top, textD->lineNumWidth, textD->height, False); + + /* Draw the line numbers, aligned to the text */ + nCols = min(11, textD->lineNumWidth / charWidth); + y = textD->top; + line = getAbsTopLineNum(textD); + for (visLine=0; visLine < textD->nVisibleLines; visLine++) { + lineStart = textD->lineStarts[visLine]; + if (lineStart != -1 && (lineStart==0 || + BufGetCharacter(textD->buffer, lineStart-1)=='\n')) { + sprintf(lineNumString, "%*d", nCols, line); + XDrawImageString(XtDisplay(textD->w), XtWindow(textD->w), + textD->lineNumGC, textD->lineNumLeft, y + textD->ascent, + lineNumString, strlen(lineNumString)); + line++; + } else { + XClearArea(XtDisplay(textD->w), XtWindow(textD->w), + textD->lineNumLeft, y, textD->lineNumWidth, + textD->ascent + textD->descent, False); + if (visLine == 0) + line++; } + y += lineHeight; + } #endif } @@ -2206,50 +2212,49 @@ static int min( int i1, int i2 ) { } /** - Count the number of newlines in a null-terminated text string; -*/ + Count the number of newlines in a null-terminated text string; + */ static int countlines( const char *string ) { const char * c; int lineCount = 0; - + if (!string) return 0; - + for ( c = string; *c != '\0'; c++ ) if ( *c == '\n' ) lineCount++; return lineCount; } /** - Return the width in pixels of the displayed line pointed to by "visLineNum" -*/ + Return the width in pixels of the displayed line pointed to by "visLineNum" + */ int Fl_Text_Display::measure_vline( int visLineNum ) const { // FIXME: the horizontal scroll bar is still messed up. Clicking the right container is not possible. int lineLen = vline_length( visLineNum ); int lineStartPos = mLineStarts[ visLineNum ]; if (lineStartPos < 0 || lineLen == 0) return 0; return handle_vline(GET_WIDTH, lineStartPos, lineLen, 0, 0, 0, 0, 0, 0); - } +} /** - Return true if there are lines visible with no corresponding buffer text -*/ + Return true if there are lines visible with no corresponding buffer text + */ int Fl_Text_Display::empty_vlines() const { - return mNVisibleLines > 0 && - mLineStarts[ mNVisibleLines - 1 ] == -1; + return (mNVisibleLines > 0) && (mLineStarts[ mNVisibleLines - 1 ] == -1); } /** - Return the length of a line (number of displayable characters) by examining - entries in the line starts array rather than by scanning for newlines -*/ + Return the length of a line (number of displayable characters) by examining + entries in the line starts array rather than by scanning for newlines + */ int Fl_Text_Display::vline_length( int visLineNum ) const { int nextLineStart, lineStartPos; - + if (visLineNum < 0 || visLineNum >= mNVisibleLines) return (0); - + lineStartPos = mLineStarts[ visLineNum ]; - + if ( lineStartPos == -1 ) return 0; if ( visLineNum + 1 >= mNVisibleLines ) @@ -2263,480 +2268,480 @@ int Fl_Text_Display::vline_length( int visLineNum ) const { } /** - When continuous wrap is on, and the user inserts or deletes characters, - wrapping can happen before and beyond the changed position. This routine - finds the extent of the changes, and counts the deleted and inserted lines - over that range. It also attempts to minimize the size of the range to - what has to be counted and re-displayed, so the results can be useful - both for delimiting where the line starts need to be recalculated, and - for deciding what part of the text to redisplay. -*/ + When continuous wrap is on, and the user inserts or deletes characters, + wrapping can happen before and beyond the changed position. This routine + finds the extent of the changes, and counts the deleted and inserted lines + over that range. It also attempts to minimize the size of the range to + what has to be counted and re-displayed, so the results can be useful + both for delimiting where the line starts need to be recalculated, and + for deciding what part of the text to redisplay. + */ void Fl_Text_Display::find_wrap_range(const char *deletedText, int pos, - int nInserted, int nDeleted, int *modRangeStart, int *modRangeEnd, - int *linesInserted, int *linesDeleted) { - int length, retPos, retLines, retLineStart, retLineEnd; - Fl_Text_Buffer *deletedTextBuf, *buf = buffer(); - int nVisLines = mNVisibleLines; - int *lineStarts = mLineStarts; - int countFrom, countTo, lineStart, adjLineStart, i; - int visLineNum = 0, nLines = 0; - - /* - ** Determine where to begin searching: either the previous newline, or - ** if possible, limit to the start of the (original) previous displayed - ** line, using information from the existing line starts array - */ - if (pos >= mFirstChar && pos <= mLastChar) { - for (i=nVisLines-1; i>0; i--) - if (lineStarts[i] != -1 && pos >= lineStarts[i]) - break; - if (i > 0) { - countFrom = lineStarts[i-1]; - visLineNum = i-1; - } else - countFrom = buf->line_start(pos); + int nInserted, int nDeleted, int *modRangeStart, int *modRangeEnd, + int *linesInserted, int *linesDeleted) { + int length, retPos, retLines, retLineStart, retLineEnd; + Fl_Text_Buffer *deletedTextBuf, *buf = buffer(); + int nVisLines = mNVisibleLines; + int *lineStarts = mLineStarts; + int countFrom, countTo, lineStart, adjLineStart, i; + int visLineNum = 0, nLines = 0; + + /* + ** Determine where to begin searching: either the previous newline, or + ** if possible, limit to the start of the (original) previous displayed + ** line, using information from the existing line starts array + */ + if (pos >= mFirstChar && pos <= mLastChar) { + for (i=nVisLines-1; i>0; i--) + if (lineStarts[i] != -1 && pos >= lineStarts[i]) + break; + if (i > 0) { + countFrom = lineStarts[i-1]; + visLineNum = i-1; } else - countFrom = buf->line_start(pos); - + countFrom = buf->line_start(pos); + } else + countFrom = buf->line_start(pos); + + + /* + ** Move forward through the (new) text one line at a time, counting + ** displayed lines, and looking for either a real newline, or for the + ** line starts to re-sync with the original line starts array + */ + lineStart = countFrom; + *modRangeStart = countFrom; + for (;;) { - /* - ** Move forward through the (new) text one line at a time, counting - ** displayed lines, and looking for either a real newline, or for the - ** line starts to re-sync with the original line starts array - */ - lineStart = countFrom; - *modRangeStart = countFrom; - for (;;) { - - /* advance to the next line. If the line ended in a real newline - or the end of the buffer, that's far enough */ - wrapped_line_counter(buf, lineStart, buf->length(), 1, true, 0, - &retPos, &retLines, &retLineStart, &retLineEnd); - if (retPos >= buf->length()) { - countTo = buf->length(); - *modRangeEnd = countTo; - if (retPos != retLineEnd) - nLines++; - break; - } else - lineStart = retPos; - nLines++; - if (lineStart > pos + nInserted && - // FIXME: character is ucs-4 + /* advance to the next line. If the line ended in a real newline + or the end of the buffer, that's far enough */ + wrapped_line_counter(buf, lineStart, buf->length(), 1, true, 0, + &retPos, &retLines, &retLineStart, &retLineEnd); + if (retPos >= buf->length()) { + countTo = buf->length(); + *modRangeEnd = countTo; + if (retPos != retLineEnd) + nLines++; + break; + } else + lineStart = retPos; + nLines++; + if (lineStart > pos + nInserted && + // FIXME: character is ucs-4 buf->char_at(lineStart-1) == '\n') { - countTo = lineStart; - *modRangeEnd = lineStart; - break; - } - - /* Don't try to resync in continuous wrap mode with non-fixed font - sizes; it would result in a chicken-and-egg dependency between - the calculations for the inserted and the deleted lines. - If we're in that mode, the number of deleted lines is calculated in - advance, without resynchronization, so we shouldn't resynchronize - for the inserted lines either. */ - if (mSuppressResync) - continue; - - /* check for synchronization with the original line starts array - before pos, if so, the modified range can begin later */ - if (lineStart <= pos) { - while (visLineNum pos + nInserted) { - adjLineStart = lineStart - nInserted + nDeleted; - while (visLineNumcopy(buffer(), countFrom, pos, 0); - if (nDeleted != 0) - deletedTextBuf->insert(pos-countFrom, deletedText); - deletedTextBuf->copy(buffer(), - pos+nInserted, countTo, pos-countFrom+nDeleted); - /* Note that we need to take into account an offset for the style buffer: - the deletedTextBuf can be out of sync with the style buffer. */ - wrapped_line_counter(deletedTextBuf, 0, length, INT_MAX, true, - countFrom, &retPos, &retLines, &retLineStart, &retLineEnd, false); - delete deletedTextBuf; - *linesDeleted = retLines; + + /* check for synchronization with the original line starts array + after pos, if so, the modified range can end early */ + else if (lineStart > pos + nInserted) { + adjLineStart = lineStart - nInserted + nDeleted; + while (visLineNumcopy(buffer(), countFrom, pos, 0); + if (nDeleted != 0) + deletedTextBuf->insert(pos-countFrom, deletedText); + deletedTextBuf->copy(buffer(), + pos+nInserted, countTo, pos-countFrom+nDeleted); + /* Note that we need to take into account an offset for the style buffer: + the deletedTextBuf can be out of sync with the style buffer. */ + wrapped_line_counter(deletedTextBuf, 0, length, INT_MAX, true, + countFrom, &retPos, &retLines, &retLineStart, &retLineEnd, false); + delete deletedTextBuf; + *linesDeleted = retLines; + mSuppressResync = 0; } /** - This is a stripped-down version of the findWrapRange() function above, - intended to be used to calculate the number of "deleted" lines during - a buffer modification. It is called _before_ the modification takes place. - - This function should only be called in continuous wrap mode with a - non-fixed font width. In that case, it is impossible to calculate - the number of deleted lines, because the necessary style information - is no longer available _after_ the modification. In other cases, we - can still perform the calculation afterwards (possibly even more - efficiently). -*/ + This is a stripped-down version of the findWrapRange() function above, + intended to be used to calculate the number of "deleted" lines during + a buffer modification. It is called _before_ the modification takes place. + + This function should only be called in continuous wrap mode with a + non-fixed font width. In that case, it is impossible to calculate + the number of deleted lines, because the necessary style information + is no longer available _after_ the modification. In other cases, we + can still perform the calculation afterwards (possibly even more + efficiently). + */ void Fl_Text_Display::measure_deleted_lines(int pos, int nDeleted) { - int retPos, retLines, retLineStart, retLineEnd; - Fl_Text_Buffer *buf = buffer(); - int nVisLines = mNVisibleLines; - int *lineStarts = mLineStarts; - int countFrom, lineStart; - int visLineNum = 0, nLines = 0, i; - /* - ** Determine where to begin searching: either the previous newline, or - ** if possible, limit to the start of the (original) previous displayed - ** line, using information from the existing line starts array - */ - if (pos >= mFirstChar && pos <= mLastChar) { - for (i=nVisLines-1; i>0; i--) - if (lineStarts[i] != -1 && pos >= lineStarts[i]) - break; - if (i > 0) { - countFrom = lineStarts[i-1]; - visLineNum = i-1; - } else - countFrom = buf->line_start(pos); + int retPos, retLines, retLineStart, retLineEnd; + Fl_Text_Buffer *buf = buffer(); + int nVisLines = mNVisibleLines; + int *lineStarts = mLineStarts; + int countFrom, lineStart; + int visLineNum = 0, nLines = 0, i; + /* + ** Determine where to begin searching: either the previous newline, or + ** if possible, limit to the start of the (original) previous displayed + ** line, using information from the existing line starts array + */ + if (pos >= mFirstChar && pos <= mLastChar) { + for (i=nVisLines-1; i>0; i--) + if (lineStarts[i] != -1 && pos >= lineStarts[i]) + break; + if (i > 0) { + countFrom = lineStarts[i-1]; + visLineNum = i-1; } else - countFrom = buf->line_start(pos); - - /* - ** Move forward through the (new) text one line at a time, counting - ** displayed lines, and looking for either a real newline, or for the - ** line starts to re-sync with the original line starts array - */ - lineStart = countFrom; - for (;;) { - /* advance to the next line. If the line ended in a real newline - or the end of the buffer, that's far enough */ - wrapped_line_counter(buf, lineStart, buf->length(), 1, true, 0, - &retPos, &retLines, &retLineStart, &retLineEnd); - if (retPos >= buf->length()) { - if (retPos != retLineEnd) - nLines++; - break; - } else - lineStart = retPos; - nLines++; - if (lineStart > pos + nDeleted && - // FIXME: character is ucs-4 + countFrom = buf->line_start(pos); + } else + countFrom = buf->line_start(pos); + + /* + ** Move forward through the (new) text one line at a time, counting + ** displayed lines, and looking for either a real newline, or for the + ** line starts to re-sync with the original line starts array + */ + lineStart = countFrom; + for (;;) { + /* advance to the next line. If the line ended in a real newline + or the end of the buffer, that's far enough */ + wrapped_line_counter(buf, lineStart, buf->length(), 1, true, 0, + &retPos, &retLines, &retLineStart, &retLineEnd); + if (retPos >= buf->length()) { + if (retPos != retLineEnd) + nLines++; + break; + } else + lineStart = retPos; + nLines++; + if (lineStart > pos + nDeleted && + // FIXME: character is ucs-4 buf->char_at(lineStart-1) == '\n') { - break; - } - - /* Unlike in the findWrapRange() function above, we don't try to - resync with the line starts, because we don't know the length - of the inserted text yet, nor the updated style information. - - Because of that, we also shouldn't resync with the line starts - after the modification either, because we must perform the - calculations for the deleted and inserted lines in the same way. - - This can result in some unnecessary recalculation and redrawing - overhead, and therefore we should only use this two-phase mode - of calculation when it's really needed (continuous wrap + variable - font width). */ + break; } - mNLinesDeleted = nLines; - mSuppressResync = 1; + + /* Unlike in the findWrapRange() function above, we don't try to + resync with the line starts, because we don't know the length + of the inserted text yet, nor the updated style information. + + Because of that, we also shouldn't resync with the line starts + after the modification either, because we must perform the + calculations for the deleted and inserted lines in the same way. + + This can result in some unnecessary recalculation and redrawing + overhead, and therefore we should only use this two-phase mode + of calculation when it's really needed (continuous wrap + variable + font width). */ + } + mNLinesDeleted = nLines; + mSuppressResync = 1; } /** - Count forward from startPos to either maxPos or maxLines (whichever is - reached first), and return all relevant positions and line count. - The provided textBuffer may differ from the actual text buffer of the - widget. In that case it must be a (partial) copy of the actual text buffer - and the styleBufOffset argument must indicate the starting position of the - copy, to take into account the correct style information. -** - Returned values: -** - retPos: Position where counting ended. When counting lines, the - position returned is the start of the line "maxLines" - lines beyond "startPos". - retLines: Number of line breaks counted - retLineStart: Start of the line where counting ended - retLineEnd: End position of the last line traversed -*/ + Count forward from startPos to either maxPos or maxLines (whichever is + reached first), and return all relevant positions and line count. + The provided textBuffer may differ from the actual text buffer of the + widget. In that case it must be a (partial) copy of the actual text buffer + and the styleBufOffset argument must indicate the starting position of the + copy, to take into account the correct style information. + ** + Returned values: + ** + retPos: Position where counting ended. When counting lines, the + position returned is the start of the line "maxLines" + lines beyond "startPos". + retLines: Number of line breaks counted + retLineStart: Start of the line where counting ended + retLineEnd: End position of the last line traversed + */ void Fl_Text_Display::wrapped_line_counter(Fl_Text_Buffer *buf, int startPos, - int maxPos, int maxLines, bool startPosIsLineStart, int styleBufOffset, - int *retPos, int *retLines, int *retLineStart, int *retLineEnd, - bool countLastLineMissingNewLine) const { - int lineStart, newLineStart = 0, b, p, colNum, wrapMargin; - int maxWidth, i, foundBreak, width; - bool countPixels; + int maxPos, int maxLines, bool startPosIsLineStart, int styleBufOffset, + int *retPos, int *retLines, int *retLineStart, int *retLineEnd, + bool countLastLineMissingNewLine) const { + int lineStart, newLineStart = 0, b, p, colNum, wrapMargin; + int maxWidth, i, foundBreak, width; + bool countPixels; int nLines = 0; - unsigned char c; - - /* If the font is fixed, or there's a wrap margin set, it's more efficient - to measure in columns, than to count pixels. Determine if we can count - in columns (countPixels == False) or must count pixels (countPixels == - True), and set the wrap target for either pixels or columns */ + unsigned char c; + + /* If the font is fixed, or there's a wrap margin set, it's more efficient + to measure in columns, than to count pixels. Determine if we can count + in columns (countPixels == False) or must count pixels (countPixels == + True), and set the wrap target for either pixels or columns */ if (mWrapMargin != 0) { // FIXME: the warp margin is actually a pixel boundary, so we have to measure nevertheless! - countPixels = false; + countPixels = false; wrapMargin = mWrapMargin; - maxWidth = INT_MAX; - } else { - countPixels = true; - wrapMargin = INT_MAX; - maxWidth = text_area.w; - } - - /* Find the start of the line if the start pos is not marked as a - line start. */ - if (startPosIsLineStart) - lineStart = startPos; - else - lineStart = line_start(startPos); - - /* - ** Loop until position exceeds maxPos or line count exceeds maxLines. + maxWidth = INT_MAX; + } else { + countPixels = true; + wrapMargin = INT_MAX; + maxWidth = text_area.w; + } + + /* Find the start of the line if the start pos is not marked as a + line start. */ + if (startPosIsLineStart) + lineStart = startPos; + else + lineStart = line_start(startPos); + + /* + ** Loop until position exceeds maxPos or line count exceeds maxLines. ** (actually, continues beyond maxPos to end of line containing maxPos, - ** in case later characters cause a word wrap back before maxPos) - */ - colNum = 0; - width = 0; - for (p=lineStart; plength(); p++) { - // FIXME: character is ucs-4 + ** in case later characters cause a word wrap back before maxPos) + */ + colNum = 0; + width = 0; + for (p=lineStart; plength(); p++) { + // FIXME: character is ucs-4 c = (unsigned char)buf->char_at(p); - - /* If the character was a newline, count the line and start over, - otherwise, add it to the width and column counts */ - if (c == '\n') { - if (p >= maxPos) { - *retPos = maxPos; - *retLines = nLines; - *retLineStart = lineStart; - *retLineEnd = maxPos; - return; - } - nLines++; - if (nLines >= maxLines) { - *retPos = p + 1; - *retLines = nLines; - *retLineStart = p + 1; - *retLineEnd = p; - return; - } - lineStart = p + 1; - colNum = 0; - width = 0; - } else { - const char *s = buf->address(p); + + /* If the character was a newline, count the line and start over, + otherwise, add it to the width and column counts */ + if (c == '\n') { + if (p >= maxPos) { + *retPos = maxPos; + *retLines = nLines; + *retLineStart = lineStart; + *retLineEnd = maxPos; + return; + } + nLines++; + if (nLines >= maxLines) { + *retPos = p + 1; + *retLines = nLines; + *retLineStart = p + 1; + *retLineEnd = p; + return; + } + lineStart = p + 1; + colNum = 0; + width = 0; + } else { + const char *s = buf->address(p); colNum++; - if (countPixels) - width += measure_proportional_character(s, colNum, p+styleBufOffset); - } - - /* If character exceeded wrap margin, find the break point - and wrap there */ - if (colNum > wrapMargin || width > maxWidth) { - foundBreak = false; - for (b=p; b>=lineStart; b--) { - // FIXME: character is ucs-4 + if (countPixels) + width += measure_proportional_character(s, colNum, p+styleBufOffset); + } + + /* If character exceeded wrap margin, find the break point + and wrap there */ + if (colNum > wrapMargin || width > maxWidth) { + foundBreak = false; + for (b=p; b>=lineStart; b--) { + // FIXME: character is ucs-4 c = (unsigned char)buf->char_at(b); - if (c == '\t' || c == ' ') { - newLineStart = b + 1; - if (countPixels) { - colNum = 0; - width = 0; - for (i=b+1; iaddress(i), colNum, - i+styleBufOffset); - colNum++; - } - } else - colNum = buf->count_displayed_characters(b+1, p+1); - foundBreak = true; - break; - } - } - if (!foundBreak) { /* no whitespace, just break at margin */ - newLineStart = max(p, lineStart+1); - const char *s = buf->address(b); + if (c == '\t' || c == ' ') { + newLineStart = b + 1; + if (countPixels) { + colNum = 0; + width = 0; + for (i=b+1; iaddress(i), colNum, + i+styleBufOffset); + colNum++; + } + } else + colNum = buf->count_displayed_characters(b+1, p+1); + foundBreak = true; + break; + } + } + if (!foundBreak) { /* no whitespace, just break at margin */ + newLineStart = max(p, lineStart+1); + const char *s = buf->address(b); colNum++; - if (countPixels) - width = measure_proportional_character(s, colNum, p+styleBufOffset); - } - if (p >= maxPos) { - *retPos = maxPos; - *retLines = maxPos < newLineStart ? nLines : nLines + 1; - *retLineStart = maxPos < newLineStart ? lineStart : - newLineStart; - *retLineEnd = maxPos; - return; - } - nLines++; - if (nLines >= maxLines) { - *retPos = foundBreak ? b + 1 : max(p, lineStart+1); - *retLines = nLines; - *retLineStart = lineStart; - *retLineEnd = foundBreak ? b : p; - return; - } - lineStart = newLineStart; - } + if (countPixels) + width = measure_proportional_character(s, colNum, p+styleBufOffset); + } + if (p >= maxPos) { + *retPos = maxPos; + *retLines = maxPos < newLineStart ? nLines : nLines + 1; + *retLineStart = maxPos < newLineStart ? lineStart : + newLineStart; + *retLineEnd = maxPos; + return; + } + nLines++; + if (nLines >= maxLines) { + *retPos = foundBreak ? b + 1 : max(p, lineStart+1); + *retLines = nLines; + *retLineStart = lineStart; + *retLineEnd = foundBreak ? b : p; + return; + } + lineStart = newLineStart; } - - /* reached end of buffer before reaching pos or line target */ - *retPos = buf->length(); - *retLines = nLines; - if (countLastLineMissingNewLine && colNum > 0) - ++(*retLines); - *retLineStart = lineStart; - *retLineEnd = buf->length(); + } + + /* reached end of buffer before reaching pos or line target */ + *retPos = buf->length(); + *retLines = nLines; + if (countLastLineMissingNewLine && colNum > 0) + ++(*retLines); + *retLineStart = lineStart; + *retLineEnd = buf->length(); } /** - Measure the width in pixels of the first character of string "s" at a - particular column "colNum" and buffer position "pos". This is for measuring - characters in proportional or mixed-width highlighting fonts. -** - A note about proportional and mixed-width fonts: the mixed width and - proportional font code in nedit does not get much use in general editing, - because nedit doesn't allow per-language-mode fonts, and editing programs - in a proportional font is usually a bad idea, so very few users would - choose a proportional font as a default. There are still probably mixed- - width syntax highlighting cases where things don't redraw properly for - insertion/deletion, though static display and wrapping and resizing - should now be solid because they are now used for online help display. -*/ + Measure the width in pixels of the first character of string "s" at a + particular column "colNum" and buffer position "pos". This is for measuring + characters in proportional or mixed-width highlighting fonts. + ** + A note about proportional and mixed-width fonts: the mixed width and + proportional font code in nedit does not get much use in general editing, + because nedit doesn't allow per-language-mode fonts, and editing programs + in a proportional font is usually a bad idea, so very few users would + choose a proportional font as a default. There are still probably mixed- + width syntax highlighting cases where things don't redraw properly for + insertion/deletion, though static display and wrapping and resizing + should now be solid because they are now used for online help display. + */ int Fl_Text_Display::measure_proportional_character(const char *s, int colNum, int pos) const { int charLen = fl_utf8len(*s), style = 0; if (mStyleBuffer) { const char *b = mStyleBuffer->address(pos); style = *b; - } + } return string_width(s, charLen, style); - } +} /** - Finds both the end of the current line and the start of the next line. Why? - In continuous wrap mode, if you need to know both, figuring out one from the - other can be expensive or error prone. The problem comes when there's a - trailing space or tab just before the end of the buffer. To translate an - end of line value to or from the next lines start value, you need to know - whether the trailing space or tab is being used as a line break or just a - normal character, and to find that out would otherwise require counting all - the way back to the beginning of the line. -*/ + Finds both the end of the current line and the start of the next line. Why? + In continuous wrap mode, if you need to know both, figuring out one from the + other can be expensive or error prone. The problem comes when there's a + trailing space or tab just before the end of the buffer. To translate an + end of line value to or from the next lines start value, you need to know + whether the trailing space or tab is being used as a line break or just a + normal character, and to find that out would otherwise require counting all + the way back to the beginning of the line. + */ void Fl_Text_Display::find_line_end(int startPos, bool startPosIsLineStart, - int *lineEnd, int *nextLineStart) const { - int retLines, retLineStart; - - /* if we're not wrapping use more efficient BufEndOfLine */ - if (!mContinuousWrap) { - *lineEnd = buffer()->line_end(startPos); - *nextLineStart = min(buffer()->length(), *lineEnd + 1); - return; - } - - /* use the wrapped line counter routine to count forward one line */ - wrapped_line_counter(buffer(), startPos, buffer()->length(), - 1, startPosIsLineStart, 0, nextLineStart, &retLines, - &retLineStart, lineEnd); + int *lineEnd, int *nextLineStart) const { + int retLines, retLineStart; + + /* if we're not wrapping use more efficient BufEndOfLine */ + if (!mContinuousWrap) { + *lineEnd = buffer()->line_end(startPos); + *nextLineStart = min(buffer()->length(), *lineEnd + 1); return; + } + + /* use the wrapped line counter routine to count forward one line */ + wrapped_line_counter(buffer(), startPos, buffer()->length(), + 1, startPosIsLineStart, 0, nextLineStart, &retLines, + &retLineStart, lineEnd); + return; } /** - Line breaks in continuous wrap mode usually happen at newlines or - whitespace. This line-terminating character is not included in line - width measurements and has a special status as a non-visible character. - However, lines with no whitespace are wrapped without the benefit of a - line terminating character, and this distinction causes endless trouble - with all of the text display code which was originally written without - continuous wrap mode and always expects to wrap at a newline character. -** - Given the position of the end of the line, as returned by TextDEndOfLine - or BufEndOfLine, this returns true if there is a line terminating - character, and false if there's not. On the last character in the - buffer, this function can't tell for certain whether a trailing space was - used as a wrap point, and just guesses that it wasn't. So if an exact - accounting is necessary, don't use this function. -*/ + Line breaks in continuous wrap mode usually happen at newlines or + whitespace. This line-terminating character is not included in line + width measurements and has a special status as a non-visible character. + However, lines with no whitespace are wrapped without the benefit of a + line terminating character, and this distinction causes endless trouble + with all of the text display code which was originally written without + continuous wrap mode and always expects to wrap at a newline character. + ** + Given the position of the end of the line, as returned by TextDEndOfLine + or BufEndOfLine, this returns true if there is a line terminating + character, and false if there's not. On the last character in the + buffer, this function can't tell for certain whether a trailing space was + used as a wrap point, and just guesses that it wasn't. So if an exact + accounting is necessary, don't use this function. + */ int Fl_Text_Display::wrap_uses_character(int lineEndPos) const { - char c; - - if (!mContinuousWrap || lineEndPos == buffer()->length()) - return 1; - + char c; + + if (!mContinuousWrap || lineEndPos == buffer()->length()) + return 1; + // FIXME: character is ucs-4 c = buffer()->char_at(lineEndPos); - return c == '\n' || ((c == '\t' || c == ' ') && - lineEndPos + 1 != buffer()->length()); + return c == '\n' || ((c == '\t' || c == ' ') && + lineEndPos + 1 != buffer()->length()); } /** - Extend the range of a redraw request (from *start to *end) with additional - redraw requests resulting from changes to the attached style buffer (which - contains auxiliary information for coloring or styling text). -*/ + Extend the range of a redraw request (from *start to *end) with additional + redraw requests resulting from changes to the attached style buffer (which + contains auxiliary information for coloring or styling text). + */ void Fl_Text_Display::extend_range_for_styles( int *startpos, int *endpos ) { Fl_Text_Selection * sel = mStyleBuffer->primary_selection(); int extended = 0; - + /* The peculiar protocol used here is that modifications to the style - buffer are marked by selecting them with the buffer's primary Fl_Text_Selection. - The style buffer is usually modified in response to a modify callback on - the text buffer BEFORE Fl_Text_Display.c's modify callback, so that it can keep - the style buffer in step with the text buffer. The style-update - callback can't just call for a redraw, because Fl_Text_Display hasn't processed - the original text changes yet. Anyhow, to minimize redrawing and to - avoid the complexity of scheduling redraws later, this simple protocol - tells the text display's buffer modify callback to extend it's redraw - range to show the text color/and font changes as well. */ + buffer are marked by selecting them with the buffer's primary Fl_Text_Selection. + The style buffer is usually modified in response to a modify callback on + the text buffer BEFORE Fl_Text_Display.c's modify callback, so that it can keep + the style buffer in step with the text buffer. The style-update + callback can't just call for a redraw, because Fl_Text_Display hasn't processed + the original text changes yet. Anyhow, to minimize redrawing and to + avoid the complexity of scheduling redraws later, this simple protocol + tells the text display's buffer modify callback to extend it's redraw + range to show the text color/and font changes as well. */ if ( sel->selected() ) { if ( sel->start() < *startpos ) { *startpos = sel->start(); @@ -2747,10 +2752,10 @@ void Fl_Text_Display::extend_range_for_styles( int *startpos, int *endpos ) { extended = 1; } } - + /* If the Fl_Text_Selection was extended due to a style change, and some of the - fonts don't match in spacing, extend redraw area to end of line to - redraw characters exposed by possible font size changes */ + fonts don't match in spacing, extend redraw area to end of line to + redraw characters exposed by possible font size changes */ if ( extended ) *endpos = mBuffer->line_end( *endpos ) + 1; } @@ -2759,49 +2764,49 @@ void Fl_Text_Display::extend_range_for_styles( int *startpos, int *endpos ) { void Fl_Text_Display::draw(void) { // don't even try if there is no associated text buffer! if (!buffer()) { draw_box(); return; } - + fl_push_clip(x(),y(),w(),h()); // prevent drawing outside widget area - + // draw the non-text, non-scrollbar areas. if (damage() & FL_DAMAGE_ALL) { -// printf("drawing all (box = %d)\n", box()); + // printf("drawing all (box = %d)\n", box()); // draw the box() int W = w(), H = h(); draw_box(box(), x(), y(), W, H, color()); - + if (mHScrollBar->visible()) W -= scrollbar_width(); if (mVScrollBar->visible()) H -= scrollbar_width(); - + // left margin fl_rectf(text_area.x-LEFT_MARGIN, text_area.y-TOP_MARGIN, LEFT_MARGIN, text_area.h+TOP_MARGIN+BOTTOM_MARGIN, color()); - + // right margin fl_rectf(text_area.x+text_area.w, text_area.y-TOP_MARGIN, RIGHT_MARGIN, text_area.h+TOP_MARGIN+BOTTOM_MARGIN, color()); - + // top margin fl_rectf(text_area.x, text_area.y-TOP_MARGIN, text_area.w, TOP_MARGIN, color()); - + // bottom margin fl_rectf(text_area.x, text_area.y+text_area.h, text_area.w, BOTTOM_MARGIN, color()); - + // draw that little box in the corner of the scrollbars if (mVScrollBar->visible() && mHScrollBar->visible()) fl_rectf(mVScrollBar->x(), mHScrollBar->y(), mVScrollBar->w(), mHScrollBar->h(), FL_GRAY); - + // blank the previous cursor protrusions } else if (damage() & (FL_DAMAGE_SCROLL | FL_DAMAGE_EXPOSE)) { -// printf("blanking previous cursor extrusions at Y: %d\n", mCursorOldY); + // printf("blanking previous cursor extrusions at Y: %d\n", mCursorOldY); // CET - FIXME - save old cursor position instead and just draw side needed? fl_push_clip(text_area.x-LEFT_MARGIN, text_area.y, @@ -2813,7 +2818,7 @@ void Fl_Text_Display::draw(void) { RIGHT_MARGIN, mMaxsize, color()); fl_pop_clip(); } - + // draw the scrollbars if (damage() & (FL_DAMAGE_ALL | FL_DAMAGE_CHILD)) { mVScrollBar->damage(FL_DAMAGE_ALL); @@ -2821,7 +2826,7 @@ void Fl_Text_Display::draw(void) { } update_child(*mVScrollBar); update_child(*mHScrollBar); - + // draw all of the text if (damage() & (FL_DAMAGE_ALL | FL_DAMAGE_EXPOSE)) { //printf("drawing all text\n"); @@ -2850,7 +2855,7 @@ void Fl_Text_Display::draw(void) { damage_range2_start = damage_range2_end = -1; fl_pop_clip(); } - + // draw the text cursor if (damage() & (FL_DAMAGE_ALL | FL_DAMAGE_SCROLL | FL_DAMAGE_EXPOSE) && !buffer()->primary_selection()->selected() && @@ -2859,10 +2864,10 @@ void Fl_Text_Display::draw(void) { text_area.y, text_area.w+LEFT_MARGIN+RIGHT_MARGIN, text_area.h); - + int X, Y; if (position_to_xy(mCursorPos, &X, &Y)) draw_cursor(X, Y); -// else puts("position_to_xy() failed - unable to draw cursor!"); + // else puts("position_to_xy() failed - unable to draw cursor!"); //printf("drew cursor at pos: %d (%d,%d)\n", mCursorPos, X, Y); mCursorOldY = Y; fl_pop_clip(); @@ -2909,24 +2914,24 @@ void Fl_Text_Display::scroll_timer_cb(void *user_data) { Fl_Text_Display *w = (Fl_Text_Display*)user_data; int pos; switch (scroll_direction) { - case 1: // mouse is to the right, scroll left - w->scroll(w->mTopLineNum, w->mHorizOffset + scroll_amount); - pos = w->xy_to_position(w->text_area.x + w->text_area.w, scroll_y, CURSOR_POS); - break; - case 2: // mouse is to the left, scroll right - w->scroll(w->mTopLineNum, w->mHorizOffset + scroll_amount); - pos = w->xy_to_position(w->text_area.x, scroll_y, CURSOR_POS); - break; - case 3: // mouse is above, scroll down - w->scroll(w->mTopLineNum + scroll_amount, w->mHorizOffset); - pos = w->xy_to_position(scroll_x, w->text_area.y, CURSOR_POS); - break; - case 4: // mouse is below, scroll up - w->scroll(w->mTopLineNum + scroll_amount, w->mHorizOffset); - pos = w->xy_to_position(scroll_x, w->text_area.y + w->text_area.h, CURSOR_POS); - break; - default: - return; + case 1: // mouse is to the right, scroll left + w->scroll(w->mTopLineNum, w->mHorizOffset + scroll_amount); + pos = w->xy_to_position(w->text_area.x + w->text_area.w, scroll_y, CURSOR_POS); + break; + case 2: // mouse is to the left, scroll right + w->scroll(w->mTopLineNum, w->mHorizOffset + scroll_amount); + pos = w->xy_to_position(w->text_area.x, scroll_y, CURSOR_POS); + break; + case 3: // mouse is above, scroll down + w->scroll(w->mTopLineNum + scroll_amount, w->mHorizOffset); + pos = w->xy_to_position(scroll_x, w->text_area.y, CURSOR_POS); + break; + case 4: // mouse is below, scroll up + w->scroll(w->mTopLineNum + scroll_amount, w->mHorizOffset); + pos = w->xy_to_position(scroll_x, w->text_area.y + w->text_area.h, CURSOR_POS); + break; + default: + return; } fl_text_drag_me(pos, w); Fl::repeat_timeout(.1, scroll_timer_cb, user_data); @@ -2942,7 +2947,7 @@ int Fl_Text_Display::handle(int event) { event != FL_KEYBOARD && event != FL_KEYUP) { return Fl_Group::handle(event); } - + switch (event) { case FL_ENTER: case FL_MOVE: @@ -2954,137 +2959,137 @@ int Fl_Text_Display::handle(int event) { } else { return 0; } - + case FL_LEAVE: case FL_HIDE: if (active_r() && window()) { window()->cursor(FL_CURSOR_DEFAULT); - + return 1; } else { return 0; } - + case FL_PUSH: { - if (active_r() && window()) { - if (Fl::event_inside(text_area.x, text_area.y, text_area.w, - text_area.h)) window()->cursor(FL_CURSOR_INSERT); - else window()->cursor(FL_CURSOR_DEFAULT); - } - - if (Fl::focus() != this) { - Fl::focus(this); - handle(FL_FOCUS); - } - if (Fl_Group::handle(event)) return 1; - if (Fl::event_state()&FL_SHIFT) return handle(FL_DRAG); - dragging = 1; - int pos = xy_to_position(Fl::event_x(), Fl::event_y(), CURSOR_POS); + if (active_r() && window()) { + if (Fl::event_inside(text_area.x, text_area.y, text_area.w, + text_area.h)) window()->cursor(FL_CURSOR_INSERT); + else window()->cursor(FL_CURSOR_DEFAULT); + } + + if (Fl::focus() != this) { + Fl::focus(this); + handle(FL_FOCUS); + } + if (Fl_Group::handle(event)) return 1; + if (Fl::event_state()&FL_SHIFT) return handle(FL_DRAG); + dragging = 1; + int pos = xy_to_position(Fl::event_x(), Fl::event_y(), CURSOR_POS); + int ok = 0; + while (!ok) { + // FIXME: character is ucs-4 + char c = buffer()->char_at( pos ); + if (!((c & 0x80) && !(c & 0x40))) { + ok = 1; + } else { + pos++; + } + } + dragType = Fl::event_clicks(); + dragPos = pos; + if (dragType == DRAG_CHAR) + buffer()->unselect(); + else if (dragType == DRAG_WORD) + buffer()->select(word_start(pos), word_end(pos)); + else if (dragType == DRAG_LINE) + buffer()->select(buffer()->line_start(pos), buffer()->line_end(pos)+1); + + if (buffer()->primary_selection()->selected()) + insert_position(buffer()->primary_selection()->end()); + else + insert_position(pos); + show_insert_position(); + return 1; + } + + case FL_DRAG: { + if (dragType < 0) return 1; + int X = Fl::event_x(), Y = Fl::event_y(), pos = 0; + // if we leave the text_area, we start a timer event + // that will take care of scrolling and selecting + if (Y < text_area.y) { + scroll_x = X; + scroll_amount = (Y - text_area.y) / 5 - 1; + if (!scroll_direction) { + Fl::add_timeout(.01, scroll_timer_cb, this); + } + scroll_direction = 3; + } else if (Y >= text_area.y+text_area.h) { + scroll_x = X; + scroll_amount = (Y - text_area.y - text_area.h) / 5 + 1; + if (!scroll_direction) { + Fl::add_timeout(.01, scroll_timer_cb, this); + } + scroll_direction = 4; + } else if (X < text_area.x) { + scroll_y = Y; + scroll_amount = (X - text_area.x) / 2 - 1; + if (!scroll_direction) { + Fl::add_timeout(.01, scroll_timer_cb, this); + } + scroll_direction = 2; + } else if (X >= text_area.x+text_area.w) { + scroll_y = Y; + scroll_amount = (X - text_area.x - text_area.w) / 2 + 1; + if (!scroll_direction) { + Fl::add_timeout(.01, scroll_timer_cb, this); + } + scroll_direction = 1; + } else { + if (scroll_direction) { + Fl::remove_timeout(scroll_timer_cb, this); + scroll_direction = 0; + } + pos = xy_to_position(X, Y, CURSOR_POS); int ok = 0; while (!ok) { // FIXME: character is ucs-4 - char c = buffer()->char_at( pos ); + char c = buffer()->char_at( pos ); if (!((c & 0x80) && !(c & 0x40))) { ok = 1; } else { pos++; } } - dragType = Fl::event_clicks(); - dragPos = pos; - if (dragType == DRAG_CHAR) - buffer()->unselect(); - else if (dragType == DRAG_WORD) - buffer()->select(word_start(pos), word_end(pos)); - else if (dragType == DRAG_LINE) - buffer()->select(buffer()->line_start(pos), buffer()->line_end(pos)+1); - - if (buffer()->primary_selection()->selected()) - insert_position(buffer()->primary_selection()->end()); - else - insert_position(pos); - show_insert_position(); - return 1; - } - - case FL_DRAG: { - if (dragType < 0) return 1; - int X = Fl::event_x(), Y = Fl::event_y(), pos = 0; - // if we leave the text_area, we start a timer event - // that will take care of scrolling and selecting - if (Y < text_area.y) { - scroll_x = X; - scroll_amount = (Y - text_area.y) / 5 - 1; - if (!scroll_direction) { - Fl::add_timeout(.01, scroll_timer_cb, this); - } - scroll_direction = 3; - } else if (Y >= text_area.y+text_area.h) { - scroll_x = X; - scroll_amount = (Y - text_area.y - text_area.h) / 5 + 1; - if (!scroll_direction) { - Fl::add_timeout(.01, scroll_timer_cb, this); - } - scroll_direction = 4; - } else if (X < text_area.x) { - scroll_y = Y; - scroll_amount = (X - text_area.x) / 2 - 1; - if (!scroll_direction) { - Fl::add_timeout(.01, scroll_timer_cb, this); - } - scroll_direction = 2; - } else if (X >= text_area.x+text_area.w) { - scroll_y = Y; - scroll_amount = (X - text_area.x - text_area.w) / 2 + 1; - if (!scroll_direction) { - Fl::add_timeout(.01, scroll_timer_cb, this); - } - scroll_direction = 1; - } else { - if (scroll_direction) { - Fl::remove_timeout(scroll_timer_cb, this); - scroll_direction = 0; - } - pos = xy_to_position(X, Y, CURSOR_POS); - int ok = 0; - while (!ok) { - // FIXME: character is ucs-4 - char c = buffer()->char_at( pos ); - if (!((c & 0x80) && !(c & 0x40))) { - ok = 1; - } else { - pos++; - } - } - } - fl_text_drag_me(pos, this); - return 1; } - + fl_text_drag_me(pos, this); + return 1; + } + case FL_RELEASE: { - dragging = 0; - if (scroll_direction) { - Fl::remove_timeout(scroll_timer_cb, this); - scroll_direction = 0; - } - - // convert from WORD or LINE selection to CHAR - if (insert_position() >= dragPos) - dragPos = buffer()->primary_selection()->start(); - else - dragPos = buffer()->primary_selection()->end(); - dragType = DRAG_CHAR; - - const char* copy = buffer()->selection_text(); - if (*copy) Fl::copy(copy, strlen(copy), 0); - free((void*)copy); - return 1; + dragging = 0; + if (scroll_direction) { + Fl::remove_timeout(scroll_timer_cb, this); + scroll_direction = 0; } - + + // convert from WORD or LINE selection to CHAR + if (insert_position() >= dragPos) + dragPos = buffer()->primary_selection()->start(); + else + dragPos = buffer()->primary_selection()->end(); + dragType = DRAG_CHAR; + + const char* copy = buffer()->selection_text(); + if (*copy) Fl::copy(copy, strlen(copy), 0); + free((void*)copy); + return 1; + } + case FL_MOUSEWHEEL: if (Fl::event_dy()) return mVScrollBar->handle(event); else return mHScrollBar->handle(event); - + case FL_UNFOCUS: if (active_r() && window()) window()->cursor(FL_CURSOR_DEFAULT); case FL_FOCUS: @@ -3104,28 +3109,28 @@ int Fl_Text_Display::handle(int event) { redisplay_range(start, end); } return 1; - + case FL_KEYBOARD: // Copy? if ((Fl::event_state()&(FL_CTRL|FL_COMMAND)) && Fl::event_key()=='c') { - if (!buffer()->selected()) return 1; - const char *copy = buffer()->selection_text(); - if (*copy) Fl::copy(copy, strlen(copy), 1); - free((void*)copy); - return 1; + if (!buffer()->selected()) return 1; + const char *copy = buffer()->selection_text(); + if (*copy) Fl::copy(copy, strlen(copy), 1); + free((void*)copy); + return 1; } - + // Select all ? if ((Fl::event_state()&(FL_CTRL|FL_COMMAND)) && Fl::event_key()=='a') { - buffer()->select(0,buffer()->length()); - return 1; + buffer()->select(0,buffer()->length()); + return 1; } - + if (mVScrollBar->handle(event)) return 1; if (mHScrollBar->handle(event)) return 1; - + break; - + case FL_SHORTCUT: if (!(shortcut() ? Fl::test_shortcut(shortcut()) : test_shortcut())) return 0; @@ -3136,7 +3141,7 @@ int Fl_Text_Display::handle(int event) { break; } - + return 0; } diff --git a/test/editor.cxx b/test/editor.cxx index f9eafa9d7..3ac8ab9ca 100644 --- a/test/editor.cxx +++ b/test/editor.cxx @@ -785,6 +785,7 @@ Fl_Window* new_view() { Fl_Menu_Bar* m = new Fl_Menu_Bar(0, 0, 660, 30); m->copy(menuitems, w); w->editor = new Fl_Text_Editor(0, 30, 660, 370); + w->editor->wrap_mode(1, 32); w->editor->textfont(FL_COURIER); w->editor->textsize(TS); w->editor->buffer(textbuf); @@ -812,6 +813,7 @@ int main(int argc, char **argv) { " if ( fnfc.show() ) return;\n" " save_file(fnfc.filename());\n" "}\n\n" + " 2 4 6 8 0 2 4 6 8 0 2 4 6 8 0 2 4 6 8 0\n\n" "// Falsches Üben von Xylophonmusik quält jeden größeren Zwerg\n" "// (= Wrongful practicing of xylophone music tortures every larger dwarf)\n" "\n"