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