src/editor/editwidget.c

   1 /*
   2    Editor initialisation and callback handler.
   3
   4    Copyright (C) 1996-2020
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Paul Sheer, 1996, 1997
   9    Andrew Borodin <aborodin@vmail.ru> 2012, 2013
  10
  11    This file is part of the Midnight Commander.
  12
  13    The Midnight Commander is free software: you can redistribute it
  14    and/or modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation, either version 3 of the License,
  16    or (at your option) any later version.
  17
  18    The Midnight Commander is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25  */
  26
  27 /** \file
  28  *  \brief Source: editor initialisation and callback handler
  29  *  \author Paul Sheer
  30  *  \date 1996, 1997
  31  */
  32
  33 #include <config.h>
  34
  35 #include <ctype.h>
  36 #include <errno.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <sys/types.h>
  40 #include <unistd.h>
  41
  42 #include "lib/global.h"
  43
  44 #include "lib/tty/tty.h"        /* LINES, COLS */
  45 #include "lib/tty/key.h"        /* is_idle() */
  46 #include "lib/tty/color.h"      /* tty_setcolor() */
  47 #include "lib/skin.h"
  48 #include "lib/fileloc.h"        /* EDIT_DIR */
  49 #include "lib/strutil.h"        /* str_term_trim() */
  50 #include "lib/util.h"           /* mc_build_filename() */
  51 #include "lib/widget.h"
  52 #include "lib/mcconfig.h"
  53 #include "lib/event.h"          /* mc_event_raise() */
  54 #ifdef HAVE_CHARSET
  55 #include "lib/charsets.h"
  56 #endif
  57
  58 #include "src/keybind-defaults.h"       /* keybind_lookup_keymap_command() */
  59 #include "src/setup.h"          /* home_dir */
  60 #include "src/execute.h"        /* toggle_subshell()  */
  61 #include "src/filemanager/cmd.h"        /* save_setup_cmd()  */
  62 #include "src/learn.h"          /* learn_keys() */
  63 #include "src/args.h"           /* mcedit_arg_t */
  64
  65 #include "edit-impl.h"
  66 #include "editwidget.h"
  67 #ifdef HAVE_ASPELL
  68 #include "spell.h"
  69 #endif
  70
  71 /*** global variables ****************************************************************************/
  72
  73 char *edit_window_state_char = NULL;
  74 char *edit_window_close_char = NULL;
  75
  76 /*** file scope macro definitions ****************************************************************/
  77
  78 #define WINDOW_MIN_LINES (2 + 2)
  79 #define WINDOW_MIN_COLS (2 + LINE_STATE_WIDTH + 2)
  80
  81 /*** file scope type declarations ****************************************************************/
  82
  83 /*** file scope variables ************************************************************************/
  84 static unsigned int edit_dlg_init_refcounter = 0;
  85
  86 /*** file scope functions ************************************************************************/
  87
  88 static cb_ret_t edit_dialog_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm,
  89                                       void *data);
  90
  91 /* --------------------------------------------------------------------------------------------- */
  92 /**
  93  * Init the 'edit' subsystem
  94  */
  95
  96 static void
  97 edit_dlg_init (void)
  98 {
  99     if (edit_dlg_init_refcounter == 0)
 100     {
 101         edit_window_state_char = mc_skin_get ("widget-editor", "window-state-char", "*");
 102         edit_window_close_char = mc_skin_get ("widget-editor", "window-close-char", "X");
 103
 104 #ifdef HAVE_ASPELL
 105         aspell_init ();
 106 #endif
 107     }
 108
 109     edit_dlg_init_refcounter++;
 110 }
 111
 112 /* --------------------------------------------------------------------------------------------- */
 113 /**
 114  * Deinit the 'edit' subsystem
 115  */
 116
 117 static void
 118 edit_dlg_deinit (void)
 119 {
 120     if (edit_dlg_init_refcounter != 0)
 121         edit_dlg_init_refcounter--;
 122
 123     if (edit_dlg_init_refcounter == 0)
 124     {
 125         g_free (edit_window_state_char);
 126         g_free (edit_window_close_char);
 127
 128 #ifdef HAVE_ASPELL
 129         aspell_clean ();
 130 #endif
 131     }
 132 }
 133
 134 /* --------------------------------------------------------------------------------------------- */
 135 /**
 136  * Show info about editor
 137  */
 138
 139 static void
 140 edit_about (void)
 141 {
 142     quick_widget_t quick_widgets[] = {
 143         /* *INDENT-OFF* */
 144         QUICK_LABEL ("MCEdit " VERSION, NULL),
 145         QUICK_SEPARATOR (TRUE),
 146         QUICK_LABEL (N_("A user friendly text editor\n"
 147                         "written for the Midnight Commander."), NULL),
 148         QUICK_SEPARATOR (FALSE),
 149         QUICK_LABEL (N_("Copyright (C) 1996-2020 the Free Software Foundation"), NULL),
 150         QUICK_START_BUTTONS (TRUE, TRUE),
 151             QUICK_BUTTON (N_("&OK"), B_ENTER, NULL, NULL),
 152         QUICK_END
 153         /* *INDENT-ON* */
 154     };
 155
 156     quick_dialog_t qdlg = {
 157         -1, -1, 40,
 158         N_("About"), "[Internal File Editor]",
 159         quick_widgets, NULL, NULL
 160     };
 161
 162     quick_widgets[0].pos_flags = WPOS_KEEP_TOP | WPOS_CENTER_HORZ;
 163     quick_widgets[2].pos_flags = WPOS_KEEP_TOP | WPOS_CENTER_HORZ;
 164     quick_widgets[4].pos_flags = WPOS_KEEP_TOP | WPOS_CENTER_HORZ;
 165
 166     (void) quick_dialog (&qdlg);
 167 }
 168
 169 /* --------------------------------------------------------------------------------------------- */
 170 /**
 171  * Show a help window
 172  */
 173
 174 static void
 175 edit_help (void)
 176 {
 177     ev_help_t event_data = { NULL, "[Internal File Editor]" };
 178     mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
 179 }
 180
 181 /* --------------------------------------------------------------------------------------------- */
 182 /**
 183  * Restore saved window size.
 184  *
 185  * @param edit editor object
 186  */
 187
 188 static void
 189 edit_restore_size (WEdit * edit)
 190 {
 191     Widget *w = WIDGET (edit);
 192
 193     edit->drag_state = MCEDIT_DRAG_NONE;
 194     w->mouse.forced_capture = FALSE;
 195     widget_set_size (w, edit->y_prev, edit->x_prev, edit->lines_prev, edit->cols_prev);
 196     dlg_draw (DIALOG (w->owner));
 197 }
 198
 199 /* --------------------------------------------------------------------------------------------- */
 200 /**
 201  * Move window by one row or column in any direction.
 202  *
 203  * @param edit    editor object
 204  * @param command direction (CK_Up, CK_Down, CK_Left, CK_Right)
 205  */
 206
 207 static void
 208 edit_window_move (WEdit * edit, long command)
 209 {
 210     Widget *w = WIDGET (edit);
 211     Widget *wh = WIDGET (w->owner);
 212
 213     switch (command)
 214     {
 215     case CK_Up:
 216         if (w->y > wh->y + 1)   /* menubar */
 217             w->y--;
 218         break;
 219     case CK_Down:
 220         if (w->y < wh->y + wh->lines - 2)       /* buttonbar */
 221             w->y++;
 222         break;
 223     case CK_Left:
 224         if (w->x + w->cols > wh->x)
 225             w->x--;
 226         break;
 227     case CK_Right:
 228         if (w->x < wh->x + wh->cols)
 229             w->x++;
 230         break;
 231     default:
 232         return;
 233     }
 234
 235     edit->force |= REDRAW_PAGE;
 236     dlg_draw (DIALOG (w->owner));
 237 }
 238
 239 /* --------------------------------------------------------------------------------------------- */
 240 /**
 241  * Resize window by one row or column in any direction.
 242  *
 243  * @param edit    editor object
 244  * @param command direction (CK_Up, CK_Down, CK_Left, CK_Right)
 245  */
 246
 247 static void
 248 edit_window_resize (WEdit * edit, long command)
 249 {
 250     Widget *w = WIDGET (edit);
 251     Widget *wh = WIDGET (w->owner);
 252
 253     switch (command)
 254     {
 255     case CK_Up:
 256         if (w->lines > WINDOW_MIN_LINES)
 257             w->lines--;
 258         break;
 259     case CK_Down:
 260         if (w->y + w->lines < wh->y + wh->lines - 1)    /* buttonbar */
 261             w->lines++;
 262         break;
 263     case CK_Left:
 264         if (w->cols > WINDOW_MIN_COLS)
 265             w->cols--;
 266         break;
 267     case CK_Right:
 268         if (w->x + w->cols < wh->x + wh->cols)
 269             w->cols++;
 270         break;
 271     default:
 272         return;
 273     }
 274
 275     edit->force |= REDRAW_COMPLETELY;
 276     dlg_draw (DIALOG (w->owner));
 277 }
 278
 279 /* --------------------------------------------------------------------------------------------- */
 280 /**
 281  * Get hotkey by number.
 282  *
 283  * @param n number
 284  * @return hotkey
 285  */
 286
 287 static unsigned char
 288 get_hotkey (int n)
 289 {
 290     return (n <= 9) ? '0' + n : 'a' + n - 10;
 291 }
 292
 293 /* --------------------------------------------------------------------------------------------- */
 294
 295 static void
 296 edit_window_list (const WDialog * h)
 297 {
 298     const WGroup *g = CONST_GROUP (h);
 299     const size_t offset = 2;    /* skip menu and buttonbar */
 300     const size_t dlg_num = g_list_length (g->widgets) - offset;
 301     int lines, cols;
 302     Listbox *listbox;
 303     GList *w;
 304     WEdit *selected;
 305     int i = 0;
 306
 307     lines = MIN ((size_t) (LINES * 2 / 3), dlg_num);
 308     cols = COLS * 2 / 3;
 309
 310     listbox = create_listbox_window (lines, cols, _("Open files"), "[Open files]");
 311
 312     for (w = g->widgets; w != NULL; w = g_list_next (w))
 313         if (edit_widget_is_editor (CONST_WIDGET (w->data)))
 314         {
 315             WEdit *e = (WEdit *) w->data;
 316             char *fname;
 317
 318             if (e->filename_vpath == NULL)
 319                 fname = g_strdup_printf ("%c [%s]", e->modified ? '*' : ' ', _("NoName"));
 320             else
 321                 fname =
 322                     g_strdup_printf ("%c%s", e->modified ? '*' : ' ',
 323                                      vfs_path_as_str (e->filename_vpath));
 324
 325             listbox_add_item (listbox->list, LISTBOX_APPEND_AT_END, get_hotkey (i++),
 326                               str_term_trim (fname, WIDGET (listbox->list)->cols - 2), e, FALSE);
 327             g_free (fname);
 328         }
 329
 330     selected = run_listbox_with_data (listbox, g->current->data);
 331     if (selected != NULL)
 332         widget_select (WIDGET (selected));
 333 }
 334
 335 /* --------------------------------------------------------------------------------------------- */
 336
 337 static char *
 338 edit_get_shortcut (long command)
 339 {
 340     const char *ext_map;
 341     const char *shortcut = NULL;
 342
 343     shortcut = keybind_lookup_keymap_shortcut (editor_map, command);
 344     if (shortcut != NULL)
 345         return g_strdup (shortcut);
 346
 347     ext_map = keybind_lookup_keymap_shortcut (editor_map, CK_ExtendedKeyMap);
 348     if (ext_map != NULL)
 349         shortcut = keybind_lookup_keymap_shortcut (editor_x_map, command);
 350     if (shortcut != NULL)
 351         return g_strdup_printf ("%s %s", ext_map, shortcut);
 352
 353     return NULL;
 354 }
 355
 356 /* --------------------------------------------------------------------------------------------- */
 357
 358 static char *
 359 edit_get_title (const WDialog * h, size_t len)
 360 {
 361     const WEdit *edit = find_editor (h);
 362     const char *modified = edit->modified ? "(*) " : "    ";
 363     const char *file_label;
 364     char *filename;
 365
 366     len -= 4;
 367
 368     if (edit->filename_vpath == NULL)
 369         filename = g_strdup (_("[NoName]"));
 370     else
 371         filename = g_strdup (vfs_path_as_str (edit->filename_vpath));
 372
 373     file_label = str_term_trim (filename, len - str_term_width1 (_("Edit: ")));
 374     g_free (filename);
 375
 376     return g_strconcat (_("Edit: "), modified, file_label, (char *) NULL);
 377 }
 378
 379 /* --------------------------------------------------------------------------------------------- */
 380
 381 static cb_ret_t
 382 edit_dialog_command_execute (WDialog * h, long command)
 383 {
 384     WGroup *g = GROUP (h);
 385     Widget *wh = WIDGET (h);
 386     cb_ret_t ret = MSG_HANDLED;
 387
 388     switch (command)
 389     {
 390     case CK_EditNew:
 391         edit_add_window (h, wh->y + 1, wh->x, wh->lines - 2, wh->cols, NULL, 0);
 392         break;
 393     case CK_EditFile:
 394         edit_load_cmd (h);
 395         break;
 396     case CK_History:
 397         edit_load_file_from_history (h);
 398         break;
 399     case CK_EditSyntaxFile:
 400         edit_load_syntax_file (h);
 401         break;
 402     case CK_EditUserMenu:
 403         edit_load_menu_file (h);
 404         break;
 405     case CK_Close:
 406         /* if there are no opened files anymore, close MC editor */
 407         if (edit_widget_is_editor (CONST_WIDGET (g->current->data)) &&
 408             edit_close_cmd ((WEdit *) g->current->data) && find_editor (h) == NULL)
 409             dlg_stop (h);
 410         break;
 411     case CK_Help:
 412         edit_help ();
 413         /* edit->force |= REDRAW_COMPLETELY; */
 414         break;
 415     case CK_Menu:
 416         edit_menu_cmd (h);
 417         break;
 418     case CK_Quit:
 419     case CK_Cancel:
 420         /* don't close editor due to SIGINT, but stop move/resize window */
 421         {
 422             Widget *w = WIDGET (g->current->data);
 423
 424             if (edit_widget_is_editor (w) && ((WEdit *) w)->drag_state != MCEDIT_DRAG_NONE)
 425                 edit_restore_size ((WEdit *) w);
 426             else if (command == CK_Quit)
 427                 dlg_stop (h);
 428         }
 429         break;
 430     case CK_About:
 431         edit_about ();
 432         break;
 433     case CK_SyntaxOnOff:
 434         edit_syntax_onoff_cmd (h);
 435         break;
 436     case CK_ShowTabTws:
 437         edit_show_tabs_tws_cmd (h);
 438         break;
 439     case CK_ShowMargin:
 440         edit_show_margin_cmd (h);
 441         break;
 442     case CK_ShowNumbers:
 443         edit_show_numbers_cmd (h);
 444         break;
 445     case CK_Refresh:
 446         edit_refresh_cmd ();
 447         break;
 448     case CK_Shell:
 449         toggle_subshell ();
 450         break;
 451     case CK_LearnKeys:
 452         learn_keys ();
 453         break;
 454     case CK_WindowMove:
 455     case CK_WindowResize:
 456         if (edit_widget_is_editor (CONST_WIDGET (g->current->data)))
 457             edit_handle_move_resize ((WEdit *) g->current->data, command);
 458         break;
 459     case CK_WindowList:
 460         edit_window_list (h);
 461         break;
 462     case CK_WindowNext:
 463         group_select_next_widget (g);
 464         break;
 465     case CK_WindowPrev:
 466         group_select_prev_widget (g);
 467         break;
 468     case CK_Options:
 469         edit_options_dialog (h);
 470         break;
 471     case CK_OptionsSaveMode:
 472         edit_save_mode_cmd ();
 473         break;
 474     case CK_SaveSetup:
 475         save_setup_cmd ();
 476         break;
 477     default:
 478         ret = MSG_NOT_HANDLED;
 479         break;
 480     }
 481
 482     return ret;
 483 }
 484
 485 /* --------------------------------------------------------------------------------------------- */
 486 /*
 487  * Translate the keycode into either 'command' or 'char_for_insertion'.
 488  * 'command' is one of the editor commands from cmddef.h.
 489  */
 490
 491 static gboolean
 492 edit_translate_key (WEdit * edit, long x_key, int *cmd, int *ch)
 493 {
 494     long command = CK_InsertChar;
 495     int char_for_insertion = -1;
 496
 497     /* an ordinary insertable character */
 498     if (!edit->extmod && x_key < 256)
 499     {
 500 #ifndef HAVE_CHARSET
 501         if (is_printable (x_key))
 502         {
 503             char_for_insertion = x_key;
 504             goto fin;
 505         }
 506 #else
 507         int c;
 508
 509         if (edit->charpoint >= 4)
 510         {
 511             edit->charpoint = 0;
 512             edit->charbuf[edit->charpoint] = '\0';
 513         }
 514         if (edit->charpoint < 4)
 515         {
 516             edit->charbuf[edit->charpoint++] = x_key;
 517             edit->charbuf[edit->charpoint] = '\0';
 518         }
 519
 520         /* input from 8-bit locale */
 521         if (!mc_global.utf8_display)
 522         {
 523             /* source in 8-bit codeset */
 524             c = convert_from_input_c (x_key);
 525
 526             if (is_printable (c))
 527             {
 528                 if (!edit->utf8)
 529                     char_for_insertion = c;
 530                 else
 531                     char_for_insertion = convert_from_8bit_to_utf_c2 ((char) x_key);
 532                 goto fin;
 533             }
 534         }
 535         else
 536         {
 537             /* UTF-8 locale */
 538             int res;
 539
 540             res = str_is_valid_char (edit->charbuf, edit->charpoint);
 541             if (res < 0 && res != -2)
 542             {
 543                 edit->charpoint = 0;    /* broken multibyte char, skip */
 544                 goto fin;
 545             }
 546
 547             if (edit->utf8)
 548             {
 549                 /* source in UTF-8 codeset */
 550                 if (res < 0)
 551                 {
 552                     char_for_insertion = x_key;
 553                     goto fin;
 554                 }
 555
 556                 edit->charbuf[edit->charpoint] = '\0';
 557                 edit->charpoint = 0;
 558                 if (g_unichar_isprint (g_utf8_get_char (edit->charbuf)))
 559                 {
 560                     char_for_insertion = x_key;
 561                     goto fin;
 562                 }
 563             }
 564             else
 565             {
 566                 /* 8-bit source */
 567                 if (res < 0)
 568                 {
 569                     /* not finised multibyte input (in meddle multibyte utf-8 char) */
 570                     goto fin;
 571                 }
 572
 573                 if (g_unichar_isprint (g_utf8_get_char (edit->charbuf)))
 574                 {
 575                     c = convert_from_utf_to_current (edit->charbuf);
 576                     edit->charbuf[0] = '\0';
 577                     edit->charpoint = 0;
 578                     char_for_insertion = c;
 579                     goto fin;
 580                 }
 581
 582                 /* unprinteble utf input, skip it */
 583                 edit->charbuf[0] = '\0';
 584                 edit->charpoint = 0;
 585             }
 586         }
 587 #endif /* HAVE_CHARSET */
 588     }
 589
 590     /* Commands specific to the key emulation */
 591     if (edit->extmod)
 592     {
 593         edit->extmod = FALSE;
 594         command = keybind_lookup_keymap_command (editor_x_map, x_key);
 595     }
 596     else
 597         command = keybind_lookup_keymap_command (editor_map, x_key);
 598
 599     if (command == CK_IgnoreKey)
 600         command = CK_InsertChar;
 601
 602   fin:
 603     *cmd = (int) command;       /* FIXME */
 604     *ch = char_for_insertion;
 605
 606     return !(command == CK_InsertChar && char_for_insertion == -1);
 607 }
 608
 609
 610 /* --------------------------------------------------------------------------------------------- */
 611
 612 static inline void
 613 edit_quit (WDialog * h)
 614 {
 615     GList *l;
 616     WEdit *e = NULL;
 617     GSList *m = NULL;
 618     GSList *me;
 619
 620     /* don't stop the dialog before final decision */
 621     widget_set_state (WIDGET (h), WST_ACTIVE, TRUE);
 622
 623     /* check window state and get modified files */
 624     for (l = GROUP (h)->widgets; l != NULL; l = g_list_next (l))
 625         if (edit_widget_is_editor (CONST_WIDGET (l->data)))
 626         {
 627             e = (WEdit *) l->data;
 628
 629             if (e->drag_state != MCEDIT_DRAG_NONE)
 630             {
 631                 edit_restore_size (e);
 632                 g_slist_free (m);
 633                 return;
 634             }
 635
 636             /* create separate list because widget_select()
 637                changes the window position in Z order */
 638             if (e->modified)
 639                 m = g_slist_prepend (m, l->data);
 640         }
 641
 642     for (me = m; me != NULL; me = g_slist_next (me))
 643     {
 644         e = (WEdit *) me->data;
 645
 646         widget_select (WIDGET (e));
 647
 648         if (!edit_ok_to_exit (e))
 649             break;
 650     }
 651
 652     /* if all files were checked, quit editor */
 653     if (me == NULL)
 654         dlg_stop (h);
 655
 656     g_slist_free (m);
 657 }
 658
 659 /* --------------------------------------------------------------------------------------------- */
 660
 661 static inline void
 662 edit_set_buttonbar (WEdit * edit, WButtonBar * bb)
 663 {
 664     buttonbar_set_label (bb, 1, Q_ ("ButtonBar|Help"), editor_map, NULL);
 665     buttonbar_set_label (bb, 2, Q_ ("ButtonBar|Save"), editor_map, WIDGET (edit));
 666     buttonbar_set_label (bb, 3, Q_ ("ButtonBar|Mark"), editor_map, WIDGET (edit));
 667     buttonbar_set_label (bb, 4, Q_ ("ButtonBar|Replac"), editor_map, WIDGET (edit));
 668     buttonbar_set_label (bb, 5, Q_ ("ButtonBar|Copy"), editor_map, WIDGET (edit));
 669     buttonbar_set_label (bb, 6, Q_ ("ButtonBar|Move"), editor_map, WIDGET (edit));
 670     buttonbar_set_label (bb, 7, Q_ ("ButtonBar|Search"), editor_map, WIDGET (edit));
 671     buttonbar_set_label (bb, 8, Q_ ("ButtonBar|Delete"), editor_map, WIDGET (edit));
 672     buttonbar_set_label (bb, 9, Q_ ("ButtonBar|PullDn"), editor_map, NULL);
 673     buttonbar_set_label (bb, 10, Q_ ("ButtonBar|Quit"), editor_map, NULL);
 674 }
 675
 676 /* --------------------------------------------------------------------------------------------- */
 677
 678 static void
 679 edit_total_update (WEdit * edit)
 680 {
 681     edit_find_bracket (edit);
 682     edit->force |= REDRAW_COMPLETELY;
 683     edit_update_curs_row (edit);
 684     edit_update_screen (edit);
 685 }
 686
 687 /* --------------------------------------------------------------------------------------------- */
 688
 689 static gboolean
 690 edit_update_cursor (WEdit * edit, const mouse_event_t * event)
 691 {
 692     int x, y;
 693     gboolean done;
 694
 695     x = event->x - (edit->fullscreen ? 0 : 1);
 696     y = event->y - (edit->fullscreen ? 0 : 1);
 697
 698     if (edit->mark2 != -1 && event->msg == MSG_MOUSE_UP)
 699         return TRUE;            /* don't do anything */
 700
 701     if (event->msg == MSG_MOUSE_DOWN || event->msg == MSG_MOUSE_UP)
 702         edit_push_key_press (edit);
 703
 704     if (!option_cursor_beyond_eol)
 705         edit->prev_col = x - edit->start_col - option_line_state_width;
 706     else
 707     {
 708         long line_len;
 709
 710         line_len =
 711             edit_move_forward3 (edit, edit_buffer_get_current_bol (&edit->buffer), 0,
 712                                 edit_buffer_get_current_eol (&edit->buffer));
 713
 714         if (x > line_len - 1)
 715         {
 716             edit->over_col = x - line_len - edit->start_col - option_line_state_width;
 717             edit->prev_col = line_len;
 718         }
 719         else
 720         {
 721             edit->over_col = 0;
 722             edit->prev_col = x - option_line_state_width - edit->start_col;
 723         }
 724     }
 725
 726     if (y > edit->curs_row)
 727         edit_move_down (edit, y - edit->curs_row, FALSE);
 728     else if (y < edit->curs_row)
 729         edit_move_up (edit, edit->curs_row - y, FALSE);
 730     else
 731         edit_move_to_prev_col (edit, edit_buffer_get_current_bol (&edit->buffer));
 732
 733     if (event->msg == MSG_MOUSE_CLICK)
 734     {
 735         edit_mark_cmd (edit, TRUE);     /* reset */
 736         edit->highlight = 0;
 737     }
 738
 739     done = (event->msg != MSG_MOUSE_DRAG);
 740     if (done)
 741         edit_mark_cmd (edit, FALSE);
 742
 743     return done;
 744 }
 745
 746 /* --------------------------------------------------------------------------------------------- */
 747 /** Callback for the edit dialog */
 748
 749 static cb_ret_t
 750 edit_dialog_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
 751 {
 752     WGroup *g = GROUP (w);
 753     WDialog *h = DIALOG (w);
 754
 755     switch (msg)
 756     {
 757     case MSG_INIT:
 758         edit_dlg_init ();
 759         return MSG_HANDLED;
 760
 761     case MSG_DRAW:
 762         /* don't use dlg_default_repaint() -- we don't need a frame */
 763         tty_setcolor (EDITOR_BACKGROUND);
 764         dlg_erase (h);
 765         return MSG_HANDLED;
 766
 767     case MSG_RESIZE:
 768         dlg_default_callback (w, NULL, MSG_RESIZE, 0, NULL);
 769         menubar_arrange (find_menubar (h));
 770         return MSG_HANDLED;
 771
 772     case MSG_ACTION:
 773         {
 774             /* Handle shortcuts, menu, and buttonbar. */
 775
 776             cb_ret_t result;
 777
 778             result = edit_dialog_command_execute (h, parm);
 779
 780             /* We forward any commands coming from the menu, and which haven't been
 781                handled by the dialog, to the focused WEdit window. */
 782             if (result == MSG_NOT_HANDLED && sender == WIDGET (find_menubar (h)))
 783                 result = send_message (g->current->data, NULL, MSG_ACTION, parm, NULL);
 784
 785             return result;
 786         }
 787
 788     case MSG_KEY:
 789         {
 790             Widget *we = WIDGET (g->current->data);
 791             cb_ret_t ret = MSG_NOT_HANDLED;
 792
 793             if (edit_widget_is_editor (we))
 794             {
 795                 WEdit *e = (WEdit *) we;
 796                 long command;
 797
 798                 if (!e->extmod)
 799                     command = keybind_lookup_keymap_command (editor_map, parm);
 800                 else
 801                     command = keybind_lookup_keymap_command (editor_x_map, parm);
 802
 803                 if (command == CK_IgnoreKey)
 804                     e->extmod = FALSE;
 805                 else
 806                 {
 807                     ret = edit_dialog_command_execute (h, command);
 808                     /* if command was not handled, keep the extended mode
 809                        for the further key processing */
 810                     if (ret == MSG_HANDLED)
 811                         e->extmod = FALSE;
 812                 }
 813             }
 814
 815             /*
 816              * Due to the "end of bracket" escape the editor sees input with is_idle() == false
 817              * (expects more characters) and hence doesn't yet refresh the screen, but then
 818              * no further characters arrive (there's only an "end of bracket" which is swallowed
 819              * by tty_get_event()), so you end up with a screen that's not refreshed after pasting.
 820              * So let's trigger an IDLE signal.
 821              */
 822             if (!is_idle ())
 823                 widget_idle (w, TRUE);
 824             return ret;
 825         }
 826
 827         /* hardcoded menu hotkeys (see edit_drop_hotkey_menu) */
 828     case MSG_UNHANDLED_KEY:
 829         return edit_drop_hotkey_menu (h, parm) ? MSG_HANDLED : MSG_NOT_HANDLED;
 830
 831     case MSG_VALIDATE:
 832         edit_quit (h);
 833         return MSG_HANDLED;
 834
 835     case MSG_END:
 836         edit_dlg_deinit ();
 837         return MSG_HANDLED;
 838
 839     case MSG_IDLE:
 840         widget_idle (w, FALSE);
 841         return send_message (g->current->data, NULL, MSG_IDLE, 0, NULL);
 842
 843     default:
 844         return dlg_default_callback (w, sender, msg, parm, data);
 845     }
 846 }
 847
 848 /* --------------------------------------------------------------------------------------------- */
 849
 850 /**
 851  * Handle mouse events of editor screen.
 852  *
 853  * @param w Widget object (the editor)
 854  * @param msg mouse event message
 855  * @param event mouse event data
 856  */
 857 static void
 858 edit_dialog_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event)
 859 {
 860     gboolean unhandled = TRUE;
 861
 862     if (msg == MSG_MOUSE_DOWN && event->y == 0)
 863     {
 864         WGroup *g = GROUP (w);
 865         WDialog *h = DIALOG (w);
 866         WMenuBar *b;
 867
 868         b = find_menubar (h);
 869
 870         if (!widget_get_state (WIDGET (b), WST_FOCUSED))
 871         {
 872             /* menubar */
 873
 874             GList *l;
 875             GList *top = NULL;
 876             int x;
 877
 878             /* Try find top fullscreen window */
 879             for (l = g->widgets; l != NULL; l = g_list_next (l))
 880                 if (edit_widget_is_editor (CONST_WIDGET (l->data))
 881                     && ((WEdit *) l->data)->fullscreen)
 882                     top = l;
 883
 884             /* Handle fullscreen/close buttons in the top line */
 885             x = w->cols - 6;
 886
 887             if (top != NULL && event->x >= x)
 888             {
 889                 WEdit *e = (WEdit *) top->data;
 890
 891                 if (top != g->current)
 892                 {
 893                     /* Window is not active. Activate it */
 894                     widget_select (WIDGET (e));
 895                 }
 896
 897                 /* Handle buttons */
 898                 if (event->x - x <= 2)
 899                     edit_toggle_fullscreen (e);
 900                 else
 901                     send_message (h, NULL, MSG_ACTION, CK_Close, NULL);
 902
 903                 unhandled = FALSE;
 904             }
 905
 906             if (unhandled)
 907                 menubar_activate (b, drop_menus, -1);
 908         }
 909     }
 910
 911     /* Continue handling of unhandled event in window or menu */
 912     event->result.abort = unhandled;
 913 }
 914
 915 /* --------------------------------------------------------------------------------------------- */
 916
 917 static cb_ret_t
 918 edit_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
 919 {
 920     WEdit *e = (WEdit *) w;
 921
 922     switch (msg)
 923     {
 924     case MSG_FOCUS:
 925         edit_set_buttonbar (e, find_buttonbar (DIALOG (w->owner)));
 926         return MSG_HANDLED;
 927
 928     case MSG_DRAW:
 929         e->force |= REDRAW_COMPLETELY;
 930         edit_update_screen (e);
 931         return MSG_HANDLED;
 932
 933     case MSG_KEY:
 934         {
 935             int cmd, ch;
 936             cb_ret_t ret = MSG_NOT_HANDLED;
 937
 938             /* The user may override the access-keys for the menu bar. */
 939             if (macro_index == -1 && edit_execute_macro (e, parm))
 940             {
 941                 edit_update_screen (e);
 942                 ret = MSG_HANDLED;
 943             }
 944             else if (edit_translate_key (e, parm, &cmd, &ch))
 945             {
 946                 edit_execute_key_command (e, cmd, ch);
 947                 edit_update_screen (e);
 948                 ret = MSG_HANDLED;
 949             }
 950
 951             return ret;
 952         }
 953
 954     case MSG_ACTION:
 955         /* command from menubar or buttonbar */
 956         edit_execute_key_command (e, parm, -1);
 957         edit_update_screen (e);
 958         return MSG_HANDLED;
 959
 960     case MSG_CURSOR:
 961         {
 962             int y, x;
 963
 964             y = (e->fullscreen ? 0 : 1) + EDIT_TEXT_VERTICAL_OFFSET + e->curs_row;
 965             x = (e->fullscreen ? 0 : 1) + EDIT_TEXT_HORIZONTAL_OFFSET + option_line_state_width +
 966                 e->curs_col + e->start_col + e->over_col;
 967
 968             widget_gotoyx (w, y, x);
 969             return MSG_HANDLED;
 970         }
 971
 972     case MSG_IDLE:
 973         edit_update_screen (e);
 974         return MSG_HANDLED;
 975
 976     case MSG_DESTROY:
 977         edit_clean (e);
 978         return MSG_HANDLED;
 979
 980     default:
 981         return widget_default_callback (w, sender, msg, parm, data);
 982     }
 983 }
 984
 985 /* --------------------------------------------------------------------------------------------- */
 986
 987 /**
 988  * Handle move/resize mouse events.
 989  */
 990 static void
 991 edit_mouse_handle_move_resize (Widget * w, mouse_msg_t msg, mouse_event_t * event)
 992 {
 993     WEdit *edit = (WEdit *) (w);
 994     Widget *h = WIDGET (w->owner);
 995     int global_x, global_y;
 996
 997     if (msg == MSG_MOUSE_UP)
 998     {
 999         /* Exit move/resize mode. */
1000         edit_execute_cmd (edit, CK_Enter, -1);
1001         edit_update_screen (edit);      /* Paint the buttonbar over our possibly overlapping frame. */
1002         return;
1003     }
1004
1005     if (msg != MSG_MOUSE_DRAG)
1006         /**
1007          * We ignore any other events. Specifically, MSG_MOUSE_DOWN.
1008          *
1009          * When the move/resize is initiated by the menu, we let the user
1010          * stop it by clicking with the mouse. Which is why we don't want
1011          * a mouse down to affect the window.
1012          */
1013         return;
1014
1015     /* Convert point to global coordinates for easier calculations. */
1016     global_x = event->x + w->x;
1017     global_y = event->y + w->y;
1018
1019     /* Clamp the point to the dialog's client area. */
1020     global_y = CLAMP (global_y, h->y + 1, h->y + h->lines - 2); /* Status line, buttonbar */
1021     global_x = CLAMP (global_x, h->x, h->x + h->cols - 1);      /* Currently a no-op, as the dialog has no left/right margins. */
1022
1023     if (edit->drag_state == MCEDIT_DRAG_MOVE)
1024     {
1025         w->y = global_y;
1026         w->x = global_x - edit->drag_state_start;
1027     }
1028     else if (edit->drag_state == MCEDIT_DRAG_RESIZE)
1029     {
1030         w->lines = MAX (WINDOW_MIN_LINES, global_y - w->y + 1);
1031         w->cols = MAX (WINDOW_MIN_COLS, global_x - w->x + 1);
1032     }
1033
1034     edit->force |= REDRAW_COMPLETELY;   /* Not really needed as WEdit's MSG_DRAW already does this. */
1035
1036     /* We draw the whole dialog because dragging/resizing exposes area beneath. */
1037     dlg_draw (DIALOG (w->owner));
1038 }
1039
1040 /* --------------------------------------------------------------------------------------------- */
1041
1042 /**
1043  * Handle mouse events of editor window
1044  *
1045  * @param w Widget object (the editor window)
1046  * @param msg mouse event message
1047  * @param event mouse event data
1048  */
1049 static void
1050 edit_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event)
1051 {
1052     WEdit *edit = (WEdit *) w;
1053     /* buttons' distance from right edge */
1054     int dx = edit->fullscreen ? 0 : 2;
1055     /* location of 'Close' and 'Toggle fullscreen' pictograms */
1056     int close_x, toggle_fullscreen_x;
1057
1058     close_x = (w->cols - 1) - dx - 1;
1059     toggle_fullscreen_x = close_x - 3;
1060
1061     if (edit->drag_state != MCEDIT_DRAG_NONE)
1062     {
1063         /* window is being resized/moved */
1064         edit_mouse_handle_move_resize (w, msg, event);
1065         return;
1066     }
1067
1068     /* If it's the last line on the screen, we abort the event to make the
1069      * system channel it to the overlapping buttonbar instead. We have to do
1070      * this because a WEdit has the WOP_TOP_SELECT flag, which makes it above
1071      * the buttonbar in Z-order. */
1072     if (msg == MSG_MOUSE_DOWN && (event->y + w->y == LINES - 1))
1073     {
1074         event->result.abort = TRUE;
1075         return;
1076     }
1077
1078     switch (msg)
1079     {
1080     case MSG_MOUSE_DOWN:
1081         widget_select (w);
1082         edit_update_curs_row (edit);
1083         edit_update_curs_col (edit);
1084
1085         if (!edit->fullscreen)
1086         {
1087             if (event->y == 0)
1088             {
1089                 if (event->x >= close_x - 1 && event->x <= close_x + 1)
1090                     ;           /* do nothing (see MSG_MOUSE_CLICK) */
1091                 else if (event->x >= toggle_fullscreen_x - 1 && event->x <= toggle_fullscreen_x + 1)
1092                     ;           /* do nothing (see MSG_MOUSE_CLICK) */
1093                 else
1094                 {
1095                     /* start window move */
1096                     edit_execute_cmd (edit, CK_WindowMove, -1);
1097                     edit_update_screen (edit);  /* Paint the buttonbar over our possibly overlapping frame. */
1098                     edit->drag_state_start = event->x;
1099                 }
1100                 break;
1101             }
1102
1103             if (event->y == w->lines - 1 && event->x == w->cols - 1)
1104             {
1105                 /* bottom-right corner -- start window resize */
1106                 edit_execute_cmd (edit, CK_WindowResize, -1);
1107                 break;
1108             }
1109         }
1110
1111         MC_FALLTHROUGH;         /* to start/stop text selection */
1112
1113     case MSG_MOUSE_UP:
1114         edit_update_cursor (edit, event);
1115         edit_total_update (edit);
1116         break;
1117
1118     case MSG_MOUSE_CLICK:
1119         if (event->y == 0)
1120         {
1121             if (event->x >= close_x - 1 && event->x <= close_x + 1)
1122                 send_message (w->owner, NULL, MSG_ACTION, CK_Close, NULL);
1123             else if (event->x >= toggle_fullscreen_x - 1 && event->x <= toggle_fullscreen_x + 1)
1124                 edit_toggle_fullscreen (edit);
1125             else if (!edit->fullscreen && event->count == GPM_DOUBLE)
1126                 /* double click on top line (toggle fullscreen) */
1127                 edit_toggle_fullscreen (edit);
1128         }
1129         else if (event->count == GPM_DOUBLE)
1130         {
1131             /* double click */
1132             edit_mark_current_word_cmd (edit);
1133             edit_total_update (edit);
1134         }
1135         else if (event->count == GPM_TRIPLE)
1136         {
1137             /* triple click: works in GPM only, not in xterm */
1138             edit_mark_current_line_cmd (edit);
1139             edit_total_update (edit);
1140         }
1141         break;
1142
1143     case MSG_MOUSE_DRAG:
1144         edit_update_cursor (edit, event);
1145         edit_total_update (edit);
1146         break;
1147
1148     case MSG_MOUSE_SCROLL_UP:
1149         edit_move_up (edit, 2, TRUE);
1150         edit_total_update (edit);
1151         break;
1152
1153     case MSG_MOUSE_SCROLL_DOWN:
1154         edit_move_down (edit, 2, TRUE);
1155         edit_total_update (edit);
1156         break;
1157
1158     default:
1159         break;
1160     }
1161 }
1162
1163 /* --------------------------------------------------------------------------------------------- */
1164 /*** public functions ****************************************************************************/
1165 /* --------------------------------------------------------------------------------------------- */
1166 /**
1167  * Edit one file.
1168  *
1169  * @param file_vpath file object
1170  * @param line       line number
1171  * @return TRUE if no errors was occurred, FALSE otherwise
1172  */
1173
1174 gboolean
1175 edit_file (const vfs_path_t * file_vpath, long line)
1176 {
1177     mcedit_arg_t arg = { (vfs_path_t *) file_vpath, line };
1178     GList *files;
1179     gboolean ok;
1180
1181     files = g_list_prepend (NULL, &arg);
1182     ok = edit_files (files);
1183     g_list_free (files);
1184
1185     return ok;
1186 }
1187
1188 /* --------------------------------------------------------------------------------------------- */
1189
1190 gboolean
1191 edit_files (const GList * files)
1192 {
1193     static gboolean made_directory = FALSE;
1194     WDialog *edit_dlg;
1195     WGroup *g;
1196     WMenuBar *menubar;
1197     Widget *w, *wd;
1198     const GList *file;
1199     gboolean ok = FALSE;
1200
1201     if (!made_directory)
1202     {
1203         char *dir;
1204
1205         dir = mc_build_filename (mc_config_get_cache_path (), EDIT_DIR, (char *) NULL);
1206         made_directory = (mkdir (dir, 0700) != -1 || errno == EEXIST);
1207         g_free (dir);
1208
1209         dir = mc_build_filename (mc_config_get_path (), EDIT_DIR, (char *) NULL);
1210         made_directory = (mkdir (dir, 0700) != -1 || errno == EEXIST);
1211         g_free (dir);
1212
1213         dir = mc_build_filename (mc_config_get_data_path (), EDIT_DIR, (char *) NULL);
1214         made_directory = (mkdir (dir, 0700) != -1 || errno == EEXIST);
1215         g_free (dir);
1216     }
1217
1218     /* Create a new dialog and add it widgets to it */
1219     edit_dlg =
1220         dlg_create (FALSE, 0, 0, 1, 1, WPOS_FULLSCREEN, FALSE, NULL, edit_dialog_callback,
1221                     edit_dialog_mouse_callback, "[Internal File Editor]", NULL);
1222     wd = WIDGET (edit_dlg);
1223     widget_want_tab (wd, TRUE);
1224
1225     edit_dlg->get_shortcut = edit_get_shortcut;
1226     edit_dlg->get_title = edit_get_title;
1227
1228     g = GROUP (edit_dlg);
1229
1230     menubar = menubar_new (NULL, TRUE);
1231     w = WIDGET (menubar);
1232     group_add_widget_autopos (g, w, w->pos_flags, NULL);
1233     edit_init_menu (menubar);
1234
1235     w = WIDGET (buttonbar_new (TRUE));
1236     group_add_widget_autopos (g, w, w->pos_flags, NULL);
1237
1238     for (file = files; file != NULL; file = g_list_next (file))
1239     {
1240         mcedit_arg_t *f = (mcedit_arg_t *) file->data;
1241         gboolean f_ok;
1242
1243         f_ok = edit_add_window (edit_dlg, wd->y + 1, wd->x, wd->lines - 2, wd->cols, f->file_vpath,
1244                                 f->line_number);
1245         /* at least one file has been opened succefully */
1246         ok = ok || f_ok;
1247     }
1248
1249     if (ok)
1250         dlg_run (edit_dlg);
1251
1252     if (!ok || widget_get_state (wd, WST_CLOSED))
1253         dlg_destroy (edit_dlg);
1254
1255     return ok;
1256 }
1257
1258 /* --------------------------------------------------------------------------------------------- */
1259
1260 const char *
1261 edit_get_file_name (const WEdit * edit)
1262 {
1263     return vfs_path_as_str (edit->filename_vpath);
1264 }
1265
1266 /* --------------------------------------------------------------------------------------------- */
1267
1268 WEdit *
1269 find_editor (const WDialog * h)
1270 {
1271     const WGroup *g = CONST_GROUP (h);
1272
1273     if (edit_widget_is_editor (CONST_WIDGET (g->current->data)))
1274         return (WEdit *) g->current->data;
1275     return (WEdit *) find_widget_type (h, edit_callback);
1276 }
1277
1278 /* --------------------------------------------------------------------------------------------- */
1279 /**
1280  * Check if widget is an WEdit class.
1281  *
1282  * @param w probably editor object
1283  * @return TRUE if widget is an WEdit class, FALSE otherwise
1284  */
1285
1286 gboolean
1287 edit_widget_is_editor (const Widget * w)
1288 {
1289     return (w != NULL && w->callback == edit_callback);
1290 }
1291
1292 /* --------------------------------------------------------------------------------------------- */
1293
1294 void
1295 edit_update_screen (WEdit * e)
1296 {
1297     edit_scroll_screen_over_cursor (e);
1298     edit_update_curs_col (e);
1299     edit_status (e, widget_get_state (WIDGET (e), WST_FOCUSED));
1300
1301     /* pop all events for this window for internal handling */
1302     if (!is_idle ())
1303         e->force |= REDRAW_PAGE;
1304     else
1305     {
1306         if ((e->force & REDRAW_COMPLETELY) != 0)
1307             e->force |= REDRAW_PAGE;
1308         edit_render_keypress (e);
1309     }
1310
1311     widget_draw (WIDGET (find_buttonbar (DIALOG (WIDGET (e)->owner))));
1312 }
1313
1314 /* --------------------------------------------------------------------------------------------- */
1315 /**
1316  * Save current window size.
1317  *
1318  * @param edit editor object
1319  */
1320
1321 void
1322 edit_save_size (WEdit * edit)
1323 {
1324     Widget *w = WIDGET (edit);
1325
1326     edit->y_prev = w->y;
1327     edit->x_prev = w->x;
1328     edit->lines_prev = w->lines;
1329     edit->cols_prev = w->cols;
1330 }
1331
1332 /* --------------------------------------------------------------------------------------------- */
1333 /**
1334  * Create new editor window and insert it into editor screen.
1335  *
1336  * @param h     editor dialog (screen)
1337  * @param y     y coordinate
1338  * @param x     x coordinate
1339  * @param lines window height
1340  * @param cols  window width
1341  * @param f     file object
1342  * @param fline line number in file
1343  * @return TRUE if new window was successfully created and inserted into editor screen,
1344  *         FALSE otherwise
1345  */
1346
1347 gboolean
1348 edit_add_window (WDialog * h, int y, int x, int lines, int cols, const vfs_path_t * f, long fline)
1349 {
1350     WEdit *edit;
1351     Widget *w;
1352
1353     edit = edit_init (NULL, y, x, lines, cols, f, fline);
1354     if (edit == NULL)
1355         return FALSE;
1356
1357     w = WIDGET (edit);
1358     w->callback = edit_callback;
1359     w->mouse_callback = edit_mouse_callback;
1360
1361     group_add_widget_autopos (GROUP (h), w, WPOS_KEEP_ALL, NULL);
1362     edit_set_buttonbar (edit, find_buttonbar (h));
1363     dlg_draw (h);
1364
1365     return TRUE;
1366 }
1367
1368 /* --------------------------------------------------------------------------------------------- */
1369 /**
1370  * Handle move/resize events.
1371  *
1372  * @param edit    editor object
1373  * @param command action id
1374  * @return TRUE if the action was handled, FALSE otherwise
1375  */
1376
1377 gboolean
1378 edit_handle_move_resize (WEdit * edit, long command)
1379 {
1380     Widget *w = WIDGET (edit);
1381     gboolean ret = FALSE;
1382
1383     if (edit->fullscreen)
1384     {
1385         edit->drag_state = MCEDIT_DRAG_NONE;
1386         w->mouse.forced_capture = FALSE;
1387         return ret;
1388     }
1389
1390     switch (edit->drag_state)
1391     {
1392     case MCEDIT_DRAG_NONE:
1393         /* possible start move/resize */
1394         switch (command)
1395         {
1396         case CK_WindowMove:
1397             edit->drag_state = MCEDIT_DRAG_MOVE;
1398             edit_save_size (edit);
1399             edit_status (edit, TRUE);   /* redraw frame and status */
1400             /**
1401              * If a user initiates a move by the menu, not by the mouse, we
1402              * make a subsequent mouse drag pull the frame from its middle.
1403              * (We can instead choose '0' to pull it from the corner.)
1404              */
1405             edit->drag_state_start = w->cols / 2;
1406             ret = TRUE;
1407             break;
1408         case CK_WindowResize:
1409             edit->drag_state = MCEDIT_DRAG_RESIZE;
1410             edit_save_size (edit);
1411             edit_status (edit, TRUE);   /* redraw frame and status */
1412             ret = TRUE;
1413             break;
1414         default:
1415             break;
1416         }
1417         break;
1418
1419     case MCEDIT_DRAG_MOVE:
1420         switch (command)
1421         {
1422         case CK_WindowResize:
1423             edit->drag_state = MCEDIT_DRAG_RESIZE;
1424             ret = TRUE;
1425             break;
1426         case CK_Up:
1427         case CK_Down:
1428         case CK_Left:
1429         case CK_Right:
1430             edit_window_move (edit, command);
1431             ret = TRUE;
1432             break;
1433         case CK_Enter:
1434         case CK_WindowMove:
1435             edit->drag_state = MCEDIT_DRAG_NONE;
1436             edit_status (edit, TRUE);   /* redraw frame and status */
1437             MC_FALLTHROUGH;
1438         default:
1439             ret = TRUE;
1440             break;
1441         }
1442         break;
1443
1444     case MCEDIT_DRAG_RESIZE:
1445         switch (command)
1446         {
1447         case CK_WindowMove:
1448             edit->drag_state = MCEDIT_DRAG_MOVE;
1449             ret = TRUE;
1450             break;
1451         case CK_Up:
1452         case CK_Down:
1453         case CK_Left:
1454         case CK_Right:
1455             edit_window_resize (edit, command);
1456             ret = TRUE;
1457             break;
1458         case CK_Enter:
1459         case CK_WindowResize:
1460             edit->drag_state = MCEDIT_DRAG_NONE;
1461             edit_status (edit, TRUE);   /* redraw frame and status */
1462             MC_FALLTHROUGH;
1463         default:
1464             ret = TRUE;
1465             break;
1466         }
1467         break;
1468
1469     default:
1470         break;
1471     }
1472
1473     /**
1474      * - We let the user stop a resize/move operation by clicking with the
1475      *   mouse anywhere. ("clicking" = pressing and releasing a button.)
1476      * - We let the user perform a resize/move operation by a mouse drag
1477      *   initiated anywhere.
1478      *
1479      * "Anywhere" means: inside or outside the window. We make this happen
1480      * with the 'forced_capture' flag.
1481      */
1482     w->mouse.forced_capture = (edit->drag_state != MCEDIT_DRAG_NONE);
1483
1484     return ret;
1485 }
1486
1487 /* --------------------------------------------------------------------------------------------- */
1488 /**
1489  * Toggle window fuulscreen mode.
1490  *
1491  * @param edit editor object
1492  */
1493
1494 void
1495 edit_toggle_fullscreen (WEdit * edit)
1496 {
1497     Widget *w = WIDGET (edit);
1498
1499     edit->fullscreen = !edit->fullscreen;
1500     edit->force = REDRAW_COMPLETELY;
1501
1502     if (!edit->fullscreen)
1503     {
1504         edit_restore_size (edit);
1505         /* do not follow screen size on resize */
1506         w->pos_flags = WPOS_KEEP_DEFAULT;
1507     }
1508     else
1509     {
1510         Widget *h = WIDGET (w->owner);
1511
1512         edit_save_size (edit);
1513         widget_set_size (w, h->y + 1, h->x, h->lines - 2, h->cols);
1514         /* follow screen size on resize */
1515         w->pos_flags = WPOS_KEEP_ALL;
1516         edit->force |= REDRAW_PAGE;
1517         edit_update_screen (edit);
1518     }
1519 }
1520
1521 /* --------------------------------------------------------------------------------------------- */