src/editor/edit.c

   1 /*
   2    Editor low level data handling and cursor fundamentals.
   3
   4    Copyright (C) 1996, 1997, 1998, 2001, 2002, 2003, 2004, 2005, 2006,
   5    2007, 2008, 2009, 2010, 2011, 2012
   6    The Free Software Foundation, Inc.
   7
   8    Written by:
   9    Paul Sheer 1996, 1997
  10    Ilia Maslakov <il.smind@gmail.com> 2009, 2010, 2011
  11    Andrew Borodin <aborodin@vmail.ru> 2012.
  12
  13    This file is part of the Midnight Commander.
  14
  15    The Midnight Commander is free software: you can redistribute it
  16    and/or modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation, either version 3 of the License,
  18    or (at your option) any later version.
  19
  20    The Midnight Commander is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23    GNU General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  27  */
  28
  29 /** \file
  30  *  \brief Source: editor low level data handling and cursor fundamentals
  31  *  \author Paul Sheer
  32  *  \date 1996, 1997
  33  */
  34
  35 #include <config.h>
  36 #include <stdio.h>
  37 #include <stdarg.h>
  38 #include <sys/types.h>
  39 #include <unistd.h>
  40 #include <string.h>
  41 #include <ctype.h>
  42 #include <errno.h>
  43 #include <sys/stat.h>
  44 #include <stdlib.h>
  45 #include <fcntl.h>
  46
  47 #include "lib/global.h"
  48
  49 #include "lib/tty/color.h"
  50 #include "lib/tty/tty.h"        /* attrset() */
  51 #include "lib/tty/key.h"        /* is_idle() */
  52 #include "lib/skin.h"           /* EDITOR_NORMAL_COLOR */
  53 #include "lib/vfs/vfs.h"
  54 #include "lib/strutil.h"        /* utf string functions */
  55 #include "lib/util.h"           /* load_file_position(), save_file_position() */
  56 #include "lib/timefmt.h"        /* time formatting */
  57 #include "lib/lock.h"
  58 #include "lib/widget.h"
  59
  60 #ifdef HAVE_CHARSET
  61 #include "lib/charsets.h"       /* get_codepage_id */
  62 #endif
  63
  64 #include "src/filemanager/cmd.h"        /* view_other_cmd() */
  65 #include "src/filemanager/usermenu.h"   /* user_menu_cmd() */
  66
  67 #include "src/setup.h"          /* option_tab_spacing */
  68 #include "src/main.h"           /* macro_index */
  69 #include "src/learn.h"          /* learn_keys */
  70 #include "src/keybind-defaults.h"
  71
  72 #include "edit-impl.h"
  73 #include "editwidget.h"
  74
  75 /*** global variables ****************************************************************************/
  76
  77 int option_word_wrap_line_length = DEFAULT_WRAP_LINE_LENGTH;
  78 int option_typewriter_wrap = 0;
  79 int option_auto_para_formatting = 0;
  80 int option_fill_tabs_with_spaces = 0;
  81 int option_return_does_auto_indent = 1;
  82 int option_backspace_through_tabs = 0;
  83 int option_fake_half_tabs = 1;
  84 int option_save_mode = EDIT_QUICK_SAVE;
  85 int option_save_position = 1;
  86 int option_max_undo = 32768;
  87 int option_persistent_selections = 1;
  88 int option_cursor_beyond_eol = 0;
  89 int option_line_state = 0;
  90 int option_line_state_width = 0;
  91
  92 int option_edit_right_extreme = 0;
  93 int option_edit_left_extreme = 0;
  94 int option_edit_top_extreme = 0;
  95 int option_edit_bottom_extreme = 0;
  96 int enable_show_tabs_tws = 1;
  97 int option_check_nl_at_eof = 0;
  98 int option_group_undo = 0;
  99 int show_right_margin = 0;
 100
 101 const char *option_whole_chars_search = "0123456789abcdefghijklmnopqrstuvwxyz_";
 102 char *option_backup_ext = NULL;
 103
 104 unsigned int edit_stack_iterator = 0;
 105 edit_stack_type edit_history_moveto[MAX_HISTORY_MOVETO];
 106 /* magic sequense for say than block is vertical */
 107 const char VERTICAL_MAGIC[] = { '\1', '\1', '\1', '\1', '\n' };
 108
 109 /*** file scope macro definitions ****************************************************************/
 110
 111 #define TEMP_BUF_LEN 1024
 112
 113 #define space_width 1
 114
 115 /*** file scope type declarations ****************************************************************/
 116
 117 /*** file scope variables ************************************************************************/
 118
 119 /* detecting an error on save is easy: just check if every byte has been written. */
 120 /* detecting an error on read, is not so easy 'cos there is not way to tell
 121    whether you read everything or not. */
 122 /* FIXME: add proper `triple_pipe_open' to read, write and check errors. */
 123 static const struct edit_filters
 124 {
 125     const char *read, *write, *extension;
 126 } all_filters[] =
 127 {
 128     /* *INDENT-OFF* */
 129     { "xz -cd %s 2>&1", "xz > %s", ".xz"},
 130     { "lzma -cd %s 2>&1", "lzma > %s", ".lzma" },
 131     { "bzip2 -cd %s 2>&1", "bzip2 > %s", ".bz2" },
 132     { "gzip -cd %s 2>&1", "gzip > %s", ".gz" },
 133     { "gzip -cd %s 2>&1", "gzip > %s", ".Z" }
 134     /* *INDENT-ON* */
 135 };
 136
 137 static off_t last_bracket = -1;
 138
 139 /*** file scope functions ************************************************************************/
 140 /* --------------------------------------------------------------------------------------------- */
 141
 142 /*-
 143  *
 144  * here's a quick sketch of the layout: (don't run this through indent.)
 145  *
 146  * (b1 is buffers1 and b2 is buffers2)
 147  *
 148  *                                       |
 149  * \0\0\0\0\0m e _ f i l e . \nf i n . \n|T h i s _ i s _ s o\0\0\0\0\0\0\0\0\0
 150  * ______________________________________|______________________________________
 151  *                                       |
 152  * ...  |  b2[2]   |  b2[1]   |  b2[0]   |  b1[0]   |  b1[1]   |  b1[2]   | ...
 153  *      |->        |->        |->        |->        |->        |->        |
 154  *                                       |
 155  *           _<------------------------->|<----------------->_
 156  *                   WEdit->curs2        |   WEdit->curs1
 157  *           ^                           |                   ^
 158  *           |                          ^|^                  |
 159  *         cursor                       |||                cursor
 160  *                                      |||
 161  *                              file end|||file beginning
 162  *                                       |
 163  *                                       |
 164  *
 165  *           _
 166  * This_is_some_file
 167  * fin.
 168  */
 169
 170 /* --------------------------------------------------------------------------------------------- */
 171
 172 static void
 173 edit_about (void)
 174 {
 175     const char *header = N_("About");
 176     const char *button_name = N_("&OK");
 177     const char *const version = "MCEdit " VERSION;
 178     char text[BUF_LARGE];
 179
 180     int win_len, version_len, button_len;
 181     int cols, lines;
 182
 183     Dlg_head *about_dlg;
 184
 185 #ifdef ENABLE_NLS
 186     header = _(header);
 187     button_name = _(button_name);
 188 #endif
 189
 190     button_len = str_term_width1 (button_name) + 5;
 191     version_len = str_term_width1 (version);
 192
 193     g_snprintf (text, sizeof (text),
 194                 _("Copyright (C) 1996-2010 the Free Software Foundation\n\n"
 195                   "            A user friendly text editor\n"
 196                   "         written for the Midnight Commander"));
 197
 198     win_len = str_term_width1 (header);
 199     win_len = max (win_len, version_len);
 200     win_len = max (win_len, button_len);
 201
 202     /* count width and height of text */
 203     str_msg_term_size (text, &lines, &cols);
 204     lines += 9;
 205     cols = max (win_len, cols) + 6;
 206
 207     /* dialog */
 208     about_dlg = create_dlg (TRUE, 0, 0, lines, cols, dialog_colors, NULL,
 209                             "[Internal File Editor]", header, DLG_CENTER | DLG_TRYUP);
 210
 211     add_widget (about_dlg, label_new (3, (cols - version_len) / 2, version));
 212     add_widget (about_dlg, label_new (5, 3, text));
 213     add_widget (about_dlg, button_new (lines - 3, (cols - button_len) / 2,
 214                                        B_ENTER, NORMAL_BUTTON, button_name, NULL));
 215
 216     run_dlg (about_dlg);
 217     destroy_dlg (about_dlg);
 218 }
 219
 220 /* --------------------------------------------------------------------------------------------- */
 221 /**
 222  * Initialize the buffers for an empty files.
 223  */
 224
 225 static void
 226 edit_init_buffers (WEdit * edit)
 227 {
 228     int j;
 229
 230     for (j = 0; j <= MAXBUFF; j++)
 231     {
 232         edit->buffers1[j] = NULL;
 233         edit->buffers2[j] = NULL;
 234     }
 235
 236     edit->curs1 = 0;
 237     edit->curs2 = 0;
 238     edit->buffers2[0] = g_malloc0 (EDIT_BUF_SIZE);
 239 }
 240
 241 /* --------------------------------------------------------------------------------------------- */
 242
 243 /**
 244  * Load file OR text into buffers.  Set cursor to the beginning of file.
 245  *
 246  * @returns FALSE on error.
 247  */
 248
 249 static gboolean
 250 edit_load_file_fast (WEdit * edit, const vfs_path_t * filename_vpath)
 251 {
 252     off_t buf, buf2;
 253     int file = -1;
 254     gboolean ret = FALSE;
 255
 256     edit->curs2 = edit->last_byte;
 257     buf2 = edit->curs2 >> S_EDIT_BUF_SIZE;
 258
 259     file = mc_open (filename_vpath, O_RDONLY | O_BINARY);
 260     if (file == -1)
 261     {
 262         gchar *errmsg, *filename;
 263
 264         filename = vfs_path_to_str (filename_vpath);
 265         errmsg = g_strdup_printf (_("Cannot open %s for reading"), filename);
 266         g_free (filename);
 267         edit_error_dialog (_("Error"), errmsg);
 268         g_free (errmsg);
 269         return FALSE;
 270     }
 271
 272     if (!edit->buffers2[buf2])
 273         edit->buffers2[buf2] = g_malloc0 (EDIT_BUF_SIZE);
 274
 275     do
 276     {
 277         if (mc_read (file,
 278                      (char *) edit->buffers2[buf2] + EDIT_BUF_SIZE -
 279                      (edit->curs2 & M_EDIT_BUF_SIZE), edit->curs2 & M_EDIT_BUF_SIZE) < 0)
 280             break;
 281
 282         for (buf = buf2 - 1; buf >= 0; buf--)
 283         {
 284             /* edit->buffers2[0] is already allocated */
 285             if (!edit->buffers2[buf])
 286                 edit->buffers2[buf] = g_malloc0 (EDIT_BUF_SIZE);
 287             if (mc_read (file, (char *) edit->buffers2[buf], EDIT_BUF_SIZE) < 0)
 288                 break;
 289         }
 290         ret = TRUE;
 291     }
 292     while (FALSE);
 293
 294     if (!ret)
 295     {
 296         gchar *errmsg, *filename;
 297
 298         filename = vfs_path_to_str (filename_vpath);
 299         errmsg = g_strdup_printf (_("Error reading %s"), filename);
 300         g_free (filename);
 301         edit_error_dialog (_("Error"), errmsg);
 302         g_free (errmsg);
 303     }
 304     mc_close (file);
 305     return ret;
 306 }
 307
 308 /* --------------------------------------------------------------------------------------------- */
 309 /** Return index of the filter or -1 is there is no appropriate filter */
 310
 311 static int
 312 edit_find_filter (const vfs_path_t * filename_vpath)
 313 {
 314     size_t i, l, e;
 315     char *filename;
 316
 317     if (filename_vpath == NULL)
 318         return -1;
 319
 320     filename = vfs_path_to_str (filename_vpath);
 321     l = strlen (filename);
 322     for (i = 0; i < sizeof (all_filters) / sizeof (all_filters[0]); i++)
 323     {
 324         e = strlen (all_filters[i].extension);
 325         if (l > e)
 326             if (!strcmp (all_filters[i].extension, filename + l - e))
 327             {
 328                 g_free (filename);
 329                 return i;
 330             }
 331     }
 332     g_free (filename);
 333     return -1;
 334 }
 335
 336 /* --------------------------------------------------------------------------------------------- */
 337
 338 static char *
 339 edit_get_filter (const vfs_path_t * filename_vpath)
 340 {
 341     int i;
 342     char *p, *quoted_name, *filename;
 343
 344     i = edit_find_filter (filename_vpath);
 345     if (i < 0)
 346         return NULL;
 347
 348     filename = vfs_path_to_str (filename_vpath);
 349     quoted_name = name_quote (filename, 0);
 350     g_free (filename);
 351     p = g_strdup_printf (all_filters[i].read, quoted_name);
 352     g_free (quoted_name);
 353     return p;
 354 }
 355
 356 /* --------------------------------------------------------------------------------------------- */
 357
 358 static off_t
 359 edit_insert_stream (WEdit * edit, FILE * f)
 360 {
 361     int c;
 362     off_t i = 0;
 363     while ((c = fgetc (f)) >= 0)
 364     {
 365         edit_insert (edit, c);
 366         i++;
 367     }
 368     return i;
 369 }
 370
 371 /* --------------------------------------------------------------------------------------------- */
 372 /**
 373   * Open file and create it if necessary.
 374   *
 375   * @param edit           editor object
 376   * @param filename_vpath file name
 377   * @param st             buffer for store stat info
 378   * @returns TRUE for success, FALSE for error.
 379   */
 380
 381 static gboolean
 382 check_file_access (WEdit * edit, const vfs_path_t * filename_vpath, struct stat *st)
 383 {
 384     int file;
 385     gchar *errmsg = NULL;
 386
 387     /* Try opening an existing file */
 388     file = mc_open (filename_vpath, O_NONBLOCK | O_RDONLY | O_BINARY, 0666);
 389     if (file < 0)
 390     {
 391         /*
 392          * Try creating the file. O_EXCL prevents following broken links
 393          * and opening existing files.
 394          */
 395         file = mc_open (filename_vpath, O_NONBLOCK | O_RDONLY | O_BINARY | O_CREAT | O_EXCL, 0666);
 396         if (file < 0)
 397         {
 398             char *filename;
 399
 400             filename = vfs_path_to_str (filename_vpath);
 401             errmsg = g_strdup_printf (_("Cannot open %s for reading"), filename);
 402             g_free (filename);
 403             goto cleanup;
 404         }
 405
 406         /* New file, delete it if it's not modified or saved */
 407         edit->delete_file = 1;
 408     }
 409
 410     /* Check what we have opened */
 411     if (mc_fstat (file, st) < 0)
 412     {
 413         char *filename;
 414
 415         filename = vfs_path_to_str (filename_vpath);
 416         errmsg = g_strdup_printf (_("Cannot get size/permissions for %s"), filename);
 417         g_free (filename);
 418         goto cleanup;
 419     }
 420
 421     /* We want to open regular files only */
 422     if (!S_ISREG (st->st_mode))
 423     {
 424         char *filename;
 425
 426         filename = vfs_path_to_str (filename_vpath);
 427         errmsg = g_strdup_printf (_("\"%s\" is not a regular file"), filename);
 428         g_free (filename);
 429         goto cleanup;
 430     }
 431
 432     /*
 433      * Don't delete non-empty files.
 434      * O_EXCL should prevent it, but let's be on the safe side.
 435      */
 436     if (st->st_size > 0)
 437         edit->delete_file = 0;
 438
 439     if (st->st_size >= SIZE_LIMIT)
 440     {
 441         char *filename;
 442
 443         filename = vfs_path_to_str (filename_vpath);
 444         errmsg = g_strdup_printf (_("File \"%s\" is too large"), filename);
 445         g_free (filename);
 446     }
 447
 448   cleanup:
 449     (void) mc_close (file);
 450
 451     if (errmsg != NULL)
 452     {
 453         edit_error_dialog (_("Error"), errmsg);
 454         g_free (errmsg);
 455         return FALSE;
 456     }
 457     return TRUE;
 458 }
 459
 460 /* --------------------------------------------------------------------------------------------- */
 461
 462 /**
 463  * Open the file and load it into the buffers, either directly or using
 464  * a filter.  Return TRUE on success, FALSE on error.
 465  *
 466  * Fast loading (edit_load_file_fast) is used when the file size is
 467  * known.  In this case the data is read into the buffers by blocks.
 468  * If the file size is not known, the data is loaded byte by byte in
 469  * edit_insert_file.
 470  *
 471  * @param edit editor object
 472  * @return TRUE if file was successfully opened and loaded to buffers, FALSE otherwise
 473  */
 474 static gboolean
 475 edit_load_file (WEdit * edit)
 476 {
 477     gboolean fast_load = TRUE;
 478
 479     /* Cannot do fast load if a filter is used */
 480     if (edit_find_filter (edit->filename_vpath) >= 0)
 481         fast_load = FALSE;
 482
 483     /*
 484      * FIXME: line end translation should disable fast loading as well
 485      * Consider doing fseek() to the end and ftell() for the real size.
 486      */
 487     if (edit->filename_vpath != NULL)
 488     {
 489         /*
 490          * VFS may report file size incorrectly, and slow load is not a big
 491          * deal considering overhead in VFS.
 492          */
 493         if (!vfs_file_is_local (edit->filename_vpath))
 494             fast_load = FALSE;
 495
 496         /* If we are dealing with a real file, check that it exists */
 497         if (!check_file_access (edit, edit->filename_vpath, &edit->stat1))
 498             return FALSE;
 499     }
 500     else
 501     {
 502         /* nothing to load */
 503         fast_load = FALSE;
 504     }
 505
 506     edit_init_buffers (edit);
 507
 508     if (fast_load)
 509     {
 510         edit->last_byte = edit->stat1.st_size;
 511         edit_load_file_fast (edit, edit->filename_vpath);
 512         /* If fast load was used, the number of lines wasn't calculated */
 513         edit->total_lines = edit_count_lines (edit, 0, edit->last_byte);
 514     }
 515     else
 516     {
 517         edit->last_byte = 0;
 518         if (edit->filename_vpath != NULL
 519             && *(vfs_path_get_by_index (edit->filename_vpath, 0)->path) != '\0')
 520         {
 521             edit->undo_stack_disable = 1;
 522             if (edit_insert_file (edit, edit->filename_vpath) < 0)
 523             {
 524                 edit_clean (edit);
 525                 return FALSE;
 526             }
 527             edit->undo_stack_disable = 0;
 528         }
 529     }
 530     edit->lb = LB_ASIS;
 531     return TRUE;
 532 }
 533
 534 /* --------------------------------------------------------------------------------------------- */
 535 /** Restore saved cursor position in the file */
 536
 537 static void
 538 edit_load_position (WEdit * edit)
 539 {
 540     long line, column;
 541     off_t offset;
 542
 543     if (edit->filename_vpath == NULL
 544         || *(vfs_path_get_by_index (edit->filename_vpath, 0)->path) == '\0')
 545         return;
 546
 547     load_file_position (edit->filename_vpath, &line, &column, &offset, &edit->serialized_bookmarks);
 548
 549     if (line > 0)
 550     {
 551         edit_move_to_line (edit, line - 1);
 552         edit->prev_col = column;
 553     }
 554     else if (offset > 0)
 555     {
 556         edit_cursor_move (edit, offset);
 557         line = edit->curs_line;
 558         edit->search_start = edit->curs1;
 559     }
 560
 561     book_mark_restore (edit, BOOK_MARK_COLOR);
 562
 563     edit_move_to_prev_col (edit, edit_bol (edit, edit->curs1));
 564     edit_move_display (edit, line - (edit->widget.lines / 2));
 565 }
 566
 567 /* --------------------------------------------------------------------------------------------- */
 568 /** Save cursor position in the file */
 569
 570 static void
 571 edit_save_position (WEdit * edit)
 572 {
 573     if (edit->filename_vpath == NULL
 574         || *(vfs_path_get_by_index (edit->filename_vpath, 0)->path) == '\0')
 575         return;
 576
 577     book_mark_serialize (edit, BOOK_MARK_COLOR);
 578     save_file_position (edit->filename_vpath, edit->curs_line + 1, edit->curs_col, edit->curs1,
 579                         edit->serialized_bookmarks);
 580     edit->serialized_bookmarks = NULL;
 581 }
 582
 583 /* --------------------------------------------------------------------------------------------- */
 584 /** Clean the WEdit stricture except the widget part */
 585
 586 static void
 587 edit_purge_widget (WEdit * edit)
 588 {
 589     size_t len = sizeof (WEdit) - sizeof (Widget);
 590     char *start = (char *) edit + sizeof (Widget);
 591     memset (start, 0, len);
 592 }
 593
 594 /* --------------------------------------------------------------------------------------------- */
 595
 596 /*
 597    TODO: if the user undos until the stack bottom, and the stack has not wrapped,
 598    then the file should be as it was when he loaded up. Then set edit->modified to 0.
 599  */
 600
 601 static long
 602 edit_pop_undo_action (WEdit * edit)
 603 {
 604     long c;
 605     unsigned long sp = edit->undo_stack_pointer;
 606
 607     if (sp == edit->undo_stack_bottom)
 608         return STACK_BOTTOM;
 609
 610     sp = (sp - 1) & edit->undo_stack_size_mask;
 611     c = edit->undo_stack[sp];
 612     if (c >= 0)
 613     {
 614         /*      edit->undo_stack[sp] = '@'; */
 615         edit->undo_stack_pointer = (edit->undo_stack_pointer - 1) & edit->undo_stack_size_mask;
 616         return c;
 617     }
 618
 619     if (sp == edit->undo_stack_bottom)
 620         return STACK_BOTTOM;
 621
 622     c = edit->undo_stack[(sp - 1) & edit->undo_stack_size_mask];
 623     if (edit->undo_stack[sp] == -2)
 624     {
 625         /*      edit->undo_stack[sp] = '@'; */
 626         edit->undo_stack_pointer = sp;
 627     }
 628     else
 629         edit->undo_stack[sp]++;
 630
 631     return c;
 632 }
 633
 634 static long
 635 edit_pop_redo_action (WEdit * edit)
 636 {
 637     long c;
 638     unsigned long sp = edit->redo_stack_pointer;
 639
 640     if (sp == edit->redo_stack_bottom)
 641         return STACK_BOTTOM;
 642
 643     sp = (sp - 1) & edit->redo_stack_size_mask;
 644     c = edit->redo_stack[sp];
 645     if (c >= 0)
 646     {
 647         edit->redo_stack_pointer = (edit->redo_stack_pointer - 1) & edit->redo_stack_size_mask;
 648         return c;
 649     }
 650
 651     if (sp == edit->redo_stack_bottom)
 652         return STACK_BOTTOM;
 653
 654     c = edit->redo_stack[(sp - 1) & edit->redo_stack_size_mask];
 655     if (edit->redo_stack[sp] == -2)
 656         edit->redo_stack_pointer = sp;
 657     else
 658         edit->redo_stack[sp]++;
 659
 660     return c;
 661 }
 662
 663 static long
 664 get_prev_undo_action (WEdit * edit)
 665 {
 666     long c;
 667     unsigned long sp = edit->undo_stack_pointer;
 668
 669     if (sp == edit->undo_stack_bottom)
 670         return STACK_BOTTOM;
 671
 672     sp = (sp - 1) & edit->undo_stack_size_mask;
 673     c = edit->undo_stack[sp];
 674     if (c >= 0)
 675         return c;
 676
 677     if (sp == edit->undo_stack_bottom)
 678         return STACK_BOTTOM;
 679
 680     c = edit->undo_stack[(sp - 1) & edit->undo_stack_size_mask];
 681     return c;
 682 }
 683
 684 /* --------------------------------------------------------------------------------------------- */
 685 /** is called whenever a modification is made by one of the four routines below */
 686
 687 static void
 688 edit_modification (WEdit * edit)
 689 {
 690     edit->caches_valid = FALSE;
 691
 692     /* raise lock when file modified */
 693     if (!edit->modified && !edit->delete_file)
 694         edit->locked = lock_file (edit->filename_vpath);
 695     edit->modified = 1;
 696 }
 697
 698 /* --------------------------------------------------------------------------------------------- */
 699
 700 #ifdef HAVE_CHARSET
 701 static char *
 702 edit_get_byte_ptr (WEdit * edit, off_t byte_index)
 703 {
 704     if (byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0)
 705         return NULL;
 706
 707     if (byte_index >= edit->curs1)
 708     {
 709         off_t p;
 710
 711         p = edit->curs1 + edit->curs2 - byte_index - 1;
 712         return (char *) (edit->buffers2[p >> S_EDIT_BUF_SIZE] +
 713                          (EDIT_BUF_SIZE - (p & M_EDIT_BUF_SIZE) - 1));
 714     }
 715
 716     return (char *) (edit->buffers1[byte_index >> S_EDIT_BUF_SIZE] +
 717                      (byte_index & M_EDIT_BUF_SIZE));
 718 }
 719 #endif
 720
 721 /* --------------------------------------------------------------------------------------------- */
 722
 723 #ifdef HAVE_CHARSET
 724 static int
 725 edit_get_prev_utf (WEdit * edit, off_t byte_index, int *char_width)
 726 {
 727     int i, res;
 728     gchar utf8_buf[3 * UTF8_CHAR_LEN + 1];
 729     gchar *str;
 730     gchar *cursor_buf_ptr;
 731
 732     if (byte_index > (edit->curs1 + edit->curs2) || byte_index <= 0)
 733     {
 734         *char_width = 0;
 735         return 0;
 736     }
 737
 738     for (i = 0; i < (3 * UTF8_CHAR_LEN); i++)
 739         utf8_buf[i] = edit_get_byte (edit, byte_index + i - (2 * UTF8_CHAR_LEN));
 740     utf8_buf[3 * UTF8_CHAR_LEN] = '\0';
 741
 742     cursor_buf_ptr = utf8_buf + (2 * UTF8_CHAR_LEN);
 743     str = g_utf8_find_prev_char (utf8_buf, cursor_buf_ptr);
 744
 745     if (str == NULL || g_utf8_next_char (str) != cursor_buf_ptr)
 746     {
 747         *char_width = 1;
 748         return *(cursor_buf_ptr - 1);
 749     }
 750     else
 751     {
 752         res = g_utf8_get_char_validated (str, -1);
 753
 754         if (res < 0)
 755         {
 756             *char_width = 1;
 757             return *(cursor_buf_ptr - 1);
 758         }
 759         else
 760         {
 761             *char_width = cursor_buf_ptr - str;
 762             return res;
 763         }
 764     }
 765 }
 766 #endif
 767
 768 /* --------------------------------------------------------------------------------------------- */
 769
 770 static int
 771 edit_backspace (WEdit * edit, const int byte_delete)
 772 {
 773     int p = 0;
 774     int cw = 1;
 775     int i;
 776
 777     if (edit->curs1 == 0)
 778         return 0;
 779
 780     if (edit->mark2 != edit->mark1)
 781         edit_push_markers (edit);
 782
 783 #ifdef HAVE_CHARSET
 784     if (edit->utf8 && byte_delete == 0)
 785     {
 786         edit_get_prev_utf (edit, edit->curs1, &cw);
 787         if (cw < 1)
 788             cw = 1;
 789     }
 790 #else
 791     (void) byte_delete;
 792 #endif
 793
 794     for (i = 1; i <= cw; i++)
 795     {
 796         if (edit->mark1 >= edit->curs1)
 797         {
 798             edit->mark1--;
 799             edit->end_mark_curs--;
 800         }
 801         if (edit->mark2 >= edit->curs1)
 802             edit->mark2--;
 803         if (edit->last_get_rule >= edit->curs1)
 804             edit->last_get_rule--;
 805
 806         p = *(edit->buffers1[(edit->curs1 - 1) >> S_EDIT_BUF_SIZE] +
 807               ((edit->curs1 - 1) & M_EDIT_BUF_SIZE));
 808         if (((edit->curs1 - 1) & M_EDIT_BUF_SIZE) == 0)
 809         {
 810             g_free (edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE]);
 811             edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = NULL;
 812         }
 813         edit->last_byte--;
 814         edit->curs1--;
 815         edit_push_undo_action (edit, p);
 816     }
 817     edit_modification (edit);
 818     if (p == '\n')
 819     {
 820         book_mark_dec (edit, edit->curs_line);
 821         edit->curs_line--;
 822         edit->total_lines--;
 823         edit->force |= REDRAW_AFTER_CURSOR;
 824     }
 825
 826     if (edit->curs1 < edit->start_display)
 827     {
 828         edit->start_display--;
 829         if (p == '\n')
 830             edit->start_line--;
 831     }
 832
 833     return p;
 834 }
 835
 836 /* --------------------------------------------------------------------------------------------- */
 837 /* high level cursor movement commands */
 838 /* --------------------------------------------------------------------------------------------- */
 839 /** check whether cursor is in indent part of line
 840  *
 841  * @param edit editor object
 842  *
 843  * @return TRUE if cursor is in indent, FALSE otherwise
 844  */
 845
 846 static gboolean
 847 is_in_indent (WEdit * edit)
 848 {
 849     off_t p;
 850
 851     for (p = edit_bol (edit, edit->curs1); p < edit->curs1; p++)
 852         if (strchr (" \t", edit_get_byte (edit, p)) == NULL)
 853             return FALSE;
 854
 855     return TRUE;
 856 }
 857
 858 /* --------------------------------------------------------------------------------------------- */
 859 /** check whether line in editor is blank or not
 860  *
 861  * @param edit editor object
 862  * @param offset position in file
 863  *
 864  * @return TRUE if line in blank, FALSE otherwise
 865  */
 866
 867 static gboolean
 868 is_blank (WEdit * edit, off_t offset)
 869 {
 870     off_t s, f;
 871     int c;
 872
 873     s = edit_bol (edit, offset);
 874     f = edit_eol (edit, offset) - 1;
 875     while (s <= f)
 876     {
 877         c = edit_get_byte (edit, s++);
 878         if (!isspace (c))
 879             return FALSE;
 880     }
 881     return TRUE;
 882 }
 883
 884 /* --------------------------------------------------------------------------------------------- */
 885 /** returns the offset of line i */
 886
 887 static off_t
 888 edit_find_line (WEdit * edit, long line)
 889 {
 890     long i, j = 0;
 891     long m = 2000000000;        /* what is the magic number? */
 892
 893     if (!edit->caches_valid)
 894     {
 895         memset (edit->line_numbers, 0, sizeof (edit->line_numbers));
 896         memset (edit->line_offsets, 0, sizeof (edit->line_offsets));
 897         /* three offsets that we *know* are line 0 at 0 and these two: */
 898         edit->line_numbers[1] = edit->curs_line;
 899         edit->line_offsets[1] = edit_bol (edit, edit->curs1);
 900         edit->line_numbers[2] = edit->total_lines;
 901         edit->line_offsets[2] = edit_bol (edit, edit->last_byte);
 902         edit->caches_valid = TRUE;
 903     }
 904     if (line >= edit->total_lines)
 905         return edit->line_offsets[2];
 906     if (line <= 0)
 907         return 0;
 908     /* find the closest known point */
 909     for (i = 0; i < N_LINE_CACHES; i++)
 910     {
 911         long n;
 912
 913         n = abs (edit->line_numbers[i] - line);
 914         if (n < m)
 915         {
 916             m = n;
 917             j = i;
 918         }
 919     }
 920     if (m == 0)
 921         return edit->line_offsets[j];   /* know the offset exactly */
 922     if (m == 1 && j >= 3)
 923         i = j;                  /* one line different - caller might be looping, so stay in this cache */
 924     else
 925         i = 3 + (rand () % (N_LINE_CACHES - 3));
 926     if (line > edit->line_numbers[j])
 927         edit->line_offsets[i] =
 928             edit_move_forward (edit, edit->line_offsets[j], line - edit->line_numbers[j], 0);
 929     else
 930         edit->line_offsets[i] =
 931             edit_move_backward (edit, edit->line_offsets[j], edit->line_numbers[j] - line);
 932     edit->line_numbers[i] = line;
 933     return edit->line_offsets[i];
 934 }
 935
 936 /* --------------------------------------------------------------------------------------------- */
 937 /** moves up until a blank line is reached, or until just
 938    before a non-blank line is reached */
 939
 940 static void
 941 edit_move_up_paragraph (WEdit * edit, gboolean do_scroll)
 942 {
 943     long i = 0;
 944
 945     if (edit->curs_line > 1)
 946     {
 947         if (!line_is_blank (edit, edit->curs_line))
 948         {
 949             for (i = edit->curs_line - 1; i != 0; i--)
 950                 if (line_is_blank (edit, i))
 951                     break;
 952         }
 953         else if (line_is_blank (edit, edit->curs_line - 1))
 954         {
 955             for (i = edit->curs_line - 1; i != 0; i--)
 956                 if (!line_is_blank (edit, i))
 957                 {
 958                     i++;
 959                     break;
 960                 }
 961         }
 962         else
 963         {
 964             for (i = edit->curs_line - 1; i != 0; i--)
 965                 if (line_is_blank (edit, i))
 966                     break;
 967         }
 968     }
 969     edit_move_up (edit, edit->curs_line - i, do_scroll);
 970 }
 971
 972 /* --------------------------------------------------------------------------------------------- */
 973 /** moves down until a blank line is reached, or until just
 974    before a non-blank line is reached */
 975
 976 static void
 977 edit_move_down_paragraph (WEdit * edit, gboolean do_scroll)
 978 {
 979     long i;
 980
 981     if (edit->curs_line >= edit->total_lines - 1)
 982         i = edit->total_lines;
 983     else if (!line_is_blank (edit, edit->curs_line))
 984     {
 985         for (i = edit->curs_line + 1; i; i++)
 986             if (line_is_blank (edit, i) || i >= edit->total_lines)
 987                 break;
 988     }
 989     else if (line_is_blank (edit, edit->curs_line + 1))
 990     {
 991         for (i = edit->curs_line + 1; i; i++)
 992             if (!line_is_blank (edit, i) || i > edit->total_lines)
 993             {
 994                 i--;
 995                 break;
 996             }
 997     }
 998     else
 999     {
1000         for (i = edit->curs_line + 1; i; i++)
1001             if (line_is_blank (edit, i) || i >= edit->total_lines)
1002                 break;
1003     }
1004
1005     edit_move_down (edit, i - edit->curs_line, do_scroll);
1006 }
1007
1008 /* --------------------------------------------------------------------------------------------- */
1009
1010 static void
1011 edit_begin_page (WEdit * edit)
1012 {
1013     edit_update_curs_row (edit);
1014     edit_move_up (edit, edit->curs_row, 0);
1015 }
1016
1017 /* --------------------------------------------------------------------------------------------- */
1018
1019 static void
1020 edit_end_page (WEdit * edit)
1021 {
1022     edit_update_curs_row (edit);
1023     edit_move_down (edit, edit->widget.lines - edit->curs_row - 1, 0);
1024 }
1025
1026
1027 /* --------------------------------------------------------------------------------------------- */
1028 /** goto beginning of text */
1029
1030 static void
1031 edit_move_to_top (WEdit * edit)
1032 {
1033     if (edit->curs_line)
1034     {
1035         edit_cursor_move (edit, -edit->curs1);
1036         edit_move_to_prev_col (edit, 0);
1037         edit->force |= REDRAW_PAGE;
1038         edit->search_start = 0;
1039         edit_update_curs_row (edit);
1040     }
1041 }
1042
1043
1044 /* --------------------------------------------------------------------------------------------- */
1045 /** goto end of text */
1046
1047 static void
1048 edit_move_to_bottom (WEdit * edit)
1049 {
1050     if (edit->curs_line < edit->total_lines)
1051     {
1052         edit_move_down (edit, edit->total_lines - edit->curs_row, 0);
1053         edit->start_display = edit->last_byte;
1054         edit->start_line = edit->total_lines;
1055         edit_scroll_upward (edit, edit->widget.lines - 1);
1056         edit->force |= REDRAW_PAGE;
1057     }
1058 }
1059
1060 /* --------------------------------------------------------------------------------------------- */
1061 /** goto beginning of line */
1062
1063 static void
1064 edit_cursor_to_bol (WEdit * edit)
1065 {
1066     edit_cursor_move (edit, edit_bol (edit, edit->curs1) - edit->curs1);
1067     edit->search_start = edit->curs1;
1068     edit->prev_col = edit_get_col (edit);
1069     edit->over_col = 0;
1070 }
1071
1072 /* --------------------------------------------------------------------------------------------- */
1073 /** goto end of line */
1074
1075 static void
1076 edit_cursor_to_eol (WEdit * edit)
1077 {
1078     edit_cursor_move (edit, edit_eol (edit, edit->curs1) - edit->curs1);
1079     edit->search_start = edit->curs1;
1080     edit->prev_col = edit_get_col (edit);
1081     edit->over_col = 0;
1082 }
1083
1084 /* --------------------------------------------------------------------------------------------- */
1085
1086 static unsigned long
1087 my_type_of (int c)
1088 {
1089     int x, r = 0;
1090     const char *p, *q;
1091     const char option_chars_move_whole_word[] =
1092         "!=&|<>^~ !:;, !'!`!.?!\"!( !) !{ !} !Aa0 !+-*/= |<> ![ !] !\\#! ";
1093
1094     if (!c)
1095         return 0;
1096     if (c == '!')
1097     {
1098         if (*option_chars_move_whole_word == '!')
1099             return 2;
1100         return 0x80000000UL;
1101     }
1102     if (g_ascii_isupper ((gchar) c))
1103         c = 'A';
1104     else if (g_ascii_islower ((gchar) c))
1105         c = 'a';
1106     else if (g_ascii_isalpha (c))
1107         c = 'a';
1108     else if (isdigit (c))
1109         c = '0';
1110     else if (isspace (c))
1111         c = ' ';
1112     q = strchr (option_chars_move_whole_word, c);
1113     if (!q)
1114         return 0xFFFFFFFFUL;
1115     do
1116     {
1117         for (x = 1, p = option_chars_move_whole_word; p < q; p++)
1118             if (*p == '!')
1119                 x <<= 1;
1120         r |= x;
1121     }
1122     while ((q = strchr (q + 1, c)));
1123     return r;
1124 }
1125
1126 /* --------------------------------------------------------------------------------------------- */
1127
1128 static void
1129 edit_left_word_move (WEdit * edit, int s)
1130 {
1131     for (;;)
1132     {
1133         int c1, c2;
1134         if (edit->column_highlight
1135             && edit->mark1 != edit->mark2
1136             && edit->over_col == 0 && edit->curs1 == edit_bol (edit, edit->curs1))
1137             break;
1138         edit_cursor_move (edit, -1);
1139         if (!edit->curs1)
1140             break;
1141         c1 = edit_get_byte (edit, edit->curs1 - 1);
1142         c2 = edit_get_byte (edit, edit->curs1);
1143         if (c1 == '\n' || c2 == '\n')
1144             break;
1145         if ((my_type_of (c1) & my_type_of (c2)) == 0)
1146             break;
1147         if (isspace (c1) && !isspace (c2))
1148             break;
1149         if (s)
1150             if (!isspace (c1) && isspace (c2))
1151                 break;
1152     }
1153 }
1154
1155 /* --------------------------------------------------------------------------------------------- */
1156
1157 static void
1158 edit_left_word_move_cmd (WEdit * edit)
1159 {
1160     edit_left_word_move (edit, 0);
1161     edit->force |= REDRAW_PAGE;
1162 }
1163
1164 /* --------------------------------------------------------------------------------------------- */
1165
1166 static void
1167 edit_right_word_move (WEdit * edit, int s)
1168 {
1169     for (;;)
1170     {
1171         int c1, c2;
1172         if (edit->column_highlight
1173             && edit->mark1 != edit->mark2
1174             && edit->over_col == 0 && edit->curs1 == edit_eol (edit, edit->curs1))
1175             break;
1176         edit_cursor_move (edit, 1);
1177         if (edit->curs1 >= edit->last_byte)
1178             break;
1179         c1 = edit_get_byte (edit, edit->curs1 - 1);
1180         c2 = edit_get_byte (edit, edit->curs1);
1181         if (c1 == '\n' || c2 == '\n')
1182             break;
1183         if ((my_type_of (c1) & my_type_of (c2)) == 0)
1184             break;
1185         if (isspace (c1) && !isspace (c2))
1186             break;
1187         if (s)
1188             if (!isspace (c1) && isspace (c2))
1189                 break;
1190     }
1191 }
1192
1193 /* --------------------------------------------------------------------------------------------- */
1194
1195 static void
1196 edit_right_word_move_cmd (WEdit * edit)
1197 {
1198     edit_right_word_move (edit, 0);
1199     edit->force |= REDRAW_PAGE;
1200 }
1201
1202 /* --------------------------------------------------------------------------------------------- */
1203
1204 static void
1205 edit_right_char_move_cmd (WEdit * edit)
1206 {
1207     int cw = 1;
1208     int c = 0;
1209
1210 #ifdef HAVE_CHARSET
1211     if (edit->utf8)
1212     {
1213         c = edit_get_utf (edit, edit->curs1, &cw);
1214         if (cw < 1)
1215             cw = 1;
1216     }
1217     else
1218 #endif
1219     {
1220         c = edit_get_byte (edit, edit->curs1);
1221     }
1222     if (option_cursor_beyond_eol && c == '\n')
1223     {
1224         edit->over_col++;
1225     }
1226     else
1227     {
1228         edit_cursor_move (edit, cw);
1229     }
1230 }
1231
1232 /* --------------------------------------------------------------------------------------------- */
1233
1234 static void
1235 edit_left_char_move_cmd (WEdit * edit)
1236 {
1237     int cw = 1;
1238
1239     if (edit->column_highlight
1240         && option_cursor_beyond_eol
1241         && edit->mark1 != edit->mark2
1242         && edit->over_col == 0 && edit->curs1 == edit_bol (edit, edit->curs1))
1243         return;
1244
1245 #ifdef HAVE_CHARSET
1246     if (edit->utf8)
1247     {
1248         edit_get_prev_utf (edit, edit->curs1, &cw);
1249         if (cw < 1)
1250             cw = 1;
1251     }
1252 #endif
1253     if (option_cursor_beyond_eol && edit->over_col > 0)
1254     {
1255         edit->over_col--;
1256     }
1257     else
1258     {
1259         edit_cursor_move (edit, -cw);
1260     }
1261 }
1262
1263 /* --------------------------------------------------------------------------------------------- */
1264 /** Up or down cursor moving.
1265  direction = TRUE - move up
1266            = FALSE - move down
1267 */
1268
1269 static void
1270 edit_move_updown (WEdit * edit, long lines, gboolean do_scroll, gboolean direction)
1271 {
1272     long p;
1273     long l = direction ? edit->curs_line : edit->total_lines - edit->curs_line;
1274
1275     if (lines > l)
1276         lines = l;
1277
1278     if (lines == 0)
1279         return;
1280
1281     if (lines > 1)
1282         edit->force |= REDRAW_PAGE;
1283     if (do_scroll)
1284     {
1285         if (direction)
1286             edit_scroll_upward (edit, lines);
1287         else
1288             edit_scroll_downward (edit, lines);
1289     }
1290     p = edit_bol (edit, edit->curs1);
1291
1292     p = direction ? edit_move_backward (edit, p, lines) : edit_move_forward (edit, p, lines, 0);
1293
1294     edit_cursor_move (edit, p - edit->curs1);
1295
1296     edit_move_to_prev_col (edit, p);
1297
1298     /* search start of current multibyte char (like CJK) */
1299     if (edit->curs1 + 1 < edit->last_byte)
1300     {
1301         edit_right_char_move_cmd (edit);
1302         edit_left_char_move_cmd (edit);
1303     }
1304
1305     edit->search_start = edit->curs1;
1306     edit->found_len = 0;
1307 }
1308
1309 /* --------------------------------------------------------------------------------------------- */
1310
1311 static void
1312 edit_right_delete_word (WEdit * edit)
1313 {
1314     int c1, c2;
1315     for (;;)
1316     {
1317         if (edit->curs1 >= edit->last_byte)
1318             break;
1319         c1 = edit_delete (edit, 1);
1320         c2 = edit_get_byte (edit, edit->curs1);
1321         if (c1 == '\n' || c2 == '\n')
1322             break;
1323         if ((isspace (c1) == 0) != (isspace (c2) == 0))
1324             break;
1325         if ((my_type_of (c1) & my_type_of (c2)) == 0)
1326             break;
1327     }
1328 }
1329
1330 /* --------------------------------------------------------------------------------------------- */
1331
1332 static void
1333 edit_left_delete_word (WEdit * edit)
1334 {
1335     int c1, c2;
1336     for (;;)
1337     {
1338         if (edit->curs1 <= 0)
1339             break;
1340         c1 = edit_backspace (edit, 1);
1341         c2 = edit_get_byte (edit, edit->curs1 - 1);
1342         if (c1 == '\n' || c2 == '\n')
1343             break;
1344         if ((isspace (c1) == 0) != (isspace (c2) == 0))
1345             break;
1346         if ((my_type_of (c1) & my_type_of (c2)) == 0)
1347             break;
1348     }
1349 }
1350
1351 /* --------------------------------------------------------------------------------------------- */
1352 /**
1353    the start column position is not recorded, and hence does not
1354    undo as it happed. But who would notice.
1355  */
1356
1357 static void
1358 edit_do_undo (WEdit * edit)
1359 {
1360     long ac;
1361     long count = 0;
1362
1363     edit->undo_stack_disable = 1;       /* don't record undo's onto undo stack! */
1364     edit->over_col = 0;
1365     while ((ac = edit_pop_undo_action (edit)) < KEY_PRESS)
1366     {
1367         switch ((int) ac)
1368         {
1369         case STACK_BOTTOM:
1370             goto done_undo;
1371         case CURS_RIGHT:
1372             edit_cursor_move (edit, 1);
1373             break;
1374         case CURS_LEFT:
1375             edit_cursor_move (edit, -1);
1376             break;
1377         case BACKSPACE:
1378         case BACKSPACE_BR:
1379             edit_backspace (edit, 1);
1380             break;
1381         case DELCHAR:
1382         case DELCHAR_BR:
1383             edit_delete (edit, 1);
1384             break;
1385         case COLUMN_ON:
1386             edit->column_highlight = 1;
1387             break;
1388         case COLUMN_OFF:
1389             edit->column_highlight = 0;
1390             break;
1391         }
1392         if (ac >= 256 && ac < 512)
1393             edit_insert_ahead (edit, ac - 256);
1394         if (ac >= 0 && ac < 256)
1395             edit_insert (edit, ac);
1396
1397         if (ac >= MARK_1 - 2 && ac < MARK_2 - 2)
1398         {
1399             edit->mark1 = ac - MARK_1;
1400             edit->column1 =
1401                 (long) edit_move_forward3 (edit, edit_bol (edit, edit->mark1), 0, edit->mark1);
1402         }
1403         if (ac >= MARK_2 - 2 && ac < MARK_CURS - 2)
1404         {
1405             edit->mark2 = ac - MARK_2;
1406             edit->column2 =
1407                 (long) edit_move_forward3 (edit, edit_bol (edit, edit->mark2), 0, edit->mark2);
1408         }
1409         else if (ac >= MARK_CURS - 2 && ac < KEY_PRESS)
1410         {
1411             edit->end_mark_curs = ac - MARK_CURS;
1412         }
1413         if (count++)
1414             edit->force |= REDRAW_PAGE; /* more than one pop usually means something big */
1415     }
1416
1417     if (edit->start_display > ac - KEY_PRESS)
1418     {
1419         edit->start_line -= edit_count_lines (edit, ac - KEY_PRESS, edit->start_display);
1420         edit->force |= REDRAW_PAGE;
1421     }
1422     else if (edit->start_display < ac - KEY_PRESS)
1423     {
1424         edit->start_line += edit_count_lines (edit, edit->start_display, ac - KEY_PRESS);
1425         edit->force |= REDRAW_PAGE;
1426     }
1427     edit->start_display = ac - KEY_PRESS;       /* see push and pop above */
1428     edit_update_curs_row (edit);
1429
1430   done_undo:
1431     edit->undo_stack_disable = 0;
1432 }
1433
1434 /* --------------------------------------------------------------------------------------------- */
1435
1436 static void
1437 edit_do_redo (WEdit * edit)
1438 {
1439     long ac;
1440     long count = 0;
1441
1442     if (edit->redo_stack_reset)
1443         return;
1444
1445     edit->over_col = 0;
1446     while ((ac = edit_pop_redo_action (edit)) < KEY_PRESS)
1447     {
1448         switch ((int) ac)
1449         {
1450         case STACK_BOTTOM:
1451             goto done_redo;
1452         case CURS_RIGHT:
1453             edit_cursor_move (edit, 1);
1454             break;
1455         case CURS_LEFT:
1456             edit_cursor_move (edit, -1);
1457             break;
1458         case BACKSPACE:
1459             edit_backspace (edit, 1);
1460             break;
1461         case DELCHAR:
1462             edit_delete (edit, 1);
1463             break;
1464         case COLUMN_ON:
1465             edit->column_highlight = 1;
1466             break;
1467         case COLUMN_OFF:
1468             edit->column_highlight = 0;
1469             break;
1470         }
1471         if (ac >= 256 && ac < 512)
1472             edit_insert_ahead (edit, ac - 256);
1473         if (ac >= 0 && ac < 256)
1474             edit_insert (edit, ac);
1475
1476         if (ac >= MARK_1 - 2 && ac < MARK_2 - 2)
1477         {
1478             edit->mark1 = ac - MARK_1;
1479             edit->column1 =
1480                 (long) edit_move_forward3 (edit, edit_bol (edit, edit->mark1), 0, edit->mark1);
1481         }
1482         else if (ac >= MARK_2 - 2 && ac < KEY_PRESS)
1483         {
1484             edit->mark2 = ac - MARK_2;
1485             edit->column2 =
1486                 (long) edit_move_forward3 (edit, edit_bol (edit, edit->mark2), 0, edit->mark2);
1487         }
1488         /* more than one pop usually means something big */
1489         if (count++)
1490             edit->force |= REDRAW_PAGE;
1491     }
1492
1493     if (edit->start_display > ac - KEY_PRESS)
1494     {
1495         edit->start_line -= edit_count_lines (edit, ac - KEY_PRESS, edit->start_display);
1496         edit->force |= REDRAW_PAGE;
1497     }
1498     else if (edit->start_display < ac - KEY_PRESS)
1499     {
1500         edit->start_line += edit_count_lines (edit, edit->start_display, ac - KEY_PRESS);
1501         edit->force |= REDRAW_PAGE;
1502     }
1503     edit->start_display = ac - KEY_PRESS;       /* see push and pop above */
1504     edit_update_curs_row (edit);
1505
1506   done_redo:
1507     ;
1508 }
1509
1510 /* --------------------------------------------------------------------------------------------- */
1511
1512 static void
1513 edit_group_undo (WEdit * edit)
1514 {
1515     long ac = KEY_PRESS;
1516     long cur_ac = KEY_PRESS;
1517     while (ac != STACK_BOTTOM && ac == cur_ac)
1518     {
1519         cur_ac = get_prev_undo_action (edit);
1520         edit_do_undo (edit);
1521         ac = get_prev_undo_action (edit);
1522         /* exit from cycle if option_group_undo is not set,
1523          * and make single UNDO operation
1524          */
1525         if (!option_group_undo)
1526             ac = STACK_BOTTOM;
1527     }
1528 }
1529
1530 /* --------------------------------------------------------------------------------------------- */
1531
1532 static void
1533 edit_delete_to_line_end (WEdit * edit)
1534 {
1535     while (edit_get_byte (edit, edit->curs1) != '\n' && edit->curs2 != 0)
1536         edit_delete (edit, 1);
1537 }
1538
1539 /* --------------------------------------------------------------------------------------------- */
1540
1541 static void
1542 edit_delete_to_line_begin (WEdit * edit)
1543 {
1544     while (edit_get_byte (edit, edit->curs1 - 1) != '\n' && edit->curs1 != 0)
1545         edit_backspace (edit, 1);
1546 }
1547
1548 /* --------------------------------------------------------------------------------------------- */
1549
1550 static gboolean
1551 is_aligned_on_a_tab (WEdit * edit)
1552 {
1553     long curs_col;
1554
1555     edit_update_curs_col (edit);
1556     curs_col = edit->curs_col % (TAB_SIZE * space_width);
1557     return (curs_col == 0 || curs_col == (HALF_TAB_SIZE * space_width));
1558 }
1559
1560 /* --------------------------------------------------------------------------------------------- */
1561
1562 static gboolean
1563 right_of_four_spaces (WEdit * edit)
1564 {
1565     int i, ch = 0;
1566
1567     for (i = 1; i <= HALF_TAB_SIZE; i++)
1568         ch |= edit_get_byte (edit, edit->curs1 - i);
1569
1570     return (ch == ' ' && is_aligned_on_a_tab (edit));
1571 }
1572
1573 /* --------------------------------------------------------------------------------------------- */
1574
1575 static gboolean
1576 left_of_four_spaces (WEdit * edit)
1577 {
1578     int i, ch = 0;
1579
1580     for (i = 0; i < HALF_TAB_SIZE; i++)
1581         ch |= edit_get_byte (edit, edit->curs1 + i);
1582
1583     return (ch == ' ' && is_aligned_on_a_tab (edit));
1584 }
1585
1586 /* --------------------------------------------------------------------------------------------- */
1587
1588 static void
1589 edit_auto_indent (WEdit * edit)
1590 {
1591     off_t p;
1592     char c;
1593     p = edit->curs1;
1594     /* use the previous line as a template */
1595     p = edit_move_backward (edit, p, 1);
1596     /* copy the leading whitespace of the line */
1597     for (;;)
1598     {                           /* no range check - the line _is_ \n-terminated */
1599         c = edit_get_byte (edit, p++);
1600         if (c != ' ' && c != '\t')
1601             break;
1602         edit_insert (edit, c);
1603     }
1604 }
1605
1606 /* --------------------------------------------------------------------------------------------- */
1607
1608 static inline void
1609 edit_double_newline (WEdit * edit)
1610 {
1611     edit_insert (edit, '\n');
1612     if (edit_get_byte (edit, edit->curs1) == '\n' || edit_get_byte (edit, edit->curs1 - 2) == '\n')
1613         return;
1614     edit->force |= REDRAW_PAGE;
1615     edit_insert (edit, '\n');
1616 }
1617
1618
1619 /* --------------------------------------------------------------------------------------------- */
1620
1621 static void
1622 insert_spaces_tab (WEdit * edit, gboolean half)
1623 {
1624     long i;
1625
1626     edit_update_curs_col (edit);
1627     i = option_tab_spacing * space_width;
1628     if (half)
1629         i /= 2;
1630     i = ((edit->curs_col / i) + 1) * i - edit->curs_col;
1631     while (i > 0)
1632     {
1633         edit_insert (edit, ' ');
1634         i -= space_width;
1635     }
1636 }
1637
1638 /* --------------------------------------------------------------------------------------------- */
1639
1640 static inline void
1641 edit_tab_cmd (WEdit * edit)
1642 {
1643     if (option_fake_half_tabs && is_in_indent (edit))
1644     {
1645         /*insert a half tab (usually four spaces) unless there is a
1646            half tab already behind, then delete it and insert a
1647            full tab. */
1648         if (option_fill_tabs_with_spaces || !right_of_four_spaces (edit))
1649             insert_spaces_tab (edit, TRUE);
1650         else
1651         {
1652             int i;
1653
1654             for (i = 1; i <= HALF_TAB_SIZE; i++)
1655                 edit_backspace (edit, 1);
1656             edit_insert (edit, '\t');
1657         }
1658     }
1659     else if (option_fill_tabs_with_spaces)
1660         insert_spaces_tab (edit, FALSE);
1661     else
1662         edit_insert (edit, '\t');
1663 }
1664
1665 /* --------------------------------------------------------------------------------------------- */
1666
1667 static void
1668 check_and_wrap_line (WEdit * edit)
1669 {
1670     off_t curs;
1671     int c;
1672
1673     if (!option_typewriter_wrap)
1674         return;
1675     edit_update_curs_col (edit);
1676     if (edit->curs_col < option_word_wrap_line_length)
1677         return;
1678     curs = edit->curs1;
1679     for (;;)
1680     {
1681         curs--;
1682         c = edit_get_byte (edit, curs);
1683         if (c == '\n' || curs <= 0)
1684         {
1685             edit_insert (edit, '\n');
1686             return;
1687         }
1688         if (c == ' ' || c == '\t')
1689         {
1690             off_t current = edit->curs1;
1691             edit_cursor_move (edit, curs - edit->curs1 + 1);
1692             edit_insert (edit, '\n');
1693             edit_cursor_move (edit, current - edit->curs1 + 1);
1694             return;
1695         }
1696     }
1697 }
1698
1699 /* --------------------------------------------------------------------------------------------- */
1700 /** this find the matching bracket in either direction, and sets edit->bracket
1701  *
1702  * @param edit editor object
1703  * @param in_screen seach only on the current screen
1704  * @param furthest_bracket_search count of the bytes for search
1705  *
1706  * @return position of the found bracket (-1 if no match)
1707  */
1708
1709 static off_t
1710 edit_get_bracket (WEdit * edit, gboolean in_screen, unsigned long furthest_bracket_search)
1711 {
1712     const char *const b = "{}{[][()(", *p;
1713     int i = 1, a, inc = -1, c, d, n = 0;
1714     unsigned long j = 0;
1715     off_t q;
1716     edit_update_curs_row (edit);
1717     c = edit_get_byte (edit, edit->curs1);
1718     p = strchr (b, c);
1719     /* no limit */
1720     if (!furthest_bracket_search)
1721         furthest_bracket_search--;
1722     /* not on a bracket at all */
1723     if (p == NULL)
1724         return -1;
1725     /* the matching bracket */
1726     d = p[1];
1727     /* going left or right? */
1728     if (strchr ("{[(", c))
1729         inc = 1;
1730     for (q = edit->curs1 + inc;; q += inc)
1731     {
1732         /* out of buffer? */
1733         if (q >= edit->last_byte || q < 0)
1734             break;
1735         a = edit_get_byte (edit, q);
1736         /* don't want to eat CPU */
1737         if (j++ > furthest_bracket_search)
1738             break;
1739         /* out of screen? */
1740         if (in_screen)
1741         {
1742             if (q < edit->start_display)
1743                 break;
1744             /* count lines if searching downward */
1745             if (inc > 0 && a == '\n')
1746                 if (n++ >= edit->widget.lines - edit->curs_row) /* out of screen */
1747                     break;
1748         }
1749         /* count bracket depth */
1750         i += (a == c) - (a == d);
1751         /* return if bracket depth is zero */
1752         if (i == 0)
1753             return q;
1754     }
1755     /* no match */
1756     return -1;
1757 }
1758
1759 /* --------------------------------------------------------------------------------------------- */
1760
1761 static inline void
1762 edit_goto_matching_bracket (WEdit * edit)
1763 {
1764     off_t q;
1765
1766     q = edit_get_bracket (edit, 0, 0);
1767     if (q >= 0)
1768     {
1769         edit->bracket = edit->curs1;
1770         edit->force |= REDRAW_PAGE;
1771         edit_cursor_move (edit, q - edit->curs1);
1772     }
1773 }
1774
1775 /* --------------------------------------------------------------------------------------------- */
1776
1777 static void
1778 edit_move_block_to_right (WEdit * edit)
1779 {
1780     off_t start_mark, end_mark;
1781     long cur_bol, start_bol;
1782
1783     if (eval_marks (edit, &start_mark, &end_mark))
1784         return;
1785
1786     start_bol = edit_bol (edit, start_mark);
1787     cur_bol = edit_bol (edit, end_mark - 1);
1788
1789     do
1790     {
1791         edit_cursor_move (edit, cur_bol - edit->curs1);
1792         if (!line_is_blank (edit, edit->curs_line))
1793         {
1794             if (option_fill_tabs_with_spaces)
1795                 insert_spaces_tab (edit, option_fake_half_tabs);
1796             else
1797                 edit_insert (edit, '\t');
1798             edit_cursor_move (edit, edit_bol (edit, cur_bol) - edit->curs1);
1799         }
1800
1801         if (cur_bol == 0)
1802             break;
1803
1804         cur_bol = edit_bol (edit, cur_bol - 1);
1805     }
1806     while (cur_bol >= start_bol);
1807
1808     edit->force |= REDRAW_PAGE;
1809 }
1810
1811 /* --------------------------------------------------------------------------------------------- */
1812
1813 static void
1814 edit_move_block_to_left (WEdit * edit)
1815 {
1816     off_t start_mark, end_mark;
1817     off_t cur_bol, start_bol;
1818     int i;
1819
1820     if (eval_marks (edit, &start_mark, &end_mark))
1821         return;
1822
1823     start_bol = edit_bol (edit, start_mark);
1824     cur_bol = edit_bol (edit, end_mark - 1);
1825
1826     do
1827     {
1828         int del_tab_width;
1829         int next_char;
1830
1831         edit_cursor_move (edit, cur_bol - edit->curs1);
1832
1833         if (option_fake_half_tabs)
1834             del_tab_width = HALF_TAB_SIZE;
1835         else
1836             del_tab_width = option_tab_spacing;
1837
1838         next_char = edit_get_byte (edit, edit->curs1);
1839         if (next_char == '\t')
1840             edit_delete (edit, 1);
1841         else if (next_char == ' ')
1842             for (i = 1; i <= del_tab_width; i++)
1843             {
1844                 if (next_char == ' ')
1845                     edit_delete (edit, 1);
1846                 next_char = edit_get_byte (edit, edit->curs1);
1847             }
1848
1849         if (cur_bol == 0)
1850             break;
1851
1852         cur_bol = edit_bol (edit, cur_bol - 1);
1853     }
1854     while (cur_bol >= start_bol);
1855
1856     edit->force |= REDRAW_PAGE;
1857 }
1858
1859 /* --------------------------------------------------------------------------------------------- */
1860 /**
1861  * prints at the cursor
1862  * @returns the number of chars printed
1863  */
1864
1865 static size_t
1866 edit_print_string (WEdit * e, const char *s)
1867 {
1868     size_t i = 0;
1869
1870     while (s[i] != '\0')
1871         edit_execute_cmd (e, CK_InsertChar, (unsigned char) s[i++]);
1872     e->force |= REDRAW_COMPLETELY;
1873     edit_update_screen (e);
1874     return i;
1875 }
1876
1877 /* --------------------------------------------------------------------------------------------- */
1878 /*** public functions ****************************************************************************/
1879 /* --------------------------------------------------------------------------------------------- */
1880
1881 /** User edit menu, like user menu (F2) but only in editor. */
1882
1883 void
1884 user_menu (WEdit * edit, const char *menu_file, int selected_entry)
1885 {
1886     char *block_file;
1887     int nomark;
1888     off_t curs;
1889     off_t start_mark, end_mark;
1890     struct stat status;
1891     vfs_path_t *block_file_vpath;
1892
1893     block_file = mc_config_get_full_path (EDIT_BLOCK_FILE);
1894     block_file_vpath = vfs_path_from_str (block_file);
1895     curs = edit->curs1;
1896     nomark = eval_marks (edit, &start_mark, &end_mark);
1897     if (nomark == 0)
1898         edit_save_block (edit, block_file, start_mark, end_mark);
1899
1900     /* run shell scripts from menu */
1901     if (user_menu_cmd (edit, menu_file, selected_entry)
1902         && (mc_stat (block_file_vpath, &status) == 0) && (status.st_size != 0))
1903     {
1904         int rc = 0;
1905         FILE *fd;
1906
1907         /* i.e. we have marked block */
1908         if (nomark == 0)
1909             rc = edit_block_delete_cmd (edit);
1910
1911         if (rc == 0)
1912         {
1913             off_t ins_len;
1914
1915             ins_len = edit_insert_file (edit, block_file_vpath);
1916             if (nomark == 0 && ins_len > 0)
1917                 edit_set_markers (edit, start_mark, start_mark + ins_len, 0, 0);
1918         }
1919         /* truncate block file */
1920         fd = fopen (block_file, "w");
1921         if (fd != NULL)
1922             fclose (fd);
1923     }
1924     edit_cursor_move (edit, curs - edit->curs1);
1925     edit_refresh_cmd (edit);
1926     edit->force |= REDRAW_COMPLETELY;
1927
1928     g_free (block_file);
1929     vfs_path_free (block_file_vpath);
1930 }
1931
1932 /* --------------------------------------------------------------------------------------------- */
1933
1934 int
1935 edit_get_byte (WEdit * edit, off_t byte_index)
1936 {
1937     off_t p;
1938
1939     if (byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0)
1940         return '\n';
1941
1942     if (byte_index >= edit->curs1)
1943     {
1944         p = edit->curs1 + edit->curs2 - byte_index - 1;
1945         return edit->buffers2[p >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE - (p & M_EDIT_BUF_SIZE) - 1];
1946     }
1947
1948     return edit->buffers1[byte_index >> S_EDIT_BUF_SIZE][byte_index & M_EDIT_BUF_SIZE];
1949 }
1950
1951 /* --------------------------------------------------------------------------------------------- */
1952
1953 #ifdef HAVE_CHARSET
1954 int
1955 edit_get_utf (WEdit * edit, off_t byte_index, int *char_width)
1956 {
1957     gchar *str = NULL;
1958     int res = -1;
1959     gunichar ch;
1960     gchar *next_ch = NULL;
1961     int width = 0;
1962     gchar utf8_buf[UTF8_CHAR_LEN + 1];
1963
1964     if (byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0)
1965     {
1966         *char_width = 0;
1967         return '\n';
1968     }
1969
1970     str = edit_get_byte_ptr (edit, byte_index);
1971
1972     if (str == NULL)
1973     {
1974         *char_width = 0;
1975         return 0;
1976     }
1977
1978     res = g_utf8_get_char_validated (str, -1);
1979
1980     if (res < 0)
1981     {
1982         /* Retry with explicit bytes to make sure it's not a buffer boundary */
1983         int i;
1984         for (i = 0; i < UTF8_CHAR_LEN; i++)
1985             utf8_buf[i] = edit_get_byte (edit, byte_index + i);
1986         utf8_buf[UTF8_CHAR_LEN] = '\0';
1987         str = utf8_buf;
1988         res = g_utf8_get_char_validated (str, -1);
1989     }
1990
1991     if (res < 0)
1992     {
1993         ch = *str;
1994         width = 0;
1995     }
1996     else
1997     {
1998         ch = res;
1999         /* Calculate UTF-8 char width */
2000         next_ch = g_utf8_next_char (str);
2001         if (next_ch)
2002         {
2003             width = next_ch - str;
2004         }
2005         else
2006         {
2007             ch = 0;
2008             width = 0;
2009         }
2010     }
2011     *char_width = width;
2012     return ch;
2013 }
2014 #endif
2015
2016 /* --------------------------------------------------------------------------------------------- */
2017
2018 char *
2019 edit_get_write_filter (const vfs_path_t * write_name_vpath, const vfs_path_t * filename_vpath)
2020 {
2021     int i;
2022     char *p, *writename;
2023     const vfs_path_element_t *path_element;
2024
2025     i = edit_find_filter (filename_vpath);
2026     if (i < 0)
2027         return NULL;
2028
2029     path_element = vfs_path_get_by_index (write_name_vpath, -1);
2030     writename = name_quote (path_element->path, 0);
2031     p = g_strdup_printf (all_filters[i].write, writename);
2032     g_free (writename);
2033     return p;
2034 }
2035
2036 /* --------------------------------------------------------------------------------------------- */
2037 /**
2038  * @param edit   editor object
2039  * @param f      value of stream file
2040  * @returns      the length of the file
2041  */
2042
2043 off_t
2044 edit_write_stream (WEdit * edit, FILE * f)
2045 {
2046     long i;
2047
2048     if (edit->lb == LB_ASIS)
2049     {
2050         for (i = 0; i < edit->last_byte; i++)
2051             if (fputc (edit_get_byte (edit, i), f) < 0)
2052                 break;
2053         return i;
2054     }
2055
2056     /* change line breaks */
2057     for (i = 0; i < edit->last_byte; i++)
2058     {
2059         unsigned char c = edit_get_byte (edit, i);
2060
2061         if (!(c == '\n' || c == '\r'))
2062         {
2063             /* not line break */
2064             if (fputc (c, f) < 0)
2065                 return i;
2066         }
2067         else
2068         {                       /* (c == '\n' || c == '\r') */
2069             unsigned char c1 = edit_get_byte (edit, i + 1);     /* next char */
2070
2071             switch (edit->lb)
2072             {
2073             case LB_UNIX:      /* replace "\r\n" or '\r' to '\n' */
2074                 /* put one line break unconditionally */
2075                 if (fputc ('\n', f) < 0)
2076                     return i;
2077
2078                 i++;            /* 2 chars are processed */
2079
2080                 if (c == '\r' && c1 == '\n')
2081                     /* Windows line break; go to the next char */
2082                     break;
2083
2084                 if (c == '\r' && c1 == '\r')
2085                 {
2086                     /* two Macintosh line breaks; put second line break */
2087                     if (fputc ('\n', f) < 0)
2088                         return i;
2089                     break;
2090                 }
2091
2092                 if (fputc (c1, f) < 0)
2093                     return i;
2094                 break;
2095
2096             case LB_WIN:       /* replace '\n' or '\r' to "\r\n" */
2097                 /* put one line break unconditionally */
2098                 if (fputc ('\r', f) < 0 || fputc ('\n', f) < 0)
2099                     return i;
2100
2101                 if (c == '\r' && c1 == '\n')
2102                     /* Windows line break; go to the next char */
2103                     i++;
2104                 break;
2105
2106             case LB_MAC:       /* replace "\r\n" or '\n' to '\r' */
2107                 /* put one line break unconditionally */
2108                 if (fputc ('\r', f) < 0)
2109                     return i;
2110
2111                 i++;            /* 2 chars are processed */
2112
2113                 if (c == '\r' && c1 == '\n')
2114                     /* Windows line break; go to the next char */
2115                     break;
2116
2117                 if (c == '\n' && c1 == '\n')
2118                 {
2119                     /* two Windows line breaks; put second line break */
2120                     if (fputc ('\r', f) < 0)
2121                         return i;
2122                     break;
2123                 }
2124
2125                 if (fputc (c1, f) < 0)
2126                     return i;
2127                 break;
2128             case LB_ASIS:      /* default without changes */
2129                 break;
2130             }
2131         }
2132     }
2133
2134     return edit->last_byte;
2135 }
2136
2137 /* --------------------------------------------------------------------------------------------- */
2138 /** inserts a file at the cursor, returns count of inserted bytes on success */
2139 long
2140 edit_insert_file (WEdit * edit, const vfs_path_t * filename_vpath)
2141 {
2142     char *p;
2143     off_t ins_len = 0;
2144
2145     p = edit_get_filter (filename_vpath);
2146     if (p != NULL)
2147     {
2148         FILE *f;
2149         off_t current = edit->curs1;
2150
2151         f = (FILE *) popen (p, "r");
2152         if (f != NULL)
2153         {
2154             edit_insert_stream (edit, f);
2155             ins_len = edit->curs1 - current;
2156             edit_cursor_move (edit, -ins_len);
2157             if (pclose (f) > 0)
2158             {
2159                 char *errmsg;
2160
2161                 errmsg = g_strdup_printf (_("Error reading from pipe: %s"), p);
2162                 edit_error_dialog (_("Error"), errmsg);
2163                 g_free (errmsg);
2164                 ins_len = -1;
2165             }
2166         }
2167         else
2168         {
2169             char *errmsg;
2170
2171             errmsg = g_strdup_printf (_("Cannot open pipe for reading: %s"), p);
2172             edit_error_dialog (_("Error"), errmsg);
2173             g_free (errmsg);
2174             ins_len = -1;
2175         }
2176         g_free (p);
2177     }
2178     else
2179     {
2180         int file;
2181         off_t blocklen;
2182         off_t current = edit->curs1;
2183         int vertical_insertion = 0;
2184         char *buf;
2185
2186         file = mc_open (filename_vpath, O_RDONLY | O_BINARY);
2187         if (file == -1)
2188             return -1;
2189
2190         buf = g_malloc0 (TEMP_BUF_LEN);
2191         blocklen = mc_read (file, buf, sizeof (VERTICAL_MAGIC));
2192         if (blocklen > 0)
2193         {
2194             /* if contain signature VERTICAL_MAGIC then it vertical block */
2195             if (memcmp (buf, VERTICAL_MAGIC, sizeof (VERTICAL_MAGIC)) == 0)
2196                 vertical_insertion = 1;
2197             else
2198                 mc_lseek (file, 0, SEEK_SET);
2199         }
2200
2201         if (vertical_insertion)
2202         {
2203             off_t mark1, mark2;
2204             long c1, c2;
2205
2206             blocklen = edit_insert_column_of_text_from_file (edit, file, &mark1, &mark2, &c1, &c2);
2207             edit_set_markers (edit, edit->curs1, mark2, c1, c2);
2208             /* highlight inserted text then not persistent blocks */
2209             if (!option_persistent_selections)
2210             {
2211                 if (!edit->column_highlight)
2212                     edit_push_undo_action (edit, COLUMN_OFF);
2213                 edit->column_highlight = 1;
2214             }
2215         }
2216         else
2217         {
2218             off_t i;
2219
2220             while ((blocklen = mc_read (file, (char *) buf, TEMP_BUF_LEN)) > 0)
2221             {
2222                 for (i = 0; i < blocklen; i++)
2223                     edit_insert (edit, buf[i]);
2224             }
2225             /* highlight inserted text then not persistent blocks */
2226             if (!option_persistent_selections && edit->modified)
2227             {
2228                 edit_set_markers (edit, edit->curs1, current, 0, 0);
2229                 if (edit->column_highlight)
2230                     edit_push_undo_action (edit, COLUMN_ON);
2231                 edit->column_highlight = 0;
2232             }
2233         }
2234
2235         edit->force |= REDRAW_PAGE;
2236         ins_len = edit->curs1 - current;
2237         edit_cursor_move (edit, -ins_len);
2238         g_free (buf);
2239         mc_close (file);
2240         if (blocklen != 0)
2241             ins_len = 0;
2242     }
2243
2244     return ins_len;
2245 }
2246
2247 /* --------------------------------------------------------------------------------------------- */
2248 /**
2249  * Fill in the edit structure.  Return NULL on failure.  Pass edit as
2250  * NULL to allocate a new structure.
2251  *
2252  * If line is 0, try to restore saved position.  Otherwise put the
2253  * cursor on that line and show it in the middle of the screen.
2254  */
2255
2256 WEdit *
2257 edit_init (WEdit * edit, int y, int x, int lines, int cols, const vfs_path_t * filename_vpath,
2258            long line)
2259 {
2260     gboolean to_free = FALSE;
2261
2262     option_auto_syntax = 1;     /* Resetting to auto on every invokation */
2263     if (option_line_state)
2264         option_line_state_width = LINE_STATE_WIDTH;
2265     else
2266         option_line_state_width = 0;
2267
2268     if (edit == NULL)
2269     {
2270 #ifdef ENABLE_NLS
2271         /*
2272          * Expand option_whole_chars_search by national letters using
2273          * current locale
2274          */
2275
2276         static char option_whole_chars_search_buf[256];
2277
2278         if (option_whole_chars_search_buf != option_whole_chars_search)
2279         {
2280             size_t i;
2281             size_t len = str_term_width1 (option_whole_chars_search);
2282
2283             strcpy (option_whole_chars_search_buf, option_whole_chars_search);
2284
2285             for (i = 1; i <= sizeof (option_whole_chars_search_buf); i++)
2286             {
2287                 if (g_ascii_islower ((gchar) i) && !strchr (option_whole_chars_search, i))
2288                 {
2289                     option_whole_chars_search_buf[len++] = i;
2290                 }
2291             }
2292
2293             option_whole_chars_search_buf[len] = 0;
2294             option_whole_chars_search = option_whole_chars_search_buf;
2295         }
2296 #endif /* ENABLE_NLS */
2297         edit = g_malloc0 (sizeof (WEdit));
2298         edit->search = NULL;
2299         to_free = TRUE;
2300     }
2301
2302     edit_purge_widget (edit);
2303     edit->widget.y = y;
2304     edit->widget.x = x;
2305     edit->widget.lines = lines;
2306     edit->widget.cols = cols;
2307
2308     edit->stat1.st_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
2309     edit->stat1.st_uid = getuid ();
2310     edit->stat1.st_gid = getgid ();
2311     edit->stat1.st_mtime = 0;
2312
2313     edit->over_col = 0;
2314     edit->bracket = -1;
2315     edit->force |= REDRAW_PAGE;
2316     edit_set_filename (edit, filename_vpath);
2317
2318     edit->undo_stack_size = START_STACK_SIZE;
2319     edit->undo_stack_size_mask = START_STACK_SIZE - 1;
2320     edit->undo_stack = g_malloc0 ((edit->undo_stack_size + 10) * sizeof (long));
2321
2322     edit->redo_stack_size = START_STACK_SIZE;
2323     edit->redo_stack_size_mask = START_STACK_SIZE - 1;
2324     edit->redo_stack = g_malloc0 ((edit->redo_stack_size + 10) * sizeof (long));
2325
2326 #ifdef HAVE_CHARSET
2327     edit->utf8 = FALSE;
2328     edit->converter = str_cnv_from_term;
2329     edit_set_codeset (edit);
2330 #endif
2331
2332     if (!edit_load_file (edit))
2333     {
2334         /* edit_load_file already gives an error message */
2335         if (to_free)
2336             g_free (edit);
2337         return NULL;
2338     }
2339
2340     edit->loading_done = 1;
2341     edit->modified = 0;
2342     edit->locked = 0;
2343     edit_load_syntax (edit, NULL, NULL);
2344     {
2345         int color;
2346         edit_get_syntax_color (edit, -1, &color);
2347     }
2348
2349     /* load saved cursor position */
2350     if ((line == 0) && option_save_position)
2351         edit_load_position (edit);
2352     else
2353     {
2354         if (line <= 0)
2355             line = 1;
2356         edit_move_display (edit, line - 1);
2357         edit_move_to_line (edit, line - 1);
2358     }
2359
2360     edit_load_macro_cmd (edit);
2361     return edit;
2362 }
2363
2364 /* --------------------------------------------------------------------------------------------- */
2365
2366 /** Clear the edit struct, freeing everything in it.  Return TRUE on success */
2367 gboolean
2368 edit_clean (WEdit * edit)
2369 {
2370     int j = 0;
2371
2372     if (edit == NULL)
2373         return FALSE;
2374
2375     /* a stale lock, remove it */
2376     if (edit->locked)
2377         edit->locked = unlock_file (edit->filename_vpath);
2378
2379     /* save cursor position */
2380     if (option_save_position)
2381         edit_save_position (edit);
2382     else if (edit->serialized_bookmarks != NULL)
2383         edit->serialized_bookmarks = (GArray *) g_array_free (edit->serialized_bookmarks, TRUE);
2384
2385     /* File specified on the mcedit command line and never saved */
2386     if (edit->delete_file)
2387         unlink (vfs_path_get_last_path_str (edit->filename_vpath));
2388
2389     edit_free_syntax_rules (edit);
2390     book_mark_flush (edit, -1);
2391     for (; j <= MAXBUFF; j++)
2392     {
2393         g_free (edit->buffers1[j]);
2394         g_free (edit->buffers2[j]);
2395     }
2396
2397     g_free (edit->undo_stack);
2398     g_free (edit->redo_stack);
2399     vfs_path_free (edit->filename_vpath);
2400     vfs_path_free (edit->dir_vpath);
2401     mc_search_free (edit->search);
2402     edit->search = NULL;
2403
2404 #ifdef HAVE_CHARSET
2405     if (edit->converter != str_cnv_from_term)
2406         str_close_conv (edit->converter);
2407 #endif
2408
2409     edit_purge_widget (edit);
2410
2411     return TRUE;
2412 }
2413
2414 /* --------------------------------------------------------------------------------------------- */
2415
2416 /** returns TRUE on success */
2417 gboolean
2418 edit_renew (WEdit * edit)
2419 {
2420     int y = edit->widget.y;
2421     int x = edit->widget.x;
2422     int lines = edit->widget.lines;
2423     int columns = edit->widget.cols;
2424
2425     edit_clean (edit);
2426     return (edit_init (edit, y, x, lines, columns, NULL, 0) != NULL);
2427 }
2428
2429 /* --------------------------------------------------------------------------------------------- */
2430
2431 /**
2432  * Load a new file into the editor and set line.  If it fails, preserve the old file.
2433  * To do it, allocate a new widget, initialize it and, if the new file
2434  * was loaded, copy the data to the old widget.
2435  *
2436  * @returns TRUE on success, FALSE on failure.
2437  */
2438 gboolean
2439 edit_reload_line (WEdit * edit, const vfs_path_t * filename_vpath, long line)
2440 {
2441     WEdit *e;
2442     int y = edit->widget.y;
2443     int x = edit->widget.x;
2444     int lines = edit->widget.lines;
2445     int columns = edit->widget.cols;
2446
2447     e = g_malloc0 (sizeof (WEdit));
2448     e->widget = edit->widget;
2449
2450     if (edit_init (e, y, x, lines, columns, filename_vpath, line) == NULL)
2451     {
2452         g_free (e);
2453         return FALSE;
2454     }
2455
2456     edit_clean (edit);
2457     memcpy (edit, e, sizeof (WEdit));
2458     g_free (e);
2459
2460     return TRUE;
2461 }
2462
2463 /* --------------------------------------------------------------------------------------------- */
2464
2465 #ifdef HAVE_CHARSET
2466 void
2467 edit_set_codeset (WEdit * edit)
2468 {
2469     const char *cp_id;
2470
2471     cp_id =
2472         get_codepage_id (mc_global.source_codepage >=
2473                          0 ? mc_global.source_codepage : mc_global.display_codepage);
2474
2475     if (cp_id != NULL)
2476     {
2477         GIConv conv;
2478         conv = str_crt_conv_from (cp_id);
2479         if (conv != INVALID_CONV)
2480         {
2481             if (edit->converter != str_cnv_from_term)
2482                 str_close_conv (edit->converter);
2483             edit->converter = conv;
2484         }
2485     }
2486
2487     if (cp_id != NULL)
2488         edit->utf8 = str_isutf8 (cp_id);
2489 }
2490 #endif
2491
2492 /* --------------------------------------------------------------------------------------------- */
2493 /**
2494    Recording stack for undo:
2495    The following is an implementation of a compressed stack. Identical
2496    pushes are recorded by a negative prefix indicating the number of times the
2497    same char was pushed. This saves space for repeated curs-left or curs-right
2498    delete etc.
2499
2500    eg:
2501
2502    pushed:       stored:
2503
2504    a
2505    b             a
2506    b            -3
2507    b             b
2508    c  -->       -4
2509    c             c
2510    c             d
2511    c
2512    d
2513
2514    If the stack long int is 0-255 it represents a normal insert (from a backspace),
2515    256-512 is an insert ahead (from a delete), If it is betwen 600 and 700 it is one
2516    of the cursor functions #define'd in edit-impl.h. 1000 through 700'000'000 is to
2517    set edit->mark1 position. 700'000'000 through 1400'000'000 is to set edit->mark2
2518    position.
2519
2520    The only way the cursor moves or the buffer is changed is through the routines:
2521    insert, backspace, insert_ahead, delete, and cursor_move.
2522    These record the reverse undo movements onto the stack each time they are
2523    called.
2524
2525    Each key press results in a set of actions (insert; delete ...). So each time
2526    a key is pressed the current position of start_display is pushed as
2527    KEY_PRESS + start_display. Then for undoing, we pop until we get to a number
2528    over KEY_PRESS. We then assign this number less KEY_PRESS to start_display. So undo
2529    tracks scrolling and key actions exactly. (KEY_PRESS is about (2^31) * (2/3) = 1400'000'000)
2530
2531  */
2532
2533 void
2534 edit_push_undo_action (WEdit * edit, long c, ...)
2535 {
2536     unsigned long sp = edit->undo_stack_pointer;
2537     unsigned long spm1;
2538     long *t;
2539
2540     /* first enlarge the stack if necessary */
2541     if (sp > edit->undo_stack_size - 10)
2542     {                           /* say */
2543         if (option_max_undo < 256)
2544             option_max_undo = 256;
2545         if (edit->undo_stack_size < (unsigned long) option_max_undo)
2546         {
2547             t = g_realloc (edit->undo_stack, (edit->undo_stack_size * 2 + 10) * sizeof (long));
2548             if (t != NULL)
2549             {
2550                 edit->undo_stack = t;
2551                 edit->undo_stack_size <<= 1;
2552                 edit->undo_stack_size_mask = edit->undo_stack_size - 1;
2553             }
2554         }
2555     }
2556     spm1 = (edit->undo_stack_pointer - 1) & edit->undo_stack_size_mask;
2557     if (edit->undo_stack_disable)
2558     {
2559         edit_push_redo_action (edit, KEY_PRESS);
2560         edit_push_redo_action (edit, c);
2561         return;
2562     }
2563     if (edit->redo_stack_reset)
2564         edit->redo_stack_bottom = edit->redo_stack_pointer = 0;
2565
2566     if (edit->undo_stack_bottom != sp
2567         && spm1 != edit->undo_stack_bottom
2568         && ((sp - 2) & edit->undo_stack_size_mask) != edit->undo_stack_bottom)
2569     {
2570         int d;
2571
2572         if (edit->undo_stack[spm1] < 0)
2573         {
2574             d = edit->undo_stack[(sp - 2) & edit->undo_stack_size_mask];
2575             if (d == c && edit->undo_stack[spm1] > -1000000000)
2576             {
2577                 if (c < KEY_PRESS)      /* --> no need to push multiple do-nothings */
2578                     edit->undo_stack[spm1]--;
2579                 return;
2580             }
2581         }
2582         else
2583         {
2584             d = edit->undo_stack[spm1];
2585             if (d == c)
2586             {
2587                 if (c >= KEY_PRESS)
2588                     return;     /* --> no need to push multiple do-nothings */
2589                 edit->undo_stack[sp] = -2;
2590                 goto check_bottom;
2591             }
2592         }
2593     }
2594     edit->undo_stack[sp] = c;
2595
2596   check_bottom:
2597     edit->undo_stack_pointer = (edit->undo_stack_pointer + 1) & edit->undo_stack_size_mask;
2598
2599     /* if the sp wraps round and catches the undo_stack_bottom then erase
2600      * the first set of actions on the stack to make space - by moving
2601      * undo_stack_bottom forward one "key press" */
2602     c = (edit->undo_stack_pointer + 2) & edit->undo_stack_size_mask;
2603     if ((unsigned long) c == edit->undo_stack_bottom ||
2604         (((unsigned long) c + 1) & edit->undo_stack_size_mask) == edit->undo_stack_bottom)
2605         do
2606         {
2607             edit->undo_stack_bottom = (edit->undo_stack_bottom + 1) & edit->undo_stack_size_mask;
2608         }
2609         while (edit->undo_stack[edit->undo_stack_bottom] < KEY_PRESS
2610                && edit->undo_stack_bottom != edit->undo_stack_pointer);
2611
2612     /*If a single key produced enough pushes to wrap all the way round then we would notice that the [undo_stack_bottom] does not contain KEY_PRESS. The stack is then initialised: */
2613     if (edit->undo_stack_pointer != edit->undo_stack_bottom
2614         && edit->undo_stack[edit->undo_stack_bottom] < KEY_PRESS)
2615     {
2616         edit->undo_stack_bottom = edit->undo_stack_pointer = 0;
2617     }
2618 }
2619
2620 /* --------------------------------------------------------------------------------------------- */
2621
2622 void
2623 edit_push_redo_action (WEdit * edit, long c, ...)
2624 {
2625     unsigned long sp = edit->redo_stack_pointer;
2626     unsigned long spm1;
2627     long *t;
2628
2629     /* first enlarge the stack if necessary */
2630     if (sp > edit->redo_stack_size - 10)
2631     {                           /* say */
2632         if (option_max_undo < 256)
2633             option_max_undo = 256;
2634         if (edit->redo_stack_size < (unsigned long) option_max_undo)
2635         {
2636             t = g_realloc (edit->redo_stack, (edit->redo_stack_size * 2 + 10) * sizeof (long));
2637             if (t != NULL)
2638             {
2639                 edit->redo_stack = t;
2640                 edit->redo_stack_size <<= 1;
2641                 edit->redo_stack_size_mask = edit->redo_stack_size - 1;
2642             }
2643         }
2644     }
2645     spm1 = (edit->redo_stack_pointer - 1) & edit->redo_stack_size_mask;
2646
2647     if (edit->redo_stack_bottom != sp
2648         && spm1 != edit->redo_stack_bottom
2649         && ((sp - 2) & edit->redo_stack_size_mask) != edit->redo_stack_bottom)
2650     {
2651         int d;
2652
2653         if (edit->redo_stack[spm1] < 0)
2654         {
2655             d = edit->redo_stack[(sp - 2) & edit->redo_stack_size_mask];
2656             if (d == c && edit->redo_stack[spm1] > -1000000000)
2657             {
2658                 if (c < KEY_PRESS)      /* --> no need to push multiple do-nothings */
2659                     edit->redo_stack[spm1]--;
2660                 return;
2661             }
2662         }
2663         else
2664         {
2665             d = edit->redo_stack[spm1];
2666             if (d == c)
2667             {
2668                 if (c >= KEY_PRESS)
2669                     return;     /* --> no need to push multiple do-nothings */
2670                 edit->redo_stack[sp] = -2;
2671                 goto redo_check_bottom;
2672             }
2673         }
2674     }
2675     edit->redo_stack[sp] = c;
2676
2677   redo_check_bottom:
2678     edit->redo_stack_pointer = (edit->redo_stack_pointer + 1) & edit->redo_stack_size_mask;
2679
2680     /* if the sp wraps round and catches the redo_stack_bottom then erase
2681      * the first set of actions on the stack to make space - by moving
2682      * redo_stack_bottom forward one "key press" */
2683     c = (edit->redo_stack_pointer + 2) & edit->redo_stack_size_mask;
2684     if ((unsigned long) c == edit->redo_stack_bottom ||
2685         (((unsigned long) c + 1) & edit->redo_stack_size_mask) == edit->redo_stack_bottom)
2686         do
2687         {
2688             edit->redo_stack_bottom = (edit->redo_stack_bottom + 1) & edit->redo_stack_size_mask;
2689         }
2690         while (edit->redo_stack[edit->redo_stack_bottom] < KEY_PRESS
2691                && edit->redo_stack_bottom != edit->redo_stack_pointer);
2692
2693     /*
2694      * If a single key produced enough pushes to wrap all the way round then
2695      * we would notice that the [redo_stack_bottom] does not contain KEY_PRESS.
2696      * The stack is then initialised:
2697      */
2698
2699     if (edit->redo_stack_pointer != edit->redo_stack_bottom
2700         && edit->redo_stack[edit->redo_stack_bottom] < KEY_PRESS)
2701         edit->redo_stack_bottom = edit->redo_stack_pointer = 0;
2702
2703 }
2704
2705 /* --------------------------------------------------------------------------------------------- */
2706 /**
2707    Basic low level single character buffer alterations and movements at the cursor.
2708    Returns char passed over, inserted or removed.
2709  */
2710
2711 void
2712 edit_insert (WEdit * edit, int c)
2713 {
2714     /* check if file has grown to large */
2715     if (edit->last_byte >= SIZE_LIMIT)
2716         return;
2717
2718     /* first we must update the position of the display window */
2719     if (edit->curs1 < edit->start_display)
2720     {
2721         edit->start_display++;
2722         if (c == '\n')
2723             edit->start_line++;
2724     }
2725
2726     /* Mark file as modified, unless the file hasn't been fully loaded */
2727     if (edit->loading_done)
2728         edit_modification (edit);
2729
2730     /* now we must update some info on the file and check if a redraw is required */
2731     if (c == '\n')
2732     {
2733         book_mark_inc (edit, edit->curs_line);
2734         edit->curs_line++;
2735         edit->total_lines++;
2736         edit->force |= REDRAW_LINE_ABOVE | REDRAW_AFTER_CURSOR;
2737     }
2738
2739     /* save the reverse command onto the undo stack */
2740     /* ordinary char and not space */
2741     if (c > 32)
2742         edit_push_undo_action (edit, BACKSPACE);
2743     else
2744         edit_push_undo_action (edit, BACKSPACE_BR);
2745     /* update markers */
2746     edit->mark1 += (edit->mark1 > edit->curs1);
2747     edit->mark2 += (edit->mark2 > edit->curs1);
2748     edit->last_get_rule += (edit->last_get_rule > edit->curs1);
2749
2750     /* add a new buffer if we've reached the end of the last one */
2751     if ((edit->curs1 & M_EDIT_BUF_SIZE) == 0)
2752         edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = g_malloc0 (EDIT_BUF_SIZE);
2753
2754     /* perform the insertion */
2755     edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE][edit->curs1 & M_EDIT_BUF_SIZE]
2756         = (unsigned char) c;
2757
2758     /* update file length */
2759     edit->last_byte++;
2760
2761     /* update cursor position */
2762     edit->curs1++;
2763 }
2764
2765 /* --------------------------------------------------------------------------------------------- */
2766 /** same as edit_insert and move left */
2767
2768 void
2769 edit_insert_ahead (WEdit * edit, int c)
2770 {
2771     if (edit->last_byte >= SIZE_LIMIT)
2772         return;
2773
2774     if (edit->curs1 < edit->start_display)
2775     {
2776         edit->start_display++;
2777         if (c == '\n')
2778             edit->start_line++;
2779     }
2780     edit_modification (edit);
2781     if (c == '\n')
2782     {
2783         book_mark_inc (edit, edit->curs_line);
2784         edit->total_lines++;
2785         edit->force |= REDRAW_AFTER_CURSOR;
2786     }
2787     /* ordinary char and not space */
2788     if (c > 32)
2789         edit_push_undo_action (edit, DELCHAR);
2790     else
2791         edit_push_undo_action (edit, DELCHAR_BR);
2792
2793     edit->mark1 += (edit->mark1 >= edit->curs1);
2794     edit->mark2 += (edit->mark2 >= edit->curs1);
2795     edit->last_get_rule += (edit->last_get_rule >= edit->curs1);
2796
2797     if (((edit->curs2 + 1) & M_EDIT_BUF_SIZE) == 0)
2798         edit->buffers2[(edit->curs2 + 1) >> S_EDIT_BUF_SIZE] = g_malloc0 (EDIT_BUF_SIZE);
2799     edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE]
2800         [EDIT_BUF_SIZE - (edit->curs2 & M_EDIT_BUF_SIZE) - 1] = c;
2801
2802     edit->last_byte++;
2803     edit->curs2++;
2804 }
2805
2806 /* --------------------------------------------------------------------------------------------- */
2807
2808 int
2809 edit_delete (WEdit * edit, const int byte_delete)
2810 {
2811     int p = 0;
2812     int cw = 1;
2813     int i;
2814
2815     if (edit->curs2 == 0)
2816         return 0;
2817
2818 #ifdef HAVE_CHARSET
2819     /* if byte_delete = 1 then delete only one byte not multibyte char */
2820     if (edit->utf8 && byte_delete == 0)
2821     {
2822         edit_get_utf (edit, edit->curs1, &cw);
2823         if (cw < 1)
2824             cw = 1;
2825     }
2826 #else
2827     (void) byte_delete;
2828 #endif
2829
2830     if (edit->mark2 != edit->mark1)
2831         edit_push_markers (edit);
2832
2833     for (i = 1; i <= cw; i++)
2834     {
2835         if (edit->mark1 > edit->curs1)
2836         {
2837             edit->mark1--;
2838             edit->end_mark_curs--;
2839         }
2840         if (edit->mark2 > edit->curs1)
2841             edit->mark2--;
2842         if (edit->last_get_rule > edit->curs1)
2843             edit->last_get_rule--;
2844
2845         p = edit->buffers2[(edit->curs2 - 1) >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE -
2846                                                                  ((edit->curs2 -
2847                                                                    1) & M_EDIT_BUF_SIZE) - 1];
2848
2849         if ((edit->curs2 & M_EDIT_BUF_SIZE) == 0)
2850         {
2851             g_free (edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE]);
2852             edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] = NULL;
2853         }
2854         edit->last_byte--;
2855         edit->curs2--;
2856         edit_push_undo_action (edit, p + 256);
2857     }
2858
2859     edit_modification (edit);
2860     if (p == '\n')
2861     {
2862         book_mark_dec (edit, edit->curs_line);
2863         edit->total_lines--;
2864         edit->force |= REDRAW_AFTER_CURSOR;
2865     }
2866     if (edit->curs1 < edit->start_display)
2867     {
2868         edit->start_display--;
2869         if (p == '\n')
2870             edit->start_line--;
2871     }
2872
2873     return p;
2874 }
2875
2876 /* --------------------------------------------------------------------------------------------- */
2877 /** moves the cursor right or left: increment positive or negative respectively */
2878
2879 void
2880 edit_cursor_move (WEdit * edit, off_t increment)
2881 {
2882     /* this is the same as a combination of two of the above routines, with only one push onto the undo stack */
2883     int c;
2884
2885     if (increment < 0)
2886     {
2887         for (; increment < 0; increment++)
2888         {
2889             if (edit->curs1 == 0)
2890                 return;
2891
2892             edit_push_undo_action (edit, CURS_RIGHT);
2893
2894             c = edit_get_byte (edit, edit->curs1 - 1);
2895             if (((edit->curs2 + 1) & M_EDIT_BUF_SIZE) == 0)
2896                 edit->buffers2[(edit->curs2 + 1) >> S_EDIT_BUF_SIZE] = g_malloc0 (EDIT_BUF_SIZE);
2897             edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE -
2898                                                            (edit->curs2 & M_EDIT_BUF_SIZE) - 1] = c;
2899             edit->curs2++;
2900             c = edit->buffers1[(edit->curs1 - 1) >> S_EDIT_BUF_SIZE][(edit->curs1 -
2901                                                                       1) & M_EDIT_BUF_SIZE];
2902             if (((edit->curs1 - 1) & M_EDIT_BUF_SIZE) == 0)
2903             {
2904                 g_free (edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE]);
2905                 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = NULL;
2906             }
2907             edit->curs1--;
2908             if (c == '\n')
2909             {
2910                 edit->curs_line--;
2911                 edit->force |= REDRAW_LINE_BELOW;
2912             }
2913         }
2914
2915     }
2916     else
2917     {
2918         for (; increment > 0; increment--)
2919         {
2920             if (edit->curs2 == 0)
2921                 return;
2922
2923             edit_push_undo_action (edit, CURS_LEFT);
2924
2925             c = edit_get_byte (edit, edit->curs1);
2926             if ((edit->curs1 & M_EDIT_BUF_SIZE) == 0)
2927                 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = g_malloc0 (EDIT_BUF_SIZE);
2928             edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE][edit->curs1 & M_EDIT_BUF_SIZE] = c;
2929             edit->curs1++;
2930             c = edit->buffers2[(edit->curs2 - 1) >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE -
2931                                                                      ((edit->curs2 -
2932                                                                        1) & M_EDIT_BUF_SIZE) - 1];
2933             if ((edit->curs2 & M_EDIT_BUF_SIZE) == 0)
2934             {
2935                 g_free (edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE]);
2936                 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] = 0;
2937             }
2938             edit->curs2--;
2939             if (c == '\n')
2940             {
2941                 edit->curs_line++;
2942                 edit->force |= REDRAW_LINE_ABOVE;
2943             }
2944         }
2945     }
2946 }
2947
2948 /* These functions return positions relative to lines */
2949
2950 /* --------------------------------------------------------------------------------------------- */
2951 /** returns index of last char on line + 1 */
2952
2953 off_t
2954 edit_eol (WEdit * edit, off_t current)
2955 {
2956     if (current >= edit->last_byte)
2957         return edit->last_byte;
2958
2959     for (; edit_get_byte (edit, current) != '\n'; current++)
2960         ;
2961
2962     return current;
2963 }
2964
2965 /* --------------------------------------------------------------------------------------------- */
2966 /** returns index of first char on line */
2967
2968 off_t
2969 edit_bol (WEdit * edit, off_t current)
2970 {
2971     if (current <= 0)
2972         return 0;
2973
2974     for (; edit_get_byte (edit, current - 1) != '\n'; current--)
2975         ;
2976
2977     return current;
2978 }
2979
2980 /* --------------------------------------------------------------------------------------------- */
2981
2982 long
2983 edit_count_lines (WEdit * edit, off_t current, off_t upto)
2984 {
2985     long lines = 0;
2986     if (upto > edit->last_byte)
2987         upto = edit->last_byte;
2988     if (current < 0)
2989         current = 0;
2990     while (current < upto)
2991         if (edit_get_byte (edit, current++) == '\n')
2992             lines++;
2993     return lines;
2994 }
2995
2996 /* --------------------------------------------------------------------------------------------- */
2997 /* If lines is zero this returns the count of lines from current to upto. */
2998 /* If upto is zero returns index of lines forward current. */
2999
3000 off_t
3001 edit_move_forward (WEdit * edit, off_t current, long lines, off_t upto)
3002 {
3003     if (upto != 0)
3004     {
3005         return (off_t) edit_count_lines (edit, current, upto);
3006     }
3007     else
3008     {
3009         long next;
3010
3011         if (lines < 0)
3012             lines = 0;
3013         while (lines-- != 0)
3014         {
3015             next = edit_eol (edit, current) + 1;
3016             if (next > edit->last_byte)
3017                 break;
3018             current = next;
3019         }
3020         return current;
3021     }
3022 }
3023
3024 /* --------------------------------------------------------------------------------------------- */
3025 /** Returns offset of 'lines' lines up from current */
3026
3027 off_t
3028 edit_move_backward (WEdit * edit, off_t current, long lines)
3029 {
3030     if (lines < 0)
3031         lines = 0;
3032     current = edit_bol (edit, current);
3033     while (lines-- != 0 && current != 0)
3034         current = edit_bol (edit, current - 1);
3035     return current;
3036 }
3037
3038 /* --------------------------------------------------------------------------------------------- */
3039 /* If cols is zero this returns the count of columns from current to upto. */
3040 /* If upto is zero returns index of cols across from current. */
3041
3042 off_t
3043 edit_move_forward3 (WEdit * edit, off_t current, long cols, off_t upto)
3044 {
3045     off_t p, q;
3046     long col;
3047
3048     if (upto != 0)
3049     {
3050         q = upto;
3051         cols = -10;
3052     }
3053     else
3054         q = edit->last_byte + 2;
3055
3056     for (col = 0, p = current; p < q; p++)
3057     {
3058         int c, orig_c;
3059
3060         if (cols != -10)
3061         {
3062             if (col == cols)
3063                 return p;
3064             if (col > cols)
3065                 return p - 1;
3066         }
3067
3068         orig_c = c = edit_get_byte (edit, p);
3069
3070 #ifdef HAVE_CHARSET
3071         if (edit->utf8)
3072         {
3073             int utf_ch;
3074             int cw = 1;
3075
3076             utf_ch = edit_get_utf (edit, p, &cw);
3077             if (mc_global.utf8_display)
3078             {
3079                 if (cw > 1)
3080                     col -= cw - 1;
3081                 if (g_unichar_iswide (utf_ch))
3082                     col++;
3083             }
3084             else if (cw > 1 && g_unichar_isprint (utf_ch))
3085                 col -= cw - 1;
3086         }
3087
3088         c = convert_to_display_c (c);
3089 #endif
3090
3091         if (c == '\n')
3092             return (upto != 0 ? (off_t) col : p);
3093         if (c == '\t')
3094             col += TAB_SIZE - col % TAB_SIZE;
3095         else if ((c < 32 || c == 127) && (orig_c == c
3096 #ifdef HAVE_CHARSET
3097                                           || (!mc_global.utf8_display && !edit->utf8)
3098 #endif
3099                  ))
3100             /* '\r' is shown as ^M, so we must advance 2 characters */
3101             /* Caret notation for control characters */
3102             col += 2;
3103         else
3104             col++;
3105     }
3106     return (off_t) col;
3107 }
3108
3109 /* --------------------------------------------------------------------------------------------- */
3110 /** returns the current column position of the cursor */
3111
3112 long
3113 edit_get_col (WEdit * edit)
3114 {
3115     return (long) edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0, edit->curs1);
3116 }
3117
3118 /* --------------------------------------------------------------------------------------------- */
3119 /* Scrolling functions */
3120 /* --------------------------------------------------------------------------------------------- */
3121
3122 void
3123 edit_update_curs_row (WEdit * edit)
3124 {
3125     edit->curs_row = edit->curs_line - edit->start_line;
3126 }
3127
3128 /* --------------------------------------------------------------------------------------------- */
3129
3130 void
3131 edit_update_curs_col (WEdit * edit)
3132 {
3133     edit->curs_col = (long) edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0, edit->curs1);
3134 }
3135
3136 /* --------------------------------------------------------------------------------------------- */
3137
3138 long
3139 edit_get_curs_col (const WEdit * edit)
3140 {
3141     return edit->curs_col;
3142 }
3143
3144 /* --------------------------------------------------------------------------------------------- */
3145 /** moves the display start position up by i lines */
3146
3147 void
3148 edit_scroll_upward (WEdit * edit, long i)
3149 {
3150     long lines_above = edit->start_line;
3151
3152     if (i > lines_above)
3153         i = lines_above;
3154     if (i != 0)
3155     {
3156         edit->start_line -= i;
3157         edit->start_display = edit_move_backward (edit, edit->start_display, i);
3158         edit->force |= REDRAW_PAGE;
3159         edit->force &= (0xfff - REDRAW_CHAR_ONLY);
3160     }
3161     edit_update_curs_row (edit);
3162 }
3163
3164
3165 /* --------------------------------------------------------------------------------------------- */
3166
3167 void
3168 edit_scroll_downward (WEdit * edit, long i)
3169 {
3170     long lines_below;
3171
3172     lines_below = edit->total_lines - edit->start_line - (edit->widget.lines - 1);
3173     if (lines_below > 0)
3174     {
3175         if (i > lines_below)
3176             i = lines_below;
3177         edit->start_line += i;
3178         edit->start_display = edit_move_forward (edit, edit->start_display, i, 0);
3179         edit->force |= REDRAW_PAGE;
3180         edit->force &= (0xfff - REDRAW_CHAR_ONLY);
3181     }
3182     edit_update_curs_row (edit);
3183 }
3184
3185 /* --------------------------------------------------------------------------------------------- */
3186
3187 void
3188 edit_scroll_right (WEdit * edit, long i)
3189 {
3190     edit->force |= REDRAW_PAGE;
3191     edit->force &= (0xfff - REDRAW_CHAR_ONLY);
3192     edit->start_col -= i;
3193 }
3194
3195 /* --------------------------------------------------------------------------------------------- */
3196
3197 void
3198 edit_scroll_left (WEdit * edit, long i)
3199 {
3200     if (edit->start_col)
3201     {
3202         edit->start_col += i;
3203         if (edit->start_col > 0)
3204             edit->start_col = 0;
3205         edit->force |= REDRAW_PAGE;
3206         edit->force &= (0xfff - REDRAW_CHAR_ONLY);
3207     }
3208 }
3209
3210 /* --------------------------------------------------------------------------------------------- */
3211 /* high level cursor movement commands */
3212 /* --------------------------------------------------------------------------------------------- */
3213
3214 void
3215 edit_move_to_prev_col (WEdit * edit, off_t p)
3216 {
3217     long prev = edit->prev_col;
3218     long over = edit->over_col;
3219
3220     edit_cursor_move (edit, edit_move_forward3 (edit, p, prev + edit->over_col, 0) - edit->curs1);
3221
3222     if (option_cursor_beyond_eol)
3223     {
3224         long line_len;
3225
3226         line_len = (long) edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0,
3227                                               edit_eol (edit, edit->curs1));
3228         if (line_len < prev + edit->over_col)
3229         {
3230             edit->over_col = prev + over - line_len;
3231             edit->prev_col = line_len;
3232             edit->curs_col = line_len;
3233         }
3234         else
3235         {
3236             edit->curs_col = prev + over;
3237             edit->prev_col = edit->curs_col;
3238             edit->over_col = 0;
3239         }
3240     }
3241     else
3242     {
3243         edit->over_col = 0;
3244         if (option_fake_half_tabs && is_in_indent (edit))
3245         {
3246             edit_update_curs_col (edit);
3247             if (space_width != 0 && edit->curs_col % (HALF_TAB_SIZE * space_width) != 0)
3248             {
3249                 int q;
3250
3251                 q = edit->curs_col;
3252                 edit->curs_col -= (edit->curs_col % (HALF_TAB_SIZE * space_width));
3253                 p = edit_bol (edit, edit->curs1);
3254                 edit_cursor_move (edit,
3255                                   edit_move_forward3 (edit, p, edit->curs_col, 0) - edit->curs1);
3256                 if (!left_of_four_spaces (edit))
3257                     edit_cursor_move (edit, edit_move_forward3 (edit, p, q, 0) - edit->curs1);
3258             }
3259         }
3260     }
3261 }
3262
3263 /* --------------------------------------------------------------------------------------------- */
3264 /** check whether line in editor is blank or not
3265  *
3266  * @param edit editor object
3267  * @param line number of line
3268  *
3269  * @return TRUE if line in blank, FALSE otherwise
3270  */
3271
3272 gboolean
3273 line_is_blank (WEdit * edit, long line)
3274 {
3275     return is_blank (edit, edit_find_line (edit, line));
3276 }
3277
3278 /* --------------------------------------------------------------------------------------------- */
3279 /** move cursor to line 'line' */
3280
3281 void
3282 edit_move_to_line (WEdit * e, long line)
3283 {
3284     if (line < e->curs_line)
3285         edit_move_up (e, e->curs_line - line, 0);
3286     else
3287         edit_move_down (e, line - e->curs_line, 0);
3288     edit_scroll_screen_over_cursor (e);
3289 }
3290
3291 /* --------------------------------------------------------------------------------------------- */
3292 /** scroll window so that first visible line is 'line' */
3293
3294 void
3295 edit_move_display (WEdit * e, long line)
3296 {
3297     if (line < e->start_line)
3298         edit_scroll_upward (e, e->start_line - line);
3299     else
3300         edit_scroll_downward (e, line - e->start_line);
3301 }
3302
3303 /* --------------------------------------------------------------------------------------------- */
3304 /** save markers onto undo stack */
3305
3306 void
3307 edit_push_markers (WEdit * edit)
3308 {
3309     edit_push_undo_action (edit, MARK_1 + edit->mark1);
3310     edit_push_undo_action (edit, MARK_2 + edit->mark2);
3311     edit_push_undo_action (edit, MARK_CURS + edit->end_mark_curs);
3312 }
3313
3314 /* --------------------------------------------------------------------------------------------- */
3315
3316 void
3317 edit_set_markers (WEdit * edit, off_t m1, off_t m2, long c1, long c2)
3318 {
3319     edit->mark1 = m1;
3320     edit->mark2 = m2;
3321     edit->column1 = c1;
3322     edit->column2 = c2;
3323 }
3324
3325 /* --------------------------------------------------------------------------------------------- */
3326 /** highlight marker toggle */
3327
3328 void
3329 edit_mark_cmd (WEdit * edit, gboolean unmark)
3330 {
3331     edit_push_markers (edit);
3332     if (unmark)
3333     {
3334         edit_set_markers (edit, 0, 0, 0, 0);
3335         edit->force |= REDRAW_PAGE;
3336     }
3337     else if (edit->mark2 >= 0)
3338     {
3339         edit->end_mark_curs = -1;
3340         edit_set_markers (edit, edit->curs1, -1, edit->curs_col + edit->over_col,
3341                           edit->curs_col + edit->over_col);
3342         edit->force |= REDRAW_PAGE;
3343     }
3344     else
3345     {
3346         edit->end_mark_curs = edit->curs1;
3347         edit_set_markers (edit, edit->mark1, edit->curs1, edit->column1,
3348                           edit->curs_col + edit->over_col);
3349     }
3350 }
3351
3352 /* --------------------------------------------------------------------------------------------- */
3353 /** highlight the word under cursor */
3354
3355 void
3356 edit_mark_current_word_cmd (WEdit * edit)
3357 {
3358     long pos;
3359
3360     for (pos = edit->curs1; pos != 0; pos--)
3361     {
3362         int c1, c2;
3363
3364         c1 = edit_get_byte (edit, pos);
3365         c2 = edit_get_byte (edit, pos - 1);
3366         if (!isspace (c1) && isspace (c2))
3367             break;
3368         if ((my_type_of (c1) & my_type_of (c2)) == 0)
3369             break;
3370     }
3371     edit->mark1 = pos;
3372
3373     for (; pos < edit->last_byte; pos++)
3374     {
3375         int c1, c2;
3376
3377         c1 = edit_get_byte (edit, pos);
3378         c2 = edit_get_byte (edit, pos + 1);
3379         if (!isspace (c1) && isspace (c2))
3380             break;
3381         if ((my_type_of (c1) & my_type_of (c2)) == 0)
3382             break;
3383     }
3384     edit->mark2 = min (pos + 1, edit->last_byte);
3385
3386     edit->force |= REDRAW_LINE_ABOVE | REDRAW_AFTER_CURSOR;
3387 }
3388
3389 /* --------------------------------------------------------------------------------------------- */
3390
3391 void
3392 edit_mark_current_line_cmd (WEdit * edit)
3393 {
3394     long pos = edit->curs1;
3395
3396     edit->mark1 = edit_bol (edit, pos);
3397     edit->mark2 = edit_eol (edit, pos);
3398
3399     edit->force |= REDRAW_LINE_ABOVE | REDRAW_AFTER_CURSOR;
3400 }
3401
3402 /* --------------------------------------------------------------------------------------------- */
3403
3404 void
3405 edit_delete_line (WEdit * edit)
3406 {
3407     /*
3408      * Delete right part of the line.
3409      * Note that edit_get_byte() returns '\n' when byte position is
3410      *   beyond EOF.
3411      */
3412     while (edit_get_byte (edit, edit->curs1) != '\n')
3413         (void) edit_delete (edit, 1);
3414
3415     /*
3416      * Delete '\n' char.
3417      * Note that edit_delete() will not corrupt anything if called while
3418      *   cursor position is EOF.
3419      */
3420     (void) edit_delete (edit, 1);
3421
3422     /*
3423      * Delete left part of the line.
3424      * Note, that edit_get_byte() returns '\n' when byte position is < 0.
3425      */
3426     while (edit_get_byte (edit, edit->curs1 - 1) != '\n')
3427         (void) edit_backspace (edit, 1);
3428 }
3429
3430 /* --------------------------------------------------------------------------------------------- */
3431
3432 long
3433 edit_indent_width (WEdit * edit, off_t p)
3434 {
3435     off_t q = p;
3436
3437     /* move to the end of the leading whitespace of the line */
3438     while (strchr ("\t ", edit_get_byte (edit, q)) && q < edit->last_byte - 1)
3439         q++;
3440     /* count the number of columns of indentation */
3441     return (long) edit_move_forward3 (edit, p, 0, q);
3442 }
3443
3444 /* --------------------------------------------------------------------------------------------- */
3445
3446 void
3447 edit_insert_indent (WEdit * edit, int indent)
3448 {
3449     if (!option_fill_tabs_with_spaces)
3450     {
3451         while (indent >= TAB_SIZE)
3452         {
3453             edit_insert (edit, '\t');
3454             indent -= TAB_SIZE;
3455         }
3456     }
3457     while (indent-- > 0)
3458         edit_insert (edit, ' ');
3459 }
3460
3461 /* --------------------------------------------------------------------------------------------- */
3462
3463 void
3464 edit_push_key_press (WEdit * edit)
3465 {
3466     edit_push_undo_action (edit, KEY_PRESS + edit->start_display);
3467     if (edit->mark2 == -1)
3468     {
3469         edit_push_undo_action (edit, MARK_1 + edit->mark1);
3470         edit_push_undo_action (edit, MARK_CURS + edit->end_mark_curs);
3471     }
3472 }
3473
3474 /* --------------------------------------------------------------------------------------------- */
3475
3476 void
3477 edit_find_bracket (WEdit * edit)
3478 {
3479     edit->bracket = edit_get_bracket (edit, 1, 10000);
3480     if (last_bracket != edit->bracket)
3481         edit->force |= REDRAW_PAGE;
3482     last_bracket = edit->bracket;
3483 }
3484
3485 /* --------------------------------------------------------------------------------------------- */
3486 /**
3487  * This executes a command as though the user initiated it through a key
3488  * press.  Callback with WIDGET_KEY as a message calls this after
3489  * translating the key press.  This function can be used to pass any
3490  * command to the editor.  Note that the screen wouldn't update
3491  * automatically.  Either of command or char_for_insertion must be
3492  * passed as -1.  Commands are executed, and char_for_insertion is
3493  * inserted at the cursor.
3494  */
3495
3496 void
3497 edit_execute_key_command (WEdit * edit, unsigned long command, int char_for_insertion)
3498 {
3499     if (command == CK_MacroStartRecord || command == CK_RepeatStartRecord
3500         || (macro_index < 0
3501             && (command == CK_MacroStartStopRecord || command == CK_RepeatStartStopRecord)))
3502     {
3503         macro_index = 0;
3504         edit->force |= REDRAW_CHAR_ONLY | REDRAW_LINE;
3505         return;
3506     }
3507     if (macro_index != -1)
3508     {
3509         edit->force |= REDRAW_COMPLETELY;
3510         if (command == CK_MacroStopRecord || command == CK_MacroStartStopRecord)
3511         {
3512             edit_store_macro_cmd (edit);
3513             macro_index = -1;
3514             return;
3515         }
3516         if (command == CK_RepeatStopRecord || command == CK_RepeatStartStopRecord)
3517         {
3518             edit_repeat_macro_cmd (edit);
3519             macro_index = -1;
3520             return;
3521         }
3522     }
3523
3524     if (macro_index >= 0 && macro_index < MAX_MACRO_LENGTH - 1)
3525     {
3526         record_macro_buf[macro_index].action = command;
3527         record_macro_buf[macro_index++].ch = char_for_insertion;
3528     }
3529     /* record the beginning of a set of editing actions initiated by a key press */
3530     if (command != CK_Undo && command != CK_ExtendedKeyMap)
3531         edit_push_key_press (edit);
3532
3533     edit_execute_cmd (edit, command, char_for_insertion);
3534     if (edit->column_highlight)
3535         edit->force |= REDRAW_PAGE;
3536 }
3537
3538 /* --------------------------------------------------------------------------------------------- */
3539 /**
3540    This executes a command at a lower level than macro recording.
3541    It also does not push a key_press onto the undo stack. This means
3542    that if it is called many times, a single undo command will undo
3543    all of them. It also does not check for the Undo command.
3544  */
3545 void
3546 edit_execute_cmd (WEdit * edit, unsigned long command, int char_for_insertion)
3547 {
3548     edit->force |= REDRAW_LINE;
3549
3550     /* The next key press will unhighlight the found string, so update
3551      * the whole page */
3552     if (edit->found_len || edit->column_highlight)
3553         edit->force |= REDRAW_PAGE;
3554
3555     switch (command)
3556     {
3557         /* a mark command with shift-arrow */
3558     case CK_MarkLeft:
3559     case CK_MarkRight:
3560     case CK_MarkToWordBegin:
3561     case CK_MarkToWordEnd:
3562     case CK_MarkToHome:
3563     case CK_MarkToEnd:
3564     case CK_MarkUp:
3565     case CK_MarkDown:
3566     case CK_MarkPageUp:
3567     case CK_MarkPageDown:
3568     case CK_MarkToFileBegin:
3569     case CK_MarkToFileEnd:
3570     case CK_MarkToPageBegin:
3571     case CK_MarkToPageEnd:
3572     case CK_MarkScrollUp:
3573     case CK_MarkScrollDown:
3574     case CK_MarkParagraphUp:
3575     case CK_MarkParagraphDown:
3576         /* a mark command with alt-arrow */
3577     case CK_MarkColumnPageUp:
3578     case CK_MarkColumnPageDown:
3579     case CK_MarkColumnLeft:
3580     case CK_MarkColumnRight:
3581     case CK_MarkColumnUp:
3582     case CK_MarkColumnDown:
3583     case CK_MarkColumnScrollUp:
3584     case CK_MarkColumnScrollDown:
3585     case CK_MarkColumnParagraphUp:
3586     case CK_MarkColumnParagraphDown:
3587         edit->column_highlight = 0;
3588         if (edit->highlight == 0 || (edit->mark2 != -1 && edit->mark1 != edit->mark2))
3589         {
3590             edit_mark_cmd (edit, TRUE); /* clear */
3591             edit_mark_cmd (edit, FALSE);        /* marking on */
3592         }
3593         edit->highlight = 1;
3594         break;
3595
3596         /* any other command */
3597     default:
3598         if (edit->highlight)
3599             edit_mark_cmd (edit, FALSE);        /* clear */
3600         edit->highlight = 0;
3601     }
3602
3603     /* first check for undo */
3604     if (command == CK_Undo)
3605     {
3606         edit->redo_stack_reset = 0;
3607         edit_group_undo (edit);
3608         edit->found_len = 0;
3609         edit->prev_col = edit_get_col (edit);
3610         edit->search_start = edit->curs1;
3611         return;
3612     }
3613     /*  check for redo */
3614     if (command == CK_Redo)
3615     {
3616         edit->redo_stack_reset = 0;
3617         edit_do_redo (edit);
3618         edit->found_len = 0;
3619         edit->prev_col = edit_get_col (edit);
3620         edit->search_start = edit->curs1;
3621         return;
3622     }
3623
3624     edit->redo_stack_reset = 1;
3625
3626     /* An ordinary key press */
3627     if (char_for_insertion >= 0)
3628     {
3629         /* if non persistent selection and text selected */
3630         if (!option_persistent_selections && edit->mark1 != edit->mark2)
3631             edit_block_delete_cmd (edit);
3632
3633         if (edit->overwrite)
3634         {
3635             /* remove char only one time, after input first byte, multibyte chars */
3636 #ifdef HAVE_CHARSET
3637             if (!mc_global.utf8_display || edit->charpoint == 0)
3638 #endif
3639                 if (edit_get_byte (edit, edit->curs1) != '\n')
3640                     edit_delete (edit, 0);
3641         }
3642         if (option_cursor_beyond_eol && edit->over_col > 0)
3643             edit_insert_over (edit);
3644 #ifdef HAVE_CHARSET
3645         if (char_for_insertion > 255 && !mc_global.utf8_display)
3646         {
3647             unsigned char str[6 + 1];
3648             size_t i = 0;
3649             int res;
3650
3651             res = g_unichar_to_utf8 (char_for_insertion, (char *) str);
3652             if (res == 0)
3653             {
3654                 str[0] = '.';
3655                 str[1] = '\0';
3656             }
3657             else
3658             {
3659                 str[res] = '\0';
3660             }
3661             while (str[i] != 0 && i <= 6)
3662             {
3663                 char_for_insertion = str[i];
3664                 edit_insert (edit, char_for_insertion);
3665                 i++;
3666             }
3667         }
3668         else
3669 #endif
3670             edit_insert (edit, char_for_insertion);
3671
3672         if (option_auto_para_formatting)
3673         {
3674             format_paragraph (edit, 0);
3675             edit->force |= REDRAW_PAGE;
3676         }
3677         else
3678             check_and_wrap_line (edit);
3679         edit->found_len = 0;
3680         edit->prev_col = edit_get_col (edit);
3681         edit->search_start = edit->curs1;
3682         edit_find_bracket (edit);
3683         return;
3684     }
3685
3686     switch (command)
3687     {
3688     case CK_TopOnScreen:
3689     case CK_BottomOnScreen:
3690     case CK_Top:
3691     case CK_Bottom:
3692     case CK_PageUp:
3693     case CK_PageDown:
3694     case CK_Home:
3695     case CK_End:
3696     case CK_Up:
3697     case CK_Down:
3698     case CK_Left:
3699     case CK_Right:
3700     case CK_WordLeft:
3701     case CK_WordRight:
3702         if (!option_persistent_selections && edit->mark2 >= 0)
3703         {
3704             if (edit->column_highlight)
3705                 edit_push_undo_action (edit, COLUMN_ON);
3706             edit->column_highlight = 0;
3707             edit_mark_cmd (edit, TRUE);
3708         }
3709     }
3710
3711     switch (command)
3712     {
3713     case CK_TopOnScreen:
3714     case CK_BottomOnScreen:
3715     case CK_MarkToPageBegin:
3716     case CK_MarkToPageEnd:
3717     case CK_Up:
3718     case CK_Down:
3719     case CK_WordLeft:
3720     case CK_WordRight:
3721     case CK_MarkToWordBegin:
3722     case CK_MarkToWordEnd:
3723     case CK_MarkUp:
3724     case CK_MarkDown:
3725     case CK_MarkColumnUp:
3726     case CK_MarkColumnDown:
3727         if (edit->mark2 == -1)
3728             break;              /*marking is following the cursor: may need to highlight a whole line */
3729     case CK_Left:
3730     case CK_Right:
3731     case CK_MarkLeft:
3732     case CK_MarkRight:
3733         edit->force |= REDRAW_CHAR_ONLY;
3734     }
3735
3736     /* basic cursor key commands */
3737     switch (command)
3738     {
3739     case CK_BackSpace:
3740         /* if non persistent selection and text selected */
3741         if (!option_persistent_selections && edit->mark1 != edit->mark2)
3742             edit_block_delete_cmd (edit);
3743         else if (option_cursor_beyond_eol && edit->over_col > 0)
3744             edit->over_col--;
3745         else if (option_backspace_through_tabs && is_in_indent (edit))
3746             while (edit_get_byte (edit, edit->curs1 - 1) != '\n' && edit->curs1 > 0)
3747                 edit_backspace (edit, 1);
3748         else if (option_fake_half_tabs && is_in_indent (edit) && right_of_four_spaces (edit))
3749         {
3750             int i;
3751
3752             for (i = 0; i < HALF_TAB_SIZE; i++)
3753                 edit_backspace (edit, 1);
3754         }
3755         else
3756             edit_backspace (edit, 0);
3757         break;
3758     case CK_Delete:
3759         /* if non persistent selection and text selected */
3760         if (!option_persistent_selections && edit->mark1 != edit->mark2)
3761             edit_block_delete_cmd (edit);
3762         else
3763         {
3764             if (option_cursor_beyond_eol && edit->over_col > 0)
3765                 edit_insert_over (edit);
3766
3767             if (option_fake_half_tabs && is_in_indent (edit) && left_of_four_spaces (edit))
3768             {
3769                 int i;
3770
3771                 for (i = 1; i <= HALF_TAB_SIZE; i++)
3772                     edit_delete (edit, 1);
3773             }
3774             else
3775                 edit_delete (edit, 0);
3776         }
3777         break;
3778     case CK_DeleteToWordBegin:
3779         edit->over_col = 0;
3780         edit_left_delete_word (edit);
3781         break;
3782     case CK_DeleteToWordEnd:
3783         if (option_cursor_beyond_eol && edit->over_col > 0)
3784             edit_insert_over (edit);
3785
3786         edit_right_delete_word (edit);
3787         break;
3788     case CK_DeleteLine:
3789         edit_delete_line (edit);
3790         break;
3791     case CK_DeleteToHome:
3792         edit_delete_to_line_begin (edit);
3793         break;
3794     case CK_DeleteToEnd:
3795         edit_delete_to_line_end (edit);
3796         break;
3797     case CK_Enter:
3798         edit->over_col = 0;
3799         if (option_auto_para_formatting)
3800         {
3801             edit_double_newline (edit);
3802             if (option_return_does_auto_indent)
3803                 edit_auto_indent (edit);
3804             format_paragraph (edit, 0);
3805         }
3806         else
3807         {
3808             edit_insert (edit, '\n');
3809             if (option_return_does_auto_indent)
3810                 edit_auto_indent (edit);
3811         }
3812         break;
3813     case CK_Return:
3814         edit_insert (edit, '\n');
3815         break;
3816
3817     case CK_MarkColumnPageUp:
3818         edit->column_highlight = 1;
3819     case CK_PageUp:
3820     case CK_MarkPageUp:
3821         edit_move_up (edit, edit->widget.lines - 1, 1);
3822         break;
3823     case CK_MarkColumnPageDown:
3824         edit->column_highlight = 1;
3825     case CK_PageDown:
3826     case CK_MarkPageDown:
3827         edit_move_down (edit, edit->widget.lines - 1, 1);
3828         break;
3829     case CK_MarkColumnLeft:
3830         edit->column_highlight = 1;
3831     case CK_Left:
3832     case CK_MarkLeft:
3833         if (option_fake_half_tabs && is_in_indent (edit) && right_of_four_spaces (edit))
3834         {
3835             if (option_cursor_beyond_eol && edit->over_col > 0)
3836                 edit->over_col--;
3837             else
3838                 edit_cursor_move (edit, -HALF_TAB_SIZE);
3839             edit->force &= (0xFFF - REDRAW_CHAR_ONLY);
3840         }
3841         else
3842             edit_left_char_move_cmd (edit);
3843         break;
3844     case CK_MarkColumnRight:
3845         edit->column_highlight = 1;
3846     case CK_Right:
3847     case CK_MarkRight:
3848         if (option_fake_half_tabs && is_in_indent (edit) && left_of_four_spaces (edit))
3849         {
3850             edit_cursor_move (edit, HALF_TAB_SIZE);
3851             edit->force &= (0xFFF - REDRAW_CHAR_ONLY);
3852         }
3853         else
3854             edit_right_char_move_cmd (edit);
3855         break;
3856     case CK_TopOnScreen:
3857     case CK_MarkToPageBegin:
3858         edit_begin_page (edit);
3859         break;
3860     case CK_BottomOnScreen:
3861     case CK_MarkToPageEnd:
3862         edit_end_page (edit);
3863         break;
3864     case CK_WordLeft:
3865     case CK_MarkToWordBegin:
3866         edit->over_col = 0;
3867         edit_left_word_move_cmd (edit);
3868         break;
3869     case CK_WordRight:
3870     case CK_MarkToWordEnd:
3871         edit->over_col = 0;
3872         edit_right_word_move_cmd (edit);
3873         break;
3874     case CK_MarkColumnUp:
3875         edit->column_highlight = 1;
3876     case CK_Up:
3877     case CK_MarkUp:
3878         edit_move_up (edit, 1, 0);
3879         break;
3880     case CK_MarkColumnDown:
3881         edit->column_highlight = 1;
3882     case CK_Down:
3883     case CK_MarkDown:
3884         edit_move_down (edit, 1, 0);
3885         break;
3886     case CK_MarkColumnParagraphUp:
3887         edit->column_highlight = 1;
3888     case CK_ParagraphUp:
3889     case CK_MarkParagraphUp:
3890         edit_move_up_paragraph (edit, 0);
3891         break;
3892     case CK_MarkColumnParagraphDown:
3893         edit->column_highlight = 1;
3894     case CK_ParagraphDown:
3895     case CK_MarkParagraphDown:
3896         edit_move_down_paragraph (edit, 0);
3897         break;
3898     case CK_MarkColumnScrollUp:
3899         edit->column_highlight = 1;
3900     case CK_ScrollUp:
3901     case CK_MarkScrollUp:
3902         edit_move_up (edit, 1, 1);
3903         break;
3904     case CK_MarkColumnScrollDown:
3905         edit->column_highlight = 1;
3906     case CK_ScrollDown:
3907     case CK_MarkScrollDown:
3908         edit_move_down (edit, 1, 1);
3909         break;
3910     case CK_Home:
3911     case CK_MarkToHome:
3912         edit_cursor_to_bol (edit);
3913         break;
3914     case CK_End:
3915     case CK_MarkToEnd:
3916         edit_cursor_to_eol (edit);
3917         break;
3918     case CK_Tab:
3919         /* if text marked shift block */
3920         if (edit->mark1 != edit->mark2 && !option_persistent_selections)
3921         {
3922             if (edit->mark2 < 0)
3923                 edit_mark_cmd (edit, FALSE);
3924             edit_move_block_to_right (edit);
3925         }
3926         else
3927         {
3928             if (option_cursor_beyond_eol)
3929                 edit_insert_over (edit);
3930             edit_tab_cmd (edit);
3931             if (option_auto_para_formatting)
3932             {
3933                 format_paragraph (edit, 0);
3934                 edit->force |= REDRAW_PAGE;
3935             }
3936             else
3937                 check_and_wrap_line (edit);
3938         }
3939         break;
3940
3941     case CK_InsertOverwrite:
3942         edit->overwrite = !edit->overwrite;
3943         break;
3944
3945     case CK_Mark:
3946         if (edit->mark2 >= 0)
3947         {
3948             if (edit->column_highlight)
3949                 edit_push_undo_action (edit, COLUMN_ON);
3950             edit->column_highlight = 0;
3951         }
3952         edit_mark_cmd (edit, FALSE);
3953         break;
3954     case CK_MarkColumn:
3955         if (!edit->column_highlight)
3956             edit_push_undo_action (edit, COLUMN_OFF);
3957         edit->column_highlight = 1;
3958         edit_mark_cmd (edit, FALSE);
3959         break;
3960     case CK_MarkAll:
3961         edit_set_markers (edit, 0, edit->last_byte, 0, 0);
3962         edit->force |= REDRAW_PAGE;
3963         break;
3964     case CK_Unmark:
3965         if (edit->column_highlight)
3966             edit_push_undo_action (edit, COLUMN_ON);
3967         edit->column_highlight = 0;
3968         edit_mark_cmd (edit, TRUE);
3969         break;
3970     case CK_MarkWord:
3971         if (edit->column_highlight)
3972             edit_push_undo_action (edit, COLUMN_ON);
3973         edit->column_highlight = 0;
3974         edit_mark_current_word_cmd (edit);
3975         break;
3976     case CK_MarkLine:
3977         if (edit->column_highlight)
3978             edit_push_undo_action (edit, COLUMN_ON);
3979         edit->column_highlight = 0;
3980         edit_mark_current_line_cmd (edit);
3981         break;
3982
3983     case CK_ShowNumbers:
3984         option_line_state = !option_line_state;
3985         option_line_state_width = option_line_state ? LINE_STATE_WIDTH : 0;
3986         edit->force |= REDRAW_PAGE;
3987         break;
3988
3989     case CK_ShowMargin:
3990         show_right_margin = !show_right_margin;
3991         edit->force |= REDRAW_PAGE;
3992         break;
3993
3994     case CK_Bookmark:
3995         book_mark_clear (edit, edit->curs_line, BOOK_MARK_FOUND_COLOR);
3996         if (book_mark_query_color (edit, edit->curs_line, BOOK_MARK_COLOR))
3997             book_mark_clear (edit, edit->curs_line, BOOK_MARK_COLOR);
3998         else
3999             book_mark_insert (edit, edit->curs_line, BOOK_MARK_COLOR);
4000         break;
4001     case CK_BookmarkFlush:
4002         book_mark_flush (edit, BOOK_MARK_COLOR);
4003         book_mark_flush (edit, BOOK_MARK_FOUND_COLOR);
4004         edit->force |= REDRAW_PAGE;
4005         break;
4006     case CK_BookmarkNext:
4007         if (edit->book_mark != NULL)
4008         {
4009             struct _book_mark *p;
4010
4011             p = (struct _book_mark *) book_mark_find (edit, edit->curs_line);
4012             if (p->next != NULL)
4013             {
4014                 p = p->next;
4015                 if (p->line >= edit->start_line + edit->widget.lines || p->line < edit->start_line)
4016                     edit_move_display (edit, p->line - edit->widget.lines / 2);
4017                 edit_move_to_line (edit, p->line);
4018             }
4019         }
4020         break;
4021     case CK_BookmarkPrev:
4022         if (edit->book_mark != NULL)
4023         {
4024             struct _book_mark *p;
4025
4026             p = (struct _book_mark *) book_mark_find (edit, edit->curs_line);
4027             while (p->line == edit->curs_line)
4028                 if (p->prev != NULL)
4029                     p = p->prev;
4030             if (p->line >= 0)
4031             {
4032                 if (p->line >= edit->start_line + edit->widget.lines || p->line < edit->start_line)
4033                     edit_move_display (edit, p->line - edit->widget.lines / 2);
4034                 edit_move_to_line (edit, p->line);
4035             }
4036         }
4037         break;
4038
4039     case CK_Top:
4040     case CK_MarkToFileBegin:
4041         edit_move_to_top (edit);
4042         break;
4043     case CK_Bottom:
4044     case CK_MarkToFileEnd:
4045         edit_move_to_bottom (edit);
4046         break;
4047
4048     case CK_Copy:
4049         if (option_cursor_beyond_eol && edit->over_col > 0)
4050             edit_insert_over (edit);
4051         edit_block_copy_cmd (edit);
4052         break;
4053     case CK_Remove:
4054         edit_block_delete_cmd (edit);
4055         break;
4056     case CK_Move:
4057         edit_block_move_cmd (edit);
4058         break;
4059
4060     case CK_BlockShiftLeft:
4061         if (edit->mark1 != edit->mark2)
4062             edit_move_block_to_left (edit);
4063         break;
4064     case CK_BlockShiftRight:
4065         if (edit->mark1 != edit->mark2)
4066             edit_move_block_to_right (edit);
4067         break;
4068     case CK_Store:
4069         edit_copy_to_X_buf_cmd (edit);
4070         break;
4071     case CK_Cut:
4072         edit_cut_to_X_buf_cmd (edit);
4073         break;
4074     case CK_Paste:
4075         /* if non persistent selection and text selected */
4076         if (!option_persistent_selections && edit->mark1 != edit->mark2)
4077             edit_block_delete_cmd (edit);
4078         if (option_cursor_beyond_eol && edit->over_col > 0)
4079             edit_insert_over (edit);
4080         edit_paste_from_X_buf_cmd (edit);
4081         break;
4082     case CK_History:
4083         edit_paste_from_history (edit);
4084         break;
4085
4086     case CK_SaveAs:
4087         edit_save_as_cmd (edit);
4088         break;
4089     case CK_Save:
4090         edit_save_confirm_cmd (edit);
4091         break;
4092     case CK_EditFile:
4093         edit_load_cmd (edit, EDIT_FILE_COMMON);
4094         break;
4095     case CK_BlockSave:
4096         edit_save_block_cmd (edit);
4097         break;
4098     case CK_InsertFile:
4099         edit_insert_file_cmd (edit);
4100         break;
4101
4102     case CK_FilePrev:
4103         edit_load_back_cmd (edit);
4104         break;
4105     case CK_FileNext:
4106         edit_load_forward_cmd (edit);
4107         break;
4108
4109     case CK_EditSyntaxFile:
4110         edit_load_cmd (edit, EDIT_FILE_SYNTAX);
4111         break;
4112     case CK_SyntaxChoose:
4113         edit_syntax_dialog (edit);
4114         break;
4115
4116     case CK_EditUserMenu:
4117         edit_load_cmd (edit, EDIT_FILE_MENU);
4118         break;
4119
4120     case CK_SyntaxOnOff:
4121         option_syntax_highlighting ^= 1;
4122         if (option_syntax_highlighting == 1)
4123             edit_load_syntax (edit, NULL, edit->syntax_type);
4124         edit->force |= REDRAW_PAGE;
4125         break;
4126
4127     case CK_ShowTabTws:
4128         enable_show_tabs_tws ^= 1;
4129         edit->force |= REDRAW_PAGE;
4130         break;
4131
4132     case CK_Search:
4133         edit_search_cmd (edit, FALSE);
4134         break;
4135     case CK_SearchContinue:
4136         edit_search_cmd (edit, TRUE);
4137         break;
4138     case CK_Replace:
4139         edit_replace_cmd (edit, 0);
4140         break;
4141     case CK_ReplaceContinue:
4142         edit_replace_cmd (edit, 1);
4143         break;
4144     case CK_Complete:
4145         /* if text marked shift block */
4146         if (edit->mark1 != edit->mark2 && !option_persistent_selections)
4147             edit_move_block_to_left (edit);
4148         else
4149             edit_complete_word_cmd (edit);
4150         break;
4151     case CK_Find:
4152         edit_get_match_keyword_cmd (edit);
4153         break;
4154     case CK_Quit:
4155         dlg_stop (edit->widget.owner);
4156         break;
4157     case CK_EditNew:
4158         edit_new_cmd (edit);
4159         break;
4160     case CK_Help:
4161         edit_help_cmd (edit);
4162         break;
4163     case CK_Refresh:
4164         edit_refresh_cmd (edit);
4165         break;
4166     case CK_SaveSetup:
4167         save_setup_cmd ();
4168         break;
4169     case CK_About:
4170         edit_about ();
4171         break;
4172     case CK_LearnKeys:
4173         learn_keys ();
4174         break;
4175     case CK_Options:
4176         edit_options_dialog (edit);
4177         break;
4178     case CK_OptionsSaveMode:
4179         menu_save_mode_cmd ();
4180         break;
4181     case CK_Date:
4182         {
4183             char s[BUF_MEDIUM];
4184             /* fool gcc to prevent a Y2K warning */
4185             char time_format[] = "_c";
4186             time_format[0] = '%';
4187
4188             FMT_LOCALTIME_CURRENT (s, sizeof (s), time_format);
4189             edit_print_string (edit, s);
4190             edit->force |= REDRAW_PAGE;
4191         }
4192         break;
4193     case CK_Goto:
4194         edit_goto_cmd (edit);
4195         break;
4196     case CK_ParagraphFormat:
4197         format_paragraph (edit, 1);
4198         edit->force |= REDRAW_PAGE;
4199         break;
4200     case CK_MacroDelete:
4201         edit_delete_macro_cmd (edit);
4202         break;
4203     case CK_MatchBracket:
4204         edit_goto_matching_bracket (edit);
4205         break;
4206     case CK_UserMenu:
4207         user_menu (edit, NULL, -1);
4208         break;
4209     case CK_Sort:
4210         edit_sort_cmd (edit);
4211         break;
4212     case CK_ExternalCommand:
4213         edit_ext_cmd (edit);
4214         break;
4215     case CK_Mail:
4216         edit_mail_dialog (edit);
4217         break;
4218     case CK_Shell:
4219         view_other_cmd ();
4220         break;
4221 #ifdef HAVE_CHARSET
4222     case CK_SelectCodepage:
4223         edit_select_codepage_cmd (edit);
4224         break;
4225 #endif
4226     case CK_InsertLiteral:
4227         edit_insert_literal_cmd (edit);
4228         break;
4229     case CK_MacroStartStopRecord:
4230         edit_begin_end_macro_cmd (edit);
4231         break;
4232     case CK_RepeatStartStopRecord:
4233         edit_begin_end_repeat_cmd (edit);
4234         break;
4235     case CK_ExtendedKeyMap:
4236         edit->extmod = TRUE;
4237         break;
4238     default:
4239         break;
4240     }
4241
4242     /* CK_PipeBlock */
4243     if ((command / CK_PipeBlock (0)) == 1)
4244         edit_block_process_cmd (edit, command - CK_PipeBlock (0));
4245
4246     /* keys which must set the col position, and the search vars */
4247     switch (command)
4248     {
4249     case CK_Search:
4250     case CK_SearchContinue:
4251     case CK_Replace:
4252     case CK_ReplaceContinue:
4253     case CK_Complete:
4254         edit->prev_col = edit_get_col (edit);
4255         break;
4256     case CK_Up:
4257     case CK_MarkUp:
4258     case CK_MarkColumnUp:
4259     case CK_Down:
4260     case CK_MarkDown:
4261     case CK_MarkColumnDown:
4262     case CK_PageUp:
4263     case CK_MarkPageUp:
4264     case CK_MarkColumnPageUp:
4265     case CK_PageDown:
4266     case CK_MarkPageDown:
4267     case CK_MarkColumnPageDown:
4268     case CK_Top:
4269     case CK_MarkToFileBegin:
4270     case CK_Bottom:
4271     case CK_MarkToFileEnd:
4272     case CK_ParagraphUp:
4273     case CK_MarkParagraphUp:
4274     case CK_MarkColumnParagraphUp:
4275     case CK_ParagraphDown:
4276     case CK_MarkParagraphDown:
4277     case CK_MarkColumnParagraphDown:
4278     case CK_ScrollUp:
4279     case CK_MarkScrollUp:
4280     case CK_MarkColumnScrollUp:
4281     case CK_ScrollDown:
4282     case CK_MarkScrollDown:
4283     case CK_MarkColumnScrollDown:
4284         edit->search_start = edit->curs1;
4285         edit->found_len = 0;
4286         break;
4287     default:
4288         edit->found_len = 0;
4289         edit->prev_col = edit_get_col (edit);
4290         edit->search_start = edit->curs1;
4291     }
4292     edit_find_bracket (edit);
4293
4294     if (option_auto_para_formatting)
4295     {
4296         switch (command)
4297         {
4298         case CK_BackSpace:
4299         case CK_Delete:
4300         case CK_DeleteToWordBegin:
4301         case CK_DeleteToWordEnd:
4302         case CK_DeleteToHome:
4303         case CK_DeleteToEnd:
4304             format_paragraph (edit, 0);
4305             edit->force |= REDRAW_PAGE;
4306         }
4307     }
4308 }
4309
4310 /* --------------------------------------------------------------------------------------------- */
4311
4312 void
4313 edit_stack_init (void)
4314 {
4315     for (edit_stack_iterator = 0; edit_stack_iterator < MAX_HISTORY_MOVETO; edit_stack_iterator++)
4316     {
4317         edit_history_moveto[edit_stack_iterator].filename_vpath = NULL;
4318         edit_history_moveto[edit_stack_iterator].line = -1;
4319     }
4320
4321     edit_stack_iterator = 0;
4322 }
4323
4324 /* --------------------------------------------------------------------------------------------- */
4325
4326 void
4327 edit_stack_free (void)
4328 {
4329     for (edit_stack_iterator = 0; edit_stack_iterator < MAX_HISTORY_MOVETO; edit_stack_iterator++)
4330         vfs_path_free (edit_history_moveto[edit_stack_iterator].filename_vpath);
4331 }
4332
4333 /* --------------------------------------------------------------------------------------------- */
4334 /** move i lines */
4335
4336 void
4337 edit_move_up (WEdit * edit, long i, gboolean do_scroll)
4338 {
4339     edit_move_updown (edit, i, do_scroll, TRUE);
4340 }
4341
4342 /* --------------------------------------------------------------------------------------------- */
4343 /** move i lines */
4344
4345 void
4346 edit_move_down (WEdit * edit, long i, gboolean do_scroll)
4347 {
4348     edit_move_updown (edit, i, do_scroll, FALSE);
4349 }
4350
4351 /* --------------------------------------------------------------------------------------------- */