deb-goldedplus/golded3/geedit.cpp

//  ------------------------------------------------------------------
//  GoldED+
//  Copyright (C) 1990-1999 Odinn Sorensen
//  Copyright (C) 1999-2000 Alexander S. Aganichev
//  ------------------------------------------------------------------
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License as
//  published by the Free Software Foundation; either version 2 of the
//  License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
//  MA 02111-1307 USA
//  ------------------------------------------------------------------
//  $Id$
//  ------------------------------------------------------------------
//  The Internal Editor (IE), part 1.
//  ------------------------------------------------------------------

#ifdef __GNUG__
#pragma implementation "geedit.h"
#endif

//  ------------------------------------------------------------------

#include <golded.h>
#include <geedit.h>

gkey kbxget_raw(int mode);


//  ------------------------------------------------------------------
//  Globals

Line* Edit__killbuf  = NULL;
Line* Edit__pastebuf = NULL;

Path Edit__exportfilename = {""};

UndoItem** UndoItem::last_item;


//  ------------------------------------------------------------------

#ifndef NDEBUG

void IEclass::debugtest(char* __test, int __a, int __b, char* __file, int __line, int __values) {

  #if defined(GFTRK_ENABLE)
  int _tmp = __gftrk_on;
  __gftrk_on = false;
  #endif

  savefile(MODE_UPDATE);

  #if defined(GFTRK_ENABLE)
  __gftrk_on = _tmp;
  #endif

  if(__values)
    w_infof(" Range check: (%s) <%i,%i> [%s,%u] ", __test, __a, __b, __file, __line);
  else
    w_infof(" Range check: (%s) [%s,%u] ", __test, __file, __line);
  update_statusline(LNG->EscOrContinue);
  SayBibi();
  while(kbxhit())
    kbxget();
  gkey _key = kbxget();
  w_info(NULL);
  if(_key == Key_Esc) {
    LOG.errtest(__file, __line);
    LOG.printf("! An internal editor range check failed.");
    if(__values)
      LOG.printf(": Details: (%s) <%i,%i>.", __test, __a, __b);
    else {
      LOG.printf(": Details: (%s).", __test);
      LOG.printf(": Details: r%u,c%u,mr%u,mc%u,i%u,dm%u,qm%u,eqm%u.",
                 row, col, maxrow, maxcol, insert,
                 CFG->dispmargin, CFG->quotemargin, EDIT->QuoteMargin());
    }
    LOG.printf("+ Advice: Report to the Author.");
    TestErrorExit();
  }
}

#endif


//  ------------------------------------------------------------------

#if !defined(GCFG_NOSPELLDLL)
inline bool isscchar(int c)
{
  return isxalnum(c) || (c == '-') || (c == '\'') || (c == '.') ;
}
#endif


//  ------------------------------------------------------------------
//  Make sure line type is correct

void IEclass::setlinetype(Line* __line) {

  _test_halt(__line == NULL);

  __line->type &= ~(GLINE_ALL|GLINE_TEAR|GLINE_ORIG|GLINE_TAGL);

  if (is_quote(__line->txt.c_str()) &&
      is_quote2(__line, __line->txt.c_str()))
  {
    __line->type |= GLINE_QUOT;
  }
  else if (__line->txt[0] == CTRL_A)
  {
    __line->type |= GLINE_HIDD;
  }
}


//  ------------------------------------------------------------------
//  Insert character in string at position

//  ------------------------------------------------------------------
//  Zero-based

vattr IEclass::dispchar(vchar __ch, vattr attr) {

  if(__ch == NUL) // possible if line empty
    __ch = ' ';
  if(__ch == '\n') {
    __ch = EDIT->CharPara();
  }
  else if(__ch == ' ') {
    __ch = EDIT->CharSpace();
  }

  vattr atr;
  vchar chr;
  editwin.getc(crow, ccol, &atr, &chr);
  editwin.printc(crow, ccol, attr == DEFATTR ? atr : attr, __ch);
  return atr;
}


//  ------------------------------------------------------------------

void IEclass::cursoroff() {

  vcurhide();
}


//  ------------------------------------------------------------------

void IEclass::cursoron() {

  vcurshow();
}


//  ------------------------------------------------------------------
//  Zero-based

void IEclass::scrollup(int __scol, int __srow, int __ecol, int __erow, int __lines) {

  editwin.scroll_box_up(__srow, __scol, __erow, __ecol, __lines);
}


//  ------------------------------------------------------------------
//  Zero-based

void IEclass::scrolldown(int __scol, int __srow, int __ecol, int __erow, int __lines) {

  editwin.scroll_box_down(__srow, __scol, __erow, __ecol, __lines);
}


//  ------------------------------------------------------------------
//  Zero-based

void IEclass::prints(int wrow, int wcol, vattr atr, const char* str) {

  editwin.prints(wrow, wcol, atr, str);
}


//  ------------------------------------------------------------------

Line* IEclass::findfirstline() {

  GFTRK("Editfindfirstline");

  if(not currline)
    return NULL;

  // Rewind to the first line
  Line* _firstline = currline;
  while(_firstline->prev)
    _firstline = _firstline->prev;

  GFTRK(NULL);

  return _firstline;
}


//  ------------------------------------------------------------------
//  Find out what number the current line is and put it in "thisrow"

void IEclass::getthisrow(Line* __currline) {

  GFTRK("Editgetthisrow");

  Line* _templine = findfirstline();

  thisrow = 0;
  while((_templine != __currline) and _templine->next) {
    _templine = _templine->next;
    thisrow++;
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------
//  Zero-based

void IEclass::gotorowcol(uint __col, uint __row) {

  GFTRK("Editgotorowcol");

  _test_haltab(__col > maxcol, __col, maxcol);
  _test_haltab(__row > maxrow, __row, maxrow);

  editwin.move_cursor(__row, __col);

  ccol = __col;
  crow = __row;

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

#if !defined(GCFG_NOSPELLDLL)
void IEclass::dispstringsc(char *__buf, uint __beg, uint __end, uint __row, uint __col, char endchar)
{
  char scbuf[EDIT_BUFLEN];

  uint bbeg = __beg;
  uint bend = __beg;
  uint bpos = __beg;

  if ((bbeg > 0) && isscchar(__buf[bbeg]) && isscchar(__buf[bbeg-1]))
  {
    for (; (bpos < __end) && isscchar(__buf[bpos]); bpos++);
    bend = bpos;
  }

  while (bpos < __end)
  {
    for (; (bpos < __end) && !isscchar(__buf[bpos]); bpos++);
    bend = bpos;

    uint scpos = 0;
    for (; (bpos < __end) && isscchar(__buf[bpos]); bpos++, scpos++)
      scbuf[scpos] = __buf[bpos];

    if ((scpos == 0) || ((bpos == __end) && isscchar(endchar)))
    {
      bend = bpos;
      break;
    }

    scbuf[scpos] = NUL;

    if (schecker.Check(scbuf))
      bend = bpos;
    else
    {
      char savechar = __buf[bend];
      __buf[bend] = NUL;
      StyleCodeHighlight(__buf+bbeg, __row, __col+bbeg-__beg, false, DEFATTR);
      __buf[bend] = savechar;

      bbeg = bend; bend += scpos;

      bool oldusestylies = AA->adat->usestylies;
      bool oldhighlighturls = CFG->highlighturls;
      AA->adat->usestylies = false;
      CFG->highlighturls = false;

      savechar = __buf[bend];
      __buf[bend] = NUL;
      StyleCodeHighlight(__buf+bbeg, __row, __col+bbeg-__beg, false, C_SCERROR);
      __buf[bend] = savechar;

      AA->adat->usestylies = oldusestylies;
      CFG->highlighturls = oldhighlighturls;

      bbeg = bend;
    }
  }

  if (bbeg < bend)
    StyleCodeHighlight(__buf+bbeg, __row, __col+bbeg-__beg, false, DEFATTR);
}


//  ------------------------------------------------------------------

void IEclass::dispstring(Line* line, uint __row)
{
  GFTRK("Editdispstring");

  // Get string length
  uint _length = strlen(line->txt.c_str());

  // String longer than window width?
  _test_haltab(_length > (maxcol+1), _length, (maxcol+1));
  _length = MinV(_length, (maxcol+1));

  // Buffer for translation to visual representation
  char _buf[EDIT_BUFLEN];

  // Space-pad and nul-terminate the buffer
  memset(_buf, ' ', maxcol+1);
  _buf[maxcol+1] = NUL;

  // Copy/translate string into buffer
  for (uint _pos = 0; _pos < _length; _pos++)
  {
    char chr = line->txt[_pos];
    switch (chr)
    {
      case ' ':   _buf[_pos] = EDIT->CharSpace();  break;
      case '\n':  _buf[_pos] = EDIT->CharPara();   break;
      default:    _buf[_pos] = chr;
    }
  }

  int  selected = 0;
  uint begblock = 0;
  uint endblock = 0;
  Line *fbline = NULL;
  Line *lbline = NULL;

  if (blockcol != -1)
  {
    for (Line *ln = findfirstline(); ln; ln = ln->next)
    {
      if (ln == currline)
      {
        if (selected) { lbline = ln; selected ^= 1; endblock = col; }
        else          { fbline = ln; selected ^= 1; begblock = col; }
      }

      if (ln->type & GLINE_BLOK)
      {
        if (selected) { lbline = ln; selected ^= 1; endblock = blockcol; }
        else          { fbline = ln; selected ^= 1; begblock = blockcol; }
      }

      if (ln == line) { if (ln == lbline) selected = 1; break; }
      if (lbline) break;
    }

    if (selected)
    {
      if (fbline == lbline)
      {
        if (begblock > endblock)
        {
          int temp = begblock;
          begblock = endblock;
          endblock = temp;
        }
        else if (begblock == endblock)
          begblock = endblock = 0;
      }
      else if (line == fbline)
        endblock = maxcol+1;
      else if (line == lbline)
        begblock = 0;
      else
      {
        begblock = 0;
        endblock = maxcol+1;
      }
    }
    else
      begblock = endblock = 0;
  }


  if (0 < begblock)
  {
      char savechar = _buf[begblock];
      _buf[begblock] = NUL;

    if ((CFG->scheckerenabled == GAUTO) && schecker.IsLoaded() &&
        !(line->type & (GLINE_TAGL|GLINE_QUOT|GLINE_KLUD|GLINE_TEAR|GLINE_ORIG|GLINE_HIDD)))
    {
      dispstringsc(_buf, 0, begblock, __row, mincol, savechar);
    }
    else
      StyleCodeHighlight(_buf, __row, mincol, false, DEFATTR);

    _buf[begblock] = savechar;
  }

  if (begblock < endblock)
  {
    bool oldusestylies = AA->adat->usestylies;
    bool oldhighlighturls = CFG->highlighturls;
    AA->adat->usestylies = false;
    CFG->highlighturls = false;

    char savechar = _buf[endblock];
    _buf[endblock] = NUL;
    StyleCodeHighlight(_buf+begblock, __row, mincol+begblock, false, C_READA);
    _buf[endblock] = savechar;

    AA->adat->usestylies = oldusestylies;
    CFG->highlighturls = oldhighlighturls;
  }

  if (endblock < (maxcol+1))
  {
    if ((CFG->scheckerenabled == GAUTO) && schecker.IsLoaded() &&
        !(line->type & (GLINE_TAGL|GLINE_QUOT|GLINE_KLUD|GLINE_TEAR|GLINE_ORIG|GLINE_HIDD)))
    {
      dispstringsc(_buf, endblock, maxcol+1, __row, mincol+endblock, 0);
    }
    else
      StyleCodeHighlight(_buf+endblock, __row, mincol+endblock, false, DEFATTR);
  }

  GFTRK(NULL);
}
#else // #if !defined(GCFG_NOSPELLDLL)


//  ------------------------------------------------------------------

void IEclass::dispstring(const char* __string, uint __row, int attr, Line* line) {

  GFTRK("Editdispstring");

  _test_halt(__string == NULL);
  _test_haltab(__row > maxrow, __row, maxrow);

  // Get string length
  uint _length = strlen(__string);

  // String longer than window width?
  _test_haltab(_length > (maxcol+1), _length, (maxcol+1));
  _length = MinV(_length, (maxcol+1));

  // Buffer for translation to visual representation
  char _buf[EDIT_BUFLEN];

  // Space-pad and nul-terminate the buffer
  memset(_buf, ' ', maxcol+1);
  _buf[maxcol+1] = NUL;

  // Copy/translate string into buffer
  if(attr == -1) {
    char* _bufptr = _buf;
    uint _position = 0;
    const char* __str = __string;
    while(_position < _length) {
      switch(*__str) {
        case ' ':   *_bufptr = EDIT->CharSpace();  break;
        case '\n':  *_bufptr = EDIT->CharPara();   break;
        default:    *_bufptr = *__str;
      }
      _position++;
      _bufptr++;
      __str++;
    }
  }
  else {
    if(_length)
      memcpy(_buf, __string, _length);
  }

  // mark selected block
  if(line and (blockcol != -1)) {
    int selected = 0;
    for(Line *ln = findfirstline(); ln and ln != line; ln = ln->next) {
      if(ln == currline)
        selected ^= 1;
      if(ln->type & GLINE_BLOK)
        selected ^= 1;
    }
    if((line->type & GLINE_BLOK) and (line == currline)) {
      int begblock = ((col < blockcol) ? col : blockcol) - mincol;
      int endblock = ((col > blockcol) ? col : blockcol) - mincol;

      char savechar = _buf[begblock];
      _buf[begblock] = NUL;
      StyleCodeHighlight(_buf, __row, mincol, false, attr);
      _buf[begblock] = savechar;

      savechar = _buf[endblock];
      _buf[endblock] = NUL;
      bool oldusestylies = AA->adat->usestylies;
      bool oldhighlighturls = CFG->highlighturls;
      AA->adat->usestylies = false;
      CFG->highlighturls = false;
      StyleCodeHighlight(_buf+begblock, __row, mincol+begblock, false, C_READA);
      AA->adat->usestylies = oldusestylies;
      CFG->highlighturls = oldhighlighturls;
      _buf[endblock] = savechar;
      StyleCodeHighlight(_buf+endblock, __row, mincol+endblock, false, attr);
    }
    else if((line->type & GLINE_BLOK) or (line == currline)) {
      int blockmark = ((line->type & GLINE_BLOK) ? blockcol : col) - mincol;

      char savechar = _buf[blockmark];
      _buf[blockmark] = NUL;
      bool oldusestylies = AA->adat->usestylies;
      bool oldhighlighturls = CFG->highlighturls;
      if(selected) {
        AA->adat->usestylies = false;
        CFG->highlighturls = false;
      }
      StyleCodeHighlight(_buf, __row, mincol, false, selected ? C_READA : attr);
      AA->adat->usestylies = oldusestylies;
      _buf[blockmark] = savechar;
      if(not selected) {
        AA->adat->usestylies = false;
        CFG->highlighturls = false;
      }
      StyleCodeHighlight(_buf+blockmark, __row, mincol+blockmark, false, selected ? attr : C_READA);
      AA->adat->usestylies = oldusestylies;
      CFG->highlighturls = oldhighlighturls;
    }
    else {
      bool oldusestylies = AA->adat->usestylies;
      bool oldhighlighturls = CFG->highlighturls;
      if(selected) {
        AA->adat->usestylies = false;
        CFG->highlighturls = false;
      }
      StyleCodeHighlight(_buf, __row, mincol, false, selected ? C_READA : attr);
      AA->adat->usestylies = oldusestylies;
      CFG->highlighturls = oldhighlighturls;
    }
  }
  else
    StyleCodeHighlight(_buf, __row, mincol, false, attr);

  GFTRK(NULL);
}
#endif  // #if !defined(GCFG_NOSPELLDLL)


//  ------------------------------------------------------------------

void IEclass::setcolor(Line* __line) {

  // Set window attribute
  if(__line->type & GLINE_HIDD)
    editwin.text_color(C_READKH);
  else if(__line->type & GLINE_KLUD)
    editwin.text_color(C_READK);
  else if(__line->type & GLINE_TAGL)
    editwin.text_color(C_READG);
  else if(__line->type & GLINE_TEAR)
    editwin.text_color(C_READT);
  else if(__line->type & GLINE_ORIG)
    editwin.text_color(C_READO);
  else if(__line->type & GLINE_QUOT)
    editwin.text_color(quotecolor(__line->txt.c_str()));
  else if(__line->type & GLINE_SIGN)
    editwin.text_color(C_READS);
  else
    editwin.text_color(C_READW);

}


//  ------------------------------------------------------------------
//  Zero-based

void IEclass::displine(Line* __line, uint __row) {

  GFTRK("Editdispline");

  _test_halt(__line == NULL);
  _test_haltab(__row > maxrow, __row, maxrow);

  // Display line
  setcolor(__line);
#if !defined(GCFG_NOSPELLDLL)
  dispstring(__line, __row);
#else
  dispstring(__line->txt.c_str(), __row, -1, __line);
#endif

  GFTRK(NULL);
}


//  ------------------------------------------------------------------
//  Zero-based

void IEclass::clreol(int __col, int __row) {

  GFTRK("Editclreol");

  if(__col == -1)
    __col = ccol;

  if(__row == -1)
    __row = crow;

  if((uint)__col <= maxcol)
    editwin.fill(__row, __col, __row, maxcol, ' ', C_READW);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------
//  Zero-based

void IEclass::refresh(Line* __currline, uint __row) {

  GFTRK("Editrefresh");

  _test_halt(__currline == NULL);

  cursoroff();

  // Display as many lines as we can
  while(__currline and (__row <= maxrow)) {
    displine(__currline, __row++);
    __currline = __currline->next;
  }

  // If we ran out of lines, blank the rest
#if !defined(GCFG_NOSPELLDLL)
  if (__row <= maxrow)
    editwin.fill(__row, mincol, __row, maxcol, _box_table(W_BREAD, 1), C_READB|ACSET);
  if (++__row <= maxrow)
    editwin.fill(__row, mincol, maxrow, maxcol, ' ', C_READW);
#else
  if(__row <= maxrow) {
    vchar vbuf[256];
    for(int c = 0; c < maxcol+1; c++)
      vbuf[c] = _box_table(W_BREAD, 1);
    vbuf[maxcol+1] = NUL;
    wprintvs(__row++, mincol, C_READB|ACSET, vbuf);
    while(__row <= maxrow)
      dispstring("", __row++);
  }
#endif

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

Line* IEclass::insertlinebelow(Line* __currline, const char* __text, long __batch_mode) {

  GFTRK("Editinsertlinebelow");

  Line* _nextline = new Line(__text ? __text : "");
  throw_xnew(_nextline);

  if(__currline) {

    _nextline->prev = __currline;
    _nextline->next = __currline->next;
    if(_nextline->next)
      _nextline->next->prev = _nextline;
    __currline->next = _nextline;
  }

  Undo->PushItem(EDIT_UNDO_NEW_LINE|batch_mode|__batch_mode, _nextline);

  GFTRK(NULL);

  return _nextline;
}


//  ------------------------------------------------------------------
//  Zero-based

int IEclass::downoneline(uint __row) {

  GFTRK("Editdownoneline");

  _test_haltab(__row > maxrow, __row, maxrow);

  thisrow++;

  if(__row == maxrow)
    scrollup(mincol, minrow, maxcol, maxrow);
  else
    __row++;

  gotorowcol(mincol, __row);

  GFTRK(NULL);

  return __row;
}


//  ------------------------------------------------------------------

void IEclass::GoEOL() {

  GFTRK("EditGoEOL");

  // Move cursor to the last char on the line
  col = currline->txt.length();
  if((currline->txt[col-1] == '\n') or ((col != mincol) and (currline->txt[col-1] == ' ')))
    --col;

  // String must not be longer than the window width
  _test_haltab(col > maxcol, col, maxcol);

  if(blockcol != -1)
    displine(currline, row);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::GoUp() {

  GFTRK("EditGoUp");

  _test_haltab(row < minrow, row, minrow);

  if(currline->prev) {

    currline = currline->prev;
    thisrow--;

    if(row == minrow) {
      scrolldown(mincol, row, maxcol, maxrow);
      if(blockcol != -1)
        displine(currline->next, row+1);
      displine(currline, row);
    }
    else {
      row--;
      if(blockcol != -1) {
        displine(currline->next, row+1);
        displine(currline, row);
      }
    }

    if((col+1) > currline->txt.length())
      GoEOL();
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::GoDown() {

  GFTRK("EditGoDown");

  _test_haltab(row > maxrow, row, maxrow);

  if(currline->next) {

    currline = currline->next;
    thisrow++;

    if(row == maxrow) {
      scrollup(mincol, minrow, maxcol, maxrow);
      if(blockcol != -1)
        displine(currline->prev, row-1);
      displine(currline,row);
    }
    else {
      row++;
      if(blockcol != -1) {
        displine(currline->prev, row-1);
        displine(currline, row);
      }
    }

    if((col+1) > currline->txt.length())
      GoEOL();
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::GoLeft() {

  GFTRK("EditGoLeft");

  _test_haltab(col < mincol, col, mincol);

  if(col == mincol) {
    if(currline->prev) {
      GoUp();
      GoEOL();
      if((col != mincol) and (currline->txt.c_str()[col] == NUL))
        col--;
    }
  }
  else
    col--;

  if(blockcol != -1)
    displine(currline, row);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::GoRight() {

  GFTRK("EditGoRight");

  _test_haltab(col > maxcol, col, maxcol);

  if((col == maxcol) or ((col+1) >= currline->txt.length())) {
    if(currline->next != NULL) {
      GoDown();
      col = mincol;
    }
  }
  else
    col++;

  if(blockcol != -1)
    displine(currline, row);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

Line* IEclass::wrapit(Line** __currline, uint* __curr_col, uint* __curr_row, bool __display) {

  _test_halt(__currline == NULL);
  _test_halt(*__currline == NULL);

  int scroll = 0;

  uint  _quotelen;
  char  _quotebuf[MAXQUOTELEN];
  *_quotebuf = NUL;

  uint  _curscol = *__curr_col;
  uint  _cursrow = *__curr_row;

  uint  _thisrow = *__curr_row;
  Line* _thisline = *__currline;
  Line* _lastadded = _thisline;

  bool _wrapped_above = false;

  // Start wrapping from the current line onwards
  while(_thisline) {

    // Length of this line
    uint _thislen = _thisline->txt.length();

    setlinetype(_thisline);
    uint _wrapmargin = (_thisline->type & GLINE_QUOT) ? marginquotes : margintext;

    // Does this line need wrapping?
    if((_thislen > _wrapmargin) or ((_thislen == _wrapmargin) and not ((_thisline->txt[_thislen-1] == ' ') or (_thisline->txt[_thislen-1] == '\n')))) {

      // Reset quote string length
      _quotelen = 0;

      // Is this line quoted?
      if(_thisline->type & GLINE_QUOT) {

        // Get quote string and length
        GetQuotestr(_thisline->txt.c_str(), _quotebuf, &_quotelen);
      }

      // wrapmargin = 40
      //                   1111111111222222222233333333334444444444
      //         01234567890123456789012345678901234567890123456789
      //         --------------------------------------------------
      //                                                v- wrapptr
      // Case 1: this is another test with a bit of text to wrap.
      // Case 2: this is a test with a line that need wrapping.
      // Case 3: thisxisxaxtestxwithxaxlinexthatxneedxwrapping.
      // Case 4: >thisxisxaxtestxwithxaxlinexthatxneedxwrapping.

      // Point to the last char inside the margin
      int _wrappos = _wrapmargin - 1;

      // Locate the word to be wrapped

      // Did we find a space?
      if(_thisline->txt[_wrappos] == ' ') {

        // Case 1: A space was found as the last char inside the margin
        //
        // Now we must locate the first word outside the margin.
        // NOTE: Leading spaces to this word will be nulled out!

        // Begin at the first char outside the margin
        if(_wrappos <= maxcol)
          _wrappos++;
      }
      else {

        // Case 2: A non-space was found as the last char inside the margin
        //
        // Now we must locate the beginning of the word we found.

        // Keep copy of original pointer
        int _atmargin = _wrappos;

        // Search backwards until a space or the beginning of the line is found
        while((_wrappos > _quotelen) and (_thisline->txt[_wrappos-1] != ' '))
          _wrappos--;

        // Check if we hit leading spaces
        int _spacepos = _wrappos;
        while(_spacepos > 0) {
          _spacepos--;
          if(_thisline->txt[_spacepos] != ' ')
            break;
        }

        // Did we search all the way back to the beginning of the line?
        if((_wrappos == _quotelen) or (_thisline->txt[_spacepos] == ' ')) {

          // Case 3: There are no spaces within the margin or we hit leading spaces

          // We have to break it up at the margin
          _wrappos = _atmargin;
        }
      }

      // The wrappos now points to the location to be wrapped or NUL

      // Is the line hard-terminated?
      if(_thisline->txt.find('\n', _wrappos) != _thisline->txt.npos) {

        // The line is hard-terminated.

        // Copy the quote string, if any, to the new line first
        std::string _wrapbuf = _quotebuf;

        // Copy/append the wrapped part to the new line
        _wrapbuf += _thisline->txt.substr(_wrappos);

        // The wrapped part must be placed on a new line below.
        Line* _wrapline = _lastadded = insertlinebelow(_thisline, _wrapbuf.c_str(), BATCH_MODE);

        // Saves pointer to a line where from the wrapped part was copied, its begining
        // and length. While in Undo, appends the copied part to previous line and deletes
        // it on current, moving the rest over deleted.
        Undo->PushItem(EDIT_UNDO_WRAP_TEXT|BATCH_MODE, _thisline, _quotelen, _wrapbuf.length() - _quotelen);

        _wrapline->type = _thisline->type;
        // Make sure the type of the line is correct
        setlinetype(_wrapline);

        if(__display) {

          // Is there at least one line below this one?
          if(_thisrow < maxrow) {

            // Scroll the lines below to make room for the new line
            --scroll;

            // Display the new line
            if(_wrapline->txt.length() <= (maxcol+1))
              displine(_wrapline, _thisrow+1);
          }
        }
      }
      else {

        // The line is not hard-terminated
        //
        // The wrapped part must be inserted into the next line

        // Indicate that one or more lines were wrapped in this way
        _wrapped_above = true;

        // Pointer to the next line
        Line* _nextline = _thisline->next;

        // Copy the quote string, if any, to the new line first
        std::string _wrapbuf = _quotebuf;

        // Copy/append the wrapped part to the new line
        _wrapbuf += _thisline->txt.substr(_wrappos);

        // Flag to indicate if a new line was added below
        bool _line_added_below = false;

        // Is there no next line or is the next line quoted?
        if((_nextline == NULL) or (_nextline->type & GLINE_QUOT)) {

          // The wrapped part must be placed on a new line below
          _lastadded = _nextline = insertlinebelow(_thisline, _wrapbuf.c_str(), BATCH_MODE);
          _line_added_below = true;

          Undo->PushItem(EDIT_UNDO_WRAP_TEXT|BATCH_MODE, _thisline, _quotelen, _wrapbuf.length() - _quotelen);
        }
        else {

          _nextline->txt.insert(0, _wrapbuf);
          if(_quotelen)
            Undo->PushItem(EDIT_UNDO_INS_TEXT|BATCH_MODE, _nextline, 0, _quotelen);
          Undo->PushItem(EDIT_UNDO_WRAP_TEXT|BATCH_MODE, _thisline, _quotelen, _wrapbuf.length() - _quotelen);
        }

        // Make sure the type of the line is correct
        setlinetype(_nextline);

        if(__display) {

          // Is there at least one line below this one?
          if(_line_added_below and (_thisrow < maxrow)) {

            // Scroll the lines below to make room for the new line
            --scroll;
          }

          // Display the new/wrapped line
          if((_thisrow+1) <= maxrow and _nextline->txt.length() <= (maxcol+1))
            displine(_nextline, _thisrow+1);
        }
      }

      // Was this line truncated at space?
      bool truncated_at_space = make_bool(isspace(_thisline->txt[_wrappos]));

      // Truncate at the wrapping location
      _thisline->txt.erase(_wrappos);

      // Was this line quoted?
      if(_quotelen) {

        // Trim spaces off the end of the line
        int _trimpos = _wrappos - 1;
        if(isspace(_thisline->txt[_trimpos])) {
          while(_trimpos > 0 and isspace(_thisline->txt[_trimpos-1]))
            _trimpos--;
          if(_quotelen and (_trimpos < _quotelen))
            _trimpos++;
          Undo->PushItem(EDIT_UNDO_OVR_CHAR|BATCH_MODE, _thisline, _trimpos);
          _thisline->txt.erase(_trimpos);
        }
        Undo->PushItem((truncated_at_space?EDIT_UNDO_OVR_CHAR:EDIT_UNDO_INS_CHAR)|BATCH_MODE, _thisline, _trimpos+1);

        // Append a new linefeed
        _thisline->txt += "\n";
      }

      // Make sure the line type still is correct
      setlinetype(_thisline);

      if(__display) {

        // Display this line after wrapping
        if(_thisrow <= maxrow)
          displine(_thisline, _thisrow);
      }

      _thislen = _thisline->txt.length();

      // If we are on the cursor line, check if the cursor char was wrapped
      if((_thisrow == _cursrow) and (_thislen <= _curscol)) {
        _curscol = _quotelen + ((_curscol > _wrappos) ? _curscol-_wrappos : 0);
        _cursrow++;
        UndoItem* i = Undo->last_item;
        do { i = i->prev; } while(i->action & BATCH_MODE);
        if(i->col.num >= i->line->txt.length()) {
          i->action |= PREV_LINE;
          i->col.sav = i->col.num;
          i->col.num = _curscol;
        }
      }
    }

    // If this line is hard-terminated, we have finished wrapping
    // Unless the next line has grown too large
    if(_thisline->txt.find('\n') != _thisline->txt.npos) {
      if(_thisline->next == NULL)
        break;
      _wrapmargin = (_thisline->next->type & GLINE_QUOT) ? marginquotes : margintext;
      if(_thisline->next->txt.length() <= _wrapmargin)
        break;
    }
    else if(_thisline->type & GLINE_QUOT) {
      Undo->PushItem(EDIT_UNDO_INS_TEXT|BATCH_MODE, _thisline, _thisline->txt.length(), 1);
      _thisline->txt += '\n';
    }

    // Go to the next line
    _thisline = _thisline->next;
    _thisrow++;
  }

  if(__display) {

    // Display the current line after wrapping
    if(*__curr_row <= maxrow)
      displine(*__currline, *__curr_row);

    // Was the line or lines above wrapped?
    if(_wrapped_above) {

      // Display the last line in the paragraph
      if((_thisrow <= maxrow) and _thisline)
        displine(_thisline, _thisrow);
    }
  }

  // Move to the next line if the cursor was wrapped
  if(_cursrow != *__curr_row) {
    int i = *__curr_row;
    while ((i++ != _cursrow) and (__currline != NULL))
      *__currline = (*__currline)->next;
    if(_cursrow > maxrow) {
      _cursrow = maxrow;
      if(__display) {
        ++scroll;
        if(scroll > 0) {
          scrollup(mincol, minrow, maxcol, maxrow);
          scroll = 0;
        }
        displine(*__currline, *__curr_row);
      }
    }
  }

  if(__display and (scroll != 0)) {
    if((*__currline)->next != NULL)
      refresh((*__currline)->next, _cursrow+1);
    else
      refresh(*__currline, _cursrow);
  }

  // Update cursor position
  *__curr_row = _cursrow;
  *__curr_col = _curscol;

  GFTRK(NULL);

  return _lastadded;
}


//  ------------------------------------------------------------------

Line* IEclass::wrapdel(Line** __currline, uint* __curr_col, uint* __curr_row, bool __display) {

  GFTRK("Editwrapdel");

  Line *tmp = wrapit(__currline, __curr_col, __curr_row, __display);

  GFTRK(NULL);

  return tmp;
}


//  ------------------------------------------------------------------

Line* IEclass::wrapins(Line** __currline, uint* __curr_col, uint* __curr_row, bool __display) {

  GFTRK("Editwrapins");

  Line *tmp = wrapit(__currline, __curr_col, __curr_row, __display);

  GFTRK(NULL);

  return tmp;
}


//  ------------------------------------------------------------------

void IEclass::insertchar(char __ch) {

  GFTRK("Editinsertchar");

  uint _currline_len = currline->txt.length();
#ifndef NDEBUG
  _test_haltab(col > _currline_len, col, _currline_len);
#endif
  // Insert or overwrite the char, replacing the block if any
  if((selecting ? (BlockCut(true), batch_mode = BATCH_MODE) : false) or
     (col >= _currline_len) or (currline->txt[col] == '\n') or insert) {
    if(not isspace(__ch) and (col == mincol)) {
      // if previous line was wrapped on non-space character
      if(currline->prev and not currline->prev->txt.empty() and
         (currline->prev->txt.find('\n') == currline->prev->txt.npos) and
         not isspace(currline->prev->txt[currline->prev->txt.length()-1])) {
        if(not batch_mode) {
          Undo->PushItem(EDIT_UNDO_VOID);
          batch_mode = BATCH_MODE;
        }
        GoUp();
        GoEOL();
      }
    }
    Undo->PushItem(EDIT_UNDO_INS_CHAR|batch_mode);
    currline->txt.insert(col, 1, __ch);
  } else {
    Undo->PushItem(EDIT_UNDO_OVR_CHAR|batch_mode);
    currline->txt[col] = __ch;
  }
  batch_mode = BATCH_MODE;

  // Make sure the line type still is correct
  setlinetype(currline);

  // Move cursor
  col++;

  wrapins(&currline, &col, &row);

  // Adjust cursor position and display if necessary
  if(col > maxcol) {
    if(currline->next) {
      currline = currline->next;
      col = mincol;
      row++;
      if(row > maxrow) {
        row = maxrow;
        scrollup(mincol, minrow, maxcol, maxrow);
        displine(currline, row);
      }
    }
    else {
      col = maxcol;
    }
  }

  gotorowcol(col, row);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::DelChar() {

  GFTRK("EditDelChar");

  Line* _thisline = currline;
  Line* _nextline = currline->next;
  uint  _thislen = _thisline->txt.length();

  // Cannot delete at or beyond the nul-terminator
  if(col < _thislen) {
    Undo->PushItem(EDIT_UNDO_DEL_CHAR|batch_mode);
    _thisline->txt.erase(col, 1);
    batch_mode = BATCH_MODE;
  }
  else if(col and (col == _thislen) and _nextline) {
    GFTRK(NULL);
    if(not batch_mode) {
      Undo->PushItem(EDIT_UNDO_VOID);
      batch_mode = BATCH_MODE;
    }
    GoRight();
    DelChar();
    return;
  }

  // Did we delete the last char on the line or
  // was the cursor at or beyond the nul-terminator?
  // And is there a next line at all?
  if(((col+1) >= _thislen) and _nextline) {

    // Join the next line to this line

    // Is the next line quoted?
    // And is the cursor column non-zero?
    uint _quotelen = 0;
    if((_nextline->type & GLINE_QUOT) and col) {

      // Get quote string length
      char _quotebuf[MAXQUOTELEN];
      GetQuotestr(_nextline->txt.c_str(), _quotebuf, &_quotelen);
    }

    // Copy the next line's text to this line without quote string
    const char *_nexttext = _nextline->txt.c_str()+_quotelen;
    _thisline->txt += _nexttext + (col ? strspn(_nexttext, " ") : 0);

    Undo->PushItem(EDIT_UNDO_CUT_TEXT|batch_mode, _thisline, col);

    // Relink this line
    _thisline->next = _nextline->next;
    if(_thisline->next)
      _thisline->next->prev = _thisline;

    Undo->PushItem(EDIT_UNDO_DEL_LINE|BATCH_MODE, _nextline);
  }
  else if((_thislen > 1) and (_thisline->txt.c_str()[_thislen-2] != '\n') and _nextline and not (_nextline->type & GLINE_QUOT)) {

    _thisline->txt += _nextline->txt.c_str();

    Undo->PushItem(EDIT_UNDO_CUT_TEXT|batch_mode, _thisline, _thislen-1);

    // Relink this line
    _thisline->next = _nextline->next;
    if(_thisline->next)
      _thisline->next->prev = _thisline;

    Undo->PushItem(EDIT_UNDO_DEL_LINE|BATCH_MODE, _nextline);
  }
  batch_mode = BATCH_MODE;

  // Make sure the line type still is correct
  setlinetype(_thisline);

  // Rewrap this line
  bool display = make_bool_not(row > maxrow / 2);
  wrapdel(&currline, &col, &row, display);
  if(display) {
    refresh(currline, row);
  }
  else {
    // Refresh the display
    Line* _topline = findtopline();
    refresh(_topline, minrow);
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::DelLeft() {

  GFTRK("EditDelLeft");

  // Cannot backspace from the first column on the first line in the msg
  if(currline->prev == NULL)
    if(col == mincol) {
      GFTRK(NULL);
      return;
    }

  // Go left(/up) and delete the character there
  if(not batch_mode) {
    if(col == mincol)
      Undo->PushItem(EDIT_UNDO_VOID|PREV_LINE, currline->prev);
    else
      Undo->PushItem(EDIT_UNDO_VOID);
    batch_mode = BATCH_MODE;
  }
  GoLeft();
  DelChar();

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::GoWordLeft() {

  GFTRK("EditGoWordLeft");

  if(col == 0) {
    if(currline->prev) {
      GoUp();
      GoEOL();
    }
  }
  else {

    col--;

    if(not isxalnum(currline->txt[col])) {
      while(not isxalnum(currline->txt[col]) and (col > 0))
        col--;
      while(isxalnum(currline->txt[col]) and (col > 0))
        col--;
    }
    else {
      while(isxalnum(currline->txt[col]) and (col > 0))
        col--;
    }

    if(col != 0)
      col++;

    if(blockcol != -1)
      displine(currline, row);
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::GoWordRight() {

  GFTRK("EditGoWordRight");

  if((col >= currline->txt.length()) or (currline->txt[col] == '\n')) {
    if(currline->next) {
      GoDown();
      col = mincol;
    }
  }
  else {
    size_t len = currline->txt.length();
    if(not isxalnum(currline->txt[col])) {
      while(not isxalnum(currline->txt[col]) and ((col+1) <= len))
        col++;
    }
    else {
      while(isxalnum(currline->txt[col]) and ((col+1) <= len))
        col++;
      while(not isxalnum(currline->txt[col]) and ((col+1) <= len))
        col++;
    }

    if(currline->txt[col-1] == '\n')
       col--;

    if(len == col) {
      if(currline->next) {
        GoDown();
        col = 0;
      }
      else
        col--;
    }
  }

  if (blockcol != -1)
    displine(currline, row);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::Newline() {

  GFTRK("EditNewline");

  // Pointer to the split position
  int _splitpos = col;

  // Buffer for the second part of the split line
  std::string _splitbuf;

  // If the split line was quoted, get the quotestring
  // But do not get it if the cursor points to a linefeed or is
  uint _quotelen;
  char _quotebuf[MAXQUOTELEN];
  GetQuotestr(currline->txt.c_str(), _quotebuf, &_quotelen);

  // Eliminate the quotestring if
  // - the cursor points to a linefeed or
  // - the cursor is located inside the quotestring
  if(_quotelen and ((currline->txt.length() == col) or (currline->txt[_splitpos] == '\n') or (col < _quotelen))) {
    *_quotebuf = NUL;
    _quotelen = 0;
  }

  // Append the second part to the split buffer
  _splitbuf = _quotebuf;
  _splitbuf += currline->txt.substr(_splitpos);

  Undo->PushItem(EDIT_UNDO_INS_TEXT|batch_mode, currline, col, 1);
  batch_mode = BATCH_MODE;

  // Copy linefeed+nul to the split position
  currline->txt.erase(_splitpos);
  currline->txt += "\n";

  // Re-type and display the split line
  setlinetype(currline);
  displine(currline, row);

  uint _quotelen1 = 0;
  char _quotebuf1[MAXQUOTELEN] = "";
  if(currline->next != NULL) {
    GetQuotestr(currline->next->txt.c_str(), _quotebuf1, &_quotelen1);
  }

  if((_splitbuf.find('\n') != _splitbuf.npos) or (currline->next == NULL) or not strieql(_quotebuf, _quotebuf1)) {
    // Insert a new line below, set the line text to the split-off part
    currline = insertlinebelow(currline, _splitbuf.c_str());

    //                  --v--
    // This line would be wrapped
    // This line would be
    // wrapped

    Undo->PushItem(EDIT_UNDO_WRAP_TEXT|BATCH_MODE, currline->prev, _quotelen, _splitbuf.length() - _quotelen);
  }
  else {
    currline = currline->next;

    currline->txt.insert(_quotelen1, _splitbuf.substr(_quotelen1));

    Undo->PushItem(EDIT_UNDO_WRAP_TEXT|BATCH_MODE, currline->prev, _quotelen1, _splitbuf.length() - _quotelen1);
  }
  setlinetype(currline);

  // Move down the cursor
  col = 0;
  row = downoneline(row);

  // Scroll the remaining lines if necessary
  if(row < maxrow)
    scrolldown(mincol, row, maxcol, maxrow);

  // Rewrap the split-off line
  wrapdel(&currline, &col, &row, true);
  refresh(currline, row);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::CopyAboveChar() {

  GFTRK("EditCopyAboveChar");

  char _ch = ' ';
  if(currline->prev) {
    uint _len = currline->prev->txt.length();
    if(_len and _len > col)
      _ch = currline->prev->txt[col];
    if(_ch == '\n')
      _ch = ' ';
  }
  insertchar(_ch);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::DupLine() {

  GFTRK("EditDupLine");

  Undo->PushItem(EDIT_UNDO_VOID);
  batch_mode = BATCH_MODE;

  Line* _nextline = insertlinebelow(currline, currline->txt.c_str(), batch_mode);
  _nextline->type   = currline->type & ~GLINE_BLOK;
  _nextline->color  = currline->color;
  _nextline->kludge = currline->kludge;
  refresh(currline, row);
  GoDown();

  GFTRK(NULL);
}


//  ------------------------------------------------------------------
//  PageUp behavior:
//
//  ... The top line becomes the bottom line.
//  ... Always remain at cursor row, except if we can't page up.
//  ... If we can't page up, move the cursor row to the top line.

void IEclass::GoPgUp() {

  GFTRK("EditGoPgUp");

  // Not at the first line in msg?
  if(currline->prev) {

    // Count lines
    int _count = row;

    // Move to the top line currently displayed
    Line* _topline = currline;
    while(_count and _topline->prev) {
      _topline = _topline->prev;
      _count--;
    }

    // The count must be zero at this point!
    _test_haltab(_count, _count, _count);

    // At we already fully at the top?
    if(_topline->prev == NULL) {

      // Yes, so move the cursor row to the top line
      row = minrow;
      currline = _topline;
      if(blockcol != -1)
        refresh(currline, row);
    }
    else {

      // We are not at the top, so continue with paging

      // Move a full page of lines, if possible
      _count = maxrow;
      while(_count and _topline->prev) {
        _topline = _topline->prev;
        _count--;
      }

      // Set the current line
      _count = row;
      currline = _topline;
      while(_count--)
        currline = currline->next;

      // Refresh display
      refresh(_topline, minrow);
    }
  }
  else {
    GoTopMsg();
  }

  if(col+1 > currline->txt.length())
    GoEOL();

  GFTRK(NULL);
}


//  ------------------------------------------------------------------
//  PageDown behavior:
//
//  ... The bottom line becomes the top line.
//  ... Always remain at cursor row, except if at the last line.
//  ... If at the last line, move cursor to the last window line and
//      display the lines above.
//  ... If there are too few lines to display after the page down, the
//      rest are displayed blank.

void IEclass::GoPgDn() {

  GFTRK("EditGoPgDn");

  // Not at the last line in the msg?
  if(currline->next) {

    // Go down to the last displayed line in the window
    uint _newrow = row, _oldrow = row;
    Line *oldcurrline = currline;
    while((_newrow < maxrow) and currline->next) {
      currline = currline->next;
      _newrow++;
    }

    // If there are more lines after the last line, start displaying from the top
    if(currline->next) {
      Line *_topline = currline;

      // Set current line
      _newrow = 0;
      while((_newrow < row) and currline->next) {
        currline = currline->next;
        _newrow++;
      }

      // Move cursor row if necessary
      if(_newrow < row)
        row = _newrow;

      refresh(_topline, minrow);
    }
    else {
      row = _newrow;
      refresh(oldcurrline, _oldrow);
    }
  }
  else {
    GoBotMsg();
  }

  if(col+1 > currline->txt.length())
    GoEOL();

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::Tab() {

  GFTRK("EditTab");

  int tabsz = CFG->disptabsize ? CFG->disptabsize : 1;

  // Move to the next tab position
  do {
    if(insert)
      insertchar(' ');
    else if(currline->txt[col] != '\n')
      GoRight();
    else
      break;
  } while(col % tabsz);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::ReTab() {

  GFTRK("EditTabReverse")

  int tabsz = CFG->disptabsize ? CFG->disptabsize : 1;

  // Move to the next tab position
  do {
    if(not col)
      break;

    if(insert)
      DelLeft();
    else
      GoLeft();
  } while(col % tabsz);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::DeleteEOL() {

  GFTRK("EditDeleteEOL");

  bool _has_linefeed = (currline->txt.find('\n') != currline->txt.npos);

  Undo->PushItem(EDIT_UNDO_DEL_TEXT, currline);

  currline->txt.erase(col);

  if(_has_linefeed) {
    Undo->PushItem(EDIT_UNDO_INS_CHAR|BATCH_MODE);
    currline->txt += "\n";
  }

  clreol();

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::DeleteSOL() {

  GFTRK("EditDeleteSOL");

  if(col == 0) {
    GFTRK(NULL);
    return;
  }

  int _oldcol = col;

  col = 0;

  Undo->PushItem(EDIT_UNDO_DEL_TEXT, currline, col, _oldcol);
  currline->txt.erase(col, _oldcol);

  wrapdel(&currline, &col, &row);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::deleteline(bool zapquotesbelow) {

  GFTRK("Editdeleteline");

  bool done = false;

  do {

    // Break if need to zap quotes, but the current line is not quote and is not empty
    if(zapquotesbelow and not ((currline->type & GLINE_QUOT) or isempty(currline)))
      break;

    // Pointer to the deleted line
    Line* _deletedline = currline;

    // If last line to be deleted delete to EOL and exit
    if(currline->next == NULL) {
      if(isempty(currline))
        break;
      insertlinebelow(currline, "", batch_mode);
      batch_mode = BATCH_MODE;
      done = true;
    }

    // Pointers to the previous and next lines
    Line* _prevline = currline->prev;
    Line* _nextline = currline->next;

    Undo->PushItem(EDIT_UNDO_PUSH_LINE|batch_mode);

    // Set the new current line to the next line (which may be NULL!)
    currline = _nextline;

    if(currline == NULL) {
      currline = _prevline;
      currline->next = NULL;
      _prevline = _prevline ? _prevline->prev : NULL;
    }

    // Link the new current line to the previous line
    currline->prev = _prevline;

    // Link the previous line to this line
    if(_prevline)
      _prevline->next = currline;

    if(_deletedline->type & GLINE_BLOK) {
      blockcol = -1;
      _deletedline->type &= ~GLINE_BLOK;
    }

    // Link the deleted line to the killbuffer
    if(Edit__killbuf) {
      Edit__killbuf->next = _deletedline;
      _deletedline->prev = Edit__killbuf;
      Edit__killbuf = _deletedline;
    }
    else {
      Edit__killbuf = _deletedline;
      Edit__killbuf->prev = NULL;
    }
    Edit__killbuf->next = NULL;

    // Move the cursor to EOL if necessary
    if(col+1 > currline->txt.length())
      GoEOL();

    if(not zapquotesbelow)
      break;

    batch_mode = BATCH_MODE;

  } while(not done);

  // Refresh display from cursor row
  refresh(currline, row);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::UnDelete(bool before) {

  GFTRK("EditUnDelete");

  // If there are deleted lines
  if(Edit__killbuf) {

    Line* _prevline = Edit__killbuf->prev;
    bool down = false;

    if(before) {
      Edit__killbuf->prev = currline ? currline->prev : NULL;
      Edit__killbuf->next = currline;
    }
    else {
      Edit__killbuf->prev = currline;
      Edit__killbuf->next = currline ? currline->next : NULL;
      if(row == maxrow)
        down = true;
      else if((row < maxrow) and currline)
        row++;
    }

    if(Edit__killbuf->prev)
      Edit__killbuf->prev->next = Edit__killbuf;
    if(Edit__killbuf->next)
      Edit__killbuf->next->prev = Edit__killbuf;
    currline = Edit__killbuf;
    Edit__killbuf = _prevline;
    if(Edit__killbuf)
      Edit__killbuf->next = NULL;

    Undo->PushItem(EDIT_UNDO_POP_LINE);

    // Move the cursor to EOL if necessary
    if(col+1 > currline->txt.length())
      GoEOL();

    if(down)
      GoDown();
    else
      refresh(currline, row);
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::ZapQuoteBelow() {

  GFTRK("ZapQuoteBelow");

  if(currline->prev)
    Undo->PushItem(EDIT_UNDO_VOID|PREV_LINE|batch_mode, currline->prev);
  else
    Undo->PushItem(EDIT_UNDO_VOID|batch_mode, currline);
  batch_mode = BATCH_MODE;
  UndoItem* item_to_fix = Undo->last_item;

  deleteline(true);
  if(row == 0) {
    item_to_fix->line = currline;
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

Line* IEclass::findtopline() {

  GFTRK("Editfindtopline");

  uint  _toprow  = row;
  Line* _topline = currline;

  while(_topline->prev and (_toprow > minrow)) {
    _topline = _topline->prev;
    _toprow--;
  }

  GFTRK(NULL);

  return _topline;
}


//  ------------------------------------------------------------------

void IEclass::savefile(int __status) {

  Subj statbak;

  GFTRK("Editsavefile");

  // Turn off cursor and put up a wait window
#if defined(__USE_NCURSES__) || !defined(__WIN32__)  /* Fix after bugfix w9x console bug in gvidbase.cpp */
  int wascursoron = not vcurhidden();
  cursoroff();
#endif

  strcpy(statbak, information);
  update_statusline(LNG->Wait+1);

  // Open the save file
  const char* editorfile = AddPath(CFG->goldpath, EDIT->File());
  remove(editorfile);
  FILE* _fp = fsopen(editorfile, "wb", CFG->sharemode);
  if(_fp) {

    // Find the first line
    Line* _saveline = findfirstline();

    // First save the "unfinished" identifier
    if(__status == MODE_UPDATE) {
      fputs(unfinished, _fp);
      fputs("\r\n", _fp);
    }

    // Save as whole paragraphs
    while(_saveline) {

      // Copy the line to a buffer
      char _buf[EDIT_BUFLEN];
      strcpy(_buf, _saveline->txt.c_str());

      // If a LF was found, replace it with a CR/LF combo
      char* _lfptr = strchr(_buf, '\n');
      if(_lfptr)
        strcpy(_lfptr, "\r\n");

      // Save the line
      fputs(_buf, _fp);

      // Continue with the next line
      _saveline = _saveline->next;
    }

    // Close save file and remove wait window
    fclose(_fp);
  }

  update_statusline(statbak);

#if defined(__USE_NCURSES__) || !defined(__WIN32__)  /* Fix after bugfix w9x console bug in gvidbase.cpp */
  if(wascursoron)
    cursoron();
#endif

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::SaveFile() {

  GFTRK("EditSaveFile");

  savefile(MODE_UPDATE);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::SaveMsg() {

  GFTRK("EditSaveMsg");

  done = MODE_SAVE;

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

#if !defined(GCFG_NOSPELLDLL)
void IEclass::SCheckerMenu()
{
  if (!schecker.IsLoaded())
    return;

  const char *txt = currline->txt.c_str();
  GMenuSChecker menu;
  int finaltag;

  if (!isscchar(txt[col]))
    finaltag = menu.Run(schecker, "");
  else
  {
    char buff[EDIT_BUFLEN];
    size_t beg = col;
    size_t end = col;

    for (; (beg > 0) && isscchar(txt[beg-1]); beg--);
    for (; isscchar(txt[end]); end++);
    size_t len = end - beg;

    memcpy(buff, &txt[beg], len);
    buff[len] = 0;

    finaltag = menu.Run(schecker, buff);
    if (finaltag >= 0)
    {
      std::string &str = schecker.GetSuggest()[finaltag].second;
      size_t len2 = str.length() - 3;
      txt = &str.c_str()[2];

      if ((buff[len-1] == '.') && (txt[len2-1] != '.')) len--;
      if (col > (beg + len2 - 1)) col = beg + len2 - 1;

      Undo->PushItem(EDIT_UNDO_DEL_TEXT, currline, beg, len);
      currline->txt.erase(beg, len);

      Undo->PushItem(EDIT_UNDO_INS_TEXT|BATCH_MODE, currline, beg, len2);
      currline->txt.insert(beg, txt, len2);
      wrapit(&currline, &col, &row);
    }
  }

  if (finaltag == -2)
  {
    Line *line = currline;
    uint32_t _row = row;

    while (line->prev && (_row > minrow))
    {
      line = line->prev;
      _row--;
    }

    refresh(line, _row);
  }
}
#endif


//  ------------------------------------------------------------------

int IEclass::isempty(Line* __line) {

  if(__line == NULL)
    __line = currline;

  return (__line->txt.empty() or __line->txt[0] == '\n');
}


//  ------------------------------------------------------------------

int IEclass::reflowok(char* __qstr) {

  // Stop reflow if there is no next line
  if(currline->next == NULL)
    return false;

  // Stop reflow if the next line is empty
  if(isempty(currline->next))
    return false;

  // Stop reflow if the next line is a control line
  if(currline->next->type & (GLINE_KLUDGE|GLINE_TEAR|GLINE_ORIG|GLINE_TAGL))
    return false;

  // Stop reflow if the quotestring on the next line is not the same
  uint _qlen2;
  char _qstr2[MAXQUOTELEN];
  GetQuotestr(currline->next->txt.c_str(), _qstr2, &_qlen2);
  if(not cmp_quotes(__qstr, _qstr2))
    return false;

  return true;
}


//  ------------------------------------------------------------------

void IEclass::Reflow() {

  GFTRK("EditReflow");

  // Skip empty lines
  while(isempty()) {
    if(currline->next) {
      if(not batch_mode) {
        Undo->PushItem(EDIT_UNDO_VOID);
        batch_mode = BATCH_MODE;
      }
      GoDown();
    }
    else {
      GFTRK(NULL);
      return;
    }
  }

  // Get the first quotestring
  uint _qlen1;
  char _qstr1[MAXQUOTELEN];
  GetQuotestr(currline->txt.c_str(), _qstr1, &_qlen1);
  const char* _qlenptr = currline->txt.c_str() + _qlen1;

  // Strip leading spaces from the first line
  const char* ptr = _qlenptr;
  while(*ptr and isspace(*ptr) and (*ptr != '\n')) ptr++;
  if(ptr != _qlenptr) {
    Undo->PushItem(EDIT_UNDO_DEL_TEXT|batch_mode, currline, _qlen1, ptr-_qlenptr);
    currline->txt.erase(_qlen1, ptr-_qlenptr);
  }

  // Perform the reflow
  while(reflowok(_qstr1)) {

    // Work on the current line until it is done
    Line* _thisline = currline;
    while(_thisline == currline) {

      // Stop reflow?
      if(not reflowok(_qstr1))
        break;

      // Go to the EOL, insert a space and delete the LF
      GoEOL();
      if(col+1 < maxcol) {
        insertchar(' ');
        DelChar();
      }
      else {
        GoDown();
        col = mincol;
      }
    }
  }

  // Go to the next line
  displine(currline,row);
  GoDown();
  col = mincol;

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::ExitMsg() {

  GFTRK("EditExitMsg");

  done = MODE_QUIT;

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::DelLine() {

  GFTRK("EditDelLine");

  cursoroff();
  deleteline();

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::ToUpper() {

  GFTRK("EditToUpper");

  if(col < currline->txt.length()) {
    Undo->PushItem(EDIT_UNDO_OVR_CHAR);
    currline->txt[col] = g_toupper(currline->txt[col]);
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::ToLower() {

  GFTRK("EditToLower");

  if(col < currline->txt.length()) {
    Undo->PushItem(EDIT_UNDO_OVR_CHAR);
    currline->txt[col] = g_tolower(currline->txt[col]);
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::ToggleCase() {

  GFTRK("EditToggleCase");

  if (col < currline->txt.length())
  {
    Undo->PushItem(EDIT_UNDO_OVR_CHAR);

    char chr = currline->txt[col];
    if (g_isupper(chr))
      currline->txt[col] = g_tolower(chr);
    else
      currline->txt[col] = g_toupper(chr);
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::ToggleCaseChar(gkey key,
                             std::string::iterator it,
                             Line *ln, int n)
{
  int oldchar = *it;
  int newchar = 0;

  switch (key)
  {
  case KK_EditToLower:
    newchar = g_tolower(oldchar);
    break;

  case KK_EditToUpper:
    newchar = g_toupper(oldchar);
    break;

  case KK_EditToggleCase:
    if (g_isupper(oldchar))
      newchar = g_tolower(oldchar);
    else
      newchar = g_toupper(oldchar);
    break;
  }

  if (newchar != oldchar)
  {
    currline = ln; pcol = col = n; getthisrow(currline); prow = thisrow;
    Undo->PushItem(EDIT_UNDO_OVR_CHAR);
    *it = newchar;
  }
}


//  ------------------------------------------------------------------

void IEclass::ToggleCaseBlock(gkey key)
{
  GFTRK("EditToggleCaseBlock");

  // Find the anchor, if any
  Line* _anchor = findanchor();

  // Did we find the anchor?
  if (_anchor)
  {
    Line* oldline = currline;
    int   oldcol = col;

    Line* _firstline = currline;
    Line* _lastline  = currline;
    int   firstcol = col, lastcol = col;

    // Search below to find the anchor line
    while (_lastline->next and (_lastline != _anchor))
      _lastline = _lastline->next;

    // Was the anchor line above or on the current line?
    if (_lastline != _anchor)
    {
      // The last copy line is the current line
      _lastline = currline;

      // Search above to find the anchor line
      while (_firstline->prev and (_firstline != _anchor))
        _firstline = _firstline->prev;
      firstcol = blockcol;
    }
    else
    {
      if (currline != _anchor or blockcol > col)
        lastcol = blockcol;
      else
        firstcol = blockcol;
    }

    // The _firstline and _lastline pointers
    // are now pointing where they should

    int n;
    Line* ln = _firstline;
    std::string::iterator it1, it2;

    if (ln == _lastline)
    {
      it1 = ln->txt.begin() + firstcol;
      it2 = ln->txt.begin() + lastcol;
      for (n = firstcol; it1 < it2; it1++, n++)
        ToggleCaseChar(key, it1, ln, n);
    }
    else
    {
      it1 = ln->txt.begin() + firstcol;
      it2 = ln->txt.end();
      for (n = firstcol; it1 < it2; it1++, n++)
        ToggleCaseChar(key, it1, ln, n);

      for (ln = ln->next; ln != _lastline; ln = ln->next)
      {
        it1 = ln->txt.begin();
        it2 = ln->txt.end();
        for (n = 0; it1 < it2; it1++, n++)
          ToggleCaseChar(key, it1, ln, n);
      }

      it1 = ln->txt.begin();
      it2 = ln->txt.begin() + lastcol;
      for (n = 0; it1 < it2; it1++, n++)
        ToggleCaseChar(key, it1, ln, n);
    }

    currline = oldline;
    pcol = col = oldcol;
    getthisrow(currline);
    prow = thisrow;
  }

  // Refresh display
  Line* _topline = findtopline();
  refresh(_topline, minrow);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::SCodeChange(gkey key)
{
  GFTRK("EditSCodeChange");

  char _ch = ' ';
  switch (key)
  {
  case KK_EditSCodeBold:      _ch = '*';  break;
  case KK_EditSCodeUnderline: _ch = '_';  break;
  case KK_EditSCodeItalic:    _ch = '/';  break;
  case KK_EditSCodeReverse:   _ch = '#';  break;
  }

  const char *cltxt = currline->txt.c_str();
  const char *punct = CFG->stylecodepunct;

  if (isspace(cltxt[col]) || strchr(punct, cltxt[col]))
  {
    if (col && !isspace(cltxt[col-1]) && !strchr(punct, cltxt[col-1]))
      GoLeft();
    else if (!isspace(cltxt[col+1]) && !strchr(punct, cltxt[col+1]))
      GoRight();
    else
    {
      if (isspace(cltxt[col]) && (key != KK_EditSCodeNormal))
      {
        if (col && !isspace(cltxt[col-1]))
          insertchar(' ');

        insertchar(_ch);
        insertchar(_ch);
        GoLeft();
      }

      GFTRK(NULL);
      return;
    }
  }

  uint beg = col;
  uint end = col;

  while (beg && !isspace(cltxt[beg-1]) && !strchr(punct, cltxt[beg-1]))
    beg--;
  while (!isspace(cltxt[end+1]) && !strchr(punct, cltxt[end+1]))
    end++;

  bool replace = false;
  char c1 = cltxt[beg];
  char c2 = cltxt[end];

  if ((_ch == c1) && (c1 == c2))
  {
    GFTRK(NULL);
    return;
  }

  if ((_ch != c1) && (c1 == c2) &&
      ((c1 == '*') || (c1 == '/') || (c1 == '_') || (c1 == '#')))
    replace = true;


  while (col && !isspace(cltxt[col-1]) && !strchr(punct, cltxt[col-1]))
    GoLeft();

  if (replace) DelChar();
  if (_ch != ' ') insertchar(_ch);

  cltxt = currline->txt.c_str();
  while (!isspace(cltxt[col+1]) && !strchr(punct, cltxt[col+1]))
    GoRight();

  if (replace) DelChar();
  else         GoRight();
  if (_ch != ' ') insertchar(_ch);

  GoLeft();

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::LookupCursor() {

  GFTRK("EditLookupCursor");

  LookupNode(msgptr, currline->txt.c_str()+col, LOOK_NAME);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::LookupDest() {

  GFTRK("EditLookupDest");

  LookupNode(msgptr, "", LOOK_DEST);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::LookupOrig() {

  GFTRK("EditLookupOrig");

  LookupNode(msgptr, "", LOOK_ORIG);

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void IEclass::Soundkill() {

  HandleGEvent(EVTT_STOPVOICE);
}


//  ------------------------------------------------------------------

void IEclass::statusline() {

  if(chartyped) {
    if(EDIT->Completion.First()) {
      do {
        const char* trig = EDIT->Completion.Trigger();
        uint tlen = strlen(trig);
        if(col >= tlen) {
          if(strneql(trig, currline->txt.c_str()+col-tlen, tlen)) {
            int saved_insert = insert;
            insert = true;
            batch_mode = BATCH_MODE;
            uint n;
            for(n=0; n<tlen; n++)
              DelLeft();
            const char* cptr = EDIT->Completion.Text();
            uint clen = strlen(cptr);
            for(n=0; n<clen; n++)
              insertchar(*cptr++);
            HandleGEvent(EVTT_EDITCOMPLETION);
            insert = saved_insert;
            break;
          }
        }
      } while(EDIT->Completion.Next());
    }
  }

  char _buf[EDIT_BUFLEN];
  *_buf = NUL;

  if(EDIT->Comment.First()) {
    do {
      const char* trig = EDIT->Comment.Trigger();
      uint tlen = strlen(trig);
      if(col >= tlen) {
        if(strnieql(trig, currline->txt.c_str()+col-tlen, tlen)) {
          strcpy(_buf, EDIT->Comment.Text());
          break;
        }
      }
    } while(EDIT->Comment.Next());
  }

  uint chr = currline->txt[col];
  update_statuslinef(LNG->EditStatus, "ST_EDITSTATUS", 1+thisrow, 1+col, chr, _buf);
  if(*_buf and CFG->switches.get(beepcomment)) {
    HandleGEvent(EVTT_EDITCOMMENT);
  }
}


//  ------------------------------------------------------------------

int IEclass::handlekey(gkey __key) {

  int rc = true;

  if (drawlines &&
      (__key != KK_EditGoRight) && (__key != KK_EditGoLeft) &&
      (__key != KK_EditGoUp) && (__key != KK_EditGoDown))
  {
    drawflag = true;
  }

  switch(__key)
  {
    case KK_EditBlockRight:  __key = KK_EditGoRight;   break;
    case KK_EditBlockLeft:   __key = KK_EditGoLeft;    break;
    case KK_EditBlockUp:     __key = KK_EditGoUp;      break;
    case KK_EditBlockDown:   __key = KK_EditGoDown;    break;
    case KK_EditBlockHome:   __key = KK_EditGoBegLine; break;
    case KK_EditBlockEnd:    __key = KK_EditGoEOL;     break;
    case KK_EditBlockPgDn:   __key = KK_EditGoPgDn;    break;
    case KK_EditBlockPgUp:   __key = KK_EditGoPgUp;    break;

    case KK_EditBlockWordRight: __key = KK_EditGoWordRight; break;
    case KK_EditBlockWordLeft:  __key = KK_EditGoWordLeft;  break;

    case KK_EditCopy:
    case KK_EditCut:
    case KK_EditDelete:      goto noselecting;

    case KK_EditDelChar:
    case KK_EditDelLeft:
      if(selecting) {
        __key = KK_EditUndefine;
      }
      // fall through

    case KK_EditPaste:
    case KK_EditNewline:
      if(selecting) {
        BlockCut(true);
        batch_mode = BATCH_MODE;
      }
      goto noselecting;
      break;

    case KK_EditToLower:
    case KK_EditToUpper:
    case KK_EditToggleCase:
      if (!selecting)  goto noselecting;

      ToggleCaseBlock(__key);
      undo_ready = NO;
      return rc;

    case KK_EditGoRight:
    case KK_EditGoLeft:
    case KK_EditGoUp:
    case KK_EditGoDown:
      if (drawlines && !selecting)
      {
        DrawLines(__key);
        undo_ready = NO;
        return rc;
      }
      // fall through

    default:
      rc = PlayMacro(__key, KT_E);
      if(rc == true)
        return rc;
      rc = true;
      if(selecting) {
        Line *_line;
        selecting = NO;
        blockcol = -1;
        for(_line = findfirstline(); _line; _line = _line->next)
          _line->type &= ~GLINE_BLOK;
        // refresh screen
        int r = row;
        for(_line = currline; _line and r; _line = _line->prev)
          r--;
        refresh(_line, minrow);
      }
      goto noselecting;
  }

  if(not selecting) {
    Line *_line;
    for(_line = findfirstline(); _line; _line = _line->next)
      _line->type &= ~GLINE_BLOK;
    currline->type |= GLINE_BLOK;
    selecting = YES;
    blockcol = col;
    // refresh screen
    int r = row;
    for(_line = currline; _line and r; _line = _line->prev)
      r--;
    refresh(_line, minrow);
  }

noselecting:

  switch(__key) {
    case KK_EditAbort:            Abort();              break;
    case KK_EditAskExit:          AskExit();            break;
    case KK_EditClearDeleteBuf:   ClearDeleteBuf();     break;
    case KK_EditClearPasteBuf:    ClearPasteBuf();      break;
    case KK_EditCopyAboveChar:    CopyAboveChar();      break;
    case KK_EditDelChar:          DelChar();            break;
    case KK_EditDeleteEOL:        DeleteEOL();          break;
    case KK_EditDeleteSOL:        DeleteSOL();          break;
    case KK_EditDelLeft:          DelLeft();            break;
    case KK_EditDelLine:          DelLine();            break;
    case KK_EditDelLtWord:        DelLtWord();          break;
    case KK_EditDelRtWord:        DelRtWord();          break;
    case KK_EditDosShell:         DosShell();           break;
    case KK_EditDupLine:          DupLine();            break;
    case KK_EditExitMsg:          ExitMsg();            break;
    case KK_EditExportText:       ExportText();         break;
    case KK_EditGoBegLine:        GoBegLine();          break;
    case KK_EditGoBotLine:        GoBotLine();          break;
    case KK_EditGoBotMsg:         GoBotMsg();           break;
    case KK_EditGoDown:           GoDown();             break;
    case KK_EditGoEOL:            GoEOL();              break;
    case KK_EditGoLeft:           GoLeft();             break;
    case KK_EditGoPgDn:           GoPgDn();             break;
    case KK_EditGoPgUp:           GoPgUp();             break;
    case KK_EditGoRight:          GoRight();            break;
    case KK_EditGoTopLine:        GoTopLine();          break;
    case KK_EditGoTopMsg:         GoTopMsg();           break;
    case KK_EditGoUp:             GoUp();               break;
    case KK_EditGoWordLeft:       GoWordLeft();         break;
    case KK_EditGoWordRight:      GoWordRight();        break;
    case KK_EditHeader:           Header();             break;
    case KK_EditImportQuotebuf:   ImportQuotebuf();     break;
    case KK_EditImportText:       ImportText();         break;
    case KK_EditLoadFile:         LoadFile();           break;
    case KK_EditLookupCursor:     LookupCursor();       break;
    case KK_EditLookupDest:       LookupDest();         break;
    case KK_EditLookupOrig:       LookupOrig();         break;
    case KK_EditNewline:          Newline();            break;
    case KK_EditQuitNow:          QuitNow();            break;
    case KK_EditReflow:           Reflow();             break;
    case KK_EditSaveFile:         SaveFile();           break;
    case KK_EditSaveMsg:          SaveMsg();            break;
#if !defined(GCFG_NOSPELLDLL)
    case KK_EditSCheckerMenu:     SCheckerMenu();       break;
#endif
    case KK_EditSoundkill:        Soundkill();          break;
#if defined(GCFG_NOSPELLDLL)
    case KK_EditSpellCheck:       SpellCheck();         break;
#endif
    case KK_EditTab:              Tab();                break;
    case KK_EditTabReverse:       ReTab();              break;
    case KK_EditToggleCase:       ToggleCase();         break;
    case KK_EditToggleInsert:     ToggleInsert();       break;
    case KK_EditToLower:          ToLower();            break;
    case KK_EditToUpper:          ToUpper();            break;
    case KK_EditUndefine:                               break;
    case KK_EditUnDelete:         UnDelete();           break;
    case KK_EditUndo:             Undo->PlayItem();     break;
    case KK_EditZapQuoteBelow:    ZapQuoteBelow();      break;
    case KK_EditSCodeNormal:
    case KK_EditSCodeBold:
    case KK_EditSCodeItalic:
    case KK_EditSCodeUnderline:
    case KK_EditSCodeReverse:     SCodeChange(__key);   break;
    case KK_EditDrawLines:        ToggleDrawLines();    break;

    // Block functions
    case KK_EditAnchor:           BlockAnchor();        break;
    case KK_EditCopy:             BlockCopy();          break;
    case KK_EditCut:              BlockCut();           break;
    case KK_EditDelete:           BlockCut(true);       break;
    case KK_EditPaste:            BlockPaste();         break;

    default:
      rc = false;
      break;
  }

  if(__key != KK_EditUndo)
    undo_ready = NO;

  return rc;
}


//  ------------------------------------------------------------------

int IEclass::Start(int __mode, uint* __position, GMsg* __msg) {

  GFTRK("EditStart");

  thisrow = 0;
  quitnow = NO;
  col = mincol;
  row = minrow;
  msgptr = __msg;
  msgmode = __mode;
  currline = __msg->lin;

#if !defined(GCFG_NOSPELLDLL)
  if (CFG->scheckerenabled)
  {
    schecker.Init();
    schecker.Load(CFG->scheckerdeflang, CFG->scheckeruserdic);
  }
#endif

  if(AA->isinternet() and (CFG->soupexportmargin <= CFG->dispmargin))
    margintext = CFG->soupexportmargin;
  else
    margintext = CFG->dispmargin;

  marginquotes = EDIT->QuoteMargin() + 1; // Add one for CR
  if(marginquotes > margintext)
    marginquotes = margintext;

  if(currline == NULL) {
    currline = new Line("\n");
    throw_xnew(currline);
  }

  // Check if there is an unfinished backup message
  FILE* _fp = fsopen(AddPath(CFG->goldpath, EDIT->File()), "rt", CFG->sharemode);
  if(_fp) {
    char _buf[EDIT_BUFLEN];
    fgets(_buf, sizeof(_buf), _fp);
    fclose(_fp);
    if(striinc(unfinished, _buf)) {
      w_info(LNG->UnfinishedMsg);
      update_statusline(LNG->LoadUnfinished);
      HandleGEvent(EVTT_ATTENTION);
      gkey _ch = getxch();
      w_info(NULL);
      if(_ch != Key_Esc) {
        LoadFile();
        *__position = 0;
        remove(AddPath(CFG->goldpath, EDIT->File()));
      }
    }
  }

  if(*__position) {
    for(uint _posrow=0; _posrow < *__position; _posrow++) {
      if(currline->next) {
        currline = currline->next;
        row++;
      }
    }
    thisrow = row;
  }

  done = NO;

  // If the starting line is outside the first screenful
  if(*__position >= (maxrow+1)) {
    refresh(currline->prev, minrow);
    row = 1;
  }
  else {
    refresh(findfirstline(), minrow);
  }

  gotorowcol(mincol, minrow);
  dispins();

  time32_t _lasttime = gtime(NULL);

  while(not done) {

    statusline();

    gotorowcol(col, row);
    batch_mode = 0;

    vattr backattr = BLACK_|_BLACK;
    if(blockcol == -1) {
      backattr = dispchar(currline->txt.c_str()[col], C_READC);
      gotorowcol(col, row);
    }

    cursoron();
    if(insert)
      vcursmall();
    else
      vcurlarge();

    gkey _ch;
#if defined(__WIN32__)
    gkey keystatus = 0;
#endif

    do {
      _ch = getxchtick();
//  TO_PORT_TAG: kbxget_raw(3)
#if defined(__WIN32__)
      keystatus = kbxget_raw(3);
#endif

      if(EDIT->AutoSave()) {
        time32_t _thistime = gtime(NULL);
        if(_thistime >= (_lasttime+EDIT->AutoSave())) {
          _lasttime = _thistime;
          SaveFile();
        }
      }

      if(_ch == Key_Tick)
        CheckTick(KK_EditQuitNow);

    } while(_ch == Key_Tick);

    pcol = col; getthisrow(currline); prow = thisrow;

    int ismacro = false;
    gkey _kk = SearchKey(_ch, EditKey, EditKeys);
    if(_kk) {
      _ch = _kk;

//  TO_PORT_TAG: kbxget_raw(3)
#if defined(__WIN32__)
      if (keystatus & SHIFT_PRESSED)
#else
      if (0)
#endif
      {
        switch(_ch)
        {
        case KK_EditGoUp:         _ch = KK_EditBlockUp;         break;
        case KK_EditGoDown:       _ch = KK_EditBlockDown;       break;
        case KK_EditGoLeft:       _ch = KK_EditBlockLeft;       break;
        case KK_EditGoWordLeft:   _ch = KK_EditBlockWordLeft;   break;
        case KK_EditGoRight:      _ch = KK_EditBlockRight;      break;
        case KK_EditGoWordRight:  _ch = KK_EditBlockWordRight;  break;
        case KK_EditGoBegLine:
        case KK_EditGoTopMsg:     _ch = KK_EditBlockHome;       break;
        case KK_EditGoEOL:
        case KK_EditGoBotMsg:     _ch = KK_EditBlockEnd;        break;
        case KK_EditGoPgUp:
        case KK_EditGoTopLine:    _ch = KK_EditBlockPgUp;       break;
        case KK_EditGoPgDn:
        case KK_EditGoBotLine:    _ch = KK_EditBlockPgDn;       break;
        }
      }
    }
    else {
      ismacro = IsMacro(_ch, KT_E);
    }

    if(blockcol == -1)
      dispchar(currline->txt.c_str()[col], backattr);

    chartyped = false;
    if((_ch < KK_Commands) and (_ch & 0xFF) and not ismacro) {
      drawflag = true;
      chartyped = true;
      _ch &= 0xFF;
      insertchar((char)_ch);
      undo_ready = YES;
    }
    else if(handlekey(_ch)) {
      getthisrow(currline);
    }
  }

  cursoroff();

  msgptr->lin = findfirstline();
  savefile(quitnow ? MODE_UPDATE : MODE_SAVE);

  // Prune killbuffer
  if(Edit__killbuf) {
    Line *__line = Edit__killbuf;

    int _count = EDIT->UnDelete();
    while(__line and _count--)
      __line = __line->prev;

    if(__line)
      if(__line->next)
        __line->next->prev = NULL;

    while(__line) {
      if(Undo->FixPushLine(__line)) {
        if(__line->prev) {
          __line = __line->prev;
          __line->next = NULL;
        }
        else {
          __line = NULL;
        }
      }
      else {
        if(__line->prev) {
          __line = __line->prev;
          throw_xdelete(__line->next);
        }
        else
          throw_xdelete(__line);
      }
    }
  }

  *__position = 1 + thisrow;

  GFTRK(NULL);

  return done;
}


//  ------------------------------------------------------------------

UndoStack::UndoStack(IEclass* this_editor) :

  editor(this_editor),
  row(editor->row),
  col(editor->col),
  pcol(editor->pcol),
  prow(editor->prow),
  minrow(editor->minrow),
  maxrow(editor->maxrow),
  thisrow(editor->thisrow),
  currline(editor->currline),
  undo_ready(editor->undo_ready) {
  UndoItem::last_item = &last_item;
  last_item = NULL;
  undo_enabled = YES;
}


//  ------------------------------------------------------------------

UndoStack::~UndoStack() {

  while(last_item) {
    switch(last_item->action & EDIT_UNDO_ACTION) {
      case EDIT_UNDO_DEL_TEXT:
      case EDIT_UNDO_INS_TEXT:
      case EDIT_UNDO_WRAP_TEXT:
        throw_delete(last_item->data.text_ptr);
        break;
      case EDIT_UNDO_DEL_LINE:
        throw_xdelete(last_item->data.line_ptr);
    }
    delete last_item;
  }
}


//  ------------------------------------------------------------------

bool UndoStack::FixPushLine(Line* __line) {

  UndoItem* item = last_item;

  while(item) {
    if(((item->action & EDIT_UNDO_ACTION) == EDIT_UNDO_PUSH_LINE) and (item->data.line_ptr == __line)) {
      item->action &= ~EDIT_UNDO_ACTION;
      item->action |= EDIT_UNDO_ORPHAN_LINE;
      return true;
    }
    item = item->prev;
  }
  return false;
}


//  ------------------------------------------------------------------

void UndoStack::PushItem(uint action, Line* __line, uint __col, uint __len) {

  GFTRK("PushItem");

  if(undo_enabled) {

    throw_new(last_item = new UndoItem);
    last_item->col.num = (__col != NO_VALUE) ? __col : col;
    last_item->col.sav = 0;
    last_item->action = action;
    last_item->pcol = pcol;
    last_item->prow = prow;

    switch(action & EDIT_UNDO_ACTION) {
      case EDIT_UNDO_VOID:
      case EDIT_UNDO_INS_CHAR:
        last_item->line = __line ? __line : currline;
        last_item->data.char_int = NUL;
        break;
      case EDIT_UNDO_DEL_CHAR:
      case EDIT_UNDO_OVR_CHAR:
        last_item->line = __line ? __line : currline;
        last_item->data.char_int = last_item->line->txt[last_item->col.num];
        break;
      case EDIT_UNDO_DEL_TEXT:
        last_item->line = __line;
        __col = last_item->col.num;
        if(__len == NO_VALUE)
          __len = __line->txt.length() - __col;
        throw_new(last_item->data.text_ptr = new(__len) text_item(__col, __len));
        memcpy(last_item->data.text_ptr->text, __line->txt.c_str() + __col, __len);
        break;
      case EDIT_UNDO_CUT_TEXT:
        last_item->line = __line;
        last_item->data.text_ptr = NULL;
        break;
      case EDIT_UNDO_INS_TEXT:
      case EDIT_UNDO_WRAP_TEXT:
        last_item->line = __line;
        if(__len == NO_VALUE)
          __len = __line->txt.length() - __col;
        throw_new(last_item->data.text_ptr = new text_item(__col, __len));
        break;
      case EDIT_UNDO_NEW_LINE:
        last_item->line = last_item->data.line_ptr = __line;
        break;
      case EDIT_UNDO_DEL_LINE:
        last_item->line = __line->prev ? __line->prev : __line->next;
        last_item->data.line_ptr = __line;
        break;
      case EDIT_UNDO_PUSH_LINE:
        if(currline->next)
          last_item->line = currline->next;
        else {
          last_item->action |= LAST_LINE;
          last_item->line = currline->prev;
        }
        last_item->data.line_ptr = currline;
        break;
      case EDIT_UNDO_POP_LINE:
        last_item->line = currline;
        last_item->data.line_ptr = NULL;
        break;
    }
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------

void UndoStack::PlayItem() {

  GFTRK("PlayItem");

  if(last_item) {

    UndoItem* item;

    // Don't save any new items while in Undo function
    undo_enabled = NO;

    // Find first of the batch items
    for(item = last_item; item->action & BATCH_MODE; item = item->prev);

    uint curr_row_num = thisrow;
    uint curr_col_num = col;
    if((item->action & PREV_LINE) and item->line->next)
      currline = item->line->next;
    else
      currline = item->line;
    editor->getthisrow(currline);

    int _maxrow = maxrow;
    if((item->action & PREV_LINE) and not item->line->next)
      _maxrow--;

    col = item->col.num;

    if(curr_row_num != thisrow) {

      // Let user to see the position before performing Undo, unless it's a
      // neighbour line and the same column.
      undo_ready = ((abs(int(curr_row_num - thisrow)) < 2) and ((curr_col_num == col) or (col+1 > currline->txt.length())));

      // Move cursor up or down depending on where the undo line is,
      // then refresh window if the line is invisible.
      do {
        if(curr_row_num > thisrow) {
          if(row > minrow)
            curr_row_num--, row--;
          else {
            editor->refresh(currline, row);
            break;
          }
        }
        else {
          if(row < _maxrow)
            curr_row_num++, row++;
          else {
            Line* l = currline;
            for(uint r = row; r; l = l->prev, r--) {}
            editor->refresh(l, minrow);
            break;
          }
        }
      } while(curr_row_num != thisrow);
    }
    else
      undo_ready = ((abs(int(curr_col_num - col)) < 2) or (col+1 > currline->txt.length()));

    uint _pcol = item->pcol;
    uint _prow = item->prow;

    if(undo_ready) {

      if((item->action & PREV_LINE) and not item->line->next) {
        row++; thisrow++; curr_row_num++;
      }

      bool in_batch;

      // Keep undoing until item with no BATCH_MODE flag is reached.
      do {

        uint undo_type = last_item->action & EDIT_UNDO_TYPE;
        uint undo_action = last_item->action & EDIT_UNDO_ACTION;
        in_batch = make_bool(last_item->action & BATCH_MODE);
        currline = last_item->line;

        if(last_item->action & PREV_LINE) {
          col = last_item->col.num = last_item->col.sav;
          if(row > minrow)
            row--;
        }

        switch(undo_type) {

          case EDIT_UNDO_CHAR:
            switch(undo_action) {
              case EDIT_UNDO_INS_CHAR:
                currline->txt.erase(last_item->col.num, 1);
                break;
              case EDIT_UNDO_DEL_CHAR:
                currline->txt.insert(last_item->col.num, 1, last_item->data.char_int);
                break;
              case EDIT_UNDO_OVR_CHAR:
                currline->txt[last_item->col.num] = last_item->data.char_int;
                break;
            }
            editor->setlinetype(currline);
            break;

          case EDIT_UNDO_TEXT: {
            text_item* text_data = last_item->data.text_ptr;
            std::string *txt = &currline->txt;
            switch(undo_action) {
              case EDIT_UNDO_DEL_TEXT:
                txt->insert(text_data->col, text_data->text, text_data->len);
                throw_delete(text_data);
                break;
              case EDIT_UNDO_CUT_TEXT:
                txt->erase(last_item->col.num);
                break;
              case EDIT_UNDO_WRAP_TEXT:
                txt->append(currline->next->txt.c_str()+text_data->col, text_data->len);
                txt = &currline->next->txt;
                // fall through...
              case EDIT_UNDO_INS_TEXT:
                txt->erase(text_data->col, text_data->len);
                throw_delete(text_data);
                break;
            }
            editor->setlinetype((undo_action == EDIT_UNDO_WRAP_TEXT) ? currline->next : currline);
            break;
          }

          case EDIT_UNDO_LINE: {
            Line* thisline = last_item->data.line_ptr;
            switch(undo_action) {
              case EDIT_UNDO_NEW_LINE:
                if(thisline->next)
                  thisline->next->prev = thisline->prev;
                if(thisline->prev) {
                  thisline->prev->next = thisline->next;
                  currline = thisline->prev;
                }
                else
                  currline = thisline->next;
                throw_xdelete(thisline);
                break;
              case EDIT_UNDO_ORPHAN_LINE:
                if(last_item->action & LAST_LINE) {
                  thisline->prev = currline;
                  thisline->next = currline ? currline->next : NULL;
                  if((row < maxrow) and currline)
                    row++;
                }
                else {
                  thisline->prev = currline ? currline->prev : NULL;
                  thisline->next = currline;
                }
                // fall through...
              case EDIT_UNDO_DEL_LINE:
                if(thisline->prev)
                  thisline->prev->next = thisline;
                if(thisline->next)
                  thisline->next->prev = thisline;
                currline = thisline;
                break;
              case EDIT_UNDO_PUSH_LINE:
                editor->UnDelete(make_bool_not(last_item->action & LAST_LINE));
                break;
              case EDIT_UNDO_POP_LINE:
                editor->DelLine();
                break;
            }
          }
        }

        _pcol = last_item->pcol;
        _prow = last_item->prow;
        delete last_item;

      } while(last_item and in_batch);

      undo_enabled = YES;

      editor->getthisrow(currline);
      uint temprow = row;
      Line *templine = currline;
      Line *topline = editor->findfirstline();

      int delta = _prow-thisrow;

      if(not in_range(row+delta, minrow, maxrow)) {

        // we need to fit thisrow into the screen boundaries
        if(delta > 0) {
          for(row += delta; row > maxrow; row--) {
            if(templine) // cause refresh() issue an error since templine should never be NULL
              templine = templine->prev;
          }
          temprow = maxrow;
        }
        else {
          for(row += delta; (int)row < (int)minrow; row++) {
            if(templine) // cause refresh() issue an error since templine should never be NULL
              templine = templine->next;
          }
          temprow = minrow;
        }

        // move pointer to the top of screen so we refresh scrolled area
        while (row != minrow) {
          if(templine) // cause refresh() issue an error since templine should never be NULL
            templine = templine->prev;
          --row;
        }
      }
      else {
        if(delta < 0) {
          templine = topline;
          for(thisrow=0; thisrow < _prow; thisrow++)
            if(templine) // cause refresh() issue an error if thisrow != _prow
              templine = templine->next;
        }
        temprow = row+delta;
      }

      // refresh screen
      editor->refresh(templine, row);

      // set cursor position
      thisrow = _prow;
      col = _pcol;
      row = temprow;
      // set currline according to thisrow
      currline = topline;
      for(thisrow=0; thisrow < _prow; thisrow++)
        if(currline)
          currline = currline->next;
    }
    // Move the cursor to EOL if necessary
    else if(col+1 > currline->txt.length())
      editor->GoEOL();
    undo_ready = YES;
  }

  GFTRK(NULL);
}


//  ------------------------------------------------------------------