src/editor/edit.c

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