?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(edit_do_search): refactoring of search loop condition.
[midnight-commander.git] / src / editor / editcmd.c
blobf73fa91d14928d577a32eea718605130c8f8c7cc
1 /*
2 Editor high level editing commands
3
4 Copyright (C) 1996, 1997, 1998, 2001, 2002, 2003, 2004, 2005, 2006,
5 2007, 2011, 2012
6 The Free Software Foundation, Inc.
7
8 Written by:
9 Paul Sheer, 1996, 1997
10 Andrew Borodin <aborodin@vmail.ru> 2012
11
12 This file is part of the Midnight Commander.
13
14 The Midnight Commander is free software: you can redistribute it
15 and/or modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation, either version 3 of the License,
17 or (at your option) any later version.
18
19 The Midnight Commander is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>.
26 */
27
28 /** \file
29 * \brief Source: editor high level editing commands
30 * \author Paul Sheer
31 * \date 1996, 1997
32 */
33
34 /* #define PIPE_BLOCKS_SO_READ_BYTE_BY_BYTE */
35
36 #include <config.h>
37
38 #ifdef HAVE_ASSERT_H
39 #include <assert.h>
40 #endif
41 #include <ctype.h>
42
43 #include <stdio.h>
44 #include <stdarg.h>
45 #include <sys/types.h>
46 #include <unistd.h>
47 #include <string.h>
48 #include <errno.h>
49 #include <sys/stat.h>
50 #include <stdlib.h>
51 #include <fcntl.h>
52
53 #include "lib/global.h"
54 #include "lib/tty/tty.h"
55 #include "lib/tty/key.h" /* XCTRL */
56 #include "lib/mcconfig.h"
57 #include "lib/skin.h"
58 #include "lib/strutil.h" /* utf string functions */
59 #include "lib/lock.h"
60 #include "lib/util.h" /* tilde_expand() */
61 #include "lib/vfs/vfs.h"
62 #include "lib/widget.h"
63 #include "lib/event.h" /* mc_event_raise() */
64 #ifdef HAVE_CHARSET
65 #include "lib/charsets.h"
66 #endif
67
68 #include "src/history.h"
69 #include "src/setup.h" /* option_tab_spacing */
70 #include "src/main.h" /* mactos_t */
71 #ifdef HAVE_CHARSET
72 #include "src/selcodepage.h"
73 #endif
74 #include "src/keybind-defaults.h"
75 #include "src/util.h" /* check_for_default() */
76 #include "src/filemanager/layout.h" /* mc_refresh() */
77
78 #include "edit-impl.h"
79 #include "editwidget.h"
80 #include "editcmd_dialogs.h"
81 #include "etags.h"
82
83 /*** global variables ****************************************************************************/
84
85 /* search and replace: */
86 int search_create_bookmark = FALSE;
87
88 /* queries on a save */
89 int edit_confirm_save = 1;
90
91 /*** file scope macro definitions ****************************************************************/
92
93 #define space_width 1
94
95 #define TEMP_BUF_LEN 1024
96
97 #define INPUT_INDEX 9
98
99 /* thanks to Liviu Daia <daia@stoilow.imar.ro> for getting this
100 (and the above) routines to work properly - paul */
101
102 #define is_digit(x) ((x) >= '0' && (x) <= '9')
103
104 #define MAIL_DLG_HEIGHT 12
105
106 #define MAX_WORD_COMPLETIONS 100 /* in listbox */
107
108 /*** file scope type declarations ****************************************************************/
109
110 /*** file scope variables ************************************************************************/
111
112 /*** file scope functions ************************************************************************/
113 /* --------------------------------------------------------------------------------------------- */
114
115 /* If 0 (quick save) then a) create/truncate <filename> file,
116 b) save to <filename>;
117 if 1 (safe save) then a) save to <tempnam>,
118 b) rename <tempnam> to <filename>;
119 if 2 (do backups) then a) save to <tempnam>,
120 b) rename <filename> to <filename.backup_ext>,
121 c) rename <tempnam> to <filename>. */
122
123 /* returns 0 on error, -1 on abort */
124
125 static int
126 edit_save_file (WEdit * edit, const vfs_path_t * filename_vpath)
127 {
128 char *p;
129 gchar *tmp;
130 off_t filelen = 0;
131 int this_save_mode, fd = -1;
132 vfs_path_t *real_filename_vpath;
133 vfs_path_t *savename_vpath = NULL;
134 const char *start_filename;
135 const vfs_path_element_t *vpath_element;
136
137 vpath_element = vfs_path_get_by_index (filename_vpath, 0);
138 if (vpath_element == NULL)
139 return 0;
140
141 start_filename = vpath_element->path;
142 if (*start_filename == '\0')
143 return 0;
144
145 if (*start_filename != PATH_SEP && edit->dir_vpath != NULL)
146 {
147 real_filename_vpath = vfs_path_append_vpath_new (edit->dir_vpath, filename_vpath, NULL);
148 }
149 else
150 {
151 real_filename_vpath = vfs_path_clone (filename_vpath);
152 }
153
154 this_save_mode = option_save_mode;
155 if (this_save_mode != EDIT_QUICK_SAVE)
156 {
157 if (!vfs_file_is_local (real_filename_vpath)
158 || (fd = mc_open (real_filename_vpath, O_RDONLY | O_BINARY)) == -1)
159 {
160 /*
161 * The file does not exists yet, so no safe save or
162 * backup are necessary.
163 */
164 this_save_mode = EDIT_QUICK_SAVE;
165 }
166 if (fd != -1)
167 mc_close (fd);
168 }
169
170 if (this_save_mode == EDIT_QUICK_SAVE && !edit->skip_detach_prompt)
171 {
172 int rv;
173 struct stat sb;
174
175 rv = mc_stat (real_filename_vpath, &sb);
176 if (rv == 0 && sb.st_nlink > 1)
177 {
178 rv = edit_query_dialog3 (_("Warning"),
179 _("File has hard-links. Detach before saving?"),
180 _("&Yes"), _("&No"), _("&Cancel"));
181 switch (rv)
182 {
183 case 0:
184 this_save_mode = EDIT_SAFE_SAVE;
185 /* fallthrough */
186 case 1:
187 edit->skip_detach_prompt = 1;
188 break;
189 default:
190 vfs_path_free (real_filename_vpath);
191 return -1;
192 }
193 }
194
195 /* Prevent overwriting changes from other editor sessions. */
196 if (rv == 0 && edit->stat1.st_mtime != 0 && edit->stat1.st_mtime != sb.st_mtime)
197 {
198 /* The default action is "Cancel". */
199 query_set_sel (1);
200
201 rv = edit_query_dialog2 (_("Warning"),
202 _("The file has been modified in the meantime. Save anyway?"),
203 _("&Yes"), _("&Cancel"));
204 if (rv != 0)
205 {
206 vfs_path_free (real_filename_vpath);
207 return -1;
208 }
209 }
210 }
211
212 if (this_save_mode != EDIT_QUICK_SAVE)
213 {
214 char *savedir, *saveprefix;
215
216 savedir = vfs_path_tokens_get (real_filename_vpath, 0, -1);
217 if (savedir == NULL)
218 savedir = g_strdup (".");
219
220 /* Token-related function never return leading slash, so we need add it manually */
221 saveprefix = mc_build_filename ("/", savedir, "cooledit", NULL);
222 g_free (savedir);
223 fd = mc_mkstemps (&savename_vpath, saveprefix, NULL);
224 g_free (saveprefix);
225 if (savename_vpath == NULL)
226 {
227 vfs_path_free (real_filename_vpath);
228 return 0;
229 }
230 /* FIXME:
231 * Close for now because mc_mkstemps use pure open system call
232 * to create temporary file and it needs to be reopened by
233 * VFS-aware mc_open().
234 */
235 close (fd);
236 }
237 else
238 savename_vpath = vfs_path_clone (real_filename_vpath);
239
240 (void) mc_chown (savename_vpath, edit->stat1.st_uid, edit->stat1.st_gid);
241 (void) mc_chmod (savename_vpath, edit->stat1.st_mode);
242
243 fd = mc_open (savename_vpath, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, edit->stat1.st_mode);
244 if (fd == -1)
245 goto error_save;
246
247 /* pipe save */
248 p = edit_get_write_filter (savename_vpath, real_filename_vpath);
249 if (p != NULL)
250 {
251 FILE *file;
252
253 mc_close (fd);
254 file = (FILE *) popen (p, "w");
255
256 if (file)
257 {
258 filelen = edit_write_stream (edit, file);
259 #if 1
260 pclose (file);
261 #else
262 if (pclose (file) != 0)
263 {
264 tmp = g_strdup_printf (_("Error writing to pipe: %s"), p);
265 edit_error_dialog (_("Error"), tmp);
266 g_free (tmp);
267 g_free (p);
268 goto error_save;
269 }
270 #endif
271 }
272 else
273 {
274 tmp = g_strdup_printf (_("Cannot open pipe for writing: %s"), p);
275 edit_error_dialog (_("Error"), get_sys_error (tmp));
276 g_free (p);
277 g_free (tmp);
278 goto error_save;
279 }
280 g_free (p);
281 }
282 else if (edit->lb == LB_ASIS)
283 { /* do not change line breaks */
284 off_t buf;
285 buf = 0;
286 filelen = edit->last_byte;
287 while (buf <= (edit->curs1 >> S_EDIT_BUF_SIZE) - 1)
288 {
289 if (mc_write (fd, (char *) edit->buffers1[buf], EDIT_BUF_SIZE) != EDIT_BUF_SIZE)
290 {
291 mc_close (fd);
292 goto error_save;
293 }
294 buf++;
295 }
296 if (mc_write
297 (fd, (char *) edit->buffers1[buf],
298 edit->curs1 & M_EDIT_BUF_SIZE) != (edit->curs1 & M_EDIT_BUF_SIZE))
299 {
300 filelen = -1;
301 }
302 else if (edit->curs2)
303 {
304 edit->curs2--;
305 buf = (edit->curs2 >> S_EDIT_BUF_SIZE);
306 if (mc_write
307 (fd,
308 (char *) edit->buffers2[buf] + EDIT_BUF_SIZE -
309 (edit->curs2 & M_EDIT_BUF_SIZE) - 1,
310 1 + (edit->curs2 & M_EDIT_BUF_SIZE)) != 1 + (edit->curs2 & M_EDIT_BUF_SIZE))
311 {
312 filelen = -1;
313 }
314 else
315 {
316 while (--buf >= 0)
317 {
318 if (mc_write (fd, (char *) edit->buffers2[buf], EDIT_BUF_SIZE) != EDIT_BUF_SIZE)
319 {
320 filelen = -1;
321 break;
322 }
323 }
324 }
325 edit->curs2++;
326 }
327 if (mc_close (fd))
328 goto error_save;
329
330 /* Update the file information, especially the mtime. */
331 if (mc_stat (savename_vpath, &edit->stat1) == -1)
332 goto error_save;
333 }
334 else
335 { /* change line breaks */
336 FILE *file;
337 const vfs_path_element_t *path_element;
338
339 mc_close (fd);
340
341 path_element = vfs_path_get_by_index (savename_vpath, -1);
342 file = (FILE *) fopen (path_element->path, "w");
343 if (file != NULL)
344 {
345 filelen = edit_write_stream (edit, file);
346 fclose (file);
347 }
348 else
349 {
350 char *msg;
351
352 msg = g_strdup_printf (_("Cannot open file for writing: %s"), path_element->path);
353 edit_error_dialog (_("Error"), msg);
354 g_free (msg);
355 goto error_save;
356 }
357 }
358
359 if (filelen != edit->last_byte)
360 goto error_save;
361
362 if (this_save_mode == EDIT_DO_BACKUP)
363 {
364 char *tmp_store_filename;
365 vfs_path_element_t *last_vpath_element;
366 vfs_path_t *tmp_vpath;
367 gboolean ok;
368
369 #ifdef HAVE_ASSERT_H
370 assert (option_backup_ext != NULL);
371 #endif
372 /* add backup extention to the path */
373 tmp_vpath = vfs_path_clone (real_filename_vpath);
374 last_vpath_element = (vfs_path_element_t *) vfs_path_get_by_index (tmp_vpath, -1);
375 tmp_store_filename = last_vpath_element->path;
376 last_vpath_element->path = g_strdup_printf ("%s%s", tmp_store_filename, option_backup_ext);
377 g_free (tmp_store_filename);
378
379 ok = (mc_rename (real_filename_vpath, tmp_vpath) != -1);
380 vfs_path_free (tmp_vpath);
381 if (!ok)
382 goto error_save;
383 }
384
385 if (this_save_mode != EDIT_QUICK_SAVE)
386 if (mc_rename (savename_vpath, real_filename_vpath) == -1)
387 goto error_save;
388
389 vfs_path_free (real_filename_vpath);
390 vfs_path_free (savename_vpath);
391 return 1;
392 error_save:
393 /* FIXME: Is this safe ?
394 * if (this_save_mode != EDIT_QUICK_SAVE)
395 * mc_unlink (savename);
396 */
397 vfs_path_free (real_filename_vpath);
398 vfs_path_free (savename_vpath);
399 return 0;
400 }
401
402 /* --------------------------------------------------------------------------------------------- */
403
404 static gboolean
405 edit_check_newline (WEdit * edit)
406 {
407 return !(option_check_nl_at_eof && edit->last_byte > 0
408 && edit_get_byte (edit, edit->last_byte - 1) != '\n'
409 && edit_query_dialog2 (_("Warning"),
410 _("The file you are saving is not finished with a newline"),
411 _("C&ontinue"), _("&Cancel")));
412 }
413
414 /* --------------------------------------------------------------------------------------------- */
415
416 static vfs_path_t *
417 edit_get_save_file_as (WEdit * edit)
418 {
419 #define DLG_WIDTH 64
420 #define DLG_HEIGHT 14
421
422 static LineBreaks cur_lb = LB_ASIS;
423
424 char *filename = vfs_path_to_str (edit->filename_vpath);
425 char *filename_res;
426
427 const char *lb_names[LB_NAMES] = {
428 N_("&Do not change"),
429 N_("&Unix format (LF)"),
430 N_("&Windows/DOS format (CR LF)"),
431 N_("&Macintosh format (CR)")
432 };
433
434 QuickWidget quick_widgets[] = {
435 QUICK_BUTTON (6, 10, DLG_HEIGHT - 3, DLG_HEIGHT, N_("&Cancel"), B_CANCEL, NULL),
436 QUICK_BUTTON (2, 10, DLG_HEIGHT - 3, DLG_HEIGHT, N_("&OK"), B_ENTER, NULL),
437 QUICK_RADIO (5, DLG_WIDTH, DLG_HEIGHT - 8, DLG_HEIGHT, LB_NAMES, lb_names, (int *) &cur_lb),
438 QUICK_LABEL (3, DLG_WIDTH, DLG_HEIGHT - 9, DLG_HEIGHT, N_("Change line breaks to:")),
439 QUICK_INPUT (3, DLG_WIDTH, DLG_HEIGHT - 11, DLG_HEIGHT, filename, DLG_WIDTH - 6, 0,
440 "save-as", &filename_res),
441 QUICK_LABEL (3, DLG_WIDTH, DLG_HEIGHT - 12, DLG_HEIGHT, N_("Enter file name:")),
442 QUICK_END
443 };
444
445 QuickDialog Quick_options = {
446 DLG_WIDTH, DLG_HEIGHT, -1, -1,
447 N_("Save As"), "[Save File As]",
448 quick_widgets, NULL, FALSE
449 };
450
451 if (quick_dialog (&Quick_options) != B_CANCEL)
452 {
453 char *fname;
454 vfs_path_t *ret_vpath;
455
456 edit->lb = cur_lb;
457 fname = tilde_expand (filename_res);
458 g_free (filename_res);
459 ret_vpath = vfs_path_from_str (fname);
460 g_free (fname);
461 return ret_vpath;
462 }
463 g_free (filename);
464
465 return NULL;
466
467 #undef DLG_WIDTH
468 #undef DLG_HEIGHT
469 }
470
471 /* --------------------------------------------------------------------------------------------- */
472
473 /** returns TRUE on success */
474
475 static gboolean
476 edit_save_cmd (WEdit * edit)
477 {
478 int res, save_lock = 0;
479
480 if (!edit->locked && !edit->delete_file)
481 save_lock = lock_file (edit->filename_vpath);
482 res = edit_save_file (edit, edit->filename_vpath);
483
484 /* Maintain modify (not save) lock on failure */
485 if ((res > 0 && edit->locked) || save_lock)
486 edit->locked = unlock_file (edit->filename_vpath);
487
488 /* On failure try 'save as', it does locking on its own */
489 if (res == 0)
490 return edit_save_as_cmd (edit);
491 edit->force |= REDRAW_COMPLETELY;
492 if (res > 0)
493 {
494 edit->delete_file = 0;
495 edit->modified = 0;
496 }
497
498 return TRUE;
499 }
500
501 /* --------------------------------------------------------------------------------------------- */
502 /**
503 * Load file content
504 *
505 * @param edit widget object
506 * @param exp_vpath vfs file path
507 * @return TRUE if file content was successfully loaded, FALSE otherwise
508 */
509
510 static gboolean
511 edit_load_file_from_filename (WEdit * edit, const vfs_path_t * exp_vpath)
512 {
513 int prev_locked = edit->locked;
514 vfs_path_t *prev_filename;
515 gboolean ret = TRUE;
516
517 prev_filename = vfs_path_clone (edit->filename_vpath);
518 if (!edit_reload (edit, exp_vpath))
519 ret = FALSE;
520 else if (prev_locked)
521 unlock_file (prev_filename);
522
523 vfs_path_free (prev_filename);
524 return ret;
525 }
526
527 /* --------------------------------------------------------------------------------------------- */
528
529 static void
530 edit_load_syntax_file (WEdit * edit)
531 {
532 vfs_path_t *extdir_vpath;
533 int dir = 0;
534
535 if (geteuid () == 0)
536 {
537 dir = query_dialog (_("Syntax file edit"),
538 _("Which syntax file you want to edit?"), D_NORMAL, 2,
539 _("&User"), _("&System Wide"));
540 }
541
542 extdir_vpath =
543 vfs_path_build_filename (mc_global.sysconfig_dir, "syntax", "Syntax", (char *) NULL);
544 if (!exist_file (vfs_path_get_last_path_str (extdir_vpath)))
545 {
546 vfs_path_free (extdir_vpath);
547 extdir_vpath =
548 vfs_path_build_filename (mc_global.share_data_dir, "syntax", "Syntax", (char *) NULL);
549 }
550
551 if (dir == 0)
552 {
553 vfs_path_t *user_syntax_file_vpath;
554
555 user_syntax_file_vpath = mc_config_get_full_vpath (EDIT_SYNTAX_FILE);
556 check_for_default (extdir_vpath, user_syntax_file_vpath);
557 edit_load_file_from_filename (edit, user_syntax_file_vpath);
558 vfs_path_free (user_syntax_file_vpath);
559 }
560 else if (dir == 1)
561 edit_load_file_from_filename (edit, extdir_vpath);
562
563 vfs_path_free (extdir_vpath);
564 }
565
566 /* --------------------------------------------------------------------------------------------- */
567
568 static void
569 edit_load_menu_file (WEdit * edit)
570 {
571 vfs_path_t *buffer_vpath;
572 vfs_path_t *menufile_vpath;
573 int dir = 0;
574
575 dir = query_dialog (_("Menu edit"),
576 _("Which menu file do you want to edit?"), D_NORMAL,
577 geteuid () != 0 ? 2 : 3, _("&Local"), _("&User"), _("&System Wide"));
578
579 menufile_vpath = vfs_path_build_filename (mc_global.sysconfig_dir, EDIT_GLOBAL_MENU, NULL);
580
581 if (!exist_file (vfs_path_get_last_path_str (menufile_vpath)))
582 {
583 vfs_path_free (menufile_vpath);
584 menufile_vpath = vfs_path_build_filename (mc_global.share_data_dir, EDIT_GLOBAL_MENU, NULL);
585 }
586
587 switch (dir)
588 {
589 case 0:
590 buffer_vpath = vfs_path_from_str (EDIT_LOCAL_MENU);
591 check_for_default (menufile_vpath, buffer_vpath);
592 chmod (vfs_path_get_last_path_str (buffer_vpath), 0600);
593 break;
594
595 case 1:
596 buffer_vpath = mc_config_get_full_vpath (EDIT_HOME_MENU);
597 check_for_default (menufile_vpath, buffer_vpath);
598 break;
599
600 case 2:
601 buffer_vpath = vfs_path_build_filename (mc_global.sysconfig_dir, EDIT_GLOBAL_MENU, NULL);
602 if (!exist_file (vfs_path_get_last_path_str (buffer_vpath)))
603 {
604 vfs_path_free (buffer_vpath);
605 buffer_vpath =
606 vfs_path_build_filename (mc_global.share_data_dir, EDIT_GLOBAL_MENU, NULL);
607 }
608 break;
609
610 default:
611 vfs_path_free (menufile_vpath);
612 return;
613 }
614
615 edit_load_file_from_filename (edit, buffer_vpath);
616
617 vfs_path_free (buffer_vpath);
618 vfs_path_free (menufile_vpath);
619 }
620
621 /* --------------------------------------------------------------------------------------------- */
622
623 static void
624 edit_delete_column_of_text (WEdit * edit)
625 {
626 off_t p, q, r;
627 off_t m1, m2;
628 off_t n;
629 long b, c, d;
630
631 eval_marks (edit, &m1, &m2);
632 n = edit_move_forward (edit, m1, 0, m2) + 1;
633 c = (long) edit_move_forward3 (edit, edit_bol (edit, m1), 0, m1);
634 d = (long) edit_move_forward3 (edit, edit_bol (edit, m2), 0, m2);
635 b = max (min (c, d), min (edit->column1, edit->column2));
636 c = max (c, max (edit->column1, edit->column2));
637
638 while (n--)
639 {
640 r = edit_bol (edit, edit->curs1);
641 p = edit_move_forward3 (edit, r, b, 0);
642 q = edit_move_forward3 (edit, r, c, 0);
643 if (p < m1)
644 p = m1;
645 if (q > m2)
646 q = m2;
647 edit_cursor_move (edit, p - edit->curs1);
648 while (q > p)
649 {
650 /* delete line between margins */
651 if (edit_get_byte (edit, edit->curs1) != '\n')
652 edit_delete (edit, 1);
653 q--;
654 }
655 if (n)
656 /* move to next line except on the last delete */
657 edit_cursor_move (edit, edit_move_forward (edit, edit->curs1, 1, 0) - edit->curs1);
658 }
659 }
660
661 /* --------------------------------------------------------------------------------------------- */
662 /** if success return 0 */
663
664 static int
665 edit_block_delete (WEdit * edit)
666 {
667 off_t count;
668 off_t start_mark, end_mark;
669 int curs_pos;
670 long curs_line, c1, c2;
671
672 if (eval_marks (edit, &start_mark, &end_mark))
673 return 0;
674 if (edit->column_highlight && edit->mark2 < 0)
675 edit_mark_cmd (edit, FALSE);
676 if ((end_mark - start_mark) > option_max_undo / 2)
677 {
678 /* Warning message with a query to continue or cancel the operation */
679 if (edit_query_dialog2
680 (_("Warning"),
681 _
682 ("Block is large, you may not be able to undo this action"),
683 _("C&ontinue"), _("&Cancel")))
684 {
685 return 1;
686 }
687 }
688 c1 = min (edit->column1, edit->column2);
689 c2 = max (edit->column1, edit->column2);
690 edit->column1 = c1;
691 edit->column2 = c2;
692
693 edit_push_markers (edit);
694
695 curs_line = edit->curs_line;
696
697 curs_pos = edit->curs_col + edit->over_col;
698
699 /* move cursor to start of selection */
700 edit_cursor_move (edit, start_mark - edit->curs1);
701 edit_scroll_screen_over_cursor (edit);
702 count = start_mark;
703 if (start_mark < end_mark)
704 {
705 if (edit->column_highlight)
706 {
707 long line_width;
708
709 if (edit->mark2 < 0)
710 edit_mark_cmd (edit, FALSE);
711 edit_delete_column_of_text (edit);
712 /* move cursor to the saved position */
713 edit_move_to_line (edit, curs_line);
714 /* calculate line width and cursor position before cut */
715 line_width = (long) edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0,
716 edit_eol (edit, edit->curs1));
717 if (option_cursor_beyond_eol && curs_pos > line_width)
718 edit->over_col = curs_pos - line_width;
719 }
720 else
721 {
722 while (count < end_mark)
723 {
724 edit_delete (edit, 1);
725 count++;
726 }
727 }
728 }
729 edit_set_markers (edit, 0, 0, 0, 0);
730 edit->force |= REDRAW_PAGE;
731 return 0;
732 }
733
734 /* --------------------------------------------------------------------------------------------- */
735 /**
736 * Get EOL symbol for searching.
737 *
738 * @param edit editor object
739 * @return EOL symbol
740 */
741
742 static inline char
743 edit_search_get_current_end_line_char (const WEdit * edit)
744 {
745 switch (edit->lb)
746 {
747 case LB_MAC:
748 return '\r';
749 default:
750 return '\n';
751 }
752 }
753
754 /* --------------------------------------------------------------------------------------------- */
755 /**
756 * Checking if search condition have BOL(^) or EOL ($) regexp special characters.
757 *
758 * @param search search object
759 * @return result of checks.
760 */
761
762 static edit_search_line_t
763 edit_get_search_line_type (mc_search_t * search)
764 {
765 edit_search_line_t search_line_type = 0;
766
767 if (search->search_type != MC_SEARCH_T_REGEX)
768 return search_line_type;
769
770 if (*search->original == '^')
771 search_line_type |= AT_START_LINE;
772
773 if (search->original[search->original_len - 1] == '$')
774 search_line_type |= AT_END_LINE;
775 return search_line_type;
776 }
777
778 /* --------------------------------------------------------------------------------------------- */
779 /**
780 * Calculating the start position of next line.
781 *
782 * @param edit editor object
783 * @param current_pos current position
784 * @param max_pos max position
785 * @param end_string_symbol end of line symbol
786 * @return start position of next line
787 */
788
789 static off_t
790 edit_calculate_start_of_next_line (WEdit * edit, off_t current_pos, off_t max_pos,
791 char end_string_symbol)
792 {
793 off_t i;
794
795 for (i = current_pos; i < max_pos; i++)
796 {
797 current_pos++;
798 if (edit_get_byte (edit, i) == end_string_symbol)
799 break;
800 }
801
802 return current_pos;
803 }
804
805 /* --------------------------------------------------------------------------------------------- */
806 /**
807 * Calculating the end position of previous line.
808 *
809 * @param edit editor object
810 * @param current_pos current position
811 * @param end_string_symbol end of line symbol
812 * @return end position of previous line
813 */
814
815 static off_t
816 edit_calculate_end_of_previous_line (WEdit * edit, off_t current_pos, char end_string_symbol)
817 {
818 off_t i;
819
820 for (i = current_pos - 1; i >= 0; i--)
821 if (edit_get_byte (edit, i) == end_string_symbol)
822 break;
823
824 return i;
825 }
826
827 /* --------------------------------------------------------------------------------------------- */
828 /**
829 * Calculating the start position of previous line.
830 *
831 * @param edit editor object
832 * @param current_pos current position
833 * @param end_string_symbol end of line symbol
834 * @return start position of previous line
835 */
836
837 static inline off_t
838 edit_calculate_start_of_previous_line (WEdit * edit, off_t current_pos, char end_string_symbol)
839 {
840 current_pos = edit_calculate_end_of_previous_line (edit, current_pos, end_string_symbol);
841 current_pos = edit_calculate_end_of_previous_line (edit, current_pos, end_string_symbol);
842
843 return (current_pos + 1);
844 }
845
846 /* --------------------------------------------------------------------------------------------- */
847 /**
848 * Calculating the start position of current line.
849 *
850 * @param edit editor object
851 * @param current_pos current position
852 * @param end_string_symbol end of line symbol
853 * @return start position of current line
854 */
855
856 static inline off_t
857 edit_calculate_start_of_current_line (WEdit * edit, off_t current_pos, char end_string_symbol)
858 {
859 current_pos = edit_calculate_end_of_previous_line (edit, current_pos, end_string_symbol);
860
861 return (current_pos + 1);
862 }
863
864 /* --------------------------------------------------------------------------------------------- */
865 /**
866 * Fixing (if needed) search start position if 'only in selection' option present.
867 *
868 * @param edit editor object
869 */
870
871 static void
872 edit_search_fix_search_start_if_selection (WEdit * edit)
873 {
874 off_t start_mark = 0;
875 off_t end_mark = 0;
876
877 if (!edit_search_options.only_in_selection)
878 return;
879
880 if (eval_marks (edit, &start_mark, &end_mark) != 0)
881 return;
882
883 if (edit_search_options.backwards)
884 {
885 if (edit->search_start > end_mark || edit->search_start <= start_mark)
886 edit->search_start = end_mark;
887 }
888 else
889 {
890 if (edit->search_start < start_mark || edit->search_start >= end_mark)
891 edit->search_start = start_mark;
892 }
893 }
894
895 /* --------------------------------------------------------------------------------------------- */
896
897 static gboolean
898 editcmd_find (WEdit * edit, gsize * len)
899 {
900 off_t search_start = edit->search_start;
901 off_t search_end;
902 off_t start_mark = 0;
903 off_t end_mark = edit->last_byte;
904 int mark_res = 0;
905 char end_string_symbol;
906
907 end_string_symbol = edit_search_get_current_end_line_char (edit);
908
909 /* prepare for search */
910 if (edit_search_options.only_in_selection)
911 {
912 mark_res = eval_marks (edit, &start_mark, &end_mark);
913 if (mark_res != 0)
914 {
915 edit->search->error = MC_SEARCH_E_NOTFOUND;
916 edit->search->error_str = g_strdup (_("Search string not found"));
917 return FALSE;
918 }
919
920 /* fix the start and the end of search block positions */
921 if ((edit->search_line_type & AT_START_LINE) != 0
922 && (start_mark != 0 || edit_get_byte (edit, start_mark - 1) != end_string_symbol))
923 {
924 start_mark =
925 edit_calculate_start_of_next_line (edit, start_mark, edit->last_byte,
926 end_string_symbol);
927 }
928 if ((edit->search_line_type & AT_END_LINE) != 0
929 && (end_mark - 1 != edit->last_byte
930 || edit_get_byte (edit, end_mark) != end_string_symbol))
931 {
932 end_mark = edit_calculate_end_of_previous_line (edit, end_mark, end_string_symbol);
933 }
934 if (start_mark >= end_mark)
935 {
936 edit->search->error = MC_SEARCH_E_NOTFOUND;
937 edit->search->error_str = g_strdup (_("Search string not found"));
938 return FALSE;
939 }
940 }
941 else
942 {
943 if (edit_search_options.backwards)
944 end_mark = max (1, edit->curs1) - 1;
945 }
946
947 /* search */
948 if (edit_search_options.backwards)
949 {
950 /* backward search */
951 search_end = end_mark;
952
953 if ((edit->search_line_type & AT_START_LINE) != 0)
954 search_start =
955 edit_calculate_start_of_current_line (edit, search_start, end_string_symbol);
956
957 while ((int) search_start >= start_mark)
958 {
959 if (search_end > (off_t) (search_start + edit->search->original_len)
960 && mc_search_is_fixed_search_str (edit->search))
961 {
962 search_end = search_start + edit->search->original_len;
963 }
964 if (mc_search_run (edit->search, (void *) edit, search_start, search_end, len)
965 && edit->search->normal_offset == search_start)
966 {
967 return TRUE;
968 }
969
970
971 if ((edit->search_line_type & AT_START_LINE) != 0)
972 search_start =
973 edit_calculate_start_of_previous_line (edit, search_start, end_string_symbol);
974 else
975 search_start--;
976 }
977 edit->search->error_str = g_strdup (_("Search string not found"));
978 }
979 else
980 {
981 /* forward search */
982 if ((edit->search_line_type & AT_START_LINE) != 0 && search_start != start_mark)
983 search_start =
984 edit_calculate_start_of_next_line (edit, search_start, end_mark, end_string_symbol);
985 return mc_search_run (edit->search, (void *) edit, search_start, end_mark, len);
986 }
987 return FALSE;
988 }
989
990 /* --------------------------------------------------------------------------------------------- */
991
992 static char *
993 edit_replace_cmd__conv_to_display (char *str)
994 {
995 #ifdef HAVE_CHARSET
996 GString *tmp;
997
998 tmp = str_convert_to_display (str);
999 if (tmp != NULL)
1000 {
1001 if (tmp->len != 0)
1002 return g_string_free (tmp, FALSE);
1003 g_string_free (tmp, TRUE);
1004 }
1005 #endif
1006 return g_strdup (str);
1007 }
1008
1009 /* --------------------------------------------------------------------------------------------- */
1010
1011 static char *
1012 edit_replace_cmd__conv_to_input (char *str)
1013 {
1014 #ifdef HAVE_CHARSET
1015 GString *tmp;
1016
1017 tmp = str_convert_to_input (str);
1018 if (tmp != NULL)
1019 {
1020 if (tmp->len != 0)
1021 return g_string_free (tmp, FALSE);
1022 g_string_free (tmp, TRUE);
1023 }
1024 #endif
1025 return g_strdup (str);
1026 }
1027
1028 /* --------------------------------------------------------------------------------------------- */
1029
1030 static void
1031 edit_do_search (WEdit * edit)
1032 {
1033 gsize len = 0;
1034
1035 if (edit->search == NULL)
1036 edit->search_start = edit->curs1;
1037
1038 edit_push_undo_action (edit, KEY_PRESS + edit->start_display);
1039
1040 if (search_create_bookmark)
1041 {
1042 int found = 0, books = 0;
1043 long l = 0, l_last = -1;
1044 long q = 0;
1045
1046 search_create_bookmark = FALSE;
1047 book_mark_flush (edit, -1);
1048
1049 while (mc_search_run (edit->search, (void *) edit, q, edit->last_byte, &len))
1050 {
1051 if (found == 0)
1052 edit->search_start = edit->search->normal_offset;
1053 found++;
1054 l += edit_count_lines (edit, q, edit->search->normal_offset);
1055 if (l != l_last)
1056 {
1057 book_mark_insert (edit, l, BOOK_MARK_FOUND_COLOR);
1058 books++;
1059 }
1060 l_last = l;
1061 q = edit->search->normal_offset + 1;
1062 }
1063
1064 if (found == 0)
1065 edit_error_dialog (_("Search"), _("Search string not found"));
1066 else
1067 edit_cursor_move (edit, edit->search_start - edit->curs1);
1068 }
1069 else
1070 {
1071 if (edit->found_len != 0 && edit->search_start == edit->found_start + 1
1072 && edit_search_options.backwards)
1073 edit->search_start--;
1074
1075 if (edit->found_len != 0 && edit->search_start == edit->found_start - 1
1076 && !edit_search_options.backwards)
1077 edit->search_start++;
1078
1079 if (editcmd_find (edit, &len))
1080 {
1081 edit->found_start = edit->search_start = edit->search->normal_offset;
1082 edit->found_len = len;
1083 edit->over_col = 0;
1084 edit_cursor_move (edit, edit->search_start - edit->curs1);
1085 edit_scroll_screen_over_cursor (edit);
1086 if (edit_search_options.backwards)
1087 edit->search_start--;
1088 else
1089 edit->search_start++;
1090 }
1091 else
1092 {
1093 edit->search_start = edit->curs1;
1094 if (edit->search->error_str != NULL)
1095 edit_error_dialog (_("Search"), edit->search->error_str);
1096 }
1097 }
1098
1099 edit->force |= REDRAW_COMPLETELY;
1100 edit_scroll_screen_over_cursor (edit);
1101 }
1102
1103 /* --------------------------------------------------------------------------------------------- */
1104
1105 static void
1106 edit_search (WEdit * edit)
1107 {
1108 if (editcmd_dialog_search_show (edit))
1109 {
1110 edit->search_line_type = edit_get_search_line_type (edit->search);
1111 edit_search_fix_search_start_if_selection (edit);
1112 edit_do_search (edit);
1113 }
1114 }
1115
1116 /* --------------------------------------------------------------------------------------------- */
1117 /** Return a null terminated length of text. Result must be g_free'd */
1118
1119 static unsigned char *
1120 edit_get_block (WEdit * edit, off_t start, off_t finish, int *l)
1121 {
1122 unsigned char *s, *r;
1123 r = s = g_malloc0 (finish - start + 1);
1124 if (edit->column_highlight)
1125 {
1126 *l = 0;
1127 /* copy from buffer, excluding chars that are out of the column 'margins' */
1128 while (start < finish)
1129 {
1130 int c;
1131 off_t x;
1132
1133 x = edit_move_forward3 (edit, edit_bol (edit, start), 0, start);
1134 c = edit_get_byte (edit, start);
1135 if ((x >= edit->column1 && x < edit->column2)
1136 || (x >= edit->column2 && x < edit->column1) || c == '\n')
1137 {
1138 *s++ = c;
1139 (*l)++;
1140 }
1141 start++;
1142 }
1143 }
1144 else
1145 {
1146 *l = finish - start;
1147 while (start < finish)
1148 *s++ = edit_get_byte (edit, start++);
1149 }
1150 *s = 0;
1151 return r;
1152 }
1153
1154 /* --------------------------------------------------------------------------------------------- */
1155 /** copies a block to clipboard file */
1156
1157 static gboolean
1158 edit_save_block_to_clip_file (WEdit * edit, off_t start, off_t finish)
1159 {
1160 gboolean ret;
1161 gchar *tmp;
1162
1163 tmp = mc_config_get_full_path (EDIT_CLIP_FILE);
1164 ret = edit_save_block (edit, tmp, start, finish);
1165 g_free (tmp);
1166 return ret;
1167 }
1168
1169 /* --------------------------------------------------------------------------------------------- */
1170
1171 static void
1172 pipe_mail (WEdit * edit, char *to, char *subject, char *cc)
1173 {
1174 FILE *p = 0;
1175 char *s;
1176
1177 to = name_quote (to, 0);
1178 subject = name_quote (subject, 0);
1179 cc = name_quote (cc, 0);
1180 s = g_strconcat ("mail -s ", subject, *cc ? " -c " : "", cc, " ", to, (char *) NULL);
1181 g_free (to);
1182 g_free (subject);
1183 g_free (cc);
1184
1185 if (s)
1186 {
1187 p = popen (s, "w");
1188 g_free (s);
1189 }
1190
1191 if (p)
1192 {
1193 off_t i;
1194 for (i = 0; i < edit->last_byte; i++)
1195 fputc (edit_get_byte (edit, i), p);
1196 pclose (p);
1197 }
1198 }
1199
1200 /* --------------------------------------------------------------------------------------------- */
1201
1202 static gboolean
1203 is_break_char (char c)
1204 {
1205 return (isspace (c) || strchr ("{}[]()<>=|/\\!?~-+`'\",.;:#$%^&*", c));
1206 }
1207
1208 /* --------------------------------------------------------------------------------------------- */
1209 /** find first character of current word */
1210
1211 static gboolean
1212 edit_find_word_start (WEdit * edit, off_t * word_start, gsize * word_len)
1213 {
1214 int c, last;
1215 gsize i;
1216
1217 /* return if at begin of file */
1218 if (edit->curs1 <= 0)
1219 return FALSE;
1220
1221 c = edit_get_byte (edit, edit->curs1 - 1);
1222 /* return if not at end or in word */
1223 if (is_break_char (c))
1224 return FALSE;
1225
1226 /* search start of word to be completed */
1227 for (i = 2;; i++)
1228 {
1229 /* return if at begin of file */
1230 if ((gsize) edit->curs1 < i)
1231 return FALSE;
1232
1233 last = c;
1234 c = edit_get_byte (edit, edit->curs1 - i);
1235
1236 if (is_break_char (c))
1237 {
1238 /* return if word starts with digit */
1239 if (isdigit (last))
1240 return FALSE;
1241
1242 *word_start = edit->curs1 - (i - 1); /* start found */
1243 *word_len = i - 1;
1244 break;
1245 }
1246 }
1247 /* success */
1248 return TRUE;
1249 }
1250
1251 /* --------------------------------------------------------------------------------------------- */
1252 /**
1253 * Get current word under cursor
1254 *
1255 * @param edit editor object
1256 * @param srch mc_search object
1257 * @param word_start start word position
1258 *
1259 * @return newly allocated string or NULL if no any words under cursor
1260 */
1261
1262 static char *
1263 edit_collect_completions_get_current_word (WEdit * edit, mc_search_t * srch, off_t word_start)
1264 {
1265 gsize len = 0;
1266 off_t i;
1267 GString *temp;
1268
1269 if (!mc_search_run (srch, (void *) edit, word_start, edit->last_byte, &len))
1270 return NULL;
1271
1272 temp = g_string_sized_new (len);
1273
1274 for (i = 0; i < (off_t) len; i++)
1275 {
1276 int chr;
1277
1278 chr = edit_get_byte (edit, word_start + i);
1279 if (!isspace (chr))
1280 g_string_append_c (temp, chr);
1281 }
1282
1283 return g_string_free (temp, temp->len == 0);
1284 }
1285
1286 /* --------------------------------------------------------------------------------------------- */
1287 /** collect the possible completions */
1288
1289 static gsize
1290 edit_collect_completions (WEdit * edit, off_t word_start, gsize word_len,
1291 char *match_expr, struct selection *compl, gsize * num)
1292 {
1293 gsize len = 0;
1294 gsize max_len = 0;
1295 gsize i;
1296 int skip;
1297 GString *temp;
1298 mc_search_t *srch;
1299 off_t last_byte, start = -1;
1300 char *current_word;
1301
1302 srch = mc_search_new (match_expr, -1);
1303 if (srch == NULL)
1304 return 0;
1305
1306 if (mc_config_get_bool
1307 (mc_main_config, CONFIG_APP_SECTION, "editor_wordcompletion_collect_entire_file", 0))
1308 {
1309 last_byte = edit->last_byte;
1310 }
1311 else
1312 {
1313 last_byte = word_start;
1314 }
1315
1316 srch->search_type = MC_SEARCH_T_REGEX;
1317 srch->is_case_sensitive = TRUE;
1318 srch->search_fn = edit_search_cmd_callback;
1319
1320 current_word = edit_collect_completions_get_current_word (edit, srch, word_start);
1321
1322 temp = g_string_new ("");
1323
1324 /* collect max MAX_WORD_COMPLETIONS completions */
1325 while (mc_search_run (srch, (void *) edit, start + 1, last_byte, &len))
1326 {
1327 g_string_set_size (temp, 0);
1328 start = srch->normal_offset;
1329
1330 /* add matched completion if not yet added */
1331 for (i = 0; i < len; i++)
1332 {
1333 skip = edit_get_byte (edit, start + i);
1334 if (isspace (skip))
1335 continue;
1336
1337 /* skip current word */
1338 if (start + (off_t) i == word_start)
1339 break;
1340
1341 g_string_append_c (temp, skip);
1342 }
1343
1344 if (temp->len == 0)
1345 continue;
1346
1347 if (current_word != NULL && strcmp (current_word, temp->str) == 0)
1348 continue;
1349
1350 skip = 0;
1351
1352 for (i = 0; i < *num; i++)
1353 {
1354 if (strncmp
1355 ((char *) &compl[i].text[word_len],
1356 (char *) &temp->str[word_len], max (len, compl[i].len) - word_len) == 0)
1357 {
1358 struct selection this = compl[i];
1359 for (++i; i < *num; i++)
1360 {
1361 compl[i - 1] = compl[i];
1362 }
1363 compl[*num - 1] = this;
1364 skip = 1;
1365 break; /* skip it, already added */
1366 }
1367 }
1368 if (skip != 0)
1369 continue;
1370
1371 if (*num == MAX_WORD_COMPLETIONS)
1372 {
1373 g_free (compl[0].text);
1374 for (i = 1; i < *num; i++)
1375 {
1376 compl[i - 1] = compl[i];
1377 }
1378 (*num)--;
1379 }
1380 #ifdef HAVE_CHARSET
1381 {
1382 GString *recoded;
1383 recoded = str_convert_to_display (temp->str);
1384
1385 if (recoded && recoded->len)
1386 g_string_assign (temp, recoded->str);
1387
1388 g_string_free (recoded, TRUE);
1389 }
1390 #endif
1391 compl[*num].text = g_strdup (temp->str);
1392 compl[*num].len = temp->len;
1393 (*num)++;
1394 start += len;
1395
1396 /* note the maximal length needed for the completion dialog */
1397 if (len > max_len)
1398 max_len = len;
1399 }
1400
1401 mc_search_free (srch);
1402 g_string_free (temp, TRUE);
1403 g_free (current_word);
1404
1405 return max_len;
1406 }
1407
1408 /* --------------------------------------------------------------------------------------------- */
1409
1410 static void
1411 edit_insert_column_of_text (WEdit * edit, unsigned char *data, int size, int width,
1412 off_t * start_pos, off_t * end_pos, int *col1, int *col2)
1413 {
1414 off_t cursor;
1415 long i, col;
1416
1417 cursor = edit->curs1;
1418 col = edit_get_col (edit);
1419
1420 for (i = 0; i < size; i++)
1421 {
1422 if (data[i] != '\n')
1423 edit_insert (edit, data[i]);
1424 else
1425 { /* fill in and move to next line */
1426 int l;
1427 off_t p;
1428
1429 if (edit_get_byte (edit, edit->curs1) != '\n')
1430 {
1431 l = width - (edit_get_col (edit) - col);
1432 while (l > 0)
1433 {
1434 edit_insert (edit, ' ');
1435 l -= space_width;
1436 }
1437 }
1438 for (p = edit->curs1;; p++)
1439 {
1440 if (p == edit->last_byte)
1441 {
1442 edit_cursor_move (edit, edit->last_byte - edit->curs1);
1443 edit_insert_ahead (edit, '\n');
1444 p++;
1445 break;
1446 }
1447 if (edit_get_byte (edit, p) == '\n')
1448 {
1449 p++;
1450 break;
1451 }
1452 }
1453 edit_cursor_move (edit, edit_move_forward3 (edit, p, col, 0) - edit->curs1);
1454 l = col - edit_get_col (edit);
1455 while (l >= space_width)
1456 {
1457 edit_insert (edit, ' ');
1458 l -= space_width;
1459 }
1460 }
1461 }
1462
1463 *col1 = col;
1464 *col2 = col + width;
1465 *start_pos = cursor;
1466 *end_pos = edit->curs1;
1467 edit_cursor_move (edit, cursor - edit->curs1);
1468 }
1469
1470 /* --------------------------------------------------------------------------------------------- */
1471
1472 static int
1473 edit_macro_comparator (gconstpointer * macro1, gconstpointer * macro2)
1474 {
1475 const macros_t *m1 = (const macros_t *) macro1;
1476 const macros_t *m2 = (const macros_t *) macro2;
1477
1478 return m1->hotkey - m2->hotkey;
1479 }
1480
1481 /* --------------------------------------------------------------------------------------------- */
1482
1483 static void
1484 edit_macro_sort_by_hotkey (void)
1485 {
1486 if (macros_list != NULL && macros_list->len != 0)
1487 g_array_sort (macros_list, (GCompareFunc) edit_macro_comparator);
1488 }
1489
1490 /* --------------------------------------------------------------------------------------------- */
1491
1492 static gboolean
1493 edit_get_macro (WEdit * edit, int hotkey, const macros_t ** macros, guint * indx)
1494 {
1495 const macros_t *array_start = &g_array_index (macros_list, struct macros_t, 0);
1496 macros_t *result;
1497 macros_t search_macro;
1498
1499 (void) edit;
1500
1501 search_macro.hotkey = hotkey;
1502 result = bsearch (&search_macro, macros_list->data, macros_list->len,
1503 sizeof (macros_t), (GCompareFunc) edit_macro_comparator);
1504
1505 if (result != NULL && result->macro != NULL)
1506 {
1507 *indx = (result - array_start);
1508 *macros = result;
1509 return TRUE;
1510 }
1511 *indx = 0;
1512 return FALSE;
1513 }
1514
1515 /* --------------------------------------------------------------------------------------------- */
1516 /** returns FALSE on error */
1517
1518 static gboolean
1519 edit_delete_macro (WEdit * edit, int hotkey)
1520 {
1521 mc_config_t *macros_config = NULL;
1522 const char *section_name = "editor";
1523 gchar *macros_fname;
1524 guint indx;
1525 char *skeyname;
1526 const macros_t *macros = NULL;
1527
1528 /* clear array of actions for current hotkey */
1529 while (edit_get_macro (edit, hotkey, &macros, &indx))
1530 {
1531 if (macros->macro != NULL)
1532 g_array_free (macros->macro, TRUE);
1533 macros = NULL;
1534 g_array_remove_index (macros_list, indx);
1535 edit_macro_sort_by_hotkey ();
1536 }
1537
1538 macros_fname = mc_config_get_full_path (MC_MACRO_FILE);
1539 macros_config = mc_config_init (macros_fname, FALSE);
1540 g_free (macros_fname);
1541
1542 if (macros_config == NULL)
1543 return FALSE;
1544
1545 skeyname = lookup_key_by_code (hotkey);
1546 while (mc_config_del_key (macros_config, section_name, skeyname))
1547 ;
1548 g_free (skeyname);
1549 mc_config_save_file (macros_config, NULL);
1550 mc_config_deinit (macros_config);
1551 return TRUE;
1552 }
1553
1554
1555 /* --------------------------------------------------------------------------------------------- */
1556 /*** public functions ****************************************************************************/
1557 /* --------------------------------------------------------------------------------------------- */
1558
1559 void
1560 edit_help_cmd (WEdit * edit)
1561 {
1562 ev_help_t event_data = { NULL, "[Internal File Editor]" };
1563 mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
1564
1565 edit->force |= REDRAW_COMPLETELY;
1566 }
1567
1568 /* --------------------------------------------------------------------------------------------- */
1569
1570 void
1571 edit_refresh_cmd (WEdit * edit)
1572 {
1573 #ifdef HAVE_SLANG
1574 int color;
1575
1576 edit_get_syntax_color (edit, -1, &color);
1577 tty_touch_screen ();
1578 mc_refresh ();
1579 #else
1580 (void) edit;
1581
1582 clr_scr ();
1583 repaint_screen ();
1584 #endif /* !HAVE_SLANG */
1585 tty_keypad (TRUE);
1586 }
1587
1588 /* --------------------------------------------------------------------------------------------- */
1589
1590 void
1591 menu_save_mode_cmd (void)
1592 {
1593 /* diaog sizes */
1594 const int DLG_X = 38;
1595 const int DLG_Y = 13;
1596
1597 char *str_result;
1598
1599 const char *str[] = {
1600 N_("&Quick save"),
1601 N_("&Safe save"),
1602 N_("&Do backups with following extension:")
1603 };
1604
1605 QuickWidget widgets[] = {
1606 /* 0 */
1607 QUICK_BUTTON (18, DLG_X, DLG_Y - 3, DLG_Y, N_("&Cancel"), B_CANCEL, NULL),
1608 /* 1 */
1609 QUICK_BUTTON (6, DLG_X, DLG_Y - 3, DLG_Y, N_("&OK"), B_ENTER, NULL),
1610 /* 2 */
1611 QUICK_CHECKBOX (4, DLG_X, 8, DLG_Y, N_("Check &POSIX new line"), &option_check_nl_at_eof),
1612 /* 3 */
1613 QUICK_INPUT (8, DLG_X, 6, DLG_Y, option_backup_ext, 9, 0, "edit-backup-ext", &str_result),
1614 /* 4 */
1615 QUICK_RADIO (4, DLG_X, 3, DLG_Y, 3, str, &option_save_mode),
1616 QUICK_END
1617 };
1618
1619 QuickDialog dialog = {
1620 DLG_X, DLG_Y, -1, -1, N_("Edit Save Mode"),
1621 "[Edit Save Mode]", widgets, NULL, FALSE
1622 };
1623
1624 size_t i;
1625 size_t maxlen = 0;
1626 size_t w0, w1, b_len, w3;
1627
1628 #ifdef HAVE_ASSERT_H
1629 assert (option_backup_ext != NULL);
1630 #endif
1631
1632 /* OK/Cancel buttons */
1633 w0 = str_term_width1 (_(widgets[0].u.button.text)) + 3;
1634 w1 = str_term_width1 (_(widgets[1].u.button.text)) + 5; /* default button */
1635 b_len = w0 + w1 + 3;
1636
1637 maxlen = max (b_len, (size_t) str_term_width1 (_(dialog.title)) + 2);
1638
1639 w3 = 0;
1640 for (i = 0; i < 3; i++)
1641 {
1642 #ifdef ENABLE_NLS
1643 str[i] = _(str[i]);
1644 #endif
1645 w3 = max (w3, (size_t) str_term_width1 (str[i]));
1646 }
1647
1648 maxlen = max (maxlen, w3 + 4);
1649
1650 dialog.xlen = min ((size_t) COLS, maxlen + 8);
1651
1652 widgets[3].u.input.len = w3;
1653 widgets[1].relative_x = (dialog.xlen - b_len) / 2;
1654 widgets[0].relative_x = widgets[1].relative_x + w0 + 2;
1655
1656 for (i = 0; i < sizeof (widgets) / sizeof (widgets[0]); i++)
1657 widgets[i].x_divisions = dialog.xlen;
1658
1659 if (quick_dialog (&dialog) != B_CANCEL)
1660 {
1661 g_free (option_backup_ext);
1662 option_backup_ext = str_result;
1663 }
1664 }
1665
1666 /* --------------------------------------------------------------------------------------------- */
1667
1668 void
1669 edit_set_filename (WEdit * edit, const vfs_path_t * name_vpath)
1670 {
1671 vfs_path_free (edit->filename_vpath);
1672 edit->filename_vpath = vfs_path_clone (name_vpath);
1673
1674 if (edit->dir_vpath == NULL)
1675 edit->dir_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
1676 }
1677
1678 /* --------------------------------------------------------------------------------------------- */
1679 /* Here we want to warn the users of overwriting an existing file,
1680 but only if they have made a change to the filename */
1681 /* returns TRUE on success */
1682 gboolean
1683 edit_save_as_cmd (WEdit * edit)
1684 {
1685 /* This heads the 'Save As' dialog box */
1686 vfs_path_t *exp_vpath;
1687 int save_lock = 0;
1688 int different_filename = 0;
1689
1690 if (!edit_check_newline (edit))
1691 return FALSE;
1692
1693 exp_vpath = edit_get_save_file_as (edit);
1694 edit_push_undo_action (edit, KEY_PRESS + edit->start_display);
1695
1696 if (exp_vpath != NULL)
1697 {
1698 if (vfs_path_len (exp_vpath) == 0)
1699 goto ret;
1700 else
1701 {
1702 int rv;
1703
1704 if (vfs_path_cmp (edit->filename_vpath, exp_vpath) != 0)
1705 {
1706 int file;
1707 struct stat sb;
1708
1709 if (mc_stat (exp_vpath, &sb) == 0 && !S_ISREG (sb.st_mode))
1710 {
1711 edit_error_dialog (_("Save as"),
1712 get_sys_error (_
1713 ("Cannot save: destination is not a regular file")));
1714 goto ret;
1715 }
1716
1717 different_filename = 1;
1718 file = mc_open (exp_vpath, O_RDONLY | O_BINARY);
1719
1720 if (file != -1)
1721 {
1722 /* the file exists */
1723 mc_close (file);
1724 /* Overwrite the current file or cancel the operation */
1725 if (edit_query_dialog2
1726 (_("Warning"),
1727 _("A file already exists with this name"), _("&Overwrite"), _("&Cancel")))
1728 goto ret;
1729 }
1730 else
1731 {
1732 edit->stat1.st_mode |= S_IWUSR;
1733 }
1734 save_lock = lock_file (exp_vpath);
1735 }
1736 else
1737 {
1738 /* filenames equal, check if already locked */
1739 if (!edit->locked && !edit->delete_file)
1740 save_lock = lock_file (exp_vpath);
1741 }
1742
1743 if (different_filename)
1744 {
1745 /*
1746 * Allow user to write into saved (under another name) file
1747 * even if original file had r/o user permissions.
1748 */
1749 edit->stat1.st_mode |= S_IWRITE;
1750 }
1751
1752 rv = edit_save_file (edit, exp_vpath);
1753 switch (rv)
1754 {
1755 case 1:
1756 /* Succesful, so unlock both files */
1757 if (different_filename)
1758 {
1759 if (save_lock)
1760 unlock_file (exp_vpath);
1761 if (edit->locked)
1762 edit->locked = unlock_file (edit->filename_vpath);
1763 }
1764 else
1765 {
1766 if (edit->locked || save_lock)
1767 edit->locked = unlock_file (edit->filename_vpath);
1768 }
1769
1770 edit_set_filename (edit, exp_vpath);
1771 if (edit->lb != LB_ASIS)
1772 edit_reload (edit, exp_vpath);
1773 edit->modified = 0;
1774 edit->delete_file = 0;
1775 if (different_filename)
1776 edit_load_syntax (edit, NULL, edit->syntax_type);
1777 vfs_path_free (exp_vpath);
1778 edit->force |= REDRAW_COMPLETELY;
1779 return TRUE;
1780 default:
1781 edit_error_dialog (_("Save as"), get_sys_error (_("Cannot save file")));
1782 /* fallthrough */
1783 case -1:
1784 /* Failed, so maintain modify (not save) lock */
1785 if (save_lock)
1786 unlock_file (exp_vpath);
1787 break;
1788 }
1789 }
1790 }
1791
1792 ret:
1793 vfs_path_free (exp_vpath);
1794 edit->force |= REDRAW_COMPLETELY;
1795 return FALSE;
1796 }
1797
1798 /* {{{ Macro stuff starts here */
1799 /* --------------------------------------------------------------------------------------------- */
1800
1801 void
1802 edit_delete_macro_cmd (WEdit * edit)
1803 {
1804 int hotkey;
1805
1806 hotkey = editcmd_dialog_raw_key_query (_("Delete macro"), _("Press macro hotkey:"), TRUE);
1807
1808 if (hotkey != 0 && !edit_delete_macro (edit, hotkey))
1809 message (D_ERROR, _("Delete macro"), _("Macro not deleted"));
1810 }
1811
1812 /* --------------------------------------------------------------------------------------------- */
1813
1814 /** returns FALSE on error */
1815 gboolean
1816 edit_execute_macro (WEdit * edit, int hotkey)
1817 {
1818 gboolean res = FALSE;
1819
1820 if (hotkey != 0)
1821 {
1822 const macros_t *macros;
1823 guint indx;
1824
1825 if (edit_get_macro (edit, hotkey, &macros, &indx) &&
1826 macros->macro != NULL && macros->macro->len != 0)
1827 {
1828 guint i;
1829
1830 edit->force |= REDRAW_PAGE;
1831
1832 for (i = 0; i < macros->macro->len; i++)
1833 {
1834 const macro_action_t *m_act;
1835
1836 m_act = &g_array_index (macros->macro, struct macro_action_t, i);
1837 edit_execute_cmd (edit, m_act->action, m_act->ch);
1838 res = TRUE;
1839 }
1840 }
1841 }
1842
1843 return res;
1844 }
1845
1846 /* --------------------------------------------------------------------------------------------- */
1847
1848 /** returns FALSE on error */
1849 gboolean
1850 edit_store_macro_cmd (WEdit * edit)
1851 {
1852 int i;
1853 int hotkey;
1854 GString *marcros_string;
1855 mc_config_t *macros_config = NULL;
1856 const char *section_name = "editor";
1857 gchar *macros_fname;
1858 GArray *macros; /* current macro */
1859 int tmp_act;
1860 gboolean have_macro = FALSE;
1861 char *skeyname = NULL;
1862
1863 hotkey =
1864 editcmd_dialog_raw_key_query (_("Save macro"), _("Press the macro's new hotkey:"), TRUE);
1865 if (hotkey == ESC_CHAR)
1866 return FALSE;
1867
1868 tmp_act = keybind_lookup_keymap_command (editor_map, hotkey);
1869
1870 /* return FALSE if try assign macro into restricted hotkeys */
1871 if (tmp_act == CK_MacroStartRecord
1872 || tmp_act == CK_MacroStopRecord || tmp_act == CK_MacroStartStopRecord)
1873 return FALSE;
1874
1875 edit_delete_macro (edit, hotkey);
1876
1877 macros_fname = mc_config_get_full_path (MC_MACRO_FILE);
1878 macros_config = mc_config_init (macros_fname, FALSE);
1879 g_free (macros_fname);
1880
1881 if (macros_config == NULL)
1882 return FALSE;
1883
1884 edit_push_undo_action (edit, KEY_PRESS + edit->start_display);
1885
1886 marcros_string = g_string_sized_new (250);
1887 macros = g_array_new (TRUE, FALSE, sizeof (macro_action_t));
1888
1889 skeyname = lookup_key_by_code (hotkey);
1890
1891 for (i = 0; i < macro_index; i++)
1892 {
1893 macro_action_t m_act;
1894 const char *action_name;
1895
1896 action_name = keybind_lookup_actionname (record_macro_buf[i].action);
1897
1898 if (action_name == NULL)
1899 break;
1900
1901 m_act.action = record_macro_buf[i].action;
1902 m_act.ch = record_macro_buf[i].ch;
1903 g_array_append_val (macros, m_act);
1904 have_macro = TRUE;
1905 g_string_append_printf (marcros_string, "%s:%i;", action_name,
1906 (int) record_macro_buf[i].ch);
1907 }
1908 if (have_macro)
1909 {
1910 macros_t macro;
1911 macro.hotkey = hotkey;
1912 macro.macro = macros;
1913 g_array_append_val (macros_list, macro);
1914 mc_config_set_string (macros_config, section_name, skeyname, marcros_string->str);
1915 }
1916 else
1917 mc_config_del_key (macros_config, section_name, skeyname);
1918
1919 g_free (skeyname);
1920 edit_macro_sort_by_hotkey ();
1921
1922 g_string_free (marcros_string, TRUE);
1923 mc_config_save_file (macros_config, NULL);
1924 mc_config_deinit (macros_config);
1925 return TRUE;
1926 }
1927
1928 /* --------------------------------------------------------------------------------------------- */
1929
1930 gboolean
1931 edit_repeat_macro_cmd (WEdit * edit)
1932 {
1933 int i, j;
1934 char *f;
1935 long count_repeat;
1936 char *error = NULL;
1937
1938 f = input_dialog (_("Repeat last commands"), _("Repeat times:"), MC_HISTORY_EDIT_REPEAT, NULL);
1939 if (f == NULL || *f == '\0')
1940 {
1941 g_free (f);
1942 return FALSE;
1943 }
1944
1945 count_repeat = strtol (f, &error, 0);
1946
1947 if (*error != '\0')
1948 {
1949 g_free (f);
1950 return FALSE;
1951 }
1952
1953 g_free (f);
1954
1955 edit_push_undo_action (edit, KEY_PRESS + edit->start_display);
1956 edit->force |= REDRAW_PAGE;
1957
1958 for (j = 0; j < count_repeat; j++)
1959 for (i = 0; i < macro_index; i++)
1960 edit_execute_cmd (edit, record_macro_buf[i].action, record_macro_buf[i].ch);
1961 edit_update_screen (edit);
1962 return TRUE;
1963 }
1964
1965 /* --------------------------------------------------------------------------------------------- */
1966 /** return FALSE on error */
1967
1968 gboolean
1969 edit_load_macro_cmd (WEdit * edit)
1970 {
1971 mc_config_t *macros_config = NULL;
1972 gchar **profile_keys, **keys;
1973 gchar **values, **curr_values;
1974 gsize len, values_len;
1975 const char *section_name = "editor";
1976 gchar *macros_fname;
1977 int hotkey;
1978
1979 (void) edit;
1980
1981 macros_fname = mc_config_get_full_path (MC_MACRO_FILE);
1982 macros_config = mc_config_init (macros_fname, TRUE);
1983 g_free (macros_fname);
1984
1985 if (macros_config == NULL)
1986 return FALSE;
1987
1988 profile_keys = keys = mc_config_get_keys (macros_config, section_name, &len);
1989 while (*profile_keys != NULL)
1990 {
1991 gboolean have_macro;
1992 GArray *macros;
1993 macros_t macro;
1994
1995 macros = g_array_new (TRUE, FALSE, sizeof (macro_action_t));
1996
1997 curr_values = values = mc_config_get_string_list (macros_config, section_name,
1998 *profile_keys, &values_len);
1999 hotkey = lookup_key (*profile_keys, NULL);
2000 have_macro = FALSE;
2001
2002 while (*curr_values != NULL && *curr_values[0] != '\0')
2003 {
2004 char **macro_pair = NULL;
2005
2006 macro_pair = g_strsplit (*curr_values, ":", 2);
2007
2008 if (macro_pair != NULL)
2009 {
2010 macro_action_t m_act;
2011 if (macro_pair[0] == NULL || macro_pair[0][0] == '\0')
2012 m_act.action = 0;
2013 else
2014 {
2015 m_act.action = keybind_lookup_action (macro_pair[0]);
2016 g_free (macro_pair[0]);
2017 macro_pair[0] = NULL;
2018 }
2019 if (macro_pair[1] == NULL || macro_pair[1][0] == '\0')
2020 m_act.ch = -1;
2021 else
2022 {
2023 m_act.ch = strtol (macro_pair[1], NULL, 0);
2024 g_free (macro_pair[1]);
2025 macro_pair[1] = NULL;
2026 }
2027 if (m_act.action != 0)
2028 {
2029 /* a shell command */
2030 if ((m_act.action / CK_PipeBlock (0)) == 1)
2031 {
2032 m_act.action = CK_PipeBlock (0) + (m_act.ch > 0 ? m_act.ch : 0);
2033 m_act.ch = -1;
2034 }
2035 g_array_append_val (macros, m_act);
2036 have_macro = TRUE;
2037 }
2038 g_strfreev (macro_pair);
2039 macro_pair = NULL;
2040 }
2041 curr_values++;
2042 }
2043 if (have_macro)
2044 {
2045 macro.hotkey = hotkey;
2046 macro.macro = macros;
2047 g_array_append_val (macros_list, macro);
2048 }
2049 profile_keys++;
2050 g_strfreev (values);
2051 }
2052 g_strfreev (keys);
2053 mc_config_deinit (macros_config);
2054 edit_macro_sort_by_hotkey ();
2055 return TRUE;
2056 }
2057
2058 /* }}} Macro stuff end here */
2059
2060 /* --------------------------------------------------------------------------------------------- */
2061 /** returns TRUE on success */
2062
2063 gboolean
2064 edit_save_confirm_cmd (WEdit * edit)
2065 {
2066 char *f = NULL;
2067
2068 if (edit->filename_vpath == NULL)
2069 return edit_save_as_cmd (edit);
2070
2071 if (!edit_check_newline (edit))
2072 return FALSE;
2073
2074 if (edit_confirm_save)
2075 {
2076 char *filename;
2077 gboolean ok;
2078
2079 filename = vfs_path_to_str (edit->filename_vpath);
2080 f = g_strdup_printf (_("Confirm save file: \"%s\""), filename);
2081 g_free (filename);
2082 ok = (edit_query_dialog2 (_("Save file"), f, _("&Save"), _("&Cancel")) == 0);
2083 g_free (f);
2084 if (!ok)
2085 return FALSE;
2086 }
2087 return edit_save_cmd (edit);
2088 }
2089
2090 /* --------------------------------------------------------------------------------------------- */
2091
2092 /* returns TRUE on success */
2093 gboolean
2094 edit_new_cmd (WEdit * edit)
2095 {
2096 if (edit->modified
2097 && edit_query_dialog2 (_("Warning"),
2098 _("Current text was modified without a file save.\n"
2099 "Continue discards these changes"),
2100 _("C&ontinue"), _("&Cancel")) == 1)
2101 {
2102 edit->force |= REDRAW_COMPLETELY;
2103 return TRUE;
2104 }
2105
2106 edit->force |= REDRAW_COMPLETELY;
2107
2108 return edit_renew (edit); /* if this gives an error, something has really screwed up */
2109 }
2110
2111 /* --------------------------------------------------------------------------------------------- */
2112
2113 gboolean
2114 edit_load_cmd (WEdit * edit, edit_current_file_t what)
2115 {
2116 gboolean ret = TRUE;
2117
2118 if (edit->modified
2119 && edit_query_dialog2 (_("Warning"),
2120 _("Current text was modified without a file save.\n"
2121 "Continue discards these changes"), _("C&ontinue"),
2122 _("&Cancel")) == 1)
2123 {
2124 edit->force |= REDRAW_COMPLETELY;
2125 return TRUE;
2126 }
2127
2128 switch (what)
2129 {
2130 case EDIT_FILE_COMMON:
2131 {
2132 char *filename, *exp;
2133
2134 filename = vfs_path_to_str (edit->filename_vpath);
2135 exp = input_expand_dialog (_("Load"), _("Enter file name:"),
2136 MC_HISTORY_EDIT_LOAD, filename);
2137 g_free (filename);
2138
2139 if (exp != NULL && *exp != '\0')
2140 {
2141 vfs_path_t *exp_vpath;
2142
2143 exp_vpath = vfs_path_from_str (exp);
2144 ret = edit_load_file_from_filename (edit, exp_vpath);
2145 vfs_path_free (exp_vpath);
2146 }
2147
2148 g_free (exp);
2149 }
2150 break;
2151
2152 case EDIT_FILE_SYNTAX:
2153 edit_load_syntax_file (edit);
2154 break;
2155
2156 case EDIT_FILE_MENU:
2157 edit_load_menu_file (edit);
2158 break;
2159
2160 default:
2161 break;
2162 }
2163
2164 edit->force |= REDRAW_COMPLETELY;
2165 return ret;
2166 }
2167
2168 /* --------------------------------------------------------------------------------------------- */
2169 /**
2170 if mark2 is -1 then marking is from mark1 to the cursor.
2171 Otherwise its between the markers. This handles this.
2172 Returns 1 if no text is marked.
2173 */
2174
2175 int
2176 eval_marks (WEdit * edit, off_t * start_mark, off_t * end_mark)
2177 {
2178 if (edit->mark1 != edit->mark2)
2179 {
2180 off_t start_bol, start_eol;
2181 off_t end_bol, end_eol;
2182 off_t diff1, diff2;
2183 long col1, col2;
2184 long end_mark_curs;
2185
2186 if (edit->end_mark_curs < 0)
2187 end_mark_curs = edit->curs1;
2188 else
2189 end_mark_curs = edit->end_mark_curs;
2190
2191 if (edit->mark2 >= 0)
2192 {
2193 *start_mark = min (edit->mark1, edit->mark2);
2194 *end_mark = max (edit->mark1, edit->mark2);
2195 }
2196 else
2197 {
2198 *start_mark = min (edit->mark1, end_mark_curs);
2199 *end_mark = max (edit->mark1, end_mark_curs);
2200 edit->column2 = edit->curs_col + edit->over_col;
2201 }
2202
2203 if (edit->column_highlight
2204 && (((edit->mark1 > end_mark_curs) && (edit->column1 < edit->column2))
2205 || ((edit->mark1 < end_mark_curs) && (edit->column1 > edit->column2))))
2206 {
2207 start_bol = edit_bol (edit, *start_mark);
2208 start_eol = edit_eol (edit, start_bol - 1) + 1;
2209 end_bol = edit_bol (edit, *end_mark);
2210 end_eol = edit_eol (edit, *end_mark);
2211 col1 = min (edit->column1, edit->column2);
2212 col2 = max (edit->column1, edit->column2);
2213
2214 diff1 = edit_move_forward3 (edit, start_bol, col2, 0) -
2215 edit_move_forward3 (edit, start_bol, col1, 0);
2216 diff2 = edit_move_forward3 (edit, end_bol, col2, 0) -
2217 edit_move_forward3 (edit, end_bol, col1, 0);
2218
2219 *start_mark -= diff1;
2220 *end_mark += diff2;
2221 *start_mark = max (*start_mark, start_eol);
2222 *end_mark = min (*end_mark, end_eol);
2223 }
2224 return 0;
2225 }
2226 else
2227 {
2228 *start_mark = *end_mark = 0;
2229 edit->column2 = edit->column1 = 0;
2230 return 1;
2231 }
2232 }
2233
2234 /* --------------------------------------------------------------------------------------------- */
2235
2236 void
2237 edit_insert_over (WEdit * edit)
2238 {
2239 int i;
2240
2241 for (i = 0; i < edit->over_col; i++)
2242 {
2243 edit_insert (edit, ' ');
2244 }
2245 edit->over_col = 0;
2246 }
2247
2248 /* --------------------------------------------------------------------------------------------- */
2249
2250 off_t
2251 edit_insert_column_of_text_from_file (WEdit * edit, int file,
2252 off_t * start_pos, off_t * end_pos, long *col1, long *col2)
2253 {
2254 off_t cursor;
2255 int col;
2256 off_t blocklen = -1, width = 0;
2257 unsigned char *data;
2258
2259 cursor = edit->curs1;
2260 col = edit_get_col (edit);
2261 data = g_malloc0 (TEMP_BUF_LEN);
2262
2263 while ((blocklen = mc_read (file, (char *) data, TEMP_BUF_LEN)) > 0)
2264 {
2265 off_t i;
2266 for (width = 0; width < blocklen; width++)
2267 {
2268 if (data[width] == '\n')
2269 break;
2270 }
2271 for (i = 0; i < blocklen; i++)
2272 {
2273 if (data[i] == '\n')
2274 { /* fill in and move to next line */
2275 long l;
2276 off_t p;
2277 if (edit_get_byte (edit, edit->curs1) != '\n')
2278 {
2279 l = width - (edit_get_col (edit) - col);
2280 while (l > 0)
2281 {
2282 edit_insert (edit, ' ');
2283 l -= space_width;
2284 }
2285 }
2286 for (p = edit->curs1;; p++)
2287 {
2288 if (p == edit->last_byte)
2289 {
2290 edit_cursor_move (edit, edit->last_byte - edit->curs1);
2291 edit_insert_ahead (edit, '\n');
2292 p++;
2293 break;
2294 }
2295 if (edit_get_byte (edit, p) == '\n')
2296 {
2297 p++;
2298 break;
2299 }
2300 }
2301 edit_cursor_move (edit, edit_move_forward3 (edit, p, col, 0) - edit->curs1);
2302 l = col - edit_get_col (edit);
2303 while (l >= space_width)
2304 {
2305 edit_insert (edit, ' ');
2306 l -= space_width;
2307 }
2308 continue;
2309 }
2310 edit_insert (edit, data[i]);
2311 }
2312 }
2313 *col1 = col;
2314 *col2 = col + width;
2315 *start_pos = cursor;
2316 *end_pos = edit->curs1;
2317 edit_cursor_move (edit, cursor - edit->curs1);
2318 g_free (data);
2319
2320 return blocklen;
2321 }
2322
2323 /* --------------------------------------------------------------------------------------------- */
2324
2325 void
2326 edit_block_copy_cmd (WEdit * edit)
2327 {
2328 off_t start_mark, end_mark, current = edit->curs1;
2329 long col_delta = 0;
2330 off_t mark1, mark2;
2331 int c1, c2;
2332 int size;
2333 unsigned char *copy_buf;
2334
2335 edit_update_curs_col (edit);
2336 if (eval_marks (edit, &start_mark, &end_mark))
2337 return;
2338
2339 copy_buf = edit_get_block (edit, start_mark, end_mark, &size);
2340
2341 /* all that gets pushed are deletes hence little space is used on the stack */
2342
2343 edit_push_markers (edit);
2344
2345 if (edit->column_highlight)
2346 {
2347 col_delta = abs (edit->column2 - edit->column1);
2348 edit_insert_column_of_text (edit, copy_buf, size, col_delta, &mark1, &mark2, &c1, &c2);
2349 }
2350 else
2351 {
2352 while (size--)
2353 edit_insert_ahead (edit, copy_buf[size]);
2354 }
2355
2356 g_free (copy_buf);
2357 edit_scroll_screen_over_cursor (edit);
2358
2359 if (edit->column_highlight)
2360 edit_set_markers (edit, edit->curs1, mark2, c1, c2);
2361 else if (start_mark < current && end_mark > current)
2362 edit_set_markers (edit, start_mark, end_mark + end_mark - start_mark, 0, 0);
2363
2364 edit->force |= REDRAW_PAGE;
2365 }
2366
2367
2368 /* --------------------------------------------------------------------------------------------- */
2369
2370 void
2371 edit_block_move_cmd (WEdit * edit)
2372 {
2373 off_t current;
2374 unsigned char *copy_buf = NULL;
2375 off_t start_mark, end_mark;
2376 long line;
2377
2378 if (eval_marks (edit, &start_mark, &end_mark))
2379 return;
2380
2381 line = edit->curs_line;
2382 if (edit->mark2 < 0)
2383 edit_mark_cmd (edit, FALSE);
2384 edit_push_markers (edit);
2385
2386 if (edit->column_highlight)
2387 {
2388 off_t mark1, mark2;
2389 int size;
2390 int b_width = 0;
2391 int c1, c2;
2392 int x, x2;
2393
2394 c1 = min (edit->column1, edit->column2);
2395 c2 = max (edit->column1, edit->column2);
2396 b_width = (c2 - c1);
2397
2398 edit_update_curs_col (edit);
2399
2400 x = edit->curs_col;
2401 x2 = x + edit->over_col;
2402
2403 /* do nothing when cursor inside first line of selected area */
2404 if ((edit_eol (edit, edit->curs1) == edit_eol (edit, start_mark)) && (x2 > c1 && x2 <= c2))
2405 return;
2406
2407 if (edit->curs1 > start_mark && edit->curs1 < edit_eol (edit, end_mark))
2408 {
2409 if (x > c2)
2410 x -= b_width;
2411 else if (x > c1 && x <= c2)
2412 x = c1;
2413 }
2414 /* save current selection into buffer */
2415 copy_buf = edit_get_block (edit, start_mark, end_mark, &size);
2416
2417 /* remove current selection */
2418 edit_block_delete_cmd (edit);
2419
2420 edit->over_col = max (0, edit->over_col - b_width);
2421 /* calculate the cursor pos after delete block */
2422 current = edit_move_forward3 (edit, edit_bol (edit, edit->curs1), x, 0);
2423 edit_cursor_move (edit, current - edit->curs1);
2424 edit_scroll_screen_over_cursor (edit);
2425
2426 /* add TWS if need before block insertion */
2427 if (option_cursor_beyond_eol && edit->over_col > 0)
2428 edit_insert_over (edit);
2429
2430 edit_insert_column_of_text (edit, copy_buf, size, b_width, &mark1, &mark2, &c1, &c2);
2431 edit_set_markers (edit, mark1, mark2, c1, c2);
2432 }
2433 else
2434 {
2435 off_t count;
2436
2437 current = edit->curs1;
2438 copy_buf = g_malloc0 (end_mark - start_mark);
2439 edit_cursor_move (edit, start_mark - edit->curs1);
2440 edit_scroll_screen_over_cursor (edit);
2441 count = start_mark;
2442 while (count < end_mark)
2443 {
2444 copy_buf[end_mark - count - 1] = edit_delete (edit, 1);
2445 count++;
2446 }
2447 edit_scroll_screen_over_cursor (edit);
2448 edit_cursor_move (edit,
2449 current - edit->curs1 -
2450 (((current - edit->curs1) > 0) ? end_mark - start_mark : 0));
2451 edit_scroll_screen_over_cursor (edit);
2452 while (count-- > start_mark)
2453 edit_insert_ahead (edit, copy_buf[end_mark - count - 1]);
2454 edit_set_markers (edit, edit->curs1, edit->curs1 + end_mark - start_mark, 0, 0);
2455 }
2456
2457 edit_scroll_screen_over_cursor (edit);
2458 g_free (copy_buf);
2459 edit->force |= REDRAW_PAGE;
2460 }
2461
2462 /* --------------------------------------------------------------------------------------------- */
2463 /** returns 1 if canceelled by user */
2464
2465 int
2466 edit_block_delete_cmd (WEdit * edit)
2467 {
2468 off_t start_mark, end_mark;
2469 if (eval_marks (edit, &start_mark, &end_mark))
2470 {
2471 edit_delete_line (edit);
2472 return 0;
2473 }
2474 return edit_block_delete (edit);
2475 }
2476
2477 /* --------------------------------------------------------------------------------------------- */
2478 /** call with edit = 0 before shutdown to close memory leaks */
2479
2480 void
2481 edit_replace_cmd (WEdit * edit, int again)
2482 {
2483 /* 1 = search string, 2 = replace with */
2484 static char *saved1 = NULL; /* saved default[123] */
2485 static char *saved2 = NULL;
2486 char *input1 = NULL; /* user input from the dialog */
2487 char *input2 = NULL;
2488 GString *input2_str = NULL;
2489 char *disp1 = NULL;
2490 char *disp2 = NULL;
2491 long times_replaced = 0;
2492 gboolean once_found = FALSE;
2493
2494 if (!edit)
2495 {
2496 g_free (saved1), saved1 = NULL;
2497 g_free (saved2), saved2 = NULL;
2498 return;
2499 }
2500
2501 edit->force |= REDRAW_COMPLETELY;
2502
2503 if (again && !saved1 && !saved2)
2504 again = 0;
2505
2506 if (again)
2507 {
2508 input1 = g_strdup (saved1 ? saved1 : "");
2509 input2 = g_strdup (saved2 ? saved2 : "");
2510 }
2511 else
2512 {
2513 char *tmp_inp1, *tmp_inp2;
2514
2515 disp1 = edit_replace_cmd__conv_to_display (saved1 ? saved1 : (char *) "");
2516 disp2 = edit_replace_cmd__conv_to_display (saved2 ? saved2 : (char *) "");
2517
2518 edit_push_undo_action (edit, KEY_PRESS + edit->start_display);
2519
2520 editcmd_dialog_replace_show (edit, disp1, disp2, &input1, &input2);
2521
2522 g_free (disp1);
2523 g_free (disp2);
2524
2525 if (input1 == NULL || *input1 == '\0')
2526 {
2527 edit->force = REDRAW_COMPLETELY;
2528 goto cleanup;
2529 }
2530
2531 tmp_inp1 = input1;
2532 tmp_inp2 = input2;
2533 input1 = edit_replace_cmd__conv_to_input (input1);
2534 input2 = edit_replace_cmd__conv_to_input (input2);
2535 g_free (tmp_inp1);
2536 g_free (tmp_inp2);
2537
2538 g_free (saved1), saved1 = g_strdup (input1);
2539 g_free (saved2), saved2 = g_strdup (input2);
2540
2541 mc_search_free (edit->search);
2542 edit->search = NULL;
2543 }
2544
2545 input2_str = g_string_new (input2);
2546
2547 if (!edit->search)
2548 {
2549 edit->search = mc_search_new (input1, -1);
2550 if (edit->search == NULL)
2551 {
2552 edit->search_start = edit->curs1;
2553 goto cleanup;
2554 }
2555 edit->search->search_type = edit_search_options.type;
2556 edit->search->is_all_charsets = edit_search_options.all_codepages;
2557 edit->search->is_case_sensitive = edit_search_options.case_sens;
2558 edit->search->whole_words = edit_search_options.whole_words;
2559 edit->search->search_fn = edit_search_cmd_callback;
2560 edit->search_line_type = edit_get_search_line_type (edit->search);
2561 edit_search_fix_search_start_if_selection (edit);
2562 }
2563
2564 if (edit->found_len && edit->search_start == edit->found_start + 1
2565 && edit_search_options.backwards)
2566 edit->search_start--;
2567
2568 if (edit->found_len && edit->search_start == edit->found_start - 1
2569 && !edit_search_options.backwards)
2570 edit->search_start++;
2571
2572 do
2573 {
2574 gsize len = 0;
2575
2576 if (!editcmd_find (edit, &len))
2577 {
2578 if (!(edit->search->error == MC_SEARCH_E_OK ||
2579 (once_found && edit->search->error == MC_SEARCH_E_NOTFOUND)))
2580 {
2581 edit_error_dialog (_("Search"), edit->search->error_str);
2582 }
2583 break;
2584 }
2585 once_found = TRUE;
2586
2587 edit->search_start = edit->search->normal_offset;
2588 /*returns negative on not found or error in pattern */
2589
2590 if ((edit->search_start >= 0) && (edit->search_start < edit->last_byte))
2591 {
2592 gsize i;
2593 GString *repl_str;
2594
2595 edit->found_start = edit->search_start;
2596 i = edit->found_len = len;
2597
2598 edit_cursor_move (edit, edit->search_start - edit->curs1);
2599 edit_scroll_screen_over_cursor (edit);
2600
2601 if (edit->replace_mode == 0)
2602 {
2603 long l;
2604 int prompt;
2605
2606 l = (long) (edit->curs_row - edit->widget.lines / 3);
2607 if (l > 0)
2608 edit_scroll_downward (edit, l);
2609 if (l < 0)
2610 edit_scroll_upward (edit, -l);
2611
2612 edit_scroll_screen_over_cursor (edit);
2613 edit->force |= REDRAW_PAGE;
2614 edit_render_keypress (edit);
2615
2616 /*so that undo stops at each query */
2617 edit_push_key_press (edit);
2618 /* and prompt 2/3 down */
2619 disp1 = edit_replace_cmd__conv_to_display (saved1);
2620 disp2 = edit_replace_cmd__conv_to_display (saved2);
2621 prompt = editcmd_dialog_replace_prompt_show (edit, disp1, disp2, -1, -1);
2622 g_free (disp1);
2623 g_free (disp2);
2624
2625 if (prompt == B_REPLACE_ALL)
2626 edit->replace_mode = 1;
2627 else if (prompt == B_SKIP_REPLACE)
2628 {
2629 if (edit_search_options.backwards)
2630 edit->search_start--;
2631 else
2632 edit->search_start++;
2633 continue; /* loop */
2634 }
2635 else if (prompt == B_CANCEL)
2636 {
2637 edit->replace_mode = -1;
2638 break; /* loop */
2639 }
2640 }
2641
2642 repl_str = mc_search_prepare_replace_str (edit->search, input2_str);
2643
2644 if (edit->search->error != MC_SEARCH_E_OK)
2645 {
2646 edit_error_dialog (_("Replace"), edit->search->error_str);
2647 g_string_free (repl_str, TRUE);
2648 break;
2649 }
2650
2651 /* delete then insert new */
2652 for (i = 0; i < len; i++)
2653 edit_delete (edit, 1);
2654
2655 for (i = 0; i < repl_str->len; i++)
2656 edit_insert (edit, repl_str->str[i]);
2657
2658 edit->found_len = repl_str->len;
2659 g_string_free (repl_str, TRUE);
2660 times_replaced++;
2661
2662 /* so that we don't find the same string again */
2663 if (edit_search_options.backwards)
2664 {
2665 edit->search_start--;
2666 }
2667 else
2668 {
2669 edit->search_start += edit->found_len + (len == 0 ? 1 : 0);
2670
2671 if (edit->search_start >= edit->last_byte)
2672 break;
2673 }
2674
2675 edit_scroll_screen_over_cursor (edit);
2676 }
2677 else
2678 {
2679 /* try and find from right here for next search */
2680 edit->search_start = edit->curs1;
2681 edit_update_curs_col (edit);
2682
2683 edit->force |= REDRAW_PAGE;
2684 edit_render_keypress (edit);
2685
2686 if (times_replaced == 0)
2687 query_dialog (_("Replace"), _("Search string not found"), D_NORMAL, 1, _("&OK"));
2688 break;
2689 }
2690 }
2691 while (edit->replace_mode >= 0);
2692
2693 edit_scroll_screen_over_cursor (edit);
2694 edit->force |= REDRAW_COMPLETELY;
2695 edit_render_keypress (edit);
2696
2697 if ((edit->replace_mode == 1) && (times_replaced != 0))
2698 message (D_NORMAL, _("Replace"), _("%ld replacements made"), times_replaced);
2699
2700 cleanup:
2701 g_free (input1);
2702 g_free (input2);
2703 if (input2_str != NULL)
2704 g_string_free (input2_str, TRUE);
2705 }
2706
2707 /* --------------------------------------------------------------------------------------------- */
2708
2709 mc_search_cbret_t
2710 edit_search_cmd_callback (const void *user_data, gsize char_offset, int *current_char)
2711 {
2712 *current_char = edit_get_byte ((WEdit *) user_data, (off_t) char_offset);
2713 return MC_SEARCH_CB_OK;
2714 }
2715
2716 /* --------------------------------------------------------------------------------------------- */
2717
2718 void
2719 edit_search_cmd (WEdit * edit, gboolean again)
2720 {
2721
2722 if (edit == NULL)
2723 return;
2724
2725 if (!again)
2726 edit_search (edit);
2727 else if (edit->last_search_string != NULL)
2728 edit_do_search (edit);
2729 else
2730 {
2731 /* find last search string in history */
2732 GList *history;
2733
2734 history = history_get (MC_HISTORY_SHARED_SEARCH);
2735 if (history != NULL && history->data != NULL)
2736 {
2737 edit->last_search_string = (char *) history->data;
2738 history->data = NULL;
2739 history = g_list_first (history);
2740 g_list_foreach (history, (GFunc) g_free, NULL);
2741 g_list_free (history);
2742
2743 edit->search = mc_search_new (edit->last_search_string, -1);
2744 if (edit->search == NULL)
2745 {
2746 /* if not... then ask for an expression */
2747 g_free (edit->last_search_string);
2748 edit->last_search_string = NULL;
2749 edit_search (edit);
2750 }
2751 else
2752 {
2753 edit->search->search_type = edit_search_options.type;
2754 edit->search->is_all_charsets = edit_search_options.all_codepages;
2755 edit->search->is_case_sensitive = edit_search_options.case_sens;
2756 edit->search->whole_words = edit_search_options.whole_words;
2757 edit->search->search_fn = edit_search_cmd_callback;
2758 edit->search_line_type = edit_get_search_line_type (edit->search);
2759 edit_do_search (edit);
2760 }
2761 }
2762 else
2763 {
2764 /* if not... then ask for an expression */
2765 g_free (edit->last_search_string);
2766 edit->last_search_string = NULL;
2767 edit_search (edit);
2768 }
2769 }
2770 }
2771
2772
2773 /* --------------------------------------------------------------------------------------------- */
2774 /**
2775 * Check if it's OK to close the editor. If there are unsaved changes,
2776 * ask user. Return 1 if it's OK to exit, 0 to continue editing.
2777 */
2778
2779 gboolean
2780 edit_ok_to_exit (WEdit * edit)
2781 {
2782 int act;
2783
2784 if (!edit->modified)
2785 return TRUE;
2786
2787 if (!mc_global.midnight_shutdown)
2788 {
2789 if (!edit_check_newline (edit))
2790 return FALSE;
2791
2792 query_set_sel (2);
2793 act = edit_query_dialog3 (_("Quit"), _("File was modified. Save with exit?"),
2794 _("&Yes"), _("&No"), _("&Cancel quit"));
2795 }
2796 else
2797 {
2798 act =
2799 edit_query_dialog2 (_("Quit"),
2800 _("Midnight Commander is being shut down.\nSave modified file?"),
2801 _("&Yes"), _("&No"));
2802
2803 /* Esc is No */
2804 if (act == -1)
2805 act = 1;
2806 }
2807
2808 switch (act)
2809 {
2810 case 0: /* Yes */
2811 edit_push_markers (edit);
2812 edit_set_markers (edit, 0, 0, 0, 0);
2813 if (!edit_save_cmd (edit) || mc_global.midnight_shutdown)
2814 return mc_global.midnight_shutdown;
2815 break;
2816 case 1: /* No */
2817 break;
2818 case 2: /* Cancel quit */
2819 case -1: /* Esc */
2820 return FALSE;
2821 }
2822
2823 return TRUE;
2824 }
2825
2826 /* --------------------------------------------------------------------------------------------- */
2827 /** save block, returns TRUE on success */
2828
2829 gboolean
2830 edit_save_block (WEdit * edit, const char *filename, off_t start, off_t finish)
2831 {
2832 int len, file;
2833 vfs_path_t *vpath;
2834
2835 vpath = vfs_path_from_str (filename);
2836 file = mc_open (vpath, O_CREAT | O_WRONLY | O_TRUNC,
2837 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH | O_BINARY);
2838 vfs_path_free (vpath);
2839 if (file == -1)
2840 return FALSE;
2841
2842 if (edit->column_highlight)
2843 {
2844 int r;
2845
2846 r = mc_write (file, VERTICAL_MAGIC, sizeof (VERTICAL_MAGIC));
2847 if (r > 0)
2848 {
2849 unsigned char *block, *p;
2850
2851 p = block = edit_get_block (edit, start, finish, &len);
2852 while (len)
2853 {
2854 r = mc_write (file, p, len);
2855 if (r < 0)
2856 break;
2857 p += r;
2858 len -= r;
2859 }
2860 g_free (block);
2861 }
2862 }
2863 else
2864 {
2865 unsigned char *buf;
2866 off_t i = start;
2867 off_t end;
2868
2869 len = finish - start;
2870 buf = g_malloc0 (TEMP_BUF_LEN);
2871 while (start != finish)
2872 {
2873 end = min (finish, start + TEMP_BUF_LEN);
2874 for (; i < end; i++)
2875 buf[i - start] = edit_get_byte (edit, i);
2876 len -= mc_write (file, (char *) buf, end - start);
2877 start = end;
2878 }
2879 g_free (buf);
2880 }
2881 mc_close (file);
2882
2883 return (len == 0);
2884 }
2885
2886 /* --------------------------------------------------------------------------------------------- */
2887
2888 void
2889 edit_paste_from_history (WEdit * edit)
2890 {
2891 (void) edit;
2892 edit_error_dialog (_("Error"), _("This function is not implemented"));
2893 }
2894
2895 /* --------------------------------------------------------------------------------------------- */
2896
2897 gboolean
2898 edit_copy_to_X_buf_cmd (WEdit * edit)
2899 {
2900 off_t start_mark, end_mark;
2901
2902 if (eval_marks (edit, &start_mark, &end_mark))
2903 return TRUE;
2904 if (!edit_save_block_to_clip_file (edit, start_mark, end_mark))
2905 {
2906 edit_error_dialog (_("Copy to clipboard"), get_sys_error (_("Unable to save to file")));
2907 return FALSE;
2908 }
2909 /* try use external clipboard utility */
2910 mc_event_raise (MCEVENT_GROUP_CORE, "clipboard_file_to_ext_clip", NULL);
2911
2912 return TRUE;
2913 }
2914
2915 /* --------------------------------------------------------------------------------------------- */
2916
2917 gboolean
2918 edit_cut_to_X_buf_cmd (WEdit * edit)
2919 {
2920 off_t start_mark, end_mark;
2921
2922 if (eval_marks (edit, &start_mark, &end_mark))
2923 return TRUE;
2924 if (!edit_save_block_to_clip_file (edit, start_mark, end_mark))
2925 {
2926 edit_error_dialog (_("Cut to clipboard"), _("Unable to save to file"));
2927 return FALSE;
2928 }
2929 /* try use external clipboard utility */
2930 mc_event_raise (MCEVENT_GROUP_CORE, "clipboard_file_to_ext_clip", NULL);
2931
2932 edit_block_delete_cmd (edit);
2933 edit_mark_cmd (edit, TRUE);
2934
2935 return TRUE;
2936 }
2937
2938 /* --------------------------------------------------------------------------------------------- */
2939
2940 gboolean
2941 edit_paste_from_X_buf_cmd (WEdit * edit)
2942 {
2943 vfs_path_t *tmp;
2944 gboolean ret;
2945
2946 /* try use external clipboard utility */
2947 mc_event_raise (MCEVENT_GROUP_CORE, "clipboard_file_from_ext_clip", NULL);
2948 tmp = mc_config_get_full_vpath (EDIT_CLIP_FILE);
2949 ret = (edit_insert_file (edit, tmp) >= 0);
2950 vfs_path_free (tmp);
2951
2952 return ret;
2953 }
2954
2955 /* --------------------------------------------------------------------------------------------- */
2956 /**
2957 * Ask user for the line and go to that line.
2958 * Negative numbers mean line from the end (i.e. -1 is the last line).
2959 */
2960
2961 void
2962 edit_goto_cmd (WEdit * edit)
2963 {
2964 char *f;
2965 static long line = 0; /* line as typed, saved as default */
2966 long l;
2967 char *error;
2968 char s[32];
2969
2970 g_snprintf (s, sizeof (s), "%ld", line);
2971 f = input_dialog (_("Goto line"), _("Enter line:"), MC_HISTORY_EDIT_GOTO_LINE, line ? s : "");
2972 if (!f)
2973 return;
2974
2975 if (!*f)
2976 {
2977 g_free (f);
2978 return;
2979 }
2980
2981 l = strtol (f, &error, 0);
2982 if (*error)
2983 {
2984 g_free (f);
2985 return;
2986 }
2987
2988 line = l;
2989 if (l < 0)
2990 l = edit->total_lines + l + 2;
2991 edit_move_display (edit, l - edit->widget.lines / 2 - 1);
2992 edit_move_to_line (edit, l - 1);
2993 edit->force |= REDRAW_COMPLETELY;
2994 g_free (f);
2995 }
2996
2997
2998 /* --------------------------------------------------------------------------------------------- */
2999 /** Return TRUE on success */
3000
3001 gboolean
3002 edit_save_block_cmd (WEdit * edit)
3003 {
3004 off_t start_mark, end_mark;
3005 char *exp, *tmp;
3006 gboolean ret = FALSE;
3007
3008 if (eval_marks (edit, &start_mark, &end_mark))
3009 return TRUE;
3010
3011 tmp = mc_config_get_full_path (EDIT_CLIP_FILE);
3012 exp =
3013 input_expand_dialog (_("Save block"), _("Enter file name:"),
3014 MC_HISTORY_EDIT_SAVE_BLOCK, tmp);
3015 g_free (tmp);
3016 edit_push_undo_action (edit, KEY_PRESS + edit->start_display);
3017
3018 if (exp != NULL && *exp != '\0')
3019 {
3020 if (edit_save_block (edit, exp, start_mark, end_mark))
3021 ret = TRUE;
3022 else
3023 edit_error_dialog (_("Save block"), get_sys_error (_("Cannot save file")));
3024
3025 edit->force |= REDRAW_COMPLETELY;
3026 }
3027
3028 g_free (exp);
3029
3030 return ret;
3031 }
3032
3033
3034 /* --------------------------------------------------------------------------------------------- */
3035
3036 /** returns TRUE on success */
3037 gboolean
3038 edit_insert_file_cmd (WEdit * edit)
3039 {
3040 char *tmp;
3041 char *exp;
3042 gboolean ret = FALSE;
3043
3044 tmp = mc_config_get_full_path (EDIT_CLIP_FILE);
3045 exp = input_expand_dialog (_("Insert file"), _("Enter file name:"),
3046 MC_HISTORY_EDIT_INSERT_FILE, tmp);
3047 g_free (tmp);
3048
3049 edit_push_undo_action (edit, KEY_PRESS + edit->start_display);
3050
3051 if (exp != NULL && *exp != '\0')
3052 {
3053 vfs_path_t *exp_vpath;
3054
3055 exp_vpath = vfs_path_from_str (exp);
3056 ret = (edit_insert_file (edit, exp_vpath) >= 0);
3057 vfs_path_free (exp_vpath);
3058
3059 if (!ret)
3060 edit_error_dialog (_("Insert file"), get_sys_error (_("Cannot insert file")));
3061 }
3062
3063 g_free (exp);
3064
3065 edit->force |= REDRAW_COMPLETELY;
3066 return ret;
3067 }
3068
3069 /* --------------------------------------------------------------------------------------------- */
3070 /** sorts a block, returns -1 on system fail, 1 on cancel and 0 on success */
3071
3072 int
3073 edit_sort_cmd (WEdit * edit)
3074 {
3075 static char *old = 0;
3076 char *exp, *tmp, *tmp_edit_block_name, *tmp_edit_temp_name;
3077 off_t start_mark, end_mark;
3078 int e;
3079
3080 if (eval_marks (edit, &start_mark, &end_mark))
3081 {
3082 edit_error_dialog (_("Sort block"), _("You must first highlight a block of text"));
3083 return 0;
3084 }
3085
3086 tmp = mc_config_get_full_path (EDIT_BLOCK_FILE);
3087 edit_save_block (edit, tmp, start_mark, end_mark);
3088 g_free (tmp);
3089
3090 exp = input_dialog (_("Run sort"),
3091 _("Enter sort options (see manpage) separated by whitespace:"),
3092 MC_HISTORY_EDIT_SORT, (old != NULL) ? old : "");
3093
3094 if (!exp)
3095 return 1;
3096 g_free (old);
3097 old = exp;
3098 tmp_edit_block_name = mc_config_get_full_path (EDIT_BLOCK_FILE);
3099 tmp_edit_temp_name = mc_config_get_full_path (EDIT_TEMP_FILE);
3100 tmp =
3101 g_strconcat (" sort ", exp, " ", tmp_edit_block_name,
3102 " > ", tmp_edit_temp_name, (char *) NULL);
3103 g_free (tmp_edit_temp_name);
3104 g_free (tmp_edit_block_name);
3105
3106 e = system (tmp);
3107 g_free (tmp);
3108 if (e)
3109 {
3110 if (e == -1 || e == 127)
3111 {
3112 edit_error_dialog (_("Sort"), get_sys_error (_("Cannot execute sort command")));
3113 }
3114 else
3115 {
3116 char q[8];
3117 sprintf (q, "%d ", e);
3118 tmp = g_strdup_printf (_("Sort returned non-zero: %s"), q);
3119 edit_error_dialog (_("Sort"), tmp);
3120 g_free (tmp);
3121 }
3122 return -1;
3123 }
3124
3125 edit->force |= REDRAW_COMPLETELY;
3126
3127 if (edit_block_delete_cmd (edit))
3128 return 1;
3129
3130 {
3131 vfs_path_t *tmp_vpath;
3132
3133 tmp_vpath = mc_config_get_full_vpath (EDIT_TEMP_FILE);
3134 edit_insert_file (edit, tmp_vpath);
3135 vfs_path_free (tmp_vpath);
3136 }
3137 return 0;
3138 }
3139
3140 /* --------------------------------------------------------------------------------------------- */
3141 /**
3142 * Ask user for a command, execute it and paste its output back to the
3143 * editor.
3144 */
3145
3146 int
3147 edit_ext_cmd (WEdit * edit)
3148 {
3149 char *exp, *tmp, *tmp_edit_temp_file;
3150 int e;
3151
3152 exp =
3153 input_dialog (_("Paste output of external command"),
3154 _("Enter shell command(s):"), MC_HISTORY_EDIT_PASTE_EXTCMD, NULL);
3155
3156 if (!exp)
3157 return 1;
3158
3159 tmp_edit_temp_file = mc_config_get_full_path (EDIT_TEMP_FILE);
3160 tmp = g_strconcat (exp, " > ", tmp_edit_temp_file, (char *) NULL);
3161 g_free (tmp_edit_temp_file);
3162 e = system (tmp);
3163 g_free (tmp);
3164 g_free (exp);
3165
3166 if (e)
3167 {
3168 edit_error_dialog (_("External command"), get_sys_error (_("Cannot execute command")));
3169 return -1;
3170 }
3171
3172 edit->force |= REDRAW_COMPLETELY;
3173
3174 {
3175 vfs_path_t *tmp_vpath;
3176
3177 tmp_vpath = mc_config_get_full_vpath (EDIT_TEMP_FILE);
3178 edit_insert_file (edit, tmp_vpath);
3179 vfs_path_free (tmp_vpath);
3180 }
3181 return 0;
3182 }
3183
3184 /* --------------------------------------------------------------------------------------------- */
3185 /** if block is 1, a block must be highlighted and the shell command
3186 processes it. If block is 0 the shell command is a straight system
3187 command, that just produces some output which is to be inserted */
3188
3189 void
3190 edit_block_process_cmd (WEdit * edit, int macro_number)
3191 {
3192 char *fname;
3193 char *macros_fname = NULL;
3194
3195 fname = g_strdup_printf ("%s.%i.sh", MC_EXTMACRO_FILE, macro_number);
3196 macros_fname = g_build_filename (mc_config_get_data_path (), fname, (char *) NULL);
3197 user_menu (edit, macros_fname, 0);
3198 g_free (fname);
3199 g_free (macros_fname);
3200 edit->force |= REDRAW_COMPLETELY;
3201 }
3202
3203 /* --------------------------------------------------------------------------------------------- */
3204
3205 void
3206 edit_mail_dialog (WEdit * edit)
3207 {
3208 char *tmail_to;
3209 char *tmail_subject;
3210 char *tmail_cc;
3211
3212 static char *mail_cc_last = 0;
3213 static char *mail_subject_last = 0;
3214 static char *mail_to_last = 0;
3215
3216 QuickWidget quick_widgets[] = {
3217 /* 0 */ QUICK_BUTTON (6, 10, 9, MAIL_DLG_HEIGHT, N_("&Cancel"), B_CANCEL, NULL),
3218 /* 1 */ QUICK_BUTTON (2, 10, 9, MAIL_DLG_HEIGHT, N_("&OK"), B_ENTER, NULL),
3219 /* 2 */ QUICK_INPUT (3, 50, 8, MAIL_DLG_HEIGHT, "", 44, 0, "mail-dlg-input", &tmail_cc),
3220 /* 3 */ QUICK_LABEL (3, 50, 7, MAIL_DLG_HEIGHT, N_("Copies to")),
3221 /* 4 */ QUICK_INPUT (3, 50, 6, MAIL_DLG_HEIGHT, "", 44, 0, "mail-dlg-input-2",
3222 &tmail_subject),
3223 /* 5 */ QUICK_LABEL (3, 50, 5, MAIL_DLG_HEIGHT, N_("Subject")),
3224 /* 6 */ QUICK_INPUT (3, 50, 4, MAIL_DLG_HEIGHT, "", 44, 0, "mail-dlg-input-3", &tmail_to),
3225 /* 7 */ QUICK_LABEL (3, 50, 3, MAIL_DLG_HEIGHT, N_("To")),
3226 /* 8 */ QUICK_LABEL (3, 50, 2, MAIL_DLG_HEIGHT, N_("mail -s <subject> -c <cc> <to>")),
3227 QUICK_END
3228 };
3229
3230 QuickDialog Quick_input = {
3231 50, MAIL_DLG_HEIGHT, -1, -1, N_("Mail"),
3232 "[Input Line Keys]", quick_widgets, NULL, FALSE
3233 };
3234
3235 quick_widgets[2].u.input.text = mail_cc_last ? mail_cc_last : "";
3236 quick_widgets[4].u.input.text = mail_subject_last ? mail_subject_last : "";
3237 quick_widgets[6].u.input.text = mail_to_last ? mail_to_last : "";
3238
3239 if (quick_dialog (&Quick_input) != B_CANCEL)
3240 {
3241 g_free (mail_cc_last);
3242 g_free (mail_subject_last);
3243 g_free (mail_to_last);
3244 mail_cc_last = tmail_cc;
3245 mail_subject_last = tmail_subject;
3246 mail_to_last = tmail_to;
3247 pipe_mail (edit, mail_to_last, mail_subject_last, mail_cc_last);
3248 }
3249 }
3250
3251
3252 /*******************/
3253 /* Word Completion */
3254 /*******************/
3255
3256 /* --------------------------------------------------------------------------------------------- */
3257 /**
3258 * Complete current word using regular expression search
3259 * backwards beginning at the current cursor position.
3260 */
3261
3262 void
3263 edit_complete_word_cmd (WEdit * edit)
3264 {
3265 gsize i, max_len, word_len = 0, num_compl = 0;
3266 off_t word_start = 0;
3267 unsigned char *bufpos;
3268 char *match_expr;
3269 struct selection compl[MAX_WORD_COMPLETIONS]; /* completions */
3270
3271 /* search start of word to be completed */
3272 if (!edit_find_word_start (edit, &word_start, &word_len))
3273 return;
3274
3275 /* prepare match expression */
3276 bufpos = &edit->buffers1[word_start >> S_EDIT_BUF_SIZE][word_start & M_EDIT_BUF_SIZE];
3277
3278 /* match_expr = g_strdup_printf ("\\b%.*s[a-zA-Z_0-9]+", word_len, bufpos); */
3279 match_expr =
3280 g_strdup_printf
3281 ("(^|\\s+|\\b)%.*s[^\\s\\.=\\+\\[\\]\\(\\)\\,\\;\\:\\\"\\'\\-\\?\\/\\|\\\\\\{\\}\\*\\&\\^\\%%\\$#@\\!]+",
3282 (int) word_len, bufpos);
3283
3284 /* collect the possible completions */
3285 /* start search from begin to end of file */
3286 max_len =
3287 edit_collect_completions (edit, word_start, word_len, match_expr,
3288 (struct selection *) &compl, &num_compl);
3289
3290 if (num_compl > 0)
3291 {
3292 /* insert completed word if there is only one match */
3293 if (num_compl == 1)
3294 {
3295 for (i = word_len; i < compl[0].len; i++)
3296 edit_insert (edit, *(compl[0].text + i));
3297 }
3298 /* more than one possible completion => ask the user */
3299 else
3300 {
3301 /* !!! usually only a beep is expected and when <ALT-TAB> is !!! */
3302 /* !!! pressed again the selection dialog pops up, but that !!! */
3303 /* !!! seems to require a further internal state !!! */
3304 /*tty_beep (); */
3305
3306 /* let the user select the preferred completion */
3307 editcmd_dialog_completion_show (edit, max_len, word_len,
3308 (struct selection *) &compl, num_compl);
3309 }
3310 }
3311
3312 g_free (match_expr);
3313 /* release memory before return */
3314 for (i = 0; i < num_compl; i++)
3315 g_free (compl[i].text);
3316 }
3317
3318 /* --------------------------------------------------------------------------------------------- */
3319
3320 void
3321 edit_select_codepage_cmd (WEdit * edit)
3322 {
3323 #ifdef HAVE_CHARSET
3324 if (do_select_codepage ())
3325 edit_set_codeset (edit);
3326
3327 edit->force = REDRAW_COMPLETELY;
3328 edit_refresh_cmd (edit);
3329 #else
3330 (void) edit;
3331 #endif
3332 }
3333
3334 /* --------------------------------------------------------------------------------------------- */
3335
3336 void
3337 edit_insert_literal_cmd (WEdit * edit)
3338 {
3339 int char_for_insertion;
3340
3341 char_for_insertion = editcmd_dialog_raw_key_query (_("Insert literal"),
3342 _("Press any key:"), FALSE);
3343 edit_execute_key_command (edit, -1, ascii_alpha_to_cntrl (char_for_insertion));
3344 }
3345
3346 /* --------------------------------------------------------------------------------------------- */
3347
3348 void
3349 edit_begin_end_macro_cmd (WEdit * edit)
3350 {
3351 /* edit is a pointer to the widget */
3352 if (edit != NULL)
3353 {
3354 unsigned long command = macro_index < 0 ? CK_MacroStartRecord : CK_MacroStopRecord;
3355 edit_execute_key_command (edit, command, -1);
3356 }
3357 }
3358
3359 /* --------------------------------------------------------------------------------------------- */
3360
3361 void
3362 edit_begin_end_repeat_cmd (WEdit * edit)
3363 {
3364 /* edit is a pointer to the widget */
3365 if (edit != NULL)
3366 {
3367 unsigned long command = macro_index < 0 ? CK_RepeatStartRecord : CK_RepeatStopRecord;
3368 edit_execute_key_command (edit, command, -1);
3369 }
3370 }
3371
3372 /* --------------------------------------------------------------------------------------------- */
3373
3374 gboolean
3375 edit_load_forward_cmd (WEdit * edit)
3376 {
3377 if (edit->modified
3378 && edit_query_dialog2 (_("Warning"),
3379 _("Current text was modified without a file save.\n"
3380 "Continue discards these changes"), _("C&ontinue"),
3381 _("&Cancel")) == 1)
3382 {
3383 edit->force |= REDRAW_COMPLETELY;
3384 return TRUE;
3385 }
3386
3387 if (edit_stack_iterator + 1 >= MAX_HISTORY_MOVETO)
3388 return FALSE;
3389
3390 if (edit_history_moveto[edit_stack_iterator + 1].line < 1)
3391 return FALSE;
3392
3393 edit_stack_iterator++;
3394 if (edit_history_moveto[edit_stack_iterator].filename_vpath != NULL)
3395 return edit_reload_line (edit, edit_history_moveto[edit_stack_iterator].filename_vpath,
3396 edit_history_moveto[edit_stack_iterator].line);
3397
3398 return FALSE;
3399 }
3400
3401 /* --------------------------------------------------------------------------------------------- */
3402
3403 gboolean
3404 edit_load_back_cmd (WEdit * edit)
3405 {
3406 if (edit->modified
3407 && edit_query_dialog2 (_("Warning"),
3408 _("Current text was modified without a file save.\n"
3409 "Continue discards these changes"), _("C&ontinue"),
3410 _("&Cancel")) == 1)
3411 {
3412 edit->force |= REDRAW_COMPLETELY;
3413 return TRUE;
3414 }
3415
3416 /* we are in the bottom of the stack, NO WAY! */
3417 if (edit_stack_iterator == 0)
3418 return FALSE;
3419
3420 edit_stack_iterator--;
3421 if (edit_history_moveto[edit_stack_iterator].filename_vpath != NULL)
3422 return edit_reload_line (edit, edit_history_moveto[edit_stack_iterator].filename_vpath,
3423 edit_history_moveto[edit_stack_iterator].line);
3424
3425 return FALSE;
3426 }
3427
3428 /* --------------------------------------------------------------------------------------------- */
3429
3430 void
3431 edit_get_match_keyword_cmd (WEdit * edit)
3432 {
3433 gsize word_len = 0, max_len = 0;
3434 int num_def = 0;
3435 int i;
3436 off_t word_start = 0;
3437 unsigned char *bufpos;
3438 char *match_expr;
3439 char *path = NULL;
3440 char *ptr = NULL;
3441 char *tagfile = NULL;
3442
3443 etags_hash_t def_hash[MAX_DEFINITIONS];
3444
3445 for (i = 0; i < MAX_DEFINITIONS; i++)
3446 {
3447 def_hash[i].filename = NULL;
3448 }
3449
3450 /* search start of word to be completed */
3451 if (!edit_find_word_start (edit, &word_start, &word_len))
3452 return;
3453
3454 /* prepare match expression */
3455 bufpos = &edit->buffers1[word_start >> S_EDIT_BUF_SIZE][word_start & M_EDIT_BUF_SIZE];
3456 match_expr = g_strdup_printf ("%.*s", (int) word_len, bufpos);
3457
3458 ptr = g_get_current_dir ();
3459 path = g_strconcat (ptr, G_DIR_SEPARATOR_S, (char *) NULL);
3460 g_free (ptr);
3461
3462 /* Recursive search file 'TAGS' in parent dirs */
3463 do
3464 {
3465 ptr = g_path_get_dirname (path);
3466 g_free (path);
3467 path = ptr;
3468 g_free (tagfile);
3469 tagfile = mc_build_filename (path, TAGS_NAME, (char *) NULL);
3470 if (exist_file (tagfile))
3471 break;
3472 }
3473 while (strcmp (path, G_DIR_SEPARATOR_S) != 0);
3474
3475 if (tagfile)
3476 {
3477 num_def =
3478 etags_set_definition_hash (tagfile, path, match_expr, (etags_hash_t *) & def_hash);
3479 g_free (tagfile);
3480 }
3481 g_free (path);
3482
3483 max_len = MAX_WIDTH_DEF_DIALOG;
3484 word_len = 0;
3485 if (num_def > 0)
3486 {
3487 editcmd_dialog_select_definition_show (edit, match_expr, max_len, word_len,
3488 (etags_hash_t *) & def_hash, num_def);
3489 }
3490 g_free (match_expr);
3491 }
3492
3493 /* --------------------------------------------------------------------------------------------- */
Midnight Commander