Fl_Text_Display.cxx

Go to the documentation of this file.

//
// "$Id$"
//
// Copyright 2001-2016 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:
//
//     http://www.fltk.org/COPYING.php
//
// Please report all bugs and problems on the following page:
//
//     http://www.fltk.org/str.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 "flstring.h"
#include <limits.h>
#include <ctype.h>
#include <string.h> // strdup()
#include <FL/Fl.H>
#include <FL/Fl_Text_Buffer.H>
#include <FL/Fl_Text_Display.H>
#include <FL/Fl_Window.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
 
 
 
Fl_Text_Display::Fl_Text_Display(int X, int Y, int W, int H, const char* l)
: Fl_Group(X, Y, W, H, l) {
  int i;
 
  mMaxsize = 0;
  damage_range1_start = damage_range1_end = -1;
  damage_range2_start = damage_range2_end = -1;
  dragPos = dragging = 0;
  dragType = DRAG_CHAR;
  display_insert_position_hint = 0;
  shortcut_ = 0;
 
  color(FL_BACKGROUND2_COLOR, FL_SELECTION_COLOR);
  box(FL_DOWN_FRAME);
  textsize(FL_NORMAL_SIZE);
  textcolor(FL_FOREGROUND_COLOR);
  textfont(FL_HELVETICA);
  set_flag(SHORTCUT_LABEL);
 
  text_area.x = 0;
  text_area.y = 0;
  text_area.w = 0;
  text_area.h = 0;
 
  mVScrollBar = new Fl_Scrollbar(0,0,1,1);
  mVScrollBar->callback((Fl_Callback*)v_scrollbar_cb, this);
  mHScrollBar = new Fl_Scrollbar(0,0,1,1);
  mHScrollBar->callback((Fl_Callback*)h_scrollbar_cb, this);
  mHScrollBar->type(FL_HORIZONTAL);
 
  end();
 
  scrollbar_width(Fl::scrollbar_size());
  scrollbar_align(FL_ALIGN_BOTTOM_RIGHT);
 
  mCursorOn = 0;
  mCursorPos = 0;
  mCursorOldY = -100;
  mCursorToHint = NO_HINT;
  mCursorStyle = NORMAL_CURSOR;
  mCursorPreferredXPos = -1;
  mBuffer = 0;
  mFirstChar = 0;
  mLastChar = 0;
  mNBufferLines = 0;
  mTopLineNum = mTopLineNumHint = 1;
  mAbsTopLineNum = 1;
  mNeedAbsTopLineNum = 0;
  mHorizOffset = mHorizOffsetHint = 0;
 
  mCursor_color = FL_FOREGROUND_COLOR;
 
  mStyleBuffer = 0;
  mStyleTable = 0;
  mNStyles = 0;
  mNVisibleLines = 1;
  mLineStarts = new int[mNVisibleLines];
  mLineStarts[0] = 0;
  for (i=1; i<mNVisibleLines; i++)
    mLineStarts[i] = -1;
  mSuppressResync = 0;
  mNLinesDeleted = 0;
  mModifyingTabDistance = 0;
 
  mUnfinishedStyle = 0;
  mUnfinishedHighlightCB = 0;
  mHighlightCBArg = 0;
 
  mLineNumLeft = mLineNumWidth = 0;
  mContinuousWrap = 0;
  mWrapMarginPix = 0;
  mSuppressResync = mNLinesDeleted = mModifyingTabDistance = 0;
#if FLTK_ABI_VERSION >= 10303
  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_  = strdup("%d");
#endif
}
 
 
 
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 FLTK_ABI_VERSION >= 10303
  if (linenumber_format_) {
    free((void*)linenumber_format_);
    linenumber_format_ = 0;
  }
#endif
}
 
 
void Fl_Text_Display::linenumber_width(int width) {
  if (width < 0) return;
  mLineNumWidth = width;
  resize(x(), y(), w(), h());   // triggers code to recalculate line#s
}
 
int Fl_Text_Display::linenumber_width() const {
  return mLineNumWidth;
}
 
void Fl_Text_Display::linenumber_font(Fl_Font val) {
#if FLTK_ABI_VERSION >= 10303
  linenumber_font_ = val;
#else
  // do nothing
#endif
}
 
Fl_Font Fl_Text_Display::linenumber_font() const {
#if FLTK_ABI_VERSION >= 10303
  return linenumber_font_;
#else
  return FL_HELVETICA;
#endif
}
 
void Fl_Text_Display::linenumber_size(Fl_Fontsize val) {
#if FLTK_ABI_VERSION >= 10303
  linenumber_size_ = val;
#else
  // do nothing
#endif
}
 
Fl_Fontsize Fl_Text_Display::linenumber_size() const {
#if FLTK_ABI_VERSION >= 10303
  return linenumber_size_;
#else
  return FL_NORMAL_SIZE;
#endif
}
 
void Fl_Text_Display::linenumber_fgcolor(Fl_Color val) {
#if FLTK_ABI_VERSION >= 10303
  linenumber_fgcolor_ = val;
#else
  // do nothing
#endif
}
 
Fl_Color Fl_Text_Display::linenumber_fgcolor() const {
#if FLTK_ABI_VERSION >= 10303
  return linenumber_fgcolor_;
#else
  return FL_INACTIVE_COLOR;
#endif
}
 
void Fl_Text_Display::linenumber_bgcolor(Fl_Color val) {
#if FLTK_ABI_VERSION >= 10303
  linenumber_bgcolor_ = val;
#else
  // do nothing
#endif
}
 
Fl_Color Fl_Text_Display::linenumber_bgcolor() const {
#if FLTK_ABI_VERSION >= 10303
  return linenumber_bgcolor_;
#else
  return 53;    // hard coded ~90% gray
#endif
}
 
void Fl_Text_Display::linenumber_align(Fl_Align val) {
#if FLTK_ABI_VERSION >= 10303
  linenumber_align_ = val;
#else
  // do nothing
#endif
}
 
Fl_Align Fl_Text_Display::linenumber_align() const {
#if FLTK_ABI_VERSION >= 10303
  return linenumber_align_;
#else
  return FL_ALIGN_RIGHT;
#endif
}
 
void Fl_Text_Display::linenumber_format(const char* val) {
#if FLTK_ABI_VERSION >= 10303
  if ( linenumber_format_ ) free((void*)linenumber_format_);
  linenumber_format_ = val ? strdup(val) : 0;
#else
  // do nothing
#endif
}
 
const char* Fl_Text_Display::linenumber_format() const {
#if FLTK_ABI_VERSION >= 10303
  return linenumber_format_;
#else
  return "%d";
#endif
}
 
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... */
  resize(x(), y(), w(), h());
}
 
 
 
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);
}
 
 
 
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;
}
 
 
 
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);
  if (!buffer()) return;
 
  // did we have scrollbars initially?
  unsigned int hscrollbarvisible = mHScrollBar->visible();
  unsigned int vscrollbarvisible = mVScrollBar->visible();
 
  int oldTAWidth = text_area.w;
 
  X += Fl::box_dx(box());
  Y += Fl::box_dy(box());
  W -= Fl::box_dw(box());
  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();
 
#if (1) // optimization (experimental - seems to work well)
 
  // 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.
 
  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 -= scrollbar_width();
    }
  }
 
#endif // optimization
 
  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 (scrollbar_width()) {
 
      /* Decide if the vertical scrollbar needs to be visible */
      if (!mVScrollBar->visible() &&
      scrollbar_align() & (FL_ALIGN_LEFT|FL_ALIGN_RIGHT) &&
      mNBufferLines >= mNVisibleLines-1)
      {
    mVScrollBar->set_visible();
    text_area.w -= scrollbar_width();
    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 -= scrollbar_width();
          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 += scrollbar_width();
 
  text_area.y = Y + TOP_MARGIN;
  if (mHScrollBar->visible() &&
      scrollbar_align() & FL_ALIGN_TOP)
    text_area.y += scrollbar_width();
 
  // 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 - scrollbar_width(),
#else
      mVScrollBar->resize(X,
#endif
              text_area.y - TOP_MARGIN,
              scrollbar_width(),
              text_area.h + TOP_MARGIN + BOTTOM_MARGIN);
    } else {
      mVScrollBar->resize(X+W-scrollbar_width(),
              text_area.y - TOP_MARGIN,
              scrollbar_width(),
              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,
              scrollbar_width());
    } else {
      mHScrollBar->resize(text_area.x - LEFT_MARGIN,
              Y + H - scrollbar_width(),
              text_area.w + LEFT_MARGIN + RIGHT_MARGIN,
              scrollbar_width());
    }
  }
 
 
  // 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();
}
 
 
 
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();
}
 
 
 
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);
}
 
 
 
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 );
}
 
 
 
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));
}
 
 
 
void Fl_Text_Display::show_cursor(int b) {
  mCursorOn = b;
  if (!buffer()) return;
  redisplay_range(buffer()->prev_char_clipped(mCursorPos), buffer()->next_char(mCursorPos));
}
 
 
 
void Fl_Text_Display::cursor_style(int style) {
  mCursorStyle = style;
  if (mCursorOn) show_cursor();
}
 
 
 
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
  }
 
  resize(x(), y(), w(), h());
}
 
 
 
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;
}
 
 
 
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;
}
 
 
 
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;
}
 
 
 
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;
}
 
 
 
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);
}
 
 
 
int Fl_Text_Display::wrapped_column(int row, int column) const {
  int lineStart, dispLineStart;
 
  if (!mContinuousWrap || row < 0 || row > mNVisibleLines)
    return column;
  dispLineStart = mLineStarts[row];
  if (dispLineStart == -1)
    return column;
  lineStart = buffer()->line_start(dispLineStart);
  return column + buffer()->count_displayed_characters(lineStart, dispLineStart);
}
 
 
 
int Fl_Text_Display::wrapped_row(int row) const {
  if (!mContinuousWrap || row < 0 || row > mNVisibleLines)
    return row;
  return buffer()->count_lines(mFirstChar, mLineStarts[row]);
}
 
 
 
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);
}
 
 
void Fl_Text_Display::show_insert_position() {
  display_insert_position_hint = 1;
  resize(x(), y(), w(), h());
}
 
 
/*
 Cursor movement functions
 */
 
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;
}
 
 
 
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;
}
 
 
 
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;
}
 
 
 
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;
}
 
 
 
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;
}
 
 
 
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 BufCountForwardNLines */
  if (!mContinuousWrap)
    return buffer()->skip_lines(startPos, nLines);
 
  /* wrappedLineCounter can't handle the 0 lines case */
  if (nLines == 0)
    return startPos;
 
  /* use the common line counting routine to count forward */
  wrapped_line_counter(buffer(), startPos, buffer()->length(),
                       nLines, startPosIsLineStart, 0,
                       &retPos, &retLines, &retLineStart, &retLineEnd);
  IS_UTF8_ALIGNED2(buffer(), retPos)
  return retPos;
}
 
 
 
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 BufEndOfLine */
  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;
}
 
 
 
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 BufStartOfLine */
  if (!mContinuousWrap)
    return buffer()->line_start(pos);
 
  wrapped_line_counter(buffer(), buffer()->line_start(pos), pos, INT_MAX, true, 0,
                       &retPos, &retLines, &retLineStart, &retLineEnd);
 
  IS_UTF8_ALIGNED2(buffer(), retLineStart)
  return retLineStart;
}
 
 
 
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 BufCountBackwardNLines */
  if (!mContinuousWrap)
    return buf->rewind_lines(startPos, nLines);
 
  pos = startPos;
  for (;;) {
    lineStart = buf->line_start(pos);
    wrapped_line_counter(buf, lineStart, pos, INT_MAX, true, 0,
                         &retPos, &retLines, &retLineStart, &retLineEnd, false);
    if (retLines > nLines)
      return skip_lines(lineStart, retLines-nLines, true);
    nLines -= retLines;
    pos = lineStart - 1;
    if (pos < 0)
      return 0;
    nLines -= 1;
  }
}
 
 
 
static inline int fl_isseparator(unsigned int c) {
  // FIXME: this does not take UCS-4 encoding into account
  return c != '$' && c != '_' && (isspace(c) || ispunct(c));
}
 
 
 
void Fl_Text_Display::next_word() {
  int pos = insert_position();
 
  while (pos < buffer()->length() && !fl_isseparator(buffer()->char_at(pos))) {
    pos = buffer()->next_char(pos);
  }
 
  while (pos < buffer()->length() && fl_isseparator(buffer()->char_at(pos))) {
    pos = buffer()->next_char(pos);
  }
 
  insert_position( pos );
}
 
 
 
void Fl_Text_Display::previous_word() {
  int pos = insert_position();
  if (pos==0) return;
  pos = buffer()->prev_char(pos);
 
  while (pos && fl_isseparator(buffer()->char_at(pos))) {
    pos = buffer()->prev_char(pos);
  }
 
  while (pos && !fl_isseparator(buffer()->char_at(pos))) {
    pos = buffer()->prev_char(pos);
  }
 
  if (fl_isseparator(buffer()->char_at(pos))) {
    pos = buffer()->next_char(pos);
  }
 
  insert_position( pos );
}
 
 
 
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 */
  }
}
 
 
 
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 extendRangeForStyleMods */
      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 */
 
void Fl_Text_Display::maintain_absolute_top_line_number(int state) {
  mNeedAbsTopLineNum = state;
  reset_absolute_top_line_number();
}
 
 
 
int Fl_Text_Display::get_absolute_top_line_number() const {
  if (!mContinuousWrap)
    return mTopLineNum;
  if (maintaining_absolute_top_line_number())
    return mAbsTopLineNum;
  return 0;
}
 
 
 
void Fl_Text_Display::absolute_top_line_number(int oldFirstChar) {
  if (maintaining_absolute_top_line_number()) {
    if (mFirstChar < oldFirstChar)
      mAbsTopLineNum -= buffer()->count_lines(mFirstChar, oldFirstChar);
    else
      mAbsTopLineNum += buffer()->count_lines(oldFirstChar, mFirstChar);
  }
}
 
 
 
int Fl_Text_Display::maintaining_absolute_top_line_number() const {
  return mContinuousWrap &&
  (mLineNumWidth != 0 || mNeedAbsTopLineNum);
}
 
 
 
void Fl_Text_Display::reset_absolute_top_line_number() {
  mAbsTopLineNum = 1;
  absolute_top_line_number(0);
}
 
 
 
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 */
}
 
 
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)
 
  // FIXME: we need to allow two modes for FIND_INDEX: one on the edge of the
  // FIXME: character for selection, and one on the character center for cursors.
  int i, X, startX, startIndex, style, charStyle;
  char *lineStr;
 
  if ( lineStartPos == -1 ) {
    lineStr = NULL;
  } else {
    lineStr = mBuffer->text_range( lineStartPos, lineStartPos + lineLen );
  }
 
  if (mode==GET_WIDTH) {
    X = 0;
  } else if (mode==FIND_INDEX_FROM_ZERO) {
    X = 0;
    mode = FIND_INDEX;
  } else {
    X = text_area.x - mHorizOffset;
  }
 
  startX = X;
  startIndex = 0;
  if (!lineStr) {
    // just clear the background
    if (mode==DRAW_LINE) {
      style = position_style(lineStartPos, lineLen, -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;
  // 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
      int w = 0;
      if (prevChar=='\t') {
        // draw a single Tab space
        int tab = (int)col_to_x(mBuffer->tab_distance());
        int xAbs = (mode==GET_WIDTH) ? startX : startX+mHorizOffset-text_area.x;
        w = (((xAbs/tab)+1)*tab) - xAbs;
        if (mode==DRAW_LINE)
          draw_string( style|BG_ONLY_MASK, startX, Y, startX+w, 0, 0 );
        if (mode==FIND_INDEX && startX+w>rightClip) {
          // find x pos inside block
          free(lineStr);
          return lineStartPos + startIndex;
        }
      } else {
        // draw a text segment
        w = int( string_width( lineStr+startIndex, i-startIndex, style ) );
        if (mode==DRAW_LINE)
          draw_string( style, startX, Y, startX+w, lineStr+startIndex, i-startIndex );
        if (mode==FIND_INDEX && startX+w>rightClip) {
          // find x pos inside block
          int di = find_x(lineStr+startIndex, i-startIndex, style, rightClip-startX);
          free(lineStr);
          IS_UTF8_ALIGNED2(buffer(), (lineStartPos+startIndex+di))
          return lineStartPos + startIndex + di;
        }
      }
      style = charStyle;
      startX += w;
      startIndex = i;
    }
    i += len;
    prevChar = currChar;
  }
  int w = 0;
  if (currChar=='\t') {
    // draw a single Tab space
    int tab = (int)col_to_x(mBuffer->tab_distance());
    int xAbs = (mode==GET_WIDTH) ? startX : startX+mHorizOffset-text_area.x;
    w = (((xAbs/tab)+1)*tab) - xAbs;
    if (mode==DRAW_LINE)
      draw_string( style|BG_ONLY_MASK, startX, Y, startX+w, 0, 0 );
    if (mode==FIND_INDEX) {
      // find x pos inside block
      free(lineStr);
      return lineStartPos + startIndex + ( rightClip-startX>w ? 1 : 0 );
    }
  } else {
    w = int( string_width( lineStr+startIndex, i-startIndex, style ) );
    if (mode==DRAW_LINE)
      draw_string( style, startX, Y, startX+w, lineStr+startIndex, i-startIndex );
    if (mode==FIND_INDEX) {
      // find x pos inside block
      int di = find_x(lineStr+startIndex, i-startIndex, style, rightClip-startX);
      free(lineStr);
      IS_UTF8_ALIGNED2(buffer(), (lineStartPos+startIndex+di))
      return lineStartPos + startIndex + di;
    }
  }
  if (mode==GET_WIDTH) {
    free(lineStr);
    return startX+w;
  }
 
  // clear the rest of the line
  startX += w;
  style = position_style(lineStartPos, lineLen, i);
  if (mode==DRAW_LINE)
    draw_string( style|BG_ONLY_MASK, startX, Y, text_area.x+text_area.w, lineStr, lineLen );
 
  free(lineStr);
  IS_UTF8_ALIGNED2(buffer(), (lineStartPos+lineLen))
  return lineStartPos + lineLen;
}
 
 
int Fl_Text_Display::find_x(const char *s, int len, int style, int x) const {
  IS_UTF8_ALIGNED(s)
 
  // TODO: use binary search which may be quicker.
  int i = 0;
  while (i<len) {
    int cl = fl_utf8len1(s[i]);
    int w = int( string_width(s, i+cl, style) );
    if (w>x)
      return i;
    i += cl;
  }
  return len;
}
 
 
 
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;
}
 
 
 
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;
 
  /* 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;
 
  if ( style & STYLE_LOOKUP_MASK ) {
    int si = (style & STYLE_LOOKUP_MASK) - 'A';
    if (si < 0) si = 0;
    else if (si >= mNStyles) si = mNStyles - 1;
 
    styleRec = mStyleTable + si;
    font  = styleRec->font;
    fsize = styleRec->size;
 
    if (style & PRIMARY_MASK) {
      if (Fl::focus() == (Fl_Widget*)this) {
#ifdef __APPLE__
    if (Fl::compose_state) background = color();// Mac OS: underline marked text
    else 
#endif
    background = selection_color();
    }
      else background = fl_color_average(color(), selection_color(), 0.4f);
    } 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);
    } else background = color();
    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 {
    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 );
#if !(defined(__APPLE__) || defined(WIN32)) && USE_XFT
    // makes sure antialiased ÄÖÜ do not leak on line above
    fl_push_clip(X, Y, toX - X, mMaxsize);
#endif
    fl_draw( string, nChars, X, Y + mMaxsize - fl_descent());
#ifdef __APPLE__ // Mac OS: underline marked (= selected + Fl::compose_state != 0) text
    if (Fl::compose_state && (style & PRIMARY_MASK)) {
      fl_color( fl_color_average(foreground, background, 0.6) );
      fl_line(X, Y + mMaxsize - 1, X + fl_width(string, nChars), Y + mMaxsize - 1);
    }
#endif
#if !(defined(__APPLE__) || defined(WIN32)) && USE_XFT
    fl_pop_clip();
#endif
  }
 
  // 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);
   */
}
 
 
 
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 c;
  if (style & PRIMARY_MASK) {
    if (Fl::focus()==(Fl_Widget*)this) {
      c = selection_color();
    } else {
      c = fl_color_average(color(), selection_color(), 0.4f);
    }
  } else if (style & HIGHLIGHT_MASK) {
    if (Fl::focus()==(Fl_Widget*)this) {
      c = fl_color_average(color(), selection_color(), 0.5f);
    } else {
      c = fl_color_average(color(), selection_color(), 0.6f);
    }
  } else {
    c = color();
  }
  fl_color(active_r() ? c : fl_inactive(c));
  fl_rectf( X, Y, width, height );
}
 
 
 
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;
 
#ifdef __APPLE__
  Fl::insertion_point_location(X, bot, fontHeight);
#endif
  /* 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 );
  }
}
 
 
 
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 ( 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;
}
 
 
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 );
}
 
 
 
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 );
 
  return handle_vline(FIND_INDEX,
                      lineStart, lineLen, 0, 0,
                      0, 0,
                      text_area.x, X);
}
 
 
 
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;
}
 
 
 
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);
}
 
 
 
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;
}
 
 
 
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;
}
 
 
 
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);
}
 
 
 
void Fl_Text_Display::scroll(int topLineNum, int horizOffset) {
  mTopLineNumHint = topLineNum;
  mHorizOffsetHint = horizOffset;
  resize(x(), y(), w(), h());
}
 
 
 
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;
}
 
 
 
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+2);
  mVScrollBar->linesize(3);
}
 
 
void Fl_Text_Display::update_h_scrollbar() {
  int sliderMax = max(longest_vline(), text_area.w + mHorizOffset);
  mHScrollBar->value( mHorizOffset, text_area.w, 0, sliderMax );
}
 
 
 
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);
}
 
 
 
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());
}
 
 
 
// 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 = Fl::box_dy(box()) + ((scrollbar_align()&FL_ALIGN_TOP)?hscroll_h:0);
 
#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() + yoff,
               mLineNumWidth,
               h() - Fl::box_dw(box()) - hscroll_h);
  {
    // 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')) {
    sprintf(lineNumString, linenumber_format(), line);
    int xx = x() + xoff + 3,
        yy = Y + 3,
        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;
    }
  } 
  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;
}
 
 
 
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;
}
 
 
 
 
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);
}
 
 
 
int Fl_Text_Display::empty_vlines() const {
  return (mNVisibleLines > 0) && (mLineStarts[ mNVisibleLines - 1 ] == -1);
}
 
 
 
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;
}
 
 
 
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;
}
 
 
 
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;
}
 
 
 
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();
}
 
 
 
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);
}
 
 
 
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 BufEndOfLine */
  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);
}
 
 
 
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());
}
 
 
 
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))
}
 
 
 
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) {
    //    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()
    int W = w(), H = h();
    draw_box(box(), x(), y(), W, H, bgcolor);
 
    if (mHScrollBar->visible())
      W -= scrollbar_width();
    if (mVScrollBar->visible())
      H -= scrollbar_width();
 
    // left margin
    fl_rectf(text_area.x-LEFT_MARGIN, text_area.y-TOP_MARGIN,
             LEFT_MARGIN, text_area.h+TOP_MARGIN+BOTTOM_MARGIN,
             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_GRAY);
    //draw_line_numbers(true);      // commented out STR# 2621 / LZA
  }
  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, Y, W, H;
    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)
      && (
#ifdef __APPLE__
      Fl::compose_state ||
#endif
      !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();
}
 
 
 
// 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);
    }
  }
}
 
 
 
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);
}
 
 
 
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_state()&FL_SHIFT) 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();
#ifdef __APPLE__
          Fl_X::dnd(1);
#else
          Fl::dnd();
#endif
          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.
 */
double Fl_Text_Display::x_to_col(double y) const
{
  if (!mColumnScale) {
    mColumnScale = string_width("Mitg", 4, 'A') / 4.0;
  }
  return (y/mColumnScale)+0.5;
}
 
 
double Fl_Text_Display::col_to_x(double col) const
{
  if (!mColumnScale) {
    // recalculate column scale value
    x_to_col(0);
  }
  return col*mColumnScale;
}
 
 
//
// End of "$Id$".
//