mirror of https://github.com/fltk/fltk
4391 lines
148 KiB
C++
4391 lines
148 KiB
C++
//
|
|
// Copyright 2001-2022 by Bill Spitzak and others.
|
|
// Original code Copyright Mark Edel. Permission to distribute under
|
|
// the LGPL for the FLTK library granted by Mark Edel.
|
|
//
|
|
// This library is free software. Distribution and use rights are outlined in
|
|
// the file "COPYING" which should have been included with this file. If this
|
|
// file is missing or damaged, see the license at:
|
|
//
|
|
// https://www.fltk.org/COPYING.php
|
|
//
|
|
// Please see the following page on how to report bugs and issues:
|
|
//
|
|
// https://www.fltk.org/bugs.php
|
|
//
|
|
|
|
// TODO: rendering of the "optional hyphen"
|
|
// TODO: font background color control via style buffer
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <FL/fl_utf8.h>
|
|
#include <FL/fl_string_functions.h> // fl_strdup()
|
|
#include "flstring.h"
|
|
#include <limits.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <FL/Fl.H>
|
|
#include <FL/platform.H>
|
|
#include <FL/Fl_Text_Buffer.H>
|
|
#include <FL/Fl_Text_Display.H>
|
|
#include <FL/Fl_Window.H>
|
|
#include <FL/Fl_Menu_Item.H>
|
|
#include <FL/Fl_Input.H>
|
|
#include "Fl_Screen_Driver.H"
|
|
|
|
#undef min
|
|
#undef max
|
|
|
|
// #define DEBUG
|
|
// #define DEBUG2
|
|
|
|
#define LINENUM_LEFT_OF_VSCROLL // uncomment this line ...
|
|
// ... if you want the line numbers to be drawn left of the vertical
|
|
// scrollbar (only if the vertical scrollbar is aligned left).
|
|
// This is the default.
|
|
// If not defined and the vertical scrollbar is aligned left, then the
|
|
// scrollbar is positioned at the left border and the line numbers are
|
|
// drawn between the scrollbar (left) and the text area (right).
|
|
// If the vertical scrollbar is aligned right, then the line number
|
|
// position is not affected by this definition.
|
|
|
|
// Text area margins. Left & right margins should be at least 3 so that
|
|
// there is some room for the overhanging parts of the cursor!
|
|
#define TOP_MARGIN 1
|
|
#define BOTTOM_MARGIN 1
|
|
#define LEFT_MARGIN 3
|
|
#define RIGHT_MARGIN 3
|
|
|
|
#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 */
|
|
#define FILL_MASK 0x0100
|
|
#define SECONDARY_MASK 0x0200
|
|
#define PRIMARY_MASK 0x0400
|
|
#define HIGHLIGHT_MASK 0x0800
|
|
#define BG_ONLY_MASK 0x1000
|
|
#define TEXT_ONLY_MASK 0x2000
|
|
#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 */
|
|
#define MAX_DISP_LINE_LEN 1000
|
|
|
|
static int max( int i1, int i2 );
|
|
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. */
|
|
static int scroll_direction = 0;
|
|
static int scroll_amount = 0;
|
|
static int scroll_y = 0;
|
|
static int scroll_x = 0;
|
|
|
|
// CET - FIXME
|
|
#define TMPFONTWIDTH 6
|
|
|
|
|
|
|
|
/**
|
|
\brief Creates a new text display widget.
|
|
|
|
\param X, Y, W, H position and size of widget
|
|
\param l label text, defaults to none
|
|
*/
|
|
Fl_Text_Display::Fl_Text_Display(int X, int Y, int W, int H, const char* l)
|
|
: Fl_Group(X, Y, W, H, l) {
|
|
|
|
#define VISIBLE_LINES_INIT 1 // allow compiler to remove unused code (PR #582)
|
|
|
|
// Member initialization: same order as declared in .H file
|
|
// Any Fl_Text_Display methods should only be called /after/ all
|
|
// members initialized; avoids methods referencing uninitialized values.
|
|
//
|
|
damage_range1_start = damage_range1_end = -1;
|
|
damage_range2_start = damage_range2_end = -1;
|
|
mCursorPos = 0;
|
|
mCursorOn = 0;
|
|
mCursorOldY = -100;
|
|
mCursorToHint = NO_HINT;
|
|
mCursorStyle = NORMAL_CURSOR;
|
|
mCursorPreferredXPos = -1;
|
|
mNVisibleLines = VISIBLE_LINES_INIT;
|
|
mNBufferLines = 0;
|
|
mBuffer = NULL;
|
|
mStyleBuffer = NULL;
|
|
mFirstChar = 0;
|
|
mLastChar = 0;
|
|
mContinuousWrap = 0;
|
|
mWrapMarginPix = 0;
|
|
mLineStarts = new int[mNVisibleLines];
|
|
#if VISIBLE_LINES_INIT > 1
|
|
{ // Note: this code is unused unless mNVisibleLines is ever initialized > 1
|
|
for (int i=1; i<mNVisibleLines; i++) mLineStarts[i] = -1;
|
|
}
|
|
#endif
|
|
mLineStarts[0] = 0;
|
|
mTopLineNum = 1;
|
|
mAbsTopLineNum = 1;
|
|
mNeedAbsTopLineNum = 0;
|
|
mHorizOffset = 0;
|
|
mTopLineNumHint = 1;
|
|
mHorizOffsetHint = 0;
|
|
mNStyles = 0;
|
|
mStyleTable = NULL;
|
|
mUnfinishedStyle = 0;
|
|
mUnfinishedHighlightCB = 0;
|
|
mHighlightCBArg = 0;
|
|
mMaxsize = 0;
|
|
mSuppressResync = 0;
|
|
mNLinesDeleted = 0;
|
|
mModifyingTabDistance = 0; // XXX: UNUSED
|
|
mColumnScale = 0;
|
|
mCursor_color = FL_FOREGROUND_COLOR;
|
|
|
|
mHScrollBar = new Fl_Scrollbar(0,0,1,1);
|
|
mHScrollBar->callback((Fl_Callback*)h_scrollbar_cb, this);
|
|
mHScrollBar->type(FL_HORIZONTAL);
|
|
|
|
mVScrollBar = new Fl_Scrollbar(0,0,1,1);
|
|
mVScrollBar->callback((Fl_Callback*)v_scrollbar_cb, this);
|
|
|
|
scrollbar_width_ = 0; // 0: default from Fl::scrollbar_size()
|
|
scrollbar_align_ = FL_ALIGN_BOTTOM_RIGHT;
|
|
|
|
dragPos = 0;
|
|
dragType = DRAG_CHAR;
|
|
dragging = 0;
|
|
display_insert_position_hint = 0;
|
|
|
|
text_area.x = 0;
|
|
text_area.y = 0;
|
|
text_area.w = 0;
|
|
text_area.h = 0;
|
|
|
|
shortcut_ = 0;
|
|
textfont_ = FL_HELVETICA; // textfont()
|
|
textsize_ = FL_NORMAL_SIZE; // textsize()
|
|
textcolor_ = FL_FOREGROUND_COLOR; // textcolor()
|
|
grammar_underline_color_ = FL_BLUE;
|
|
spelling_underline_color_ = FL_RED;
|
|
secondary_selection_color_ = FL_GRAY;
|
|
mLineNumLeft = 0; // XXX: UNUSED
|
|
mLineNumWidth = 0;
|
|
|
|
linenumber_font_ = FL_HELVETICA;
|
|
linenumber_size_ = FL_NORMAL_SIZE;
|
|
linenumber_fgcolor_ = FL_INACTIVE_COLOR;
|
|
linenumber_bgcolor_ = 53; // ~90% gray
|
|
linenumber_align_ = FL_ALIGN_RIGHT;
|
|
linenumber_format_ = fl_strdup("%d");
|
|
|
|
// Method calls -- only AFTER all members initialized
|
|
color(FL_BACKGROUND2_COLOR, FL_SELECTION_COLOR);
|
|
box(FL_DOWN_FRAME);
|
|
set_flag(SHORTCUT_LABEL);
|
|
clear_flag(NEEDS_KEYBOARD);
|
|
|
|
end();
|
|
}
|
|
|
|
|
|
/**
|
|
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.
|
|
|
|
\see Fl_Text_Display::buffer(Fl_Text_Buffer* buf)
|
|
*/
|
|
|
|
Fl_Text_Display::~Fl_Text_Display() {
|
|
if (scroll_direction) {
|
|
Fl::remove_timeout(scroll_timer_cb, this);
|
|
scroll_direction = 0;
|
|
}
|
|
if (mBuffer) {
|
|
mBuffer->remove_modify_callback(buffer_modified_cb, this);
|
|
mBuffer->remove_predelete_callback(buffer_predelete_cb, this);
|
|
}
|
|
if (mLineStarts) delete[] mLineStarts;
|
|
if (linenumber_format_) {
|
|
free((void*)linenumber_format_);
|
|
linenumber_format_ = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
Set width of screen area for line numbers.
|
|
Use to also enable/disable line numbers.
|
|
A value of 0 disables line numbering, values >0 enable the line number display.
|
|
\param width The new width of the area for line numbers to appear, in pixels.
|
|
0 disables line numbers (default)
|
|
*/
|
|
void Fl_Text_Display::linenumber_width(int width) {
|
|
if (width < 0) return;
|
|
mLineNumWidth = width;
|
|
recalc_display(); // recalc line#s // resize(x(), y(), w(), h());
|
|
if (width > 0) reset_absolute_top_line_number();
|
|
}
|
|
|
|
/**
|
|
Return the screen area width provided for line numbers.
|
|
*/
|
|
int Fl_Text_Display::linenumber_width() const {
|
|
return mLineNumWidth;
|
|
}
|
|
|
|
/**
|
|
Set the font used for line numbers (if enabled).
|
|
\version 1.3.3
|
|
*/
|
|
void Fl_Text_Display::linenumber_font(Fl_Font val) {
|
|
linenumber_font_ = val;
|
|
}
|
|
|
|
/**
|
|
Return the font used for line numbers (if enabled).
|
|
*/
|
|
Fl_Font Fl_Text_Display::linenumber_font() const {
|
|
return linenumber_font_;
|
|
}
|
|
|
|
/**
|
|
Set the font size used for line numbers (if enabled).
|
|
\version 1.3.3
|
|
*/
|
|
void Fl_Text_Display::linenumber_size(Fl_Fontsize val) {
|
|
linenumber_size_ = val;
|
|
}
|
|
|
|
/**
|
|
Return the font size used for line numbers (if enabled).
|
|
*/
|
|
Fl_Fontsize Fl_Text_Display::linenumber_size() const {
|
|
return linenumber_size_;
|
|
}
|
|
|
|
/**
|
|
Set the foreground color used for line numbers (if enabled).
|
|
\version 1.3.3
|
|
*/
|
|
void Fl_Text_Display::linenumber_fgcolor(Fl_Color val) {
|
|
linenumber_fgcolor_ = val;
|
|
}
|
|
|
|
/**
|
|
Return the foreground color used for line numbers (if enabled).
|
|
*/
|
|
Fl_Color Fl_Text_Display::linenumber_fgcolor() const {
|
|
return linenumber_fgcolor_;
|
|
}
|
|
|
|
/**
|
|
Set the background color used for line numbers (if enabled).
|
|
\version 1.3.3
|
|
*/
|
|
void Fl_Text_Display::linenumber_bgcolor(Fl_Color val) {
|
|
linenumber_bgcolor_ = val;
|
|
}
|
|
|
|
/**
|
|
Returns the background color used for line numbers (if enabled).
|
|
*/
|
|
Fl_Color Fl_Text_Display::linenumber_bgcolor() const {
|
|
return linenumber_bgcolor_;
|
|
}
|
|
|
|
/**
|
|
Set alignment for line numbers (if enabled).
|
|
Valid values are FL_ALIGN_LEFT, FL_ALIGN_CENTER or FL_ALIGN_RIGHT.
|
|
\version 1.3.3
|
|
*/
|
|
void Fl_Text_Display::linenumber_align(Fl_Align val) {
|
|
linenumber_align_ = val;
|
|
}
|
|
|
|
/**
|
|
Returns the alignment used for line numbers (if enabled).
|
|
*/
|
|
Fl_Align Fl_Text_Display::linenumber_align() const {
|
|
return linenumber_align_;
|
|
}
|
|
|
|
/**
|
|
Sets the printf() style format string used for line numbers.
|
|
Default is "%d" for normal unpadded decimal integers.
|
|
|
|
An internal copy of \p val is allocated and managed;
|
|
it is automatically freed whenever a new value is assigned,
|
|
or when the widget is destroyed.
|
|
|
|
The value of \p val must \a not be NULL.
|
|
|
|
Example values:
|
|
|
|
- "%d" -- For normal line numbers without padding (Default)
|
|
- "%03d" -- For 000 padding
|
|
- "%x" -- For hexadecimal line numbers
|
|
- "%o" -- For octal line numbers
|
|
|
|
\version 1.3.3
|
|
*/
|
|
void Fl_Text_Display::linenumber_format(const char* val) {
|
|
if ( linenumber_format_ ) free((void*)linenumber_format_);
|
|
linenumber_format_ = val ? fl_strdup(val) : 0;
|
|
}
|
|
|
|
/**
|
|
Returns the line number printf() format string.
|
|
*/
|
|
const char* Fl_Text_Display::linenumber_format() const {
|
|
return linenumber_format_;
|
|
}
|
|
|
|
/**
|
|
Attach a text buffer to display, replacing the current buffer (if any).
|
|
|
|
Multiple text widgets can be associated with the same text buffer.
|
|
|
|
\note The caller is responsible for the old (replaced) buffer (if any).
|
|
This method does not delete the old buffer.
|
|
|
|
\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 */
|
|
if ( buf == mBuffer) return;
|
|
if ( mBuffer != 0 ) {
|
|
// we must provide a copy of the buffer that we are deleting!
|
|
char *deletedText = mBuffer->text();
|
|
buffer_modified_cb( 0, 0, mBuffer->length(), 0, deletedText, this );
|
|
free(deletedText);
|
|
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 */
|
|
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... */
|
|
recalc_display(); // resize(x(), y(), w(), h());
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief 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 extend_range_for_styles() 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.
|
|
|
|
\note Style information in the style buffer must have the same byte offset as
|
|
the corresponding character in the text buffer. UTF-8 characters can have a
|
|
maximum length of four bytes. Style information must take
|
|
this into account and fill the unused bytes with 0. See `fl_utf8len()`.
|
|
|
|
Text: "*g* r ü *n*" , where normal style is 'A', and bold is 'B'
|
|
\code
|
|
Text Buffer(hex): 67 72 c3 bc 6e : gr..n
|
|
Style Buffer(hex): 42 41 41 00 42 : BAA.B
|
|
\endcode
|
|
|
|
\param styleBuffer this buffer works in parallel to the text buffer. For every
|
|
character in the text buffer, the style buffer has a byte at the same offset
|
|
that contains an index into an array of possible styles.
|
|
\param styleTable a list of styles indexed by the style buffer
|
|
\param nStyles number of styles in the style table
|
|
\param unfinishedStyle if this style is found, the callback below is called
|
|
\param unfinishedHighlightCB if a character with an unfinished style is found,
|
|
this callback will be called
|
|
\param cbArg an optional argument for the callback above, usually a pointer
|
|
to the Text Display.
|
|
|
|
\see Fl_Text_Display::style_buffer()
|
|
*/
|
|
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 ) {
|
|
mStyleBuffer = styleBuffer;
|
|
mStyleTable = styleTable;
|
|
mNStyles = nStyles;
|
|
mUnfinishedStyle = unfinishedStyle;
|
|
mUnfinishedHighlightCB = unfinishedHighlightCB;
|
|
mHighlightCBArg = cbArg;
|
|
mColumnScale = 0;
|
|
|
|
mStyleBuffer->canUndo(0);
|
|
damage(FL_DAMAGE_EXPOSE);
|
|
}
|
|
|
|
/**
|
|
\brief Find the longest line of all visible lines.
|
|
|
|
\return the width of the longest visible line in pixels
|
|
*/
|
|
int Fl_Text_Display::longest_vline() const {
|
|
int longest = 0;
|
|
for (int i = 0; i < mNVisibleLines; i++)
|
|
longest = max(longest, measure_vline(i));
|
|
return longest;
|
|
}
|
|
|
|
/**
|
|
\brief Change the size of the displayed text area.
|
|
|
|
Calling this function will trigger a recalculation of all visible lines
|
|
and of all scrollbar sizes.
|
|
\param X, Y, W, H new position and size of this widget
|
|
*/
|
|
void Fl_Text_Display::resize(int X, int Y, int W, int H) {
|
|
|
|
#ifdef DEBUG2
|
|
printf("\n");
|
|
printf("Fl_Text_Display::resize(X=%d, Y=%d, W=%d, H=%d)\n", X, Y, W, H);
|
|
printf(" current size(x=%d, y=%d, w=%d, h=%d)\n", x(), y(), w(), h());
|
|
printf(" box_d* size(x=%d, y=%d, w=%d, h=%d)\n",
|
|
Fl::box_dx(box()),Fl::box_dy(box()),Fl::box_dw(box()),Fl::box_dh(box()));
|
|
printf(" text_area size(x=%d, y=%d, w=%d, h=%d)\n",
|
|
text_area.x, text_area.y, text_area.w, text_area.h);
|
|
printf(" mContinuousWrap=%d, mWrapMarginPix=%d\n",
|
|
mContinuousWrap, mWrapMarginPix);
|
|
fflush(stdout);
|
|
#endif // DEBUG2
|
|
|
|
Fl_Widget::resize(X,Y,W,H);
|
|
mColumnScale = 0; // force recomputation of the width of a column when display is rescaled
|
|
recalc_display();
|
|
}
|
|
|
|
/**
|
|
Recalculate the display's visible lines and scrollbar sizes.
|
|
*/
|
|
void Fl_Text_Display::recalc_display() {
|
|
if (!buffer()) return;
|
|
// Make sure the display is opened.
|
|
Fl_Display_Device::display_device();
|
|
// did we have scrollbars initially?
|
|
unsigned int hscrollbarvisible = mHScrollBar->visible();
|
|
unsigned int vscrollbarvisible = mVScrollBar->visible();
|
|
int scrollsize = scrollbar_width_ ? scrollbar_width_ : Fl::scrollbar_size();
|
|
|
|
int X = x() + Fl::box_dx(box());
|
|
int Y = y() + Fl::box_dy(box());
|
|
int W = w() - Fl::box_dw(box());
|
|
int H = h() - Fl::box_dh(box());
|
|
|
|
text_area.x = X + LEFT_MARGIN + mLineNumWidth;
|
|
text_area.y = Y + TOP_MARGIN;
|
|
text_area.w = W - LEFT_MARGIN - RIGHT_MARGIN - mLineNumWidth;
|
|
text_area.h = H - TOP_MARGIN - BOTTOM_MARGIN;
|
|
|
|
// Find the new maximum font height for this text display
|
|
int i;
|
|
for (i = 0, mMaxsize = fl_height(textfont(), textsize()); i < mNStyles; i++)
|
|
mMaxsize = max(mMaxsize, fl_height(mStyleTable[i].font, mStyleTable[i].size));
|
|
|
|
// try without scrollbars first
|
|
mVScrollBar->clear_visible();
|
|
mHScrollBar->clear_visible();
|
|
|
|
// Optimization: if the number of lines in the buffer does not fit in
|
|
// the display area, then we need a vertical scrollbar regardless of
|
|
// word wrapping. If we switch it on here, this saves one line counting
|
|
// run in wrap mode in the loop below ("... again ..."). This is important
|
|
// for large buffers that suffer from slow calculations of character width
|
|
// to determine line wrapping.
|
|
// Note: active since Oct 25, 2017: commit eb772d027d (svn r12526)
|
|
|
|
// force _first_ calculation in loop (STR #3412)
|
|
int oldTAWidth = -1; // was: text_area.w (before STR #3412)
|
|
|
|
if (mContinuousWrap && !mWrapMarginPix) {
|
|
|
|
int nvlines = (text_area.h + mMaxsize - 1) / mMaxsize;
|
|
int nlines = buffer()->count_lines(0,buffer()->length());
|
|
if (nvlines < 1) nvlines = 1;
|
|
if (nlines >= nvlines-1) {
|
|
mVScrollBar->set_visible(); // we need a vertical scrollbar
|
|
text_area.w -= scrollsize;
|
|
}
|
|
}
|
|
// End of optimization, see comment above.
|
|
|
|
for (int again = 1; again;) {
|
|
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 */
|
|
|
|
#ifdef DEBUG2
|
|
printf("*** again ... text_area.w = %d, oldTAWidth = %d, diff = %d\n",
|
|
text_area.w, oldTAWidth, text_area.w - oldTAWidth);
|
|
#endif // DEBUG2
|
|
|
|
if (mContinuousWrap && !mWrapMarginPix && text_area.w != oldTAWidth) {
|
|
|
|
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 DEBUG2
|
|
printf(" mNBufferLines=%d\n", mNBufferLines);
|
|
#endif // DEBUG2
|
|
|
|
}
|
|
|
|
oldTAWidth = text_area.w;
|
|
|
|
/* reallocate and update the line starts array, which may have changed
|
|
size and / or contents. */
|
|
int nvlines = (text_area.h + mMaxsize - 1) / mMaxsize;
|
|
if (nvlines < 1) nvlines = 1;
|
|
if (mNVisibleLines != nvlines) {
|
|
mNVisibleLines = nvlines;
|
|
if (mLineStarts) delete[] mLineStarts;
|
|
mLineStarts = new int [mNVisibleLines];
|
|
}
|
|
|
|
calc_line_starts(0, mNVisibleLines);
|
|
calc_last_char();
|
|
|
|
// figure the scrollbars
|
|
if (scrollsize) {
|
|
|
|
/* Decide if the vertical scrollbar needs to be visible */
|
|
if (!mVScrollBar->visible() &&
|
|
scrollbar_align() & (FL_ALIGN_LEFT|FL_ALIGN_RIGHT) &&
|
|
mNBufferLines >= mNVisibleLines-(mContinuousWrap?0:1))
|
|
{
|
|
mVScrollBar->set_visible();
|
|
text_area.w -= scrollsize;
|
|
again = 1;
|
|
}
|
|
|
|
/*
|
|
Decide if the horizontal scrollbar needs to be visible. If the text
|
|
wraps at the right edge, do not draw a horizontal scrollbar. Otherwise, if there
|
|
is a vertical scrollbar, a horizontal is always created too. This
|
|
is because the alternatives are unattractive:
|
|
* 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). */
|
|
|
|
if (!mHScrollBar->visible() &&
|
|
scrollbar_align() & (FL_ALIGN_TOP|FL_ALIGN_BOTTOM) &&
|
|
(mVScrollBar->visible() || longest_vline() > text_area.w))
|
|
{
|
|
char wrap_at_bounds = mContinuousWrap && (mWrapMarginPix<text_area.w);
|
|
if (!wrap_at_bounds) {
|
|
mHScrollBar->set_visible();
|
|
text_area.h -= scrollsize;
|
|
again = 1; // loop again to see if we now need vert. & recalc sizes
|
|
}
|
|
}
|
|
}
|
|
} // (... again ...)
|
|
|
|
// Calculate text area position, dependent on scrollbars and line numbers.
|
|
// Note: width and height have been calculated above.
|
|
text_area.x = X + mLineNumWidth + LEFT_MARGIN;
|
|
if (mVScrollBar->visible() && scrollbar_align() & FL_ALIGN_LEFT)
|
|
text_area.x += scrollsize;
|
|
|
|
text_area.y = Y + TOP_MARGIN;
|
|
if (mHScrollBar->visible() &&
|
|
scrollbar_align() & FL_ALIGN_TOP)
|
|
text_area.y += scrollsize;
|
|
|
|
// position and resize scrollbars
|
|
if (mVScrollBar->visible()) {
|
|
if (scrollbar_align() & FL_ALIGN_LEFT) {
|
|
#ifdef LINENUM_LEFT_OF_VSCROLL
|
|
mVScrollBar->resize(text_area.x - LEFT_MARGIN - scrollsize,
|
|
text_area.y - TOP_MARGIN,
|
|
scrollsize,
|
|
text_area.h + TOP_MARGIN + BOTTOM_MARGIN);
|
|
#else
|
|
mVScrollBar->resize(X,
|
|
text_area.y - TOP_MARGIN,
|
|
scrollsize,
|
|
text_area.h + TOP_MARGIN + BOTTOM_MARGIN);
|
|
#endif
|
|
} else {
|
|
mVScrollBar->resize(X+W-scrollsize,
|
|
text_area.y - TOP_MARGIN,
|
|
scrollsize,
|
|
text_area.h + TOP_MARGIN + BOTTOM_MARGIN);
|
|
}
|
|
}
|
|
|
|
if (mHScrollBar->visible()) {
|
|
if (scrollbar_align() & FL_ALIGN_TOP) {
|
|
mHScrollBar->resize(text_area.x - LEFT_MARGIN,
|
|
Y,
|
|
text_area.w + LEFT_MARGIN + RIGHT_MARGIN,
|
|
scrollsize);
|
|
} else {
|
|
mHScrollBar->resize(text_area.x - LEFT_MARGIN,
|
|
Y + H - scrollsize,
|
|
text_area.w + LEFT_MARGIN + RIGHT_MARGIN,
|
|
scrollsize);
|
|
}
|
|
}
|
|
|
|
|
|
// 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 */
|
|
} else {
|
|
while ( mNVisibleLines>=2
|
|
&& (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();
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Refresh a rectangle of the text display.
|
|
\param left, top are in coordinates of the text drawing window.
|
|
\param width, height size in pixels
|
|
*/
|
|
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 );
|
|
|
|
fl_pop_clip();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Marks text from start to end as needing a redraw.
|
|
|
|
This function will trigger a damage event and later a redraw of parts of
|
|
the widget.
|
|
\param startpos index of first character needing redraw
|
|
\param endpos index after last character needing redraw
|
|
*/
|
|
void Fl_Text_Display::redisplay_range(int startpos, int endpos) {
|
|
IS_UTF8_ALIGNED2(buffer(), startpos)
|
|
IS_UTF8_ALIGNED2(buffer(), endpos)
|
|
|
|
if (damage_range1_start == -1 && damage_range1_end == -1) {
|
|
damage_range1_start = startpos;
|
|
damage_range1_end = endpos;
|
|
} else if ((startpos >= damage_range1_start && startpos <= damage_range1_end) ||
|
|
(endpos >= damage_range1_start && endpos <= damage_range1_end)) {
|
|
damage_range1_start = min(damage_range1_start, startpos);
|
|
damage_range1_end = max(damage_range1_end, endpos);
|
|
} else if (damage_range2_start == -1 && damage_range2_end == -1) {
|
|
damage_range2_start = startpos;
|
|
damage_range2_end = endpos;
|
|
} else {
|
|
damage_range2_start = min(damage_range2_start, startpos);
|
|
damage_range2_end = max(damage_range2_end, endpos);
|
|
}
|
|
damage(FL_DAMAGE_SCROLL);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Draw a range of text.
|
|
|
|
Refresh all of the text between buffer positions \p startpos and
|
|
\p endpos not including the character at the position \p endpos.
|
|
|
|
If \p endpos points beyond the end of the buffer, refresh the whole display
|
|
after \p startpos, including blank lines which are not technically part of
|
|
any range of characters.
|
|
|
|
\param startpos index of first character to draw
|
|
\param endpos index after last character to draw
|
|
*/
|
|
void Fl_Text_Display::draw_range(int startpos, int endpos) {
|
|
startpos = buffer()->utf8_align(startpos);
|
|
endpos = buffer()->utf8_align(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;
|
|
|
|
/* 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;
|
|
if ( !position_to_line( startpos, &startLine ) )
|
|
startLine = mNVisibleLines - 1;
|
|
if ( endpos >= mLastChar ) {
|
|
lastLine = mNVisibleLines - 1;
|
|
} else {
|
|
if ( !position_to_line( endpos, &lastLine ) ) {
|
|
/* shouldn't happen */
|
|
lastLine = mNVisibleLines - 1;
|
|
}
|
|
}
|
|
|
|
/* Get the starting and ending positions within the lines */
|
|
startIndex = mLineStarts[ startLine ] == -1 ? 0 : 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" */
|
|
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 );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Sets the position of the text insertion cursor for text display.
|
|
|
|
Moves the insertion cursor in front of the character at \p newPos.
|
|
This function may trigger a redraw.
|
|
\param newPos new caret position
|
|
*/
|
|
void Fl_Text_Display::insert_position( int newPos ) {
|
|
IS_UTF8_ALIGNED2(buffer(), newPos)
|
|
|
|
/* make sure new position is ok, do nothing if it hasn't changed */
|
|
if ( newPos == mCursorPos ) return;
|
|
if ( newPos < 0 ) newPos = 0;
|
|
if ( newPos > mBuffer->length() ) newPos = mBuffer->length();
|
|
|
|
/* cursor movement cancels vertical cursor motion column */
|
|
mCursorPreferredXPos = -1;
|
|
|
|
/* erase the cursor at its previous position */
|
|
redisplay_range(buffer()->prev_char_clipped(mCursorPos), buffer()->next_char(mCursorPos));
|
|
|
|
mCursorPos = newPos;
|
|
|
|
/* draw cursor at its new position */
|
|
redisplay_range(buffer()->prev_char_clipped(mCursorPos), buffer()->next_char(mCursorPos));
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Shows the text cursor.
|
|
|
|
This function may trigger a redraw.
|
|
\param b show(1) or hide(0) the text cursor (caret).
|
|
*/
|
|
void Fl_Text_Display::show_cursor(int b) {
|
|
mCursorOn = b;
|
|
if (!buffer()) return;
|
|
redisplay_range(buffer()->prev_char_clipped(mCursorPos), buffer()->next_char(mCursorPos));
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Sets the text cursor style.
|
|
|
|
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.
|
|
|
|
This call also switches the cursor on and may trigger a redraw.
|
|
|
|
\param style new cursor style
|
|
*/
|
|
void Fl_Text_Display::cursor_style(int style) {
|
|
mCursorStyle = style;
|
|
if (mCursorOn) show_cursor();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Set the new text wrap mode.
|
|
|
|
If \p wrap mode is not zero, this call enables automatic word wrapping at column
|
|
\p wrapMargin. Word-wrapping does not change the text buffer itself, only the way
|
|
the text is displayed. Different Text Displays can have different wrap modes,
|
|
even if they share the same Text Buffer.
|
|
|
|
Valid wrap modes are:
|
|
|
|
- WRAP_NONE : don't wrap text at all
|
|
- WRAP_AT_COLUMN : wrap text at the given text column
|
|
- WRAP_AT_PIXEL : wrap text at a pixel position
|
|
- WRAP_AT_BOUNDS : wrap text so that it fits into the widget width
|
|
|
|
\param wrap new wrap mode (see above)
|
|
|
|
\param wrapMargin in WRAP_AT_COLUMN mode, text will wrap at the n'th character.
|
|
For variable width fonts, an average character width is calculated. The
|
|
column width is calculated using the current textfont or the first style
|
|
when this function is called. If the font size changes, this function
|
|
must be called again. In WRAP_AT_PIXEL mode, this is the pixel position.
|
|
*/
|
|
void Fl_Text_Display::wrap_mode(int wrap, int wrapMargin) {
|
|
switch (wrap) {
|
|
case WRAP_NONE:
|
|
mWrapMarginPix = 0;
|
|
mContinuousWrap = 0;
|
|
break;
|
|
case WRAP_AT_COLUMN:
|
|
default:
|
|
mWrapMarginPix = int(col_to_x(wrapMargin));
|
|
mContinuousWrap = 1;
|
|
break;
|
|
case WRAP_AT_PIXEL:
|
|
mWrapMarginPix = wrapMargin;
|
|
mContinuousWrap = 1;
|
|
break;
|
|
case WRAP_AT_BOUNDS:
|
|
mWrapMarginPix = 0;
|
|
mContinuousWrap = 1;
|
|
break;
|
|
}
|
|
|
|
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 */
|
|
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();
|
|
} else {
|
|
// No buffer, so just clear the state info for later...
|
|
mNBufferLines = 0;
|
|
mFirstChar = 0;
|
|
mTopLineNum = 1;
|
|
mAbsTopLineNum = 1; // changed from 0 to 1 -- LZA / STR#2621
|
|
}
|
|
|
|
recalc_display(); // resize(x(), y(), w(), h());
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Inserts "text" at the current cursor location.
|
|
|
|
This has the same effect as inserting the text into the buffer using
|
|
insert(insert_position(),text) and then moving the insert position after
|
|
the newly inserted text, except that it's optimized to do less redrawing.
|
|
|
|
\param text new text in UTF-8 encoding.
|
|
*/
|
|
void Fl_Text_Display::insert(const char* text) {
|
|
IS_UTF8_ALIGNED2(buffer(), mCursorPos)
|
|
IS_UTF8_ALIGNED(text)
|
|
|
|
int pos = mCursorPos;
|
|
|
|
mCursorToHint = (int) (pos + strlen( text ));
|
|
mBuffer->insert( pos, text );
|
|
mCursorToHint = NO_HINT;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Replaces text at the current insert position.
|
|
\param text new text in UTF-8 encoding
|
|
|
|
\todo Unicode? Find out exactly what we do here and simplify.
|
|
*/
|
|
void Fl_Text_Display::overstrike(const char* text) {
|
|
IS_UTF8_ALIGNED2(buffer(), mCursorPos)
|
|
IS_UTF8_ALIGNED(text)
|
|
|
|
int startPos = mCursorPos;
|
|
Fl_Text_Buffer *buf = mBuffer;
|
|
int lineStart = buf->line_start( startPos );
|
|
int textLen = (int) strlen( text );
|
|
int i, p, endPos, indent, startIndent, endIndent;
|
|
const char *c;
|
|
unsigned int ch;
|
|
char *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 += fl_utf8len1(*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 */
|
|
indent = startIndent;
|
|
for ( p = startPos; ; p = buf->next_char(p) ) {
|
|
if ( p == buf->length() )
|
|
break;
|
|
ch = buf->char_at( p );
|
|
if ( ch == '\n' )
|
|
break;
|
|
indent++;
|
|
if ( indent == endIndent ) {
|
|
p = buf->next_char(p);
|
|
break;
|
|
} else if ( indent > endIndent ) {
|
|
if ( ch != '\t' ) {
|
|
p = buf->next_char(p);
|
|
paddedText = new char [ textLen + FL_TEXT_MAX_EXP_CHAR_LEN + 1 ];
|
|
strcpy( paddedText, text );
|
|
for ( i = 0; i < indent - endIndent; i++ )
|
|
paddedText[ textLen + i ] = ' ';
|
|
paddedText[ textLen + i ] = '\0';
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
endPos = p;
|
|
|
|
mCursorToHint = startPos + textLen;
|
|
buf->replace( startPos, endPos, paddedText == NULL ? text : paddedText );
|
|
mCursorToHint = NO_HINT;
|
|
if ( paddedText != NULL )
|
|
delete [] paddedText;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Convert a character index into a pixel position.
|
|
|
|
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 \e \b 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.
|
|
|
|
\param pos character index
|
|
\param[out] X, Y pixel position of character on screen
|
|
\return 0 if character vertically out of view, X & Y positions otherwise
|
|
*/
|
|
int Fl_Text_Display::position_to_xy( int pos, int* X, int* Y ) const {
|
|
IS_UTF8_ALIGNED2(buffer(), pos)
|
|
|
|
int lineStartPos, fontHeight;
|
|
int visLineNum;
|
|
/* If position is not displayed, return false */
|
|
if ((pos < mFirstChar) ||
|
|
(pos > mLastChar && !empty_vlines()) ||
|
|
(pos > buffer()->length()) ) { // STR #3231
|
|
return (*X=*Y=0); // make sure X & Y are set when it is out of view
|
|
}
|
|
|
|
/* Calculate Y coordinate */
|
|
if (!position_to_line(pos, &visLineNum) || visLineNum < 0 || visLineNum > mNBufferLines) {
|
|
return (*X=*Y=0); // make sure X & Y are set when it is out of view
|
|
}
|
|
|
|
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 */
|
|
lineStartPos = mLineStarts[visLineNum];
|
|
if ( lineStartPos == -1 ) {
|
|
*X = text_area.x - mHorizOffset;
|
|
return 1;
|
|
}
|
|
*X = text_area.x + handle_vline(GET_WIDTH, lineStartPos, pos-lineStartPos, 0, 0, 0, 0, 0, 0) - mHorizOffset;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Find the line and column number of position \p pos.
|
|
|
|
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).
|
|
|
|
\param pos character index
|
|
\param[out] lineNum absolute (unwrapped) line number
|
|
\param[out] column character offset to the beginning of the line
|
|
\return 0 if \p pos is off screen, line number otherwise
|
|
\todo a column number makes little sense in the UTF-8/variable font width
|
|
environment. We will have to further define what exactly we want to return.
|
|
Please check the functions that call this particular function.
|
|
*/
|
|
int Fl_Text_Display::position_to_linecol( int pos, int* lineNum, int* column ) const {
|
|
IS_UTF8_ALIGNED2(buffer(), pos)
|
|
|
|
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;
|
|
}
|
|
|
|
retVal = position_to_line( pos, lineNum );
|
|
if ( retVal ) {
|
|
*column = mBuffer->count_displayed_characters( mLineStarts[ *lineNum ], pos );
|
|
*lineNum += mTopLineNum;
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Check if a pixel position is within the primary selection.
|
|
|
|
\param X, Y pixel position to test
|
|
\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 );
|
|
IS_UTF8_ALIGNED2(buffer(), pos)
|
|
Fl_Text_Buffer *buf = mBuffer;
|
|
return buf->primary_selection()->includes(pos);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Nobody knows what this function does.
|
|
|
|
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.
|
|
|
|
\param row
|
|
\param column
|
|
\return something unknown
|
|
|
|
\todo What does this do and how is it useful? Column numbers mean little in
|
|
this context. Which functions depend on this one?
|
|
Function TextDXYToUnconstrainedPosition does not exist (nedit port?)
|
|
|
|
\todo Unicode?
|
|
*/
|
|
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);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Nobody knows what this function does.
|
|
|
|
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.
|
|
|
|
\param row
|
|
\return something unknown
|
|
|
|
\todo What does this do and how is it useful? Column numbers mean little in
|
|
this context. Which functions depend on this one?
|
|
Function TextDXYToUnconstrainedPosition does not exist (nedit port?)
|
|
*/
|
|
int Fl_Text_Display::wrapped_row(int row) const {
|
|
if (!mContinuousWrap || row < 0 || row > mNVisibleLines)
|
|
return row;
|
|
return buffer()->count_lines(mFirstChar, mLineStarts[row]);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief 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;
|
|
|
|
if (insert_position() < mFirstChar) {
|
|
topLine -= count_lines(insert_position(), mFirstChar, false);
|
|
} else if (mNVisibleLines>=2 && 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);
|
|
}
|
|
|
|
/* 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 (!position_to_xy( mCursorPos, &X, &Y )) {
|
|
scroll_(topLine, hOffset);
|
|
if (!position_to_xy( mCursorPos, &X, &Y )) {
|
|
#ifdef DEBUG
|
|
printf ("*** display_insert/position_to_xy # GIVE UP !\n"); fflush(stdout);
|
|
#endif // DEBUG
|
|
return; /* Give up, it's not worth it (but why does it fail?) */
|
|
}
|
|
}
|
|
if (X > text_area.x + text_area.w)
|
|
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);
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Scrolls the text buffer to show the current insert position.
|
|
|
|
This function triggers a complete recalculation, ending in a call to
|
|
Fl_Text_Display::display_insert()
|
|
*/
|
|
void Fl_Text_Display::show_insert_position() {
|
|
display_insert_position_hint = 1;
|
|
recalc_display(); // resize(x(), y(), w(), h());
|
|
}
|
|
|
|
|
|
/*
|
|
Cursor movement functions
|
|
*/
|
|
|
|
/**
|
|
\brief 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;
|
|
int p = insert_position();
|
|
int q = buffer()->next_char(p);
|
|
insert_position(q);
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Moves the current insert position left one character.
|
|
\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;
|
|
int p = insert_position();
|
|
int q = buffer()->prev_char_clipped(p);
|
|
insert_position(q);
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Moves the current insert position up one line.
|
|
\return 1 if the cursor moved, 0 if the beginning of the text was reached
|
|
*/
|
|
int Fl_Text_Display::move_up() {
|
|
int lineStartPos, xPos, prevLineStartPos, newPos, visLineNum;
|
|
|
|
/* Find the position of the start of the line. Use the line starts array
|
|
if possible */
|
|
if ( position_to_line( mCursorPos, &visLineNum ) )
|
|
lineStartPos = mLineStarts[ visLineNum ];
|
|
else {
|
|
lineStartPos = line_start( mCursorPos );
|
|
visLineNum = -1;
|
|
}
|
|
if ( lineStartPos == 0 )
|
|
return 0;
|
|
|
|
/* Decide what column to move to, if there's a preferred column use that */
|
|
if (mCursorPreferredXPos >= 0)
|
|
xPos = mCursorPreferredXPos;
|
|
else
|
|
xPos = handle_vline(GET_WIDTH, lineStartPos, mCursorPos-lineStartPos,
|
|
0, 0, 0, 0, 0, INT_MAX);
|
|
|
|
/* count forward from the start of the previous line to reach the column */
|
|
if ( visLineNum != -1 && visLineNum != 0 )
|
|
prevLineStartPos = mLineStarts[ visLineNum - 1 ];
|
|
else
|
|
prevLineStartPos = rewind_lines( lineStartPos, 1 );
|
|
|
|
int lineEnd = line_end(prevLineStartPos, true);
|
|
newPos = handle_vline(FIND_INDEX_FROM_ZERO, prevLineStartPos, lineEnd-prevLineStartPos,
|
|
0, 0, 0, 0, 0, xPos);
|
|
|
|
/* move the cursor */
|
|
insert_position( newPos );
|
|
|
|
/* if a preferred column wasn't aleady established, establish it */
|
|
mCursorPreferredXPos = xPos;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Moves the current insert position down one line.
|
|
\return 1 if the cursor moved, 0 if the beginning of the text was reached
|
|
*/
|
|
int Fl_Text_Display::move_down() {
|
|
int lineStartPos, xPos, newPos, visLineNum;
|
|
|
|
if ( mCursorPos == mBuffer->length() )
|
|
return 0;
|
|
|
|
if ( position_to_line( mCursorPos, &visLineNum ) )
|
|
lineStartPos = mLineStarts[ visLineNum ];
|
|
else {
|
|
lineStartPos = line_start( mCursorPos );
|
|
visLineNum = -1;
|
|
}
|
|
if (mCursorPreferredXPos >= 0) {
|
|
xPos = mCursorPreferredXPos;
|
|
} else {
|
|
xPos = handle_vline(GET_WIDTH, lineStartPos, mCursorPos-lineStartPos,
|
|
0, 0, 0, 0, 0, INT_MAX);
|
|
}
|
|
|
|
int nextLineStartPos = skip_lines( lineStartPos, 1, true );
|
|
int lineEnd = line_end(nextLineStartPos, true);
|
|
newPos = handle_vline(FIND_INDEX_FROM_ZERO, nextLineStartPos, lineEnd-nextLineStartPos,
|
|
0, 0, 0, 0, 0, xPos);
|
|
|
|
insert_position( newPos );
|
|
mCursorPreferredXPos = xPos;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Count the number of lines between two positions.
|
|
|
|
Same as Fl_Text_Buffer::count_lines(), but takes into account wrapping if
|
|
wrapping is turned on. If the caller knows that \p startPos is at a line
|
|
start, it can pass \p startPosIsLineStart as True to make the call more
|
|
efficient by avoiding the additional step of scanning back to the last newline.
|
|
|
|
\param startPos index to first character
|
|
\param endPos index after last character
|
|
\param startPosIsLineStart avoid scanning back to the line start
|
|
\return number of lines
|
|
*/
|
|
int Fl_Text_Display::count_lines(int startPos, int endPos,
|
|
bool startPosIsLineStart) const {
|
|
IS_UTF8_ALIGNED2(buffer(), startPos)
|
|
IS_UTF8_ALIGNED2(buffer(), endPos)
|
|
|
|
int retLines, retPos, retLineStart, retLineEnd;
|
|
|
|
#ifdef DEBUG
|
|
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) Fl_Text_Buffer::count_lines() */
|
|
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);
|
|
#endif // DEBUG
|
|
|
|
return retLines;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Skip a number of lines forward.
|
|
|
|
Same as Fl_Text_Buffer::skip_lines(startPos, nLines), but takes into
|
|
account line breaks when wrapping is turned on.
|
|
If the caller knows that \p startPos is at a line start, it can pass
|
|
\p startPosIsLineStart as True to make the call more efficient
|
|
by avoiding the additional step of scanning back to the last newline.
|
|
|
|
\param startPos index to starting character
|
|
\param nLines number of lines to skip ahead
|
|
\param startPosIsLineStart avoid scanning back to the line start
|
|
\return new position as index
|
|
*/
|
|
int Fl_Text_Display::skip_lines(int startPos, int nLines,
|
|
bool startPosIsLineStart) {
|
|
IS_UTF8_ALIGNED2(buffer(), startPos)
|
|
|
|
int retLines, retPos, retLineStart, retLineEnd;
|
|
|
|
/* if we're not wrapping use more efficient skip_lines(startPos, nLines) */
|
|
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);
|
|
IS_UTF8_ALIGNED2(buffer(), retPos)
|
|
return retPos;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Returns the end of a line.
|
|
|
|
Same as buffer()->line_end(startPos), but takes into account line breaks
|
|
when wrapping is turned on.
|
|
If the caller knows that \p startPos is at a line start, it can
|
|
pass \p 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
|
|
\b 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.
|
|
|
|
\param startPos index to starting character
|
|
\param startPosIsLineStart avoid scanning back to the line start
|
|
\return new position as index
|
|
*/
|
|
int Fl_Text_Display::line_end(int startPos, bool startPosIsLineStart) const {
|
|
IS_UTF8_ALIGNED2(buffer(), startPos)
|
|
|
|
int retLines, retPos, retLineStart, retLineEnd;
|
|
|
|
/* If we're not wrapping use more efficient buffer()->line_end(startPos) */
|
|
if (!mContinuousWrap)
|
|
return buffer()->line_end(startPos);
|
|
|
|
if (startPos == buffer()->length())
|
|
return startPos;
|
|
|
|
wrapped_line_counter(buffer(), startPos, buffer()->length(), 1,
|
|
startPosIsLineStart, 0, &retPos, &retLines, &retLineStart,
|
|
&retLineEnd);
|
|
|
|
IS_UTF8_ALIGNED2(buffer(), retLineEnd)
|
|
return retLineEnd;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Return the beginning of a line.
|
|
|
|
Same as buffer()->line_start(pos), but returns the character after last
|
|
wrap point rather than the last newline.
|
|
|
|
\param pos index to starting character
|
|
\return new position as index
|
|
*/
|
|
int Fl_Text_Display::line_start(int pos) const {
|
|
IS_UTF8_ALIGNED2(buffer(), pos)
|
|
|
|
int retLines, retPos, retLineStart, retLineEnd;
|
|
|
|
/* If we're not wrapping, use the more efficient buffer()->line_start(pos) */
|
|
if (!mContinuousWrap)
|
|
return buffer()->line_start(pos);
|
|
|
|
wrapped_line_counter(buffer(), buffer()->line_start(pos), pos, INT_MAX, true, 0,
|
|
&retPos, &retLines, &retLineStart, &retLineEnd);
|
|
|
|
IS_UTF8_ALIGNED2(buffer(), retLineStart)
|
|
return retLineStart;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Skip a number of lines back.
|
|
|
|
Same as buffer()->rewind_lines(startPos, nLines), but takes into account
|
|
line breaks when wrapping is turned on.
|
|
|
|
\param startPos index to starting character
|
|
\param nLines number of lines to skip back
|
|
\return new position as index
|
|
*/
|
|
int Fl_Text_Display::rewind_lines(int startPos, int nLines) {
|
|
IS_UTF8_ALIGNED2(buffer(), startPos)
|
|
|
|
Fl_Text_Buffer *buf = buffer();
|
|
int pos, lineStart, retLines, retPos, retLineStart, retLineEnd;
|
|
|
|
/* If we're not wrapping, use the more efficient
|
|
Fl_Text_Buffer::rewind_lines(startPos, nLines) */
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Moves the current insert position right one word.
|
|
*/
|
|
void Fl_Text_Display::next_word() {
|
|
int pos = insert_position();
|
|
|
|
while (pos < buffer()->length() && !buffer()->is_word_separator(pos)) {
|
|
pos = buffer()->next_char(pos);
|
|
}
|
|
|
|
while (pos < buffer()->length() && buffer()->is_word_separator(pos)) {
|
|
pos = buffer()->next_char(pos);
|
|
}
|
|
|
|
insert_position( pos );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Moves the current insert position left one word.
|
|
*/
|
|
void Fl_Text_Display::previous_word() {
|
|
int pos = insert_position();
|
|
if (pos==0) return;
|
|
pos = buffer()->prev_char(pos);
|
|
|
|
while (pos && buffer()->is_word_separator(pos)) {
|
|
pos = buffer()->prev_char(pos);
|
|
}
|
|
|
|
while (pos && !buffer()->is_word_separator(pos)) {
|
|
pos = buffer()->prev_char(pos);
|
|
}
|
|
|
|
if (buffer()->is_word_separator(pos)) {
|
|
pos = buffer()->next_char(pos);
|
|
}
|
|
|
|
insert_position( pos );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief This is called before any characters are deleted.
|
|
|
|
Callback attached to the text buffer to receive delete information before
|
|
the modifications are actually made.
|
|
|
|
This callback can be used to adjust the display or update other setting.
|
|
It is not advisable to change any buffers or text in this callback, or
|
|
line counting may get out of sync.
|
|
|
|
\param pos starting index of deletion
|
|
\param nDeleted number of bytes we will delete (must be UTF-8 aligned!)
|
|
\param cbArg "this" pointer for static callback function
|
|
*/
|
|
void Fl_Text_Display::buffer_predelete_cb(int pos, int nDeleted, void *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. */
|
|
IS_UTF8_ALIGNED2(textD->buffer(), pos)
|
|
textD->measure_deleted_lines(pos, nDeleted);
|
|
} else {
|
|
textD->mSuppressResync = 0; /* Probably not needed, but just in case */
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief This is called whenever the buffer is modified.
|
|
|
|
Callback attached to the text buffer to receive modification information.
|
|
|
|
This callback can be used to adjust the display or update other setting.
|
|
It is not advisable to change any buffers or text in this callback, or
|
|
line counting may get out of sync.
|
|
|
|
\param pos starting index of modification
|
|
\param nInserted number of bytes we inserted (must be UTF-8 aligned!)
|
|
\param nDeleted number of bytes deleted (must be UTF-8 aligned!)
|
|
\param nRestyled ??
|
|
\param deletedText this is what was removed, must not be NULL if nDeleted is set
|
|
\param cbArg "this" pointer for static callback function
|
|
*/
|
|
void Fl_Text_Display::buffer_modified_cb( int pos, int nInserted, int nDeleted,
|
|
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 = 0, wrapModEnd = 0;
|
|
|
|
IS_UTF8_ALIGNED2(buf, pos)
|
|
IS_UTF8_ALIGNED2(buf, oldFirstChar)
|
|
|
|
/* buffer modification cancels vertical cursor motion column */
|
|
if ( nInserted != 0 || nDeleted != 0 )
|
|
textD->mCursorPreferredXPos = -1;
|
|
|
|
/* 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->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 (deletedText && (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;
|
|
textD->mCursorToHint = NO_HINT;
|
|
} else if ( textD->mCursorPos > pos ) {
|
|
if ( textD->mCursorPos < pos + nDeleted )
|
|
textD->mCursorPos = pos;
|
|
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);
|
|
if ( textD->mStyleBuffer ) /* See comments in extend_range_for_styles() */
|
|
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. */
|
|
startDispPos = textD->mContinuousWrap ? wrapModStart : pos;
|
|
IS_UTF8_ALIGNED2(buf, startDispPos)
|
|
|
|
if ( origCursorPos == startDispPos && textD->mCursorPos != startDispPos )
|
|
startDispPos = min( startDispPos, buf->prev_char_clipped(origCursorPos) );
|
|
IS_UTF8_ALIGNED2(buf, startDispPos)
|
|
|
|
if ( linesInserted == linesDeleted ) {
|
|
if ( nInserted == 0 && nDeleted == 0 )
|
|
endDispPos = pos + nRestyled;
|
|
else {
|
|
if (textD->mContinuousWrap)
|
|
endDispPos = wrapModEnd;
|
|
else
|
|
endDispPos = buf->next_char(buf->line_end( pos + nInserted ));
|
|
|
|
// CET - FIXME if ( origCursorPos >= startDispPos &&
|
|
// ( origCursorPos <= endDispPos || endDispPos == buf->length() ) )
|
|
}
|
|
if (linesInserted > 1) {
|
|
// textD->draw_line_numbers(false); // can't do this b/c not called from virtual draw();
|
|
textD->damage(::FL_DAMAGE_EXPOSE);
|
|
}
|
|
} else {
|
|
endDispPos = buf->next_char(textD->mLastChar);
|
|
// 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). */
|
|
|
|
// Call draw_line_numbers() here to ensure line# is drawn
|
|
// when hitting enter for new line -- LZA / STR #2621
|
|
//textD->draw_line_numbers(true); // no, can't call this here, not in draw() context -- ERCO / STR#2621
|
|
//textD->damage(::FL_DAMAGE_EXPOSE);
|
|
}
|
|
IS_UTF8_ALIGNED2(buf, startDispPos)
|
|
IS_UTF8_ALIGNED2(buf, endDispPos)
|
|
|
|
/* 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 */
|
|
if ( textD->mStyleBuffer )
|
|
textD->extend_range_for_styles( &startDispPos, &endDispPos );
|
|
IS_UTF8_ALIGNED2(buf, startDispPos)
|
|
IS_UTF8_ALIGNED2(buf, endDispPos)
|
|
|
|
/* Redisplay computed range */
|
|
textD->redisplay_range( startDispPos, endDispPos );
|
|
}
|
|
|
|
|
|
/* Line Numbering Methods */
|
|
|
|
/**
|
|
\brief Line numbering stuff, currently unused.
|
|
|
|
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 Fl_Text_Display::position_to_linecol()).
|
|
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();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
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;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
Re-calculate absolute top line number for a change in scroll position.
|
|
|
|
Does nothing if the absolute top line number is not being maintained.
|
|
*/
|
|
void Fl_Text_Display::absolute_top_line_number(int oldFirstChar) {
|
|
if (maintaining_absolute_top_line_number() && buffer()) {
|
|
if (mFirstChar < oldFirstChar)
|
|
mAbsTopLineNum -= buffer()->count_lines(mFirstChar, oldFirstChar);
|
|
else
|
|
mAbsTopLineNum += buffer()->count_lines(oldFirstChar, mFirstChar);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
Returns true if a separate absolute top line number is being maintained.
|
|
|
|
The absolute top line number is used for displaying line numbers in
|
|
continuous wrap mode or showing in the statistics line (the latter is
|
|
currently not available in FLTK).
|
|
*/
|
|
int Fl_Text_Display::maintaining_absolute_top_line_number() const {
|
|
return mContinuousWrap &&
|
|
(mLineNumWidth != 0 || mNeedAbsTopLineNum);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
Reestablish the absolute (non-wrapped) top line number.
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
Convert a position index into a line number offset.
|
|
|
|
Find the line number of position \p pos relative to the first line of
|
|
displayed text, counting from 0 to <i>visible lines - 1</i>.
|
|
The line number is returned in \p lineNum.
|
|
|
|
Returns 0 if the line is not displayed. In this case \p lineNum is 0 as well.
|
|
|
|
Returns 1 if the line is displayed. In this case \p lineNum is the relative
|
|
line number.
|
|
|
|
\param[in] pos byte position in buffer
|
|
\param[out] lineNum relative line number of byte \p pos in buffer
|
|
|
|
\returns whether the character at byte position \p pos is currently displayed
|
|
\retval 0 \p pos is not displayed; \p lineNum is invalid (zero)
|
|
\retval 1 \p pos is displayed; \p lineNum is valid
|
|
*/
|
|
int Fl_Text_Display::position_to_line( int pos, int *lineNum ) const {
|
|
IS_UTF8_ALIGNED2(buffer(), pos)
|
|
|
|
int i;
|
|
|
|
*lineNum = 0;
|
|
if ( pos < mFirstChar ) return 0;
|
|
if ( pos > mLastChar ) {
|
|
if ( empty_vlines() ) {
|
|
if ( mLastChar < mBuffer->length() ) {
|
|
if ( !position_to_line( mLastChar, lineNum ) ) {
|
|
Fl::error("Fl_Text_Display::position_to_line(): Consistency check ptvl failed");
|
|
return 0;
|
|
}
|
|
return ++( *lineNum ) <= mNVisibleLines - 1;
|
|
} else {
|
|
position_to_line( buffer()->prev_char_clipped(mLastChar), lineNum );
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
for ( i = mNVisibleLines - 1; i >= 0; i-- ) {
|
|
if ( mLineStarts[ i ] != -1 && pos >= mLineStarts[ i ] ) {
|
|
*lineNum = i;
|
|
return 1;
|
|
}
|
|
}
|
|
return 0; /* probably never be reached */
|
|
}
|
|
|
|
|
|
/**
|
|
Universal pixel machine.
|
|
|
|
We use a single function that handles all line layout, measuring, and drawing
|
|
\li draw a text range
|
|
\li return the width of a text range in pixels
|
|
\li return the index of a character that is at a pixel position
|
|
|
|
\param[in] mode DRAW_LINE, GET_WIDTH, FIND_INDEX, FIND_INDEX_FROM_ZERO, or FIND_CURSOR_INDEX
|
|
\param[in] lineStartPos index of first character
|
|
\param[in] lineLen size of string in bytes
|
|
\param[in] leftChar, rightChar
|
|
\param[in] Y drawing position
|
|
\param[in] bottomClip, leftClip, rightClip stop work when we reach the clipped
|
|
area. rightClip is the X position that we search in FIND_INDEX.
|
|
\retval DRAW_LINE index of last drawn character
|
|
\retval GET_WIDTH width in pixels of text segment if we would draw it
|
|
\retval FIND_INDEX index of character at given x position in window coordinates
|
|
\retval FIND_INDEX_FROM_ZERO index of character at given x position without scrolling and widget offsets
|
|
\todo we need to handle hidden hyphens and tabs here!
|
|
\todo we handle all styles and selections
|
|
\todo we must provide code to get pixel positions of the middle of a character as well
|
|
*/
|
|
int Fl_Text_Display::handle_vline(
|
|
int mode,
|
|
int lineStartPos, int lineLen, int leftChar, int rightChar,
|
|
int Y, int bottomClip,
|
|
int leftClip, int rightClip) const
|
|
{
|
|
IS_UTF8_ALIGNED2(buffer(), lineStartPos)
|
|
|
|
/* STR #2531
|
|
|
|
The variables startStyle and styleX seem to introduce some additional
|
|
complexity. They were required to fix STR #2531 in which a horizontal
|
|
character wiggle could be observed when drag-selecting text. This was caused
|
|
by native drawing an measuring routines that support kerning (inter-character
|
|
spacing, the width of 'T' plus the width of 'e' is greater than the width of
|
|
'Te', because advanced typesetting moves the 'e' slightly to the left below
|
|
the 'T').
|
|
|
|
To acommodate this, FLTK uses slightly different routines for a true style
|
|
change vs. a change in highlighting only.
|
|
*/
|
|
int i, X, startIndex, startStyle, style, charStyle;
|
|
char *lineStr;
|
|
double startX, styleX;
|
|
|
|
if ( lineStartPos == -1 ) {
|
|
lineStr = NULL;
|
|
} else {
|
|
lineStr = mBuffer->text_range( lineStartPos, lineStartPos + lineLen );
|
|
}
|
|
|
|
// STR #2788
|
|
int cursor_pos = 0;
|
|
if (mode==FIND_CURSOR_INDEX) {
|
|
mode = FIND_INDEX;
|
|
cursor_pos = 1;
|
|
}
|
|
|
|
if (mode==GET_WIDTH) {
|
|
X = 0;
|
|
} else if (mode==FIND_INDEX_FROM_ZERO) {
|
|
X = 0;
|
|
mode = FIND_INDEX;
|
|
} else {
|
|
X = text_area.x - mHorizOffset;
|
|
}
|
|
|
|
// In DRAW_LINE mode, the first iteration of the loop will draw all
|
|
// backgrounds. The second iteration will draw the text, so that text
|
|
// overlapping background color changes will not be clipped.
|
|
for (int loop=1; loop<=2; loop++) {
|
|
int mask = (loop==1) ? BG_ONLY_MASK : TEXT_ONLY_MASK;
|
|
startX = X;
|
|
startIndex = 0;
|
|
if (!lineStr) {
|
|
// just clear the background
|
|
if (mode==DRAW_LINE) {
|
|
style = position_style(lineStartPos, lineLen, -1);
|
|
if (loop==1)
|
|
draw_string( style|BG_ONLY_MASK, text_area.x, Y, text_area.x+text_area.w, lineStr, lineLen );
|
|
}
|
|
if (mode==FIND_INDEX) {
|
|
IS_UTF8_ALIGNED2(buffer(), lineStartPos)
|
|
return lineStartPos;
|
|
}
|
|
return 0;
|
|
}
|
|
char currChar = 0, prevChar = 0;
|
|
styleX = startX; startStyle = startIndex;
|
|
// draw the line
|
|
style = position_style(lineStartPos, lineLen, 0);
|
|
for (i=0; i<lineLen; ) {
|
|
currChar = lineStr[i]; // one byte is enough to handele tabs and other cases
|
|
int len = fl_utf8len1(currChar);
|
|
if (len<=0) len = 1; // OUCH!
|
|
charStyle = position_style(lineStartPos, lineLen, i);
|
|
if (charStyle!=style || currChar=='\t' || prevChar=='\t') {
|
|
// draw a segment whenever the style changes or a Tab is found
|
|
double w = 0;
|
|
if (prevChar=='\t') {
|
|
// draw a single Tab space
|
|
double tab = col_to_x(mBuffer->tab_distance());
|
|
double xAbs = (mode==GET_WIDTH) ? startX : startX+mHorizOffset-text_area.x;
|
|
w = ((int(xAbs/tab)+1)*tab) - xAbs;
|
|
styleX = startX+w; startStyle = i;
|
|
if (mode==DRAW_LINE && loop==1)
|
|
draw_string( style|BG_ONLY_MASK, int(startX), Y, int(startX+w), 0, 0 );
|
|
if (mode==FIND_INDEX && startX+w>rightClip) {
|
|
// find x pos inside block
|
|
free(lineStr);
|
|
if (cursor_pos && (startX+w/2<rightClip)) // STR #2788
|
|
return lineStartPos + startIndex + len; // STR #2788
|
|
return lineStartPos + startIndex;
|
|
}
|
|
} else {
|
|
// draw the text segment from the previous style change up to this point
|
|
if ( (style&0xff)==(charStyle&0xff)) {
|
|
w = string_width( lineStr+startStyle, i-startStyle, style ) - startX + styleX;
|
|
} else {
|
|
w = string_width( lineStr+startIndex, i-startIndex, style );
|
|
}
|
|
if (mode==DRAW_LINE) {
|
|
if (startIndex!=startStyle) {
|
|
fl_push_clip(int(startX), Y, int(w)+1, mMaxsize);
|
|
draw_string( style|mask, int(styleX), Y, int(startX+w), lineStr+startStyle, i-startStyle );
|
|
fl_pop_clip();
|
|
} else {
|
|
draw_string( style|mask, int(startX), Y, int(startX+w), lineStr+startIndex, i-startIndex );
|
|
}
|
|
}
|
|
if (mode==FIND_INDEX && startX+w>rightClip) {
|
|
// find x pos inside block
|
|
int di;
|
|
if (startIndex!=startStyle) {
|
|
di = find_x(lineStr+startStyle, i-startStyle, style, -int(rightClip-styleX)); // STR #2788
|
|
di = lineStartPos + startStyle + di;
|
|
} else {
|
|
di = find_x(lineStr+startIndex, i-startIndex, style, -int(rightClip-startX)); // STR #2788
|
|
di = lineStartPos + startIndex + di;
|
|
}
|
|
free(lineStr);
|
|
IS_UTF8_ALIGNED2(buffer(), (lineStartPos+startIndex+di))
|
|
return di;
|
|
}
|
|
if ( (style&0xff)!=(charStyle&0xff)) {
|
|
startStyle = i;
|
|
styleX = startX+w;
|
|
}
|
|
}
|
|
style = charStyle;
|
|
startX += w;
|
|
startIndex = i;
|
|
}
|
|
i += len;
|
|
prevChar = currChar;
|
|
}
|
|
double w = 0;
|
|
if (currChar=='\t') {
|
|
// draw a single Tab space
|
|
double tab = col_to_x(mBuffer->tab_distance());
|
|
double xAbs = (mode==GET_WIDTH) ? startX : startX+mHorizOffset-text_area.x;
|
|
w = ((int(xAbs/tab)+1)*tab) - xAbs;
|
|
if (mode==DRAW_LINE && loop==1)
|
|
draw_string( style|BG_ONLY_MASK, int(startX), Y, int(startX+w), 0, 0 );
|
|
if (mode==FIND_INDEX) {
|
|
// find x pos inside block
|
|
free(lineStr);
|
|
if (cursor_pos) // STR #2788
|
|
return lineStartPos + startIndex + ( rightClip-startX>w/2 ? 1 : 0 ); // STR #2788
|
|
return lineStartPos + startIndex + ( rightClip-startX>w ? 1 : 0 );
|
|
}
|
|
} else {
|
|
w = string_width( lineStr+startIndex, i-startIndex, style );
|
|
if (mode==DRAW_LINE) {
|
|
// STR 2531
|
|
if (startIndex!=startStyle) {
|
|
fl_push_clip(int(startX), Y, int(w)+1, mMaxsize);
|
|
draw_string( style|mask, int(styleX), Y, int(startX+w), lineStr+startStyle, i-startStyle );
|
|
fl_pop_clip();
|
|
} else {
|
|
draw_string( style|mask, int(startX), Y, int(startX+w), lineStr+startIndex, i-startIndex );
|
|
}
|
|
}
|
|
if (mode==FIND_INDEX) {
|
|
// find x pos inside block
|
|
int di;
|
|
if (startIndex!=startStyle) {
|
|
di = find_x(lineStr+startStyle, i-startStyle, style, -int(rightClip-styleX)); // STR #2788
|
|
di = lineStartPos + startStyle + di;
|
|
} else {
|
|
di = find_x(lineStr+startIndex, i-startIndex, style, -int(rightClip-startX)); // STR #2788
|
|
di = lineStartPos + startIndex + di;
|
|
}
|
|
free(lineStr);
|
|
IS_UTF8_ALIGNED2(buffer(), (lineStartPos+startIndex+di))
|
|
return di;
|
|
}
|
|
}
|
|
if (mode==GET_WIDTH) {
|
|
free(lineStr);
|
|
return int(startX+w);
|
|
}
|
|
|
|
// clear the rest of the line
|
|
startX += w;
|
|
style = position_style(lineStartPos, lineLen, i);
|
|
if (mode==DRAW_LINE && loop==1)
|
|
draw_string( style|BG_ONLY_MASK, int(startX), Y, text_area.x+text_area.w, lineStr, lineLen );
|
|
}
|
|
|
|
free(lineStr);
|
|
IS_UTF8_ALIGNED2(buffer(), (lineStartPos+lineLen))
|
|
return lineStartPos + lineLen;
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Find the index of the character that lies at the given x position / closest cursor position.
|
|
|
|
\param s UTF-8 text string
|
|
\param len length of string
|
|
\param style index into style lookup table
|
|
\param x position in pixels - negative returns closest cursor position
|
|
\return index into buffer
|
|
*/
|
|
int Fl_Text_Display::find_x(const char *s, int len, int style, int x) const {
|
|
IS_UTF8_ALIGNED(s)
|
|
|
|
int cursor_pos = x<0; // STR #2788
|
|
x = x<0 ? -x : x; // STR #2788
|
|
|
|
// TODO: use binary search which may be quicker.
|
|
int i = 0;
|
|
int last_w = 0; // STR #2788
|
|
while (i<len) {
|
|
int cl = fl_utf8len1(s[i]);
|
|
int w = int( string_width(s, i+cl, style) );
|
|
if (w>x) {
|
|
if (cursor_pos && (w-x < x-last_w)) return i+cl; // STR #2788
|
|
return i;
|
|
}
|
|
last_w = w; // STR #2788
|
|
i += cl;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Draw a single line of text.
|
|
|
|
Draw the text on a single line represented by \p visLineNum (the
|
|
number of lines down from the top of the display), limited by
|
|
\p leftClip and \p rightClip window coordinates and \p leftCharIndex and
|
|
\p rightCharIndex character positions (not including the character at
|
|
position \p rightCharIndex).
|
|
|
|
\param visLineNum index of line in the visible line number lookup
|
|
\param leftClip, rightClip pixel position of clipped area
|
|
\param leftCharIndex, rightCharIndex index into line of segment that we want to draw
|
|
*/
|
|
void Fl_Text_Display::draw_vline(int visLineNum, int leftClip, int rightClip,
|
|
int leftCharIndex, int rightCharIndex) {
|
|
int Y, lineStartPos, lineLen, fontHeight;
|
|
|
|
// 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 ];
|
|
if ( lineStartPos == -1 ) {
|
|
lineLen = 0;
|
|
} else {
|
|
lineLen = vline_length( visLineNum );
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Draw a text segment in a single style.
|
|
|
|
Draw a string or blank area according to parameter \p style, using the
|
|
appropriate colors and drawing method for that style, with top left
|
|
corner at \p X, \p Y. If style says to draw text, use \p string as
|
|
source of characters, and draw \p nChars, if style is FILL, erase
|
|
rectangle where text would have drawn from \p X to \p toX and from
|
|
\p Y to the maximum y extent of the current font(s).
|
|
|
|
\param style index into style lookup table
|
|
\param X, Y drawing origin
|
|
\param toX rightmost position if this is a fill operation
|
|
\param string text if this is a drawing operation
|
|
\param nChars number of characters to draw
|
|
*/
|
|
void Fl_Text_Display::draw_string(int style,
|
|
int X, int Y, int toX,
|
|
const char *string, int nChars) const {
|
|
IS_UTF8_ALIGNED(string)
|
|
|
|
const Style_Table_Entry *styleRec = NULL;
|
|
|
|
/* Draw blank area rather than text, if that was the request */
|
|
if ( style & FILL_MASK ) {
|
|
if (style & TEXT_ONLY_MASK) return;
|
|
clear_rect( style, X, Y, toX - X, mMaxsize );
|
|
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. */
|
|
|
|
Fl_Font font = textfont();
|
|
int fsize = textsize();
|
|
Fl_Color foreground;
|
|
Fl_Color background;
|
|
Fl_Color bgbasecolor;
|
|
|
|
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;
|
|
bgbasecolor = (styleRec->attr&ATTR_BGCOLOR) ? styleRec->bgcolor : color();
|
|
|
|
if (style & PRIMARY_MASK) {
|
|
if (Fl::focus() == (Fl_Widget*)this) {
|
|
if (Fl::screen_driver()->has_marked_text() && Fl::compose_state) {
|
|
background = bgbasecolor; // Mac OS: underline marked text
|
|
} else {
|
|
background = selection_color();
|
|
}
|
|
} else {
|
|
background = fl_color_average(bgbasecolor, selection_color(), 0.4f);
|
|
}
|
|
} else if (style & HIGHLIGHT_MASK) {
|
|
if (Fl::focus() == (Fl_Widget*)this) {
|
|
background = fl_color_average(bgbasecolor, selection_color(), 0.5f);
|
|
} else {
|
|
background = fl_color_average(bgbasecolor, selection_color(), 0.6f);
|
|
}
|
|
} else if (style & SECONDARY_MASK) {
|
|
if (Fl::focus() == (Fl_Widget*)this) {
|
|
background = fl_color_average(bgbasecolor, secondary_selection_color(), 0.5f);
|
|
} else {
|
|
background = fl_color_average(bgbasecolor, secondary_selection_color(), 0.6f);
|
|
}
|
|
} else {
|
|
background = bgbasecolor;
|
|
}
|
|
foreground = (style & PRIMARY_MASK) ? fl_contrast(styleRec->color, background) : styleRec->color;
|
|
} else if (style & PRIMARY_MASK) {
|
|
if (Fl::focus() == (Fl_Widget*)this) {
|
|
background = selection_color();
|
|
} else {
|
|
background = fl_color_average(color(), selection_color(), 0.4f);
|
|
}
|
|
foreground = fl_contrast(textcolor(), background);
|
|
} else if (style & HIGHLIGHT_MASK) {
|
|
if (Fl::focus() == (Fl_Widget*)this) {
|
|
background = fl_color_average(color(), selection_color(), 0.5f);
|
|
} else {
|
|
background = fl_color_average(color(), selection_color(), 0.6f);
|
|
}
|
|
foreground = fl_contrast(textcolor(), background);
|
|
} else if (style & SECONDARY_MASK) {
|
|
if (Fl::focus() == (Fl_Widget*)this) {
|
|
background = secondary_selection_color();
|
|
} else {
|
|
background = fl_color_average(color(), secondary_selection_color(), 0.4f);
|
|
}
|
|
foreground = fl_contrast(textcolor(), background);
|
|
} else {
|
|
foreground = textcolor();
|
|
background = color();
|
|
}
|
|
|
|
if ( !active_r() ) {
|
|
foreground = fl_inactive(foreground);
|
|
background = fl_inactive(background);
|
|
}
|
|
|
|
if (!(style & TEXT_ONLY_MASK)) {
|
|
fl_color( background );
|
|
fl_rectf( X, Y, toX - X, mMaxsize );
|
|
}
|
|
if (!(style & BG_ONLY_MASK)) {
|
|
fl_color( foreground );
|
|
fl_font( font, fsize );
|
|
int baseline = Y + mMaxsize - fl_descent();
|
|
// Make sure antialiased ÄÖÜ do not leak on line above:
|
|
// on X11+Xft the antialiased part of characters such as ÄÖÜ leak on the bottom pixel of the line above
|
|
static int can_leak = Fl::screen_driver()->text_display_can_leak();
|
|
// Clip top and bottom only. Add margin to avoid clipping horizontally
|
|
if (can_leak) fl_push_clip(x(), Y, w(), mMaxsize);
|
|
fl_draw( string, nChars, X, baseline);
|
|
if (styleRec) {
|
|
if (styleRec->attr & ATTR_LINES_MASK) {
|
|
int pitch = fsize/7;
|
|
int prevAA = fl_antialias();
|
|
fl_antialias(1);
|
|
switch (styleRec->attr & ATTR_LINES_MASK) {
|
|
case ATTR_UNDERLINE:
|
|
fl_color(foreground);
|
|
fl_line_style(FL_SOLID, pitch);
|
|
goto DRAW_UNDERLINE;
|
|
break;
|
|
case ATTR_GRAMMAR:
|
|
fl_color(grammar_underline_color());
|
|
goto DRAW_DOTTED_UNDERLINE;
|
|
case ATTR_SPELLING:
|
|
fl_color(spelling_underline_color());
|
|
DRAW_DOTTED_UNDERLINE:
|
|
fl_line_style(FL_DOT, pitch);
|
|
DRAW_UNDERLINE:
|
|
fl_xyline(X, baseline + fl_descent()/2, toX);
|
|
break;
|
|
case ATTR_STRIKE_THROUGH:
|
|
fl_color(foreground);
|
|
fl_line_style(FL_SOLID, pitch);
|
|
fl_xyline(X, baseline - (fl_height()-fl_descent())/3, toX);
|
|
break;
|
|
}
|
|
fl_line_style(FL_SOLID, 1);
|
|
fl_antialias(prevAA);
|
|
}
|
|
}
|
|
if (Fl::screen_driver()->has_marked_text() && Fl::compose_state && (style & PRIMARY_MASK)) {
|
|
fl_color( fl_color_average(foreground, background, 0.6f) );
|
|
fl_line(X, Y + mMaxsize - 1, X + (int)fl_width(string, nChars), Y + mMaxsize - 1);
|
|
}
|
|
if (can_leak) fl_pop_clip();
|
|
}
|
|
|
|
// 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 */
|
|
/*
|
|
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);
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Clear a rectangle with the appropriate background color for \p style.
|
|
|
|
\param style index into style table
|
|
\param X, Y, width, height size and position of background area
|
|
*/
|
|
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;
|
|
|
|
Fl_Color bgbasecolor = color();
|
|
if ( style & STYLE_LOOKUP_MASK ) {
|
|
int si = (style & STYLE_LOOKUP_MASK) - 'A';
|
|
if (si < 0) si = 0;
|
|
else if (si >= mNStyles) si = mNStyles - 1;
|
|
const Style_Table_Entry *styleRec = mStyleTable + si;
|
|
if (styleRec->attr&ATTR_BGCOLOR_EXT_)
|
|
bgbasecolor = styleRec->bgcolor;
|
|
}
|
|
|
|
Fl_Color c;
|
|
if (style & PRIMARY_MASK) {
|
|
if (Fl::focus()==(Fl_Widget*)this) {
|
|
c = selection_color();
|
|
} else {
|
|
c = fl_color_average(bgbasecolor, selection_color(), 0.4f);
|
|
}
|
|
} else if (style & HIGHLIGHT_MASK) {
|
|
if (Fl::focus()==(Fl_Widget*)this) {
|
|
c = fl_color_average(bgbasecolor, selection_color(), 0.5f);
|
|
} else {
|
|
c = fl_color_average(bgbasecolor, selection_color(), 0.6f);
|
|
}
|
|
} else {
|
|
c = bgbasecolor;
|
|
}
|
|
fl_color(active_r() ? c : fl_inactive(c));
|
|
fl_rectf( X, Y, width, height );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Draw a cursor with top center at \p X, \p Y.
|
|
|
|
\param X, Y cursor position in pixels
|
|
*/
|
|
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;
|
|
int fontWidth = TMPFONTWIDTH; // CET - FIXME
|
|
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. */
|
|
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;
|
|
segs[ 0 ].x1 = left; segs[ 0 ].y1 = bot; segs[ 0 ].x2 = X; segs[ 0 ].y2 = midY;
|
|
segs[ 1 ].x1 = X; segs[ 1 ].y1 = midY; segs[ 1 ].x2 = right; segs[ 1 ].y2 = bot;
|
|
segs[ 2 ].x1 = left; segs[ 2 ].y1 = bot; segs[ 2 ].x2 = X; segs[ 2 ].y2 = midY - 1;
|
|
segs[ 3 ].x1 = X; segs[ 3 ].y1 = midY - 1; segs[ 3 ].x2 = right; segs[ 3 ].y2 = bot;
|
|
nSegs = 4;
|
|
} else if ( mCursorStyle == NORMAL_CURSOR ) {
|
|
segs[ 0 ].x1 = left; segs[ 0 ].y1 = Y; segs[ 0 ].x2 = right; segs[ 0 ].y2 = Y;
|
|
segs[ 1 ].x1 = X; segs[ 1 ].y1 = Y; segs[ 1 ].x2 = X; segs[ 1 ].y2 = bot;
|
|
segs[ 2 ].x1 = left; segs[ 2 ].y1 = bot; segs[ 2 ].x2 = right; segs[ 2 ].y2 = bot;
|
|
nSegs = 3;
|
|
} else if ( mCursorStyle == HEAVY_CURSOR ) {
|
|
segs[ 0 ].x1 = X - 1; segs[ 0 ].y1 = Y; segs[ 0 ].x2 = X - 1; segs[ 0 ].y2 = bot;
|
|
segs[ 1 ].x1 = X; segs[ 1 ].y1 = Y; segs[ 1 ].x2 = X; segs[ 1 ].y2 = bot;
|
|
segs[ 2 ].x1 = X + 1; segs[ 2 ].y1 = Y; segs[ 2 ].x2 = X + 1; segs[ 2 ].y2 = bot;
|
|
segs[ 3 ].x1 = left; segs[ 3 ].y1 = Y; segs[ 3 ].x2 = right; segs[ 3 ].y2 = Y;
|
|
segs[ 4 ].x1 = left; segs[ 4 ].y1 = bot; segs[ 4 ].x2 = right; segs[ 4 ].y2 = bot;
|
|
nSegs = 5;
|
|
} else if ( mCursorStyle == DIM_CURSOR ) {
|
|
midY = Y + fontHeight / 2;
|
|
segs[ 0 ].x1 = X; segs[ 0 ].y1 = Y; segs[ 0 ].x2 = X; segs[ 0 ].y2 = Y;
|
|
segs[ 1 ].x1 = X; segs[ 1 ].y1 = midY; segs[ 1 ].x2 = X; segs[ 1 ].y2 = midY;
|
|
segs[ 2 ].x1 = X; segs[ 2 ].y1 = bot; segs[ 2 ].x2 = X; segs[ 2 ].y2 = bot;
|
|
nSegs = 3;
|
|
} else if ( mCursorStyle == BLOCK_CURSOR ) {
|
|
right = X + fontWidth;
|
|
segs[ 0 ].x1 = X; segs[ 0 ].y1 = Y; segs[ 0 ].x2 = right; segs[ 0 ].y2 = Y;
|
|
segs[ 1 ].x1 = right; segs[ 1 ].y1 = Y; segs[ 1 ].x2 = right; segs[ 1 ].y2 = bot;
|
|
segs[ 2 ].x1 = right; segs[ 2 ].y1 = bot; segs[ 2 ].x2 = X; segs[ 2 ].y2 = bot;
|
|
segs[ 3 ].x1 = X; segs[ 3 ].y1 = bot; segs[ 3 ].x2 = X; segs[ 3 ].y2 = Y;
|
|
nSegs = 4;
|
|
} else if ( mCursorStyle == SIMPLE_CURSOR ){
|
|
segs[ 0 ].x1 = X; segs[ 0 ].y1 = Y; segs[ 0 ].x2 = X; segs[ 0 ].y2 = bot;
|
|
segs[ 1 ].x1 = X+1; segs[ 1 ].y1 = Y; segs[ 1 ].x2 = X+1; segs[ 1 ].y2 = bot;
|
|
nSegs = 2;
|
|
}
|
|
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 );
|
|
}
|
|
|
|
//fix issue #270
|
|
if (Fl::focus() == this) {
|
|
fl_set_spot(textfont(), textsize(), X, bot, text_area.w, text_area.h, window());
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Find the correct style for a character.
|
|
|
|
Determine the drawing method to use to draw a specific character from "buf".
|
|
|
|
\p lineStartPos gives the character index where the line begins, \p lineIndex,
|
|
the number of characters past the beginning of the line, and \p lineLen
|
|
the number of displayed characters past the beginning of the line. Passing
|
|
\p 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.
|
|
|
|
If lineIndex is pointing to the last character in a line, and the second
|
|
to last character has the ATTR_BGCOLOR_EXT set, the background color will
|
|
extend into the remaining line.
|
|
|
|
\param lineStartPos beginning of this line
|
|
\param lineLen number of bytes in line
|
|
\param lineIndex position of character within line
|
|
\return style for the given character
|
|
*/
|
|
int Fl_Text_Display::position_style( int lineStartPos, int lineLen, int lineIndex) const
|
|
{
|
|
IS_UTF8_ALIGNED2(buffer(), lineStartPos)
|
|
|
|
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 ( styleBuf && lineIndex==lineLen && lineLen>0) {
|
|
style = ( unsigned char ) styleBuf->byte_at( pos-1 );
|
|
if (style == mUnfinishedStyle && mUnfinishedHighlightCB) {
|
|
(mUnfinishedHighlightCB)( pos, mHighlightCBArg);
|
|
style = (unsigned char) styleBuf->byte_at( pos);
|
|
}
|
|
int si = (style & STYLE_LOOKUP_MASK) - 'A';
|
|
if (si < 0) si = 0;
|
|
else if (si >= mNStyles) si = mNStyles - 1;
|
|
const Style_Table_Entry *styleRec = mStyleTable + si;
|
|
if ((styleRec->attr&ATTR_BGCOLOR_EXT_)==0)
|
|
style = FILL_MASK;
|
|
} else 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);
|
|
style = (unsigned char) styleBuf->byte_at( pos);
|
|
}
|
|
}
|
|
if (buf->primary_selection()->includes(pos))
|
|
style |= PRIMARY_MASK;
|
|
if (buf->highlight_selection()->includes(pos))
|
|
style |= HIGHLIGHT_MASK;
|
|
if (buf->secondary_selection()->includes(pos))
|
|
style |= SECONDARY_MASK;
|
|
return style;
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Find the width of a string in the font of a particular style.
|
|
|
|
\param string the text
|
|
\param length number of bytes in string
|
|
\param style index into style table
|
|
\return width of text segment in pixels
|
|
*/
|
|
double Fl_Text_Display::string_width( const char *string, int length, int style ) const {
|
|
IS_UTF8_ALIGNED(string)
|
|
|
|
Fl_Font font;
|
|
Fl_Fontsize fsize;
|
|
|
|
if ( mNStyles && (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 {
|
|
font = textfont();
|
|
fsize = textsize();
|
|
}
|
|
fl_font( font, fsize );
|
|
return fl_width( string, length );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Translate a pixel position into a character index.
|
|
|
|
Translate window coordinates to the nearest (insert cursor or character
|
|
cell) text position. The parameter \p 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 (\p X, \p Y).
|
|
|
|
\param X, Y pixel position
|
|
\param posType CURSOR_POS or CHARACTER_POS
|
|
\return index into text buffer
|
|
*/
|
|
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;
|
|
if ( visLineNum < 0 )
|
|
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 );
|
|
|
|
int mode = (posType == CURSOR_POS) ? FIND_CURSOR_INDEX : FIND_INDEX; // STR #2788
|
|
return handle_vline(mode,
|
|
lineStart, lineLen, 0, 0,
|
|
0, 0,
|
|
text_area.x, X);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Translate pixel coordinates into row and column.
|
|
|
|
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.
|
|
|
|
\param X, Y pixel coordinates
|
|
\param[out] row, column neares row and column
|
|
\param posType CURSOR_POS or CHARACTER_POS
|
|
*/
|
|
void Fl_Text_Display::xy_to_rowcol( int X, int Y, int *row,
|
|
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;
|
|
if ( *column < 0 ) * column = 0;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Offset line start counters for a new vertical scroll position.
|
|
|
|
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)
|
|
|
|
\param newTopLineNum index into buffer
|
|
*/
|
|
void Fl_Text_Display::offset_line_starts( int newTopLineNum ) {
|
|
int oldTopLineNum = mTopLineNum;
|
|
int oldFirstChar = mFirstChar;
|
|
int lineDelta = newTopLineNum - oldTopLineNum;
|
|
int nVisLines = mNVisibleLines;
|
|
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) */
|
|
lastLineNum = oldTopLineNum + nVisLines - 1;
|
|
if ( newTopLineNum < oldTopLineNum && newTopLineNum < -lineDelta ) {
|
|
mFirstChar = skip_lines( 0, newTopLineNum - 1, true );
|
|
} else if ( newTopLineNum < oldTopLineNum ) {
|
|
mFirstChar = rewind_lines( mFirstChar, -lineDelta );
|
|
} else if ( newTopLineNum < lastLineNum ) {
|
|
mFirstChar = lineStarts[ newTopLineNum - oldTopLineNum ];
|
|
} else if ( newTopLineNum - lastLineNum < mNBufferLines - newTopLineNum ) {
|
|
mFirstChar = skip_lines( lineStarts[ nVisLines - 1 ],
|
|
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-- )
|
|
lineStarts[ i ] = lineStarts[ i + lineDelta ];
|
|
calc_line_starts( 0, -lineDelta );
|
|
} else if ( lineDelta > 0 && lineDelta < nVisLines ) {
|
|
for ( i = 0; i < nVisLines - lineDelta; i++ )
|
|
lineStarts[ i ] = lineStarts[ i + lineDelta ];
|
|
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);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\brief Update line start arrays and variables.
|
|
|
|
Update the line starts array, mTopLineNum, mFirstChar and lastChar for this
|
|
text display after a modification to the text buffer, given by the
|
|
position \p pos where the change began, and the numbers of characters
|
|
and lines inserted and deleted.
|
|
|
|
\param pos index into buffer of recent changes
|
|
\param charsInserted number of bytes(!) inserted
|
|
\param charsDeleted number of bytes(!) deleted
|
|
\param linesInserted number of lines
|
|
\param linesDeleted number of lines
|
|
\param[out] scrolled set to 1 if the text display needs to be scrolled
|
|
*/
|
|
void Fl_Text_Display::update_line_starts(int pos, int charsInserted,
|
|
int charsDeleted, int linesInserted,
|
|
int linesDeleted, int *scrolled ) {
|
|
IS_UTF8_ALIGNED2(buffer(), pos)
|
|
|
|
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 */
|
|
if ( pos + charsDeleted < mFirstChar ) {
|
|
mTopLineNum += lineDelta;
|
|
for ( i = 0; i < nVisLines && lineStarts[i] != -1; i++ )
|
|
lineStarts[ i ] += charDelta;
|
|
mFirstChar += charDelta;
|
|
mLastChar += charDelta;
|
|
*scrolled = 0;
|
|
return;
|
|
}
|
|
|
|
/* The change began before the beginning of the displayed text, but
|
|
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 ) {
|
|
mTopLineNum = max( 1, mTopLineNum + lineDelta );
|
|
mFirstChar = rewind_lines(lineStarts[ lineOfEnd ] + charDelta, lineOfEnd );
|
|
/* Otherwise anchor on original line number and recount everything */
|
|
} else {
|
|
if ( mTopLineNum > mNBufferLines + lineDelta ) {
|
|
mTopLineNum = 1;
|
|
mFirstChar = 0;
|
|
} else
|
|
mFirstChar = skip_lines( 0, mTopLineNum - 1, true );
|
|
}
|
|
calc_line_starts( 0, nVisLines - 1 );
|
|
/* calculate lastChar by finding the end of the last displayed line */
|
|
calc_last_char();
|
|
*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 */
|
|
if ( pos <= mLastChar ) {
|
|
/* find line on which the change began */
|
|
position_to_line( pos, &lineOfPos );
|
|
/* salvage line starts after the changed area */
|
|
if ( lineDelta == 0 ) {
|
|
for ( i = lineOfPos + 1; i < nVisLines && lineStarts[ i ] != -1; i++ )
|
|
lineStarts[ i ] += charDelta;
|
|
} else if ( lineDelta > 0 ) {
|
|
for ( i = nVisLines - 1; i >= lineOfPos + lineDelta + 1; i-- )
|
|
lineStarts[ i ] = lineStarts[ i - lineDelta ] +
|
|
( 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 );
|
|
}
|
|
/* fill in the missing line starts */
|
|
if ( linesInserted >= 0 )
|
|
calc_line_starts( lineOfPos + 1, lineOfPos + linesInserted );
|
|
if ( lineDelta < 0 )
|
|
calc_line_starts( nVisLines + lineDelta, nVisLines );
|
|
/* calculate lastChar by finding the end of the last displayed line */
|
|
calc_last_char();
|
|
*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 */
|
|
if ( empty_vlines() ) {
|
|
position_to_line( pos, &lineOfPos );
|
|
calc_line_starts( lineOfPos, lineOfPos + linesInserted );
|
|
calc_last_char();
|
|
*scrolled = 0;
|
|
return;
|
|
}
|
|
|
|
/* Change was beyond the end of the buffer and not visible, do nothing */
|
|
*scrolled = 0;
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Update the line starts array.
|
|
|
|
Scan through the text in the Text Display'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.
|
|
|
|
\param startLine, endLine range of lines to scan as line numbers
|
|
*/
|
|
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;
|
|
if ( startLine < 0 ) startLine = 0;
|
|
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 */
|
|
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 */
|
|
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 */
|
|
if ( line == 0 || ( lineStarts[ line - 1 ] != bufLen &&
|
|
lineEnd != nextLineStart ) ) {
|
|
lineStarts[ line ] = bufLen;
|
|
line++;
|
|
}
|
|
break;
|
|
}
|
|
lineStarts[ line ] = startPos;
|
|
}
|
|
|
|
/* Set any entries beyond the end of the text to -1 */
|
|
for ( ; line <= endLine; line++ )
|
|
lineStarts[ line ] = -1;
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Update last display character index.
|
|
|
|
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--) ;
|
|
mLastChar = i < 0 ? 0 : line_end(mLineStarts[i], true);
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Scrolls the current buffer to start at the specified line and column.
|
|
|
|
\param topLineNum top line number
|
|
\param horizOffset column number
|
|
\todo Column numbers make little sense here.
|
|
*/
|
|
void Fl_Text_Display::scroll(int topLineNum, int horizOffset) {
|
|
mTopLineNumHint = topLineNum;
|
|
mHorizOffsetHint = horizOffset;
|
|
recalc_display(); // resize(x(), y(), w(), h());
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Scrolls the current buffer to start at the specified line and column.
|
|
|
|
\param topLineNum top line number
|
|
\param horizOffset in pixels
|
|
\return 0 if nothing changed, 1 if we scrolled
|
|
*/
|
|
int Fl_Text_Display::scroll_(int topLineNum, int horizOffset) {
|
|
/* Limit the requested scroll position to allowable values */
|
|
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 */
|
|
if (mHorizOffset == horizOffset && mTopLineNum == topLineNum)
|
|
return 0;
|
|
|
|
/* If the vertical scroll position has changed, update the line
|
|
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);
|
|
return 1;
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Update vertical scrollbar.
|
|
|
|
Update the minimum, maximum, slider size, page increment, and value
|
|
for the vertical scrollbar.
|
|
*/
|
|
void Fl_Text_Display::update_v_scrollbar() {
|
|
/* The vertical scrollbar 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 scrollbar 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+1+(mContinuousWrap?0:1));
|
|
mVScrollBar->linesize(3);
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Update horizontal scrollbar.
|
|
|
|
Update the minimum, maximum, slider size, page increment, and value
|
|
for the horizontal scrollbar.
|
|
*/
|
|
void Fl_Text_Display::update_h_scrollbar() {
|
|
int sliderMax = max(longest_vline(), text_area.w + mHorizOffset);
|
|
mHScrollBar->value( mHorizOffset, text_area.w, 0, sliderMax );
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Callback for drag or valueChanged on vertical scrollbar.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Callback for drag or valueChanged on horizontal scrollbar.
|
|
*/
|
|
void Fl_Text_Display::h_scrollbar_cb(Fl_Scrollbar* b, Fl_Text_Display* textD) {
|
|
if (b->value() == textD->mHorizOffset) return;
|
|
textD->scroll(textD->mTopLineNum, b->value());
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Refresh the line number area.
|
|
\param clearAll -- (currently unused) If False, only draws the line number text,
|
|
does not clear the area behind it. If True, clears the area
|
|
and redraws the text. Use False to avoid a 'flash' for
|
|
single buffered windows.
|
|
*/
|
|
|
|
// This draw_line_numbers() method based on patch from
|
|
// http://www.mail-archive.com/fltk-dev@easysw.com/msg06376.html
|
|
// altered to support line numbers right alignment. -LZA / STR #2621
|
|
//
|
|
void Fl_Text_Display::draw_line_numbers(bool /*clearAll*/) {
|
|
int Y, line, visLine, lineStart;
|
|
char lineNumString[16];
|
|
int lineHeight = mMaxsize;
|
|
int isactive = active_r() ? 1 : 0;
|
|
|
|
// Don't draw if lineNumWidth == 0 (line numbers are hidden),
|
|
// or widget is not yet realized
|
|
if (mLineNumWidth <= 0 || !visible_r())
|
|
return;
|
|
|
|
// Make sure we set the correct clipping range for line numbers.
|
|
// Take scrollbars and positions into account.
|
|
int hscroll_h = mHScrollBar->visible() ? mHScrollBar->h() : 0;
|
|
int xoff = Fl::box_dx(box());
|
|
int yoff = text_area.y - y();
|
|
|
|
#ifndef LINENUM_LEFT_OF_VSCROLL
|
|
int vscroll_w = mVScrollBar->visible() ? mVScrollBar->w() : 0;
|
|
if (scrollbar_align() & FL_ALIGN_LEFT)
|
|
xoff += vscroll_w;
|
|
#endif
|
|
|
|
Fl_Color fgcolor = isactive ? linenumber_fgcolor() : fl_inactive(linenumber_fgcolor());
|
|
Fl_Color bgcolor = isactive ? linenumber_bgcolor() : fl_inactive(linenumber_bgcolor());
|
|
fl_push_clip(x() + xoff,
|
|
y() + Fl::box_dy(box()),
|
|
mLineNumWidth,
|
|
h() - Fl::box_dh(box()));
|
|
{
|
|
// Set background color for line number area -- LZA / STR# 2621
|
|
// Erase background
|
|
fl_color(bgcolor);
|
|
fl_rectf(x()+xoff, y(), mLineNumWidth, h());
|
|
|
|
// Draw separator line
|
|
//fl_color(180,180,180);
|
|
//fl_line(x()+mLineNumWidth-1, y(), x()+mLineNumWidth-1, y()+h());
|
|
|
|
// Draw line number text
|
|
fl_font(linenumber_font(), linenumber_size());
|
|
|
|
Y = y() + yoff;
|
|
line = get_absolute_top_line_number();
|
|
|
|
// set font color for line numbers
|
|
fl_color(fgcolor);
|
|
for (visLine=0; visLine < mNVisibleLines; visLine++) {
|
|
lineStart = mLineStarts[visLine];
|
|
if (lineStart != -1 && (lineStart==0 || buffer()->char_at(lineStart-1)=='\n')) {
|
|
snprintf(lineNumString, sizeof(lineNumString),
|
|
linenumber_format(), line);
|
|
int xx = x() + xoff + 3,
|
|
yy = Y,
|
|
ww = mLineNumWidth - (3*2),
|
|
hh = lineHeight;
|
|
fl_draw(lineNumString, xx, yy, ww, hh, linenumber_align(), 0, 0);
|
|
//DEBUG fl_rect(xx, yy, ww, hh);
|
|
line++;
|
|
} else {
|
|
if (visLine == 0) line++;
|
|
}
|
|
Y += lineHeight;
|
|
}
|
|
}
|
|
// fill the void area to the left of the horizontal scrollbar that exists
|
|
// above or beneath the line number display (when on) with background color
|
|
fl_color(FL_BACKGROUND_COLOR);
|
|
if (scrollbar_align() & FL_ALIGN_TOP)
|
|
fl_rectf(x() + xoff, y() + Fl::box_dy(box()), mLineNumWidth, hscroll_h);
|
|
else
|
|
fl_rectf(x() + xoff, y() + h() - hscroll_h - Fl::box_dy(box()), mLineNumWidth, hscroll_h + Fl::box_dy(box()));
|
|
fl_pop_clip();
|
|
}
|
|
|
|
static int max( int i1, int i2 ) {
|
|
return i1 >= i2 ? i1 : i2;
|
|
}
|
|
|
|
static int min( int i1, int i2 ) {
|
|
return i1 <= i2 ? i1 : i2;
|
|
}
|
|
|
|
|
|
/**
|
|
Count the number of newlines in a null-terminated text string;
|
|
*/
|
|
static int countlines( const char *string ) {
|
|
IS_UTF8_ALIGNED(string)
|
|
|
|
const char * c;
|
|
int lineCount = 0;
|
|
|
|
if (!string) return 0;
|
|
|
|
for ( c = string; *c != '\0'; c++ )
|
|
if ( *c == '\n' ) lineCount++;
|
|
return lineCount;
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Returns the width in pixels of the displayed line pointed to by "visLineNum".
|
|
\param visLineNum index into visible lines array
|
|
\return width of line in pixels
|
|
*/
|
|
int Fl_Text_Display::measure_vline( int visLineNum ) const {
|
|
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);
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Return true if there are lines visible with no corresponding buffer text.
|
|
\return 1 if there are empty lines
|
|
*/
|
|
int Fl_Text_Display::empty_vlines() const {
|
|
return (mNVisibleLines > 0) && (mLineStarts[ mNVisibleLines - 1 ] == -1);
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Count number of bytes in a visible line.
|
|
|
|
Return the length of a line (number of bytes) by examining
|
|
entries in the line starts array rather than by scanning for newlines.
|
|
|
|
\param visLineNum index of line in visible line array
|
|
\return number of bytes in this line
|
|
*/
|
|
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 )
|
|
return mLastChar - lineStartPos;
|
|
|
|
nextLineStart = mLineStarts[ visLineNum + 1 ];
|
|
if ( nextLineStart == -1 )
|
|
return mLastChar - lineStartPos;
|
|
|
|
int nextLineStartMinus1 = buffer()->prev_char(nextLineStart);
|
|
if (wrap_uses_character(nextLineStartMinus1))
|
|
return nextLineStartMinus1 - lineStartPos;
|
|
|
|
return nextLineStart - lineStartPos;
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Wrapping calculations.
|
|
|
|
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.
|
|
|
|
\param deletedText
|
|
\param pos
|
|
\param nInserted
|
|
\param nDeleted
|
|
\param modRangeStart
|
|
\param modRangeEnd
|
|
\param linesInserted
|
|
\param linesDeleted
|
|
*/
|
|
void Fl_Text_Display::find_wrap_range(const char *deletedText, int pos,
|
|
int nInserted, int nDeleted,
|
|
int *modRangeStart, int *modRangeEnd,
|
|
int *linesInserted, int *linesDeleted) {
|
|
IS_UTF8_ALIGNED(deletedText)
|
|
IS_UTF8_ALIGNED2(buffer(), pos)
|
|
|
|
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);
|
|
}
|
|
} else {
|
|
countFrom = buf->line_start(pos);
|
|
}
|
|
|
|
IS_UTF8_ALIGNED2(buf, countFrom)
|
|
|
|
/*
|
|
** 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 && buf->char_at(buf->prev_char(lineStart)) == '\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<nVisLines && lineStarts[visLineNum] < lineStart)
|
|
visLineNum++;
|
|
if (visLineNum < nVisLines && lineStarts[visLineNum] == lineStart) {
|
|
countFrom = lineStart;
|
|
nLines = 0;
|
|
if (visLineNum+1 < nVisLines && lineStarts[visLineNum+1] != -1)
|
|
*modRangeStart = min(pos, buf->prev_char(lineStarts[visLineNum+1]));
|
|
else
|
|
*modRangeStart = countFrom;
|
|
} else
|
|
*modRangeStart = min(*modRangeStart, buf->prev_char(lineStart));
|
|
}
|
|
|
|
/* 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 (visLineNum<nVisLines && lineStarts[visLineNum]<adjLineStart)
|
|
visLineNum++;
|
|
if (visLineNum < nVisLines && lineStarts[visLineNum] != -1 &&
|
|
lineStarts[visLineNum] == adjLineStart) {
|
|
countTo = line_end(lineStart, true);
|
|
*modRangeEnd = lineStart;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
*linesInserted = nLines;
|
|
|
|
|
|
/* Count deleted lines between countFrom and countTo as the text existed
|
|
before the modification (that is, as if the text between pos and
|
|
pos+nInserted were replaced by "deletedText"). This extra context is
|
|
necessary because wrapping can occur outside of the modified region
|
|
as a result of adding or deleting text in the region. This is done by
|
|
creating a textBuffer containing the deleted text and the necessary
|
|
additional context, and calling the wrappedLineCounter on it.
|
|
|
|
NOTE: This must not be done in continuous wrap mode when the font
|
|
width is not fixed. In that case, the calculation would try
|
|
to access style information that is no longer available (deleted
|
|
text), or out of date (updated highlighting), possibly leading
|
|
to completely wrong calculations and/or even crashes eventually.
|
|
(This is not theoretical; it really happened.)
|
|
|
|
In that case, the calculation of the number of deleted lines
|
|
has happened before the buffer was modified (only in that case,
|
|
because resynchronization of the line starts is impossible
|
|
in that case, which makes the whole calculation less efficient).
|
|
*/
|
|
if (mSuppressResync) {
|
|
*linesDeleted = mNLinesDeleted;
|
|
mSuppressResync = 0;
|
|
return;
|
|
}
|
|
|
|
length = (pos-countFrom) + nDeleted +(countTo-(pos+nInserted));
|
|
deletedTextBuf = new Fl_Text_Buffer(length);
|
|
deletedTextBuf->copy(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;
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Wrapping calculations.
|
|
|
|
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).
|
|
|
|
\param pos
|
|
\param nDeleted
|
|
*/
|
|
void Fl_Text_Display::measure_deleted_lines(int pos, int nDeleted) {
|
|
IS_UTF8_ALIGNED2(buffer(), pos)
|
|
|
|
int retPos, retLines, retLineStart, retLineEnd;
|
|
Fl_Text_Buffer *buf = buffer();
|
|
int nVisLines = mNVisibleLines;
|
|
int *lineStarts = mLineStarts;
|
|
int countFrom, lineStart;
|
|
int 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];
|
|
} else
|
|
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 && 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). */
|
|
}
|
|
mNLinesDeleted = nLines;
|
|
mSuppressResync = 1;
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Wrapping calculations.
|
|
|
|
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.
|
|
|
|
\param[in] buf The text buffer to operate on
|
|
\param[in] startPos Starting index position into the buffer
|
|
\param[in] maxPos Maximum index position into the buffer we'll reach
|
|
\param[in] maxLines Maximum number of lines we'll reach
|
|
\param[in] startPosIsLineStart Flag indicating if startPos is start of line.
|
|
(If set, prevents our having to find the line start)
|
|
\param[in] styleBufOffset Offset index position into style buffer.
|
|
|
|
\param[out] retPos Position where counting ended. When counting lines, the
|
|
position returned is the start of the line "maxLines" lines
|
|
beyond "startPos".
|
|
\param[out] retLines Number of line breaks counted
|
|
\param[out] retLineStart Start of the line where counting ended
|
|
\param[out] retLineEnd End position of the last line traversed
|
|
\param[out] countLastLineMissingNewLine
|
|
*/
|
|
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 {
|
|
IS_UTF8_ALIGNED2(buf, startPos)
|
|
IS_UTF8_ALIGNED2(buf, maxPos)
|
|
|
|
int lineStart, newLineStart = 0, b, p, colNum, wrapMarginPix;
|
|
int i, foundBreak;
|
|
double width;
|
|
int nLines = 0;
|
|
unsigned int c;
|
|
|
|
/* Set the wrap margin to the wrap column or the view width */
|
|
if (mWrapMarginPix != 0) {
|
|
wrapMarginPix = mWrapMarginPix;
|
|
} else {
|
|
wrapMarginPix = 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; p<buf->length(); p=buf->next_char(p)) {
|
|
c = buf->char_at(p); // UCS-4
|
|
|
|
/* 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++;
|
|
int p1 = buf->next_char(p);
|
|
if (nLines >= maxLines) {
|
|
*retPos = p1;
|
|
*retLines = nLines;
|
|
*retLineStart = p1;
|
|
*retLineEnd = p;
|
|
return;
|
|
}
|
|
lineStart = p1;
|
|
colNum = 0;
|
|
width = 0;
|
|
} else {
|
|
const char *s = buf->address(p);
|
|
colNum++;
|
|
// FIXME: it is not a good idea to simply add character widths because on
|
|
// some platforms, the width is a floating point value and depends on the
|
|
// previous character as well.
|
|
width += measure_proportional_character(s, (int)width, p+styleBufOffset);
|
|
}
|
|
|
|
/* If character exceeded wrap margin, find the break point and wrap there */
|
|
if (width > wrapMarginPix) {
|
|
foundBreak = false;
|
|
for (b=p; b>=lineStart; b=buf->prev_char(b)) {
|
|
c = buf->char_at(b);
|
|
if (c == '\t' || c == ' ') {
|
|
newLineStart = buf->next_char(b);
|
|
colNum = 0;
|
|
width = 0;
|
|
int iMax = buf->next_char(p);
|
|
for (i=buf->next_char(b); i<iMax; i = buf->next_char(i)) {
|
|
width += measure_proportional_character(buf->address(i), (int)width,
|
|
i+styleBufOffset);
|
|
colNum++;
|
|
}
|
|
foundBreak = true;
|
|
break;
|
|
}
|
|
}
|
|
if (b<lineStart) b = lineStart;
|
|
if (!foundBreak) { /* no whitespace, just break at margin */
|
|
newLineStart = max(p, buf->next_char(lineStart));
|
|
colNum++;
|
|
if (b >= buf->length()) { // STR #2730
|
|
width = 0;
|
|
} else {
|
|
const char *s = buf->address(b);
|
|
width = measure_proportional_character(s, 0, 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 ? buf->next_char(b) : max(p, buf->next_char(lineStart));
|
|
*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 = buf->next_char(*retLines);
|
|
*retLineStart = lineStart;
|
|
*retLineEnd = buf->length();
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Wrapping calculations.
|
|
|
|
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.
|
|
|
|
\param s text string
|
|
\param xPix x pixel position needed for calculating tab widths
|
|
\param pos offset within string
|
|
\return width of character in pixels
|
|
*/
|
|
double Fl_Text_Display::measure_proportional_character(const char *s, int xPix, int pos) const {
|
|
IS_UTF8_ALIGNED(s)
|
|
|
|
if (*s=='\t') {
|
|
int tab = (int)col_to_x(mBuffer->tab_distance());
|
|
return (((xPix/tab)+1)*tab) - xPix;
|
|
}
|
|
|
|
int charLen = fl_utf8len1(*s), style = 0;
|
|
if (mStyleBuffer) {
|
|
style = mStyleBuffer->byte_at(pos);
|
|
}
|
|
return string_width(s, charLen, style);
|
|
}
|
|
|
|
|
|
/**
|
|
\brief 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.
|
|
|
|
\param startPos
|
|
\param startPosIsLineStart
|
|
\param[out] lineEnd
|
|
\param[out] nextLineStart
|
|
*/
|
|
void Fl_Text_Display::find_line_end(int startPos, bool startPosIsLineStart,
|
|
int *lineEnd, int *nextLineStart) const {
|
|
IS_UTF8_ALIGNED2(buffer(), startPos)
|
|
|
|
int retLines, retLineStart;
|
|
|
|
/* if we're not wrapping use more efficient Fl_Text_Buffer::line_end() */
|
|
if (!mContinuousWrap) {
|
|
int le = buffer()->line_end(startPos);
|
|
int ls = buffer()->next_char(le);
|
|
*lineEnd = le;
|
|
*nextLineStart = min(buffer()->length(), ls);
|
|
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);
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Check if the line break is caused by a newline or by line wrapping.
|
|
|
|
Line breaks in continuous wrap mode usually happen at newlines (\\n) 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 Fl_Text_Display::line_end()
|
|
or Fl_Text_Buffer::line_end(), 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.
|
|
|
|
\param lineEndPos index of character where the line wraps
|
|
\return 1 if a \\n character causes the line wrap
|
|
*/
|
|
int Fl_Text_Display::wrap_uses_character(int lineEndPos) const {
|
|
IS_UTF8_ALIGNED2(buffer(), lineEndPos)
|
|
|
|
unsigned int c;
|
|
|
|
if (!mContinuousWrap || lineEndPos == buffer()->length())
|
|
return 1;
|
|
|
|
c = buffer()->char_at(lineEndPos);
|
|
return c == '\n' || ((c == '\t' || c == ' ') &&
|
|
lineEndPos + 1 < buffer()->length());
|
|
}
|
|
|
|
|
|
/**
|
|
\brief I don't know what this does!
|
|
|
|
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).
|
|
|
|
\param startpos ??
|
|
\param endpos ??
|
|
|
|
\todo Unicode?
|
|
*/
|
|
void Fl_Text_Display::extend_range_for_styles( int *startpos, int *endpos ) {
|
|
IS_UTF8_ALIGNED2(buffer(), (*startpos))
|
|
IS_UTF8_ALIGNED2(buffer(), (*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 its redraw
|
|
range to show the text color/and font changes as well. */
|
|
if ( sel->selected() ) {
|
|
if ( sel->start() < *startpos ) {
|
|
*startpos = sel->start();
|
|
// somewhere while deleting, alignment is lost. We do this just to be sure.
|
|
*startpos = buffer()->utf8_align(*startpos);
|
|
IS_UTF8_ALIGNED2(buffer(), (*startpos))
|
|
extended = 1;
|
|
}
|
|
if ( sel->end() > *endpos ) {
|
|
*endpos = sel->end();
|
|
*endpos = buffer()->utf8_align(*endpos);
|
|
IS_UTF8_ALIGNED2(buffer(), (*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 */
|
|
if ( extended )
|
|
*endpos = mBuffer->line_end( *endpos ) + 1;
|
|
|
|
IS_UTF8_ALIGNED2(buffer(), (*endpos))
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Draw the widget.
|
|
|
|
This function tries to limit drawing to smaller areas if possible.
|
|
*/
|
|
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
|
|
|
|
// background color -- change if inactive
|
|
Fl_Color bgcolor = active_r() ? color() : fl_inactive(color());
|
|
|
|
// draw the non-text, non-scrollbar areas.
|
|
if (damage() & FL_DAMAGE_ALL) {
|
|
recalc_display();
|
|
// printf("drawing all (box = %d)\n", box());
|
|
if (Fl_Surface_Device::surface() != Fl_Display_Device::display_device()) {
|
|
// if to printer, draw the background
|
|
fl_rectf(text_area.x, text_area.y, text_area.w, text_area.h, bgcolor);
|
|
}
|
|
|
|
// draw the box()
|
|
draw_box(box(), x(), y(), w(), h(), bgcolor);
|
|
|
|
// left margin
|
|
fl_rectf(text_area.x-LEFT_MARGIN, text_area.y-TOP_MARGIN,
|
|
LEFT_MARGIN, text_area.h+TOP_MARGIN+BOTTOM_MARGIN,
|
|
bgcolor);
|
|
|
|
// right margin
|
|
fl_rectf(text_area.x+text_area.w, text_area.y-TOP_MARGIN,
|
|
RIGHT_MARGIN, text_area.h+TOP_MARGIN+BOTTOM_MARGIN,
|
|
bgcolor);
|
|
|
|
// top margin
|
|
fl_rectf(text_area.x, text_area.y-TOP_MARGIN,
|
|
text_area.w, TOP_MARGIN, bgcolor);
|
|
|
|
// bottom margin
|
|
fl_rectf(text_area.x, text_area.y+text_area.h,
|
|
text_area.w, BOTTOM_MARGIN, bgcolor);
|
|
|
|
// 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_BACKGROUND_COLOR);
|
|
}
|
|
else if (damage() & (FL_DAMAGE_SCROLL | FL_DAMAGE_EXPOSE)) {
|
|
// 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,
|
|
text_area.w+LEFT_MARGIN+RIGHT_MARGIN,
|
|
text_area.h);
|
|
fl_rectf(text_area.x-LEFT_MARGIN, mCursorOldY,
|
|
LEFT_MARGIN, mMaxsize, bgcolor);
|
|
fl_rectf(text_area.x+text_area.w, mCursorOldY,
|
|
RIGHT_MARGIN, mMaxsize, bgcolor);
|
|
fl_pop_clip();
|
|
}
|
|
|
|
// draw the scrollbars
|
|
if (damage() & (FL_DAMAGE_ALL | FL_DAMAGE_CHILD)) {
|
|
mVScrollBar->damage(FL_DAMAGE_ALL);
|
|
mHScrollBar->damage(FL_DAMAGE_ALL);
|
|
}
|
|
update_child(*mVScrollBar);
|
|
update_child(*mHScrollBar);
|
|
|
|
// draw all of the text
|
|
if (damage() & (FL_DAMAGE_ALL | FL_DAMAGE_EXPOSE)) {
|
|
//printf("drawing all text\n");
|
|
int X = 0, Y = 0, W = 0, H = 0;
|
|
if (fl_clip_box(text_area.x, text_area.y, text_area.w, text_area.h,
|
|
X, Y, W, H)) {
|
|
// Draw text using the intersected clipping box...
|
|
// (this sets the clipping internally)
|
|
draw_text(X, Y, W, H);
|
|
} else {
|
|
// Draw the whole area...
|
|
draw_text(text_area.x, text_area.y, text_area.w, text_area.h);
|
|
}
|
|
}
|
|
else if (damage() & FL_DAMAGE_SCROLL) {
|
|
// draw some lines of text
|
|
fl_push_clip(text_area.x, text_area.y,
|
|
text_area.w, text_area.h);
|
|
//printf("drawing text from %d to %d\n", damage_range1_start, damage_range1_end);
|
|
draw_range(damage_range1_start, damage_range1_end);
|
|
if (damage_range2_end != -1) {
|
|
//printf("drawing text from %d to %d\n", damage_range2_start, damage_range2_end);
|
|
draw_range(damage_range2_start, damage_range2_end);
|
|
}
|
|
damage_range1_start = damage_range1_end = -1;
|
|
damage_range2_start = damage_range2_end = -1;
|
|
fl_pop_clip();
|
|
}
|
|
|
|
// draw the text cursor
|
|
int start, end;
|
|
int has_selection = buffer()->selection_position(&start, &end);
|
|
if (damage() & (FL_DAMAGE_ALL | FL_DAMAGE_SCROLL | FL_DAMAGE_EXPOSE)
|
|
&& (
|
|
(Fl::screen_driver()->has_marked_text() && Fl::compose_state) ||
|
|
(!has_selection) || mCursorPos < start || mCursorPos > end) &&
|
|
mCursorOn && Fl::focus() == (Fl_Widget*)this ) {
|
|
fl_push_clip(text_area.x-LEFT_MARGIN,
|
|
text_area.y,
|
|
text_area.w+LEFT_MARGIN+RIGHT_MARGIN,
|
|
text_area.h);
|
|
|
|
int X = 0, Y = 0;
|
|
if (position_to_xy(mCursorPos, &X, &Y)) {
|
|
draw_cursor(X, Y);
|
|
mCursorOldY = Y;
|
|
}
|
|
// else puts("position_to_xy() failed - unable to draw cursor!");
|
|
//printf("drew cursor at pos: %d (%d,%d)\n", mCursorPos, X, Y);
|
|
fl_pop_clip();
|
|
}
|
|
|
|
// Important to do this at end of this method, otherwise line numbers
|
|
// will not scroll with the text edit area
|
|
draw_line_numbers(true);
|
|
|
|
fl_pop_clip();
|
|
}
|
|
|
|
// GitHub Issue #196: internal selection and visible selection can run out of
|
|
// sync, giving the user unexpected keyboard selection. The code block below
|
|
// captures that and fixes it.
|
|
// - set pos to the drag target postion or -1 if we don't know
|
|
// - if pos is -1, and key is not -1, key can be set to indicate a direction
|
|
// (e.g. FL_Left)
|
|
// return 0 if nothing changed, return 1 if dragPos or mCursorPos were modified
|
|
int fl_text_drag_prepare(int pos, int key, Fl_Text_Display* d) {
|
|
if (d->buffer()->selected()) {
|
|
int start, end;
|
|
d->buffer()->selection_position(&start, &end);
|
|
if ( (d->dragPos!=start || d->mCursorPos!=end) && (d->dragPos!=end || d->mCursorPos!=start) ) {
|
|
if (pos!=-1) {
|
|
if (pos<start) {
|
|
d->mCursorPos = start;
|
|
d->dragPos = end;
|
|
} else {
|
|
d->mCursorPos = end;
|
|
d->dragPos = start;
|
|
}
|
|
} else if (key!=-1) {
|
|
switch (key) {
|
|
case FL_Home: case FL_Left: case FL_Up: case FL_Page_Up:
|
|
d->dragPos = end; d->mCursorPos = start; break;
|
|
default:
|
|
d->dragPos = start; d->mCursorPos = end; break;
|
|
}
|
|
} else {
|
|
d->dragPos = start;
|
|
d->mCursorPos = end;
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// this processes drag events due to mouse for Fl_Text_Display and
|
|
// also drags due to cursor movement with shift held down for
|
|
// Fl_Text_Editor
|
|
void fl_text_drag_me(int pos, Fl_Text_Display* d) {
|
|
if (d->dragType == Fl_Text_Display::DRAG_CHAR) {
|
|
if (pos >= d->dragPos) {
|
|
d->buffer()->select(d->dragPos, pos);
|
|
} else {
|
|
d->buffer()->select(pos, d->dragPos);
|
|
}
|
|
d->insert_position(pos);
|
|
} else if (d->dragType == Fl_Text_Display::DRAG_WORD) {
|
|
if (pos >= d->dragPos) {
|
|
d->insert_position(d->word_end(pos));
|
|
d->buffer()->select(d->word_start(d->dragPos), d->word_end(pos));
|
|
} else {
|
|
d->insert_position(d->word_start(pos));
|
|
d->buffer()->select(d->word_start(pos), d->word_end(d->dragPos));
|
|
}
|
|
} else if (d->dragType == Fl_Text_Display::DRAG_LINE) {
|
|
if (pos >= d->dragPos) {
|
|
d->insert_position(d->buffer()->line_end(pos)+1);
|
|
d->buffer()->select(d->buffer()->line_start(d->dragPos),
|
|
d->buffer()->line_end(pos)+1);
|
|
} else {
|
|
d->insert_position(d->buffer()->line_start(pos));
|
|
d->buffer()->select(d->buffer()->line_start(pos),
|
|
d->buffer()->line_end(d->dragPos)+1);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
\brief Timer callback for scroll events.
|
|
|
|
This timer event scrolls the text view proportionally to
|
|
how far the mouse pointer has left the text area. This
|
|
allows for smooth scrolling without "wiggeling" the mouse.
|
|
*/
|
|
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;
|
|
}
|
|
fl_text_drag_me(pos, w);
|
|
Fl::repeat_timeout(.1, scroll_timer_cb, user_data);
|
|
}
|
|
|
|
static Fl_Menu_Item rmb_menu[] = {
|
|
{ Fl_Input::cut_menu_text, 0, NULL, (void*)1 },
|
|
{ Fl_Input::copy_menu_text, 0, NULL, (void*)2 },
|
|
{ Fl_Input::paste_menu_text, 0, NULL, (void*)3 },
|
|
{ NULL }
|
|
};
|
|
|
|
/** Handle right mouse button down events.
|
|
\return 0 for no op, 1 to cut, 2 to copy, 3 to paste
|
|
*/
|
|
int Fl_Text_Display::handle_rmb(int readonly) {
|
|
Fl_Text_Buffer *txtbuf = buffer();
|
|
int newpos = xy_to_position(Fl::event_x(), Fl::event_y(), CURSOR_POS);
|
|
int oldpos = txtbuf->primary_selection()->start();
|
|
int oldmark = txtbuf->primary_selection()->end();
|
|
if ( ((oldpos < newpos) && (oldmark > newpos))
|
|
|| ((oldmark < newpos) && (oldpos > newpos))
|
|
|| (type() == FL_SECRET_INPUT)) {
|
|
// if the user clicked inside an existing selection, keep
|
|
// the selection
|
|
} else {
|
|
if ((txtbuf->char_at(newpos) == 0) || (txtbuf->char_at(newpos) == '\n')) {
|
|
// if clicked to the right of the line or text end, clear the
|
|
// selection and set the cursor at the end of the line
|
|
txtbuf->select(newpos, newpos);
|
|
} else {
|
|
// if clicked on a word, select the entire word
|
|
txtbuf->select(txtbuf->word_start(newpos), txtbuf->word_end(newpos));
|
|
}
|
|
}
|
|
if (readonly) { // give only the menu options that make sense
|
|
rmb_menu[0].deactivate(); // cut
|
|
rmb_menu[2].deactivate(); // paste
|
|
} else {
|
|
rmb_menu[0].activate(); // cut
|
|
rmb_menu[2].activate(); // paste
|
|
}
|
|
// pop up the menu
|
|
fl_cursor(FL_CURSOR_DEFAULT);
|
|
const Fl_Menu_Item *mi = rmb_menu->popup(Fl::event_x(), Fl::event_y());
|
|
if (mi) return (int)mi->argument();
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
\brief Event handling.
|
|
*/
|
|
int Fl_Text_Display::handle(int event) {
|
|
if (!buffer()) return 0;
|
|
// This isn't very elegant!
|
|
if (!Fl::event_inside(text_area.x, text_area.y, text_area.w, text_area.h) &&
|
|
!dragging && event != FL_LEAVE && event != FL_ENTER &&
|
|
event != FL_MOVE && event != FL_FOCUS && event != FL_UNFOCUS &&
|
|
event != FL_KEYBOARD && event != FL_KEYUP) {
|
|
return Fl_Group::handle(event);
|
|
}
|
|
|
|
switch (event) {
|
|
case FL_ENTER:
|
|
case FL_MOVE:
|
|
if (active_r()) {
|
|
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);
|
|
return 1;
|
|
} 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_button() == FL_RIGHT_MOUSE) {
|
|
switch (handle_rmb(1)) {
|
|
case 2: {
|
|
if (!buffer()->selected()) break;
|
|
const char *copy = buffer()->selection_text();
|
|
if (*copy) Fl::copy(copy, (int) strlen(copy), 1);
|
|
free((void*)copy);
|
|
show_insert_position();
|
|
break;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
if (Fl::event_state()&FL_SHIFT) {
|
|
if (buffer()->primary_selection()->selected()) {
|
|
int pos = xy_to_position(Fl::event_x(), Fl::event_y(), CURSOR_POS);
|
|
fl_text_drag_prepare(pos, -1, this);
|
|
} else {
|
|
dragPos = insert_position();
|
|
}
|
|
return handle(FL_DRAG);
|
|
}
|
|
dragging = 1;
|
|
int pos = xy_to_position(Fl::event_x(), Fl::event_y(), CURSOR_POS);
|
|
dragPos = pos;
|
|
if (buffer()->primary_selection()->includes(pos)) {
|
|
dragType = DRAG_START_DND;
|
|
return 1;
|
|
}
|
|
dragType = Fl::event_clicks();
|
|
if (dragType == DRAG_CHAR) {
|
|
buffer()->unselect();
|
|
// Fl::copy("", 0, 0); /* removed for STR 2668 */
|
|
}
|
|
else if (dragType == DRAG_WORD) {
|
|
buffer()->select(word_start(pos), word_end(pos));
|
|
dragPos = word_start(pos);
|
|
}
|
|
|
|
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==DRAG_NONE)
|
|
return 1;
|
|
if (dragType==DRAG_START_DND) {
|
|
if (!Fl::event_is_click() && Fl::dnd_text_ops()) {
|
|
const char* copy = buffer()->selection_text();
|
|
Fl::copy(copy, (int)strlen(copy));
|
|
Fl::screen_driver()->dnd(1);
|
|
free((void*)copy);
|
|
}
|
|
return 1;
|
|
}
|
|
int X = Fl::event_x(), Y = Fl::event_y(), pos = insert_position();
|
|
// 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);
|
|
pos = buffer()->next_char(pos);
|
|
}
|
|
fl_text_drag_me(pos, this);
|
|
return 1;
|
|
}
|
|
|
|
case FL_RELEASE: {
|
|
if (Fl::event_is_click() && (! Fl::event_clicks()) &&
|
|
buffer()->primary_selection()->includes(dragPos) && !(Fl::event_state()&FL_SHIFT) ) {
|
|
buffer()->unselect(); // clicking in the selection: unselect and move cursor
|
|
insert_position(dragPos);
|
|
return 1;
|
|
} else if (Fl::event_clicks() == DRAG_LINE && Fl::event_button() == FL_LEFT_MOUSE) {
|
|
buffer()->select(buffer()->line_start(dragPos), buffer()->next_char(buffer()->line_end(dragPos)));
|
|
dragPos = line_start(dragPos);
|
|
dragType = DRAG_CHAR;
|
|
} else {
|
|
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, (int) 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:
|
|
if (buffer()->selected()) {
|
|
int start, end;
|
|
if (buffer()->selection_position(&start, &end))
|
|
redisplay_range(start, end);
|
|
}
|
|
if (buffer()->secondary_selected()) {
|
|
int start, end;
|
|
if (buffer()->secondary_selection_position(&start, &end))
|
|
redisplay_range(start, end);
|
|
}
|
|
if (buffer()->highlight()) {
|
|
int start, end;
|
|
if (buffer()->highlight_position(&start, &end))
|
|
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, (int) 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());
|
|
const char *copy = buffer()->selection_text();
|
|
if (*copy) Fl::copy(copy, (int) strlen(copy), 0);
|
|
free((void*)copy);
|
|
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;
|
|
if (Fl::visible_focus() && handle(FL_FOCUS)) {
|
|
Fl::focus(this);
|
|
return 1;
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
Convert an x pixel position into a column number.
|
|
The width of a column is calculated as the average width of a few
|
|
representative characters, giving a good estimate for proportional fonts.
|
|
This method does not take the possition of the scroll bars into account.
|
|
\param[in] x offset to the left edge of the text in FLTK units.
|
|
\return approximation to the corresponding text column
|
|
\see col_to_x()
|
|
*/
|
|
double Fl_Text_Display::x_to_col(double x) const
|
|
{
|
|
if (!mColumnScale) {
|
|
mColumnScale = string_width("Mitg", 4, 'A') / 4.0;
|
|
}
|
|
return (x/mColumnScale)+0.5;
|
|
}
|
|
|
|
|
|
/**
|
|
Convert a column number into an x pixel position.
|
|
\see x_to_col()
|
|
*/
|
|
double Fl_Text_Display::col_to_x(double col) const
|
|
{
|
|
if (!mColumnScale) {
|
|
// recalculate column scale value
|
|
x_to_col(0);
|
|
}
|
|
return col*mColumnScale;
|
|
}
|