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