?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Ticket #1809 (editor: incorrect cursor positioning)
[pantumic.git] / edit / edit.c
blobb4d6cd40e29fa394bc5ccf5ce35613e1881ae238
1 /* editor low level data handling and cursor fundamentals.
2
3 Copyright (C) 1996, 1997, 1998, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007 Free Software Foundation, Inc.
5
6 Authors: 1996, 1997 Paul Sheer
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA.
22 */
23
24 /** \file
25 * \brief Source: editor low level data handling and cursor fundamentals
26 * \author Paul Sheer
27 * \date 1996, 1997
28 */
29
30 #include <config.h>
31 #include <stdio.h>
32 #include <stdarg.h>
33 #include <sys/types.h>
34 #include <unistd.h>
35 #include <string.h>
36 #include <ctype.h>
37 #include <errno.h>
38 #include <sys/stat.h>
39 #include <stdlib.h>
40 #include <fcntl.h>
41
42 #include "../src/global.h"
43
44 #include "edit-impl.h"
45 #include "editlock.h"
46 #include "edit-widget.h"
47 #include "../src/cmddef.h"
48
49 #include "../src/tty/color.h" /* EDITOR_NORMAL_COLOR */
50 #include "../src/tty/tty.h" /* attrset() */
51 #include "../src/tty/key.h" /* is_idle() */
52 #include "../src/skin/skin.h" /* mc_skin_color_get */
53
54 #include "../src/widget.h"
55 #include "../src/cmd.h" /* view_other_cmd() */
56 #include "../src/user.h" /* user_menu_cmd() */
57 #include "../src/wtools.h" /* query_dialog() */
58 #include "../src/timefmt.h" /* time formatting */
59 #include "../src/strutil.h" /* utf string functions */
60 #include "../src/charsets.h" /* get_codepage_id */
61 #include "../src/main.h" /* source_codepage */
62 #include "../src/learn.h" /* learn_keys */
63
64 int option_word_wrap_line_length = 72;
65 int option_typewriter_wrap = 0;
66 int option_auto_para_formatting = 0;
67 int option_fill_tabs_with_spaces = 0;
68 int option_return_does_auto_indent = 1;
69 int option_backspace_through_tabs = 0;
70 int option_fake_half_tabs = 1;
71 int option_save_mode = EDIT_QUICK_SAVE;
72 int option_save_position = 1;
73 int option_max_undo = 32768;
74 int option_persistent_selections = 1;
75 int option_cursor_beyond_eol = 1;
76 int option_line_state = 0;
77 int option_line_state_width = 0;
78
79 int option_edit_right_extreme = 0;
80 int option_edit_left_extreme = 0;
81 int option_edit_top_extreme = 0;
82 int option_edit_bottom_extreme = 0;
83 int enable_show_tabs_tws = 1;
84 int option_check_nl_at_eof = 0;
85
86 const char *option_whole_chars_search = "0123456789abcdefghijklmnopqrstuvwxyz_";
87 char *option_backup_ext = NULL;
88
89 int edit_stack_iterator = 0;
90 edit_stack_type edit_history_moveto [MAX_HISTORY_MOVETO];
91 /* magic sequense for say than block is vertical */
92 const char VERTICAL_MAGIC[] = {'\1', '\1', '\1', '\1', '\n'};
93 /*-
94 *
95 * here's a quick sketch of the layout: (don't run this through indent.)
96 *
97 * (b1 is buffers1 and b2 is buffers2)
98 *
99 * |
100 * \0\0\0\0\0m e _ f i l e . \nf i n . \n|T h i s _ i s _ s o\0\0\0\0\0\0\0\0\0
101 * ______________________________________|______________________________________
102 * |
103 * ... | b2[2] | b2[1] | b2[0] | b1[0] | b1[1] | b1[2] | ...
104 * |-> |-> |-> |-> |-> |-> |
105 * |
106 * _<------------------------->|<----------------->_
107 * WEdit->curs2 | WEdit->curs1
108 * ^ | ^
109 * | ^|^ |
110 * cursor ||| cursor
111 * |||
112 * file end|||file beginning
113 * |
114 * |
115 *
116 * _
117 * This_is_some_file
118 * fin.
119 */
120
121 const global_keymap_t *editor_map;
122 const global_keymap_t *editor_x_map;
123
124 static void user_menu (WEdit *edit);
125
126 int edit_get_byte (WEdit * edit, long byte_index)
127 {
128 unsigned long p;
129 if (byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0)
130 return '\n';
131
132 if (byte_index >= edit->curs1) {
133 p = edit->curs1 + edit->curs2 - byte_index - 1;
134 return edit->buffers2[p >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE - (p & M_EDIT_BUF_SIZE) - 1];
135 } else {
136 return edit->buffers1[byte_index >> S_EDIT_BUF_SIZE][byte_index & M_EDIT_BUF_SIZE];
137 }
138 }
139
140 char *edit_get_byte_ptr (WEdit * edit, long byte_index)
141 {
142 unsigned long p;
143
144 if (byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0)
145 return NULL;
146
147 if (byte_index >= edit->curs1) {
148 p = edit->curs1 + edit->curs2 - byte_index - 1;
149 return (char *) (edit->buffers2[p >> S_EDIT_BUF_SIZE]+(EDIT_BUF_SIZE - (p & M_EDIT_BUF_SIZE) - 1));
150 } else {
151 return (char *) (edit->buffers1[byte_index >> S_EDIT_BUF_SIZE]+(byte_index & M_EDIT_BUF_SIZE));
152 }
153 }
154
155 char *edit_get_buf_ptr (WEdit * edit, long byte_index)
156 {
157 unsigned long p;
158
159 if (byte_index >= (edit->curs1 + edit->curs2) ) {
160 byte_index -= 1;
161 };
162
163 if ( byte_index < 0 ) {
164 return NULL;
165 }
166
167 if (byte_index >= edit->curs1) {
168 p = edit->curs1 + edit->curs2 - 1;
169 return (char *) (edit->buffers2[p >> S_EDIT_BUF_SIZE] + (EDIT_BUF_SIZE - (p & M_EDIT_BUF_SIZE) - 1));
170 } else {
171 return (char *) (edit->buffers1[byte_index >> S_EDIT_BUF_SIZE] + (0 & M_EDIT_BUF_SIZE));
172 }
173 }
174
175 int edit_get_utf (WEdit * edit, long byte_index, int *char_width)
176 {
177 gchar *str = NULL;
178 int res = -1;
179 gunichar ch;
180 gchar *next_ch = NULL;
181 int width = 0;
182
183 if (byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0) {
184 *char_width = 0;
185 return '\n';
186 }
187
188
189 str = edit_get_byte_ptr (edit, byte_index);
190 res = g_utf8_get_char_validated (str, -1);
191
192 if ( res < 0 ) {
193 ch = *str;
194 width = 0;
195 } else {
196 ch = res;
197 /* Calculate UTF-8 char width */
198 next_ch = g_utf8_next_char(str);
199 if ( next_ch ) {
200 width = next_ch - str;
201 } else {
202 ch = 0;
203 width = 0;
204 }
205 }
206 *char_width = width;
207 return ch;
208 }
209
210 int edit_get_prev_utf (WEdit * edit, long byte_index, int *char_width)
211 {
212 gchar *str, *buf = NULL;
213 int res = -1;
214 gunichar ch;
215 gchar *next_ch = NULL;
216 int width = 0;
217
218 if ( byte_index > 0 ) {
219 byte_index--;
220 }
221
222 ch = edit_get_utf (edit, byte_index, &width);
223 if ( width == 1 ) {
224 *char_width = width;
225 return ch;
226 }
227
228 if ( byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0 ) {
229 *char_width = 0;
230 return 0;
231 }
232
233 str = edit_get_byte_ptr (edit, byte_index);
234 buf = edit_get_buf_ptr (edit, byte_index);
235 /* get prev utf8 char */
236 if ( str != buf )
237 str = g_utf8_find_prev_char (buf, str);
238
239 res = g_utf8_get_char_validated (str, -1);
240 if ( res < 0 ) {
241 ch = *str;
242 width = 0;
243 } else {
244 ch = res;
245 /* Calculate UTF-8 char width */
246 next_ch = g_utf8_next_char(str);
247 if ( next_ch ) {
248 width = next_ch - str;
249 } else {
250 ch = 0;
251 width = 0;
252 }
253 }
254 *char_width = width;
255 return ch;
256 }
257
258 /*
259 * Initialize the buffers for an empty files.
260 */
261 static void
262 edit_init_buffers (WEdit *edit)
263 {
264 int j;
265
266 for (j = 0; j <= MAXBUFF; j++) {
267 edit->buffers1[j] = NULL;
268 edit->buffers2[j] = NULL;
269 }
270
271 edit->curs1 = 0;
272 edit->curs2 = 0;
273 edit->buffers2[0] = g_malloc (EDIT_BUF_SIZE);
274 }
275
276 /*
277 * Load file OR text into buffers. Set cursor to the beginning of file.
278 * Return 1 on error.
279 */
280 static int
281 edit_load_file_fast (WEdit *edit, const char *filename)
282 {
283 long buf, buf2;
284 int file = -1;
285 edit->curs2 = edit->last_byte;
286 buf2 = edit->curs2 >> S_EDIT_BUF_SIZE;
287 edit->utf8 = 0;
288 if ((file = mc_open (filename, O_RDONLY | O_BINARY)) == -1) {
289 GString *errmsg = g_string_new(NULL);
290 g_string_sprintf(errmsg, _(" Cannot open %s for reading "), filename);
291 edit_error_dialog (_("Error"), get_sys_error (errmsg->str));
292 g_string_free (errmsg, TRUE);
293 return 1;
294 }
295
296 if (!edit->buffers2[buf2])
297 edit->buffers2[buf2] = g_malloc (EDIT_BUF_SIZE);
298
299 mc_read (file,
300 (char *) edit->buffers2[buf2] + EDIT_BUF_SIZE -
301 (edit->curs2 & M_EDIT_BUF_SIZE),
302 edit->curs2 & M_EDIT_BUF_SIZE);
303
304 for (buf = buf2 - 1; buf >= 0; buf--) {
305 /* edit->buffers2[0] is already allocated */
306 if (!edit->buffers2[buf])
307 edit->buffers2[buf] = g_malloc (EDIT_BUF_SIZE);
308 mc_read (file, (char *) edit->buffers2[buf], EDIT_BUF_SIZE);
309 }
310
311 mc_close (file);
312 return 0;
313 }
314
315 /* detecting an error on save is easy: just check if every byte has been written. */
316 /* detecting an error on read, is not so easy 'cos there is not way to tell
317 whether you read everything or not. */
318 /* FIXME: add proper `triple_pipe_open' to read, write and check errors. */
319 static const struct edit_filters {
320 const char *read, *write, *extension;
321 } all_filters[] = {
322 { "xz -cd %s 2>&1", "xz > %s", ".xz" },
323 { "lzma -cd %s 2>&1", "lzma > %s", ".lzma" },
324 { "bzip2 -cd %s 2>&1", "bzip2 > %s", ".bz2" },
325 { "gzip -cd %s 2>&1", "gzip > %s", ".gz" },
326 { "gzip -cd %s 2>&1", "gzip > %s", ".Z" }
327 };
328
329 /* Return index of the filter or -1 is there is no appropriate filter */
330 static int edit_find_filter (const char *filename)
331 {
332 size_t i, l, e;
333 if (!filename)
334 return -1;
335 l = strlen (filename);
336 for (i = 0; i < sizeof (all_filters) / sizeof (all_filters[0]); i++) {
337 e = strlen (all_filters[i].extension);
338 if (l > e)
339 if (!strcmp (all_filters[i].extension, filename + l - e))
340 return i;
341 }
342 return -1;
343 }
344
345 static char *
346 edit_get_filter (const char *filename)
347 {
348 int i, l;
349 char *p, *quoted_name;
350 i = edit_find_filter (filename);
351 if (i < 0)
352 return 0;
353 quoted_name = name_quote (filename, 0);
354 l = str_term_width1 (quoted_name);
355 p = g_malloc (str_term_width1 (all_filters[i].read) + l + 2);
356 sprintf (p, all_filters[i].read, quoted_name);
357 g_free (quoted_name);
358 return p;
359 }
360
361 char *
362 edit_get_write_filter (const char *write_name, const char *filename)
363 {
364 int i, l;
365 char *p, *writename;
366 i = edit_find_filter (filename);
367 if (i < 0)
368 return 0;
369 writename = name_quote (write_name, 0);
370 l = str_term_width1 (writename);
371 p = g_malloc (str_term_width1 (all_filters[i].write) + l + 2);
372 sprintf (p, all_filters[i].write, writename);
373 g_free (writename);
374 return p;
375 }
376
377 static long
378 edit_insert_stream (WEdit * edit, FILE * f)
379 {
380 int c;
381 long i = 0;
382 while ((c = fgetc (f)) >= 0) {
383 edit_insert (edit, c);
384 i++;
385 }
386 return i;
387 }
388
389 long edit_write_stream (WEdit * edit, FILE * f)
390 {
391 long i;
392
393 if (edit->lb == LB_ASIS) {
394 for (i = 0; i < edit->last_byte; i++)
395 if (fputc (edit_get_byte (edit, i), f) < 0)
396 break;
397 return i;
398 }
399
400 /* change line breaks */
401 for (i = 0; i < edit->last_byte; i++) {
402 unsigned char c = edit_get_byte (edit, i);
403
404 if (!(c == '\n' || c == '\r')) {
405 /* not line break */
406 if (fputc (c, f) < 0)
407 return i;
408 } else { /* (c == '\n' || c == '\r') */
409 unsigned char c1 = edit_get_byte (edit, i + 1); /* next char */
410
411 switch (edit->lb) {
412 case LB_UNIX: /* replace "\r\n" or '\r' to '\n' */
413 /* put one line break unconditionally */
414 if (fputc ('\n', f) < 0)
415 return i;
416
417 i++; /* 2 chars are processed */
418
419 if (c == '\r' && c1 == '\n')
420 /* Windows line break; go to the next char */
421 break;
422
423 if (c == '\r' && c1 == '\r') {
424 /* two Macintosh line breaks; put second line break */
425 if (fputc ('\n', f) < 0)
426 return i;
427 break;
428 }
429
430 if (fputc (c1, f) < 0)
431 return i;
432 break;
433
434 case LB_WIN: /* replace '\n' or '\r' to "\r\n" */
435 /* put one line break unconditionally */
436 if (fputc ('\r', f) < 0 || fputc ('\n', f) < 0)
437 return i;
438
439 if (c == '\r' && c1 == '\n')
440 /* Windows line break; go to the next char */
441 i++;
442 break;
443
444 case LB_MAC: /* replace "\r\n" or '\n' to '\r' */
445 /* put one line break unconditionally */
446 if (fputc ('\r', f) < 0)
447 return i;
448
449 i++; /* 2 chars are processed */
450
451 if (c == '\r' && c1 == '\n')
452 /* Windows line break; go to the next char */
453 break;
454
455 if (c == '\n' && c1 == '\n') {
456 /* two Windows line breaks; put second line break */
457 if (fputc ('\r', f) < 0)
458 return i;
459 break;
460 }
461
462 if (fputc (c1, f) < 0)
463 return i;
464 break;
465 case LB_ASIS: /* default without changes */
466 break;
467 }
468 }
469 }
470
471 return edit->last_byte;
472 }
473
474 #define TEMP_BUF_LEN 1024
475
476 /* inserts a file at the cursor, returns 1 on success */
477 int
478 edit_insert_file (WEdit *edit, const char *filename)
479 {
480 char *p;
481 if ((p = edit_get_filter (filename))) {
482 FILE *f;
483 long current = edit->curs1;
484 f = (FILE *) popen (p, "r");
485 if (f) {
486 edit_insert_stream (edit, f);
487 edit_cursor_move (edit, current - edit->curs1);
488 if (pclose (f) > 0) {
489 GString *errmsg = g_string_new (NULL);
490 g_string_sprintf (errmsg, _(" Error reading from pipe: %s "), p);
491 edit_error_dialog (_("Error"), errmsg->str);
492 g_string_free (errmsg, TRUE);
493 g_free (p);
494 return 0;
495 }
496 } else {
497 GString *errmsg = g_string_new (NULL);
498 g_string_sprintf (errmsg, _(" Cannot open pipe for reading: %s "), p);
499 edit_error_dialog (_("Error"), errmsg->str);
500 g_string_free (errmsg, TRUE);
501 g_free (p);
502 return 0;
503 }
504 g_free (p);
505 } else {
506 int i, file, blocklen;
507 long current = edit->curs1;
508 int vertical_insertion = 0;
509 char *buf;
510 if ((file = mc_open (filename, O_RDONLY | O_BINARY)) == -1)
511 return 0;
512 buf = g_malloc (TEMP_BUF_LEN);
513 blocklen = mc_read (file, buf, sizeof(VERTICAL_MAGIC));
514 if (blocklen > 0) {
515 /* if contain signature VERTICAL_MAGIC tnen it vertical block */
516 if ( memcmp(buf, VERTICAL_MAGIC, sizeof(VERTICAL_MAGIC)) == 0 ) {
517 vertical_insertion = 1;
518 } else {
519 mc_lseek (file, 0, SEEK_SET);
520 }
521 }
522 if (vertical_insertion) {
523 blocklen = edit_insert_column_of_text_from_file (edit, file);
524 } else {
525 while ((blocklen = mc_read (file, (char *) buf, TEMP_BUF_LEN)) > 0) {
526 for (i = 0; i < blocklen; i++)
527 edit_insert (edit, buf[i]);
528 }
529 }
530 edit_cursor_move (edit, current - edit->curs1);
531 g_free (buf);
532 mc_close (file);
533 if (blocklen)
534 return 0;
535 }
536 return 1;
537 }
538
539 /* Open file and create it if necessary. Return 0 for success, 1 for error. */
540 static int
541 check_file_access (WEdit *edit, const char *filename, struct stat *st)
542 {
543 int file;
544 GString *errmsg = (GString *) 0;
545
546 /* Try opening an existing file */
547 file = mc_open (filename, O_NONBLOCK | O_RDONLY | O_BINARY, 0666);
548
549 if (file < 0) {
550 /*
551 * Try creating the file. O_EXCL prevents following broken links
552 * and opening existing files.
553 */
554 file =
555 mc_open (filename,
556 O_NONBLOCK | O_RDONLY | O_BINARY | O_CREAT | O_EXCL,
557 0666);
558 if (file < 0) {
559 g_string_sprintf (errmsg = g_string_new (NULL),
560 _(" Cannot open %s for reading "), filename);
561 goto cleanup;
562 } else {
563 /* New file, delete it if it's not modified or saved */
564 edit->delete_file = 1;
565 }
566 }
567
568 /* Check what we have opened */
569 if (mc_fstat (file, st) < 0) {
570 g_string_sprintf (errmsg = g_string_new (NULL),
571 _(" Cannot get size/permissions for %s "), filename);
572 goto cleanup;
573 }
574
575 /* We want to open regular files only */
576 if (!S_ISREG (st->st_mode)) {
577 g_string_sprintf (errmsg = g_string_new (NULL),
578 _(" %s is not a regular file "), filename);
579 goto cleanup;
580 }
581
582 /*
583 * Don't delete non-empty files.
584 * O_EXCL should prevent it, but let's be on the safe side.
585 */
586 if (st->st_size > 0) {
587 edit->delete_file = 0;
588 }
589
590 if (st->st_size >= SIZE_LIMIT) {
591 g_string_sprintf (errmsg = g_string_new (NULL),
592 _(" File %s is too large "), filename);
593 goto cleanup;
594 }
595
596 cleanup:
597 (void) mc_close (file);
598 if (errmsg) {
599 edit_error_dialog (_("Error"), errmsg->str);
600 g_string_free (errmsg, TRUE);
601 return 1;
602 }
603 return 0;
604 }
605
606 /*
607 * Open the file and load it into the buffers, either directly or using
608 * a filter. Return 0 on success, 1 on error.
609 *
610 * Fast loading (edit_load_file_fast) is used when the file size is
611 * known. In this case the data is read into the buffers by blocks.
612 * If the file size is not known, the data is loaded byte by byte in
613 * edit_insert_file.
614 */
615 static int
616 edit_load_file (WEdit *edit)
617 {
618 int fast_load = 1;
619
620 /* Cannot do fast load if a filter is used */
621 if (edit_find_filter (edit->filename) >= 0)
622 fast_load = 0;
623
624 /*
625 * VFS may report file size incorrectly, and slow load is not a big
626 * deal considering overhead in VFS.
627 */
628 if (!vfs_file_is_local (edit->filename))
629 fast_load = 0;
630
631 /*
632 * FIXME: line end translation should disable fast loading as well
633 * Consider doing fseek() to the end and ftell() for the real size.
634 */
635
636 if (*edit->filename) {
637 /* If we are dealing with a real file, check that it exists */
638 if (check_file_access (edit, edit->filename, &edit->stat1))
639 return 1;
640 } else {
641 /* nothing to load */
642 fast_load = 0;
643 }
644
645 edit_init_buffers (edit);
646
647 if (fast_load) {
648 edit->last_byte = edit->stat1.st_size;
649 edit_load_file_fast (edit, edit->filename);
650 /* If fast load was used, the number of lines wasn't calculated */
651 edit->total_lines = edit_count_lines (edit, 0, edit->last_byte);
652 } else {
653 #ifdef HAVE_CHARSET
654 const char *codepage_id;
655 #endif
656 edit->last_byte = 0;
657 if (*edit->filename) {
658 edit->stack_disable = 1;
659 if (!edit_insert_file (edit, edit->filename)) {
660 edit_clean (edit);
661 return 1;
662 }
663 edit->stack_disable = 0;
664 }
665
666 #ifdef HAVE_CHARSET
667 codepage_id = get_codepage_id( source_codepage );
668 if ( codepage_id )
669 edit->utf8 = str_isutf8 ( codepage_id );
670 #endif
671 }
672 edit->lb = LB_ASIS;
673 return 0;
674 }
675
676 /* Restore saved cursor position in the file */
677 static void
678 edit_load_position (WEdit *edit)
679 {
680 char *filename;
681 long line, column;
682
683 if (!edit->filename || !*edit->filename)
684 return;
685
686 filename = vfs_canon (edit->filename);
687 load_file_position (filename, &line, &column);
688 g_free (filename);
689
690 edit_move_to_line (edit, line - 1);
691 edit->prev_col = column;
692 edit_move_to_prev_col (edit, edit_bol (edit, edit->curs1));
693 edit_move_display (edit, line - (edit->num_widget_lines / 2));
694 }
695
696 /* Save cursor position in the file */
697 static void
698 edit_save_position (WEdit *edit)
699 {
700 char *filename;
701
702 if (!edit->filename || !*edit->filename)
703 return;
704
705 filename = vfs_canon (edit->filename);
706 save_file_position (filename, edit->curs_line + 1, edit->curs_col);
707 g_free (filename);
708 }
709
710 /* Clean the WEdit stricture except the widget part */
711 static void
712 edit_purge_widget (WEdit *edit)
713 {
714 int len = sizeof (WEdit) - sizeof (Widget);
715 char *start = (char *) edit + sizeof (Widget);
716 memset (start, 0, len);
717 edit->macro_i = -1; /* not recording a macro */
718 }
719
720 static void
721 edit_set_keymap (void)
722 {
723 editor_map = default_editor_keymap;
724 if (editor_keymap && editor_keymap->len > 0)
725 editor_map = (global_keymap_t *) editor_keymap->data;
726
727 editor_x_map = default_editor_x_keymap;
728 if (editor_x_keymap && editor_x_keymap->len > 0)
729 editor_x_map = (global_keymap_t *) editor_x_keymap->data;
730 }
731
732
733 #define space_width 1
734
735 /*
736 * Fill in the edit structure. Return NULL on failure. Pass edit as
737 * NULL to allocate a new structure.
738 *
739 * If line is 0, try to restore saved position. Otherwise put the
740 * cursor on that line and show it in the middle of the screen.
741 */
742 WEdit *
743 edit_init (WEdit *edit, int lines, int columns, const char *filename,
744 long line)
745 {
746 int to_free = 0;
747 option_auto_syntax = 1; /* Resetting to auto on every invokation */
748 if ( option_line_state ) {
749 option_line_state_width = LINE_STATE_WIDTH;
750 } else {
751 option_line_state_width = 0;
752 }
753 if (!edit) {
754 #ifdef ENABLE_NLS
755 /*
756 * Expand option_whole_chars_search by national letters using
757 * current locale
758 */
759
760 static char option_whole_chars_search_buf[256];
761
762 if (option_whole_chars_search_buf != option_whole_chars_search) {
763 size_t i;
764 size_t len = str_term_width1 (option_whole_chars_search);
765
766 strcpy (option_whole_chars_search_buf,
767 option_whole_chars_search);
768
769 for (i = 1; i <= sizeof (option_whole_chars_search_buf); i++) {
770 if (g_ascii_islower ((gchar) i) && !strchr (option_whole_chars_search, i)) {
771 option_whole_chars_search_buf[len++] = i;
772 }
773 }
774
775 option_whole_chars_search_buf[len] = 0;
776 option_whole_chars_search = option_whole_chars_search_buf;
777 }
778 #endif /* ENABLE_NLS */
779 edit = g_malloc0 (sizeof (WEdit));
780 edit->search = NULL;
781 to_free = 1;
782 }
783 edit_purge_widget (edit);
784 edit->num_widget_lines = lines;
785 edit->over_col = 0;
786 edit->num_widget_columns = columns;
787 edit->stat1.st_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
788 edit->stat1.st_uid = getuid ();
789 edit->stat1.st_gid = getgid ();
790 edit->stat1.st_mtime = 0;
791 edit->bracket = -1;
792 edit->force |= REDRAW_PAGE;
793 edit_set_filename (edit, filename);
794 edit->stack_size = START_STACK_SIZE;
795 edit->stack_size_mask = START_STACK_SIZE - 1;
796 edit->undo_stack = g_malloc ((edit->stack_size + 10) * sizeof (long));
797 if (edit_load_file (edit)) {
798 /* edit_load_file already gives an error message */
799 if (to_free)
800 g_free (edit);
801 return 0;
802 }
803 edit->utf8 = 0;
804 edit->converter = str_cnv_from_term;
805 #ifdef HAVE_CHARSET
806 {
807 const char *cp_id = NULL;
808 cp_id = get_codepage_id (source_codepage >= 0 ?
809 source_codepage : display_codepage);
810
811 if (cp_id != NULL) {
812 GIConv conv;
813 conv = str_crt_conv_from (cp_id);
814 if (conv != INVALID_CONV) {
815 if (edit->converter != str_cnv_from_term)
816 str_close_conv (edit->converter);
817 edit->converter = conv;
818 }
819 }
820 if (cp_id != NULL)
821 edit->utf8 = str_isutf8 (cp_id);
822 }
823 #endif
824
825 edit->loading_done = 1;
826 edit->modified = 0;
827 edit->locked = 0;
828 edit_load_syntax (edit, 0, 0);
829 {
830 int color;
831 edit_get_syntax_color (edit, -1, &color);
832 }
833
834 /* load saved cursor position */
835 if ((line == 0) && option_save_position) {
836 edit_load_position (edit);
837 } else {
838 if (line <= 0)
839 line = 1;
840 edit_move_display (edit, line - 1);
841 edit_move_to_line (edit, line - 1);
842 }
843
844 edit_set_keymap ();
845
846 return edit;
847 }
848
849 /* Clear the edit struct, freeing everything in it. Return 1 on success */
850 int
851 edit_clean (WEdit *edit)
852 {
853 int j = 0;
854
855 if (!edit)
856 return 0;
857
858 /* a stale lock, remove it */
859 if (edit->locked)
860 edit->locked = edit_unlock_file (edit->filename);
861
862 /* save cursor position */
863 if (option_save_position)
864 edit_save_position (edit);
865
866 /* File specified on the mcedit command line and never saved */
867 if (edit->delete_file)
868 unlink (edit->filename);
869
870 edit_free_syntax_rules (edit);
871 book_mark_flush (edit, -1);
872 for (; j <= MAXBUFF; j++) {
873 g_free (edit->buffers1[j]);
874 g_free (edit->buffers2[j]);
875 }
876
877 g_free (edit->undo_stack);
878 g_free (edit->filename);
879 g_free (edit->dir);
880
881 if (edit->search)
882 {
883 mc_search_free(edit->search);
884 edit->search = NULL;
885 }
886 edit_purge_widget (edit);
887
888 return 1;
889 }
890
891
892 /* returns 1 on success */
893 int edit_renew (WEdit * edit)
894 {
895 int lines = edit->num_widget_lines;
896 int columns = edit->num_widget_columns;
897 int retval = 1;
898
899 edit_clean (edit);
900 if (!edit_init (edit, lines, columns, "", 0))
901 retval = 0;
902 return retval;
903 }
904
905 /*
906 * Load a new file into the editor. If it fails, preserve the old file.
907 * To do it, allocate a new widget, initialize it and, if the new file
908 * was loaded, copy the data to the old widget.
909 * Return 1 on success, 0 on failure.
910 */
911 int
912 edit_reload (WEdit *edit, const char *filename)
913 {
914 WEdit *e;
915 int lines = edit->num_widget_lines;
916 int columns = edit->num_widget_columns;
917
918 e = g_malloc0 (sizeof (WEdit));
919 e->widget = edit->widget;
920 if (!edit_init (e, lines, columns, filename, 0)) {
921 g_free (e);
922 return 0;
923 }
924 edit_clean (edit);
925 memcpy (edit, e, sizeof (WEdit));
926 g_free (e);
927 return 1;
928 }
929
930 /*
931 * Load a new file into the editor and set line. If it fails, preserve the old file.
932 * To do it, allocate a new widget, initialize it and, if the new file
933 * was loaded, copy the data to the old widget.
934 * Return 1 on success, 0 on failure.
935 */
936 int
937 edit_reload_line (WEdit *edit, const char *filename, long line)
938 {
939 WEdit *e;
940 int lines = edit->num_widget_lines;
941 int columns = edit->num_widget_columns;
942
943 e = g_malloc0 (sizeof (WEdit));
944 e->widget = edit->widget;
945 if (!edit_init (e, lines, columns, filename, line)) {
946 g_free (e);
947 return 0;
948 }
949 edit_clean (edit);
950 memcpy (edit, e, sizeof (WEdit));
951 g_free (e);
952 return 1;
953 }
954
955
956 /*
957 Recording stack for undo:
958 The following is an implementation of a compressed stack. Identical
959 pushes are recorded by a negative prefix indicating the number of times the
960 same char was pushed. This saves space for repeated curs-left or curs-right
961 delete etc.
962
963 eg:
964
965 pushed: stored:
966
967 a
968 b a
969 b -3
970 b b
971 c --> -4
972 c c
973 c d
974 c
975 d
976
977 If the stack long int is 0-255 it represents a normal insert (from a backspace),
978 256-512 is an insert ahead (from a delete), If it is betwen 600 and 700 it is one
979 of the cursor functions #define'd in edit-impl.h. 1000 through 700'000'000 is to
980 set edit->mark1 position. 700'000'000 through 1400'000'000 is to set edit->mark2
981 position.
982
983 The only way the cursor moves or the buffer is changed is through the routines:
984 insert, backspace, insert_ahead, delete, and cursor_move.
985 These record the reverse undo movements onto the stack each time they are
986 called.
987
988 Each key press results in a set of actions (insert; delete ...). So each time
989 a key is pressed the current position of start_display is pushed as
990 KEY_PRESS + start_display. Then for undoing, we pop until we get to a number
991 over KEY_PRESS. We then assign this number less KEY_PRESS to start_display. So undo
992 tracks scrolling and key actions exactly. (KEY_PRESS is about (2^31) * (2/3) = 1400'000'000)
993
994 */
995
996 void edit_push_action (WEdit * edit, long c,...)
997 {
998 unsigned long sp = edit->stack_pointer;
999 unsigned long spm1;
1000 long *t;
1001
1002 /* first enlarge the stack if necessary */
1003 if (sp > edit->stack_size - 10) { /* say */
1004 if (option_max_undo < 256)
1005 option_max_undo = 256;
1006 if (edit->stack_size < (unsigned long) option_max_undo) {
1007 t = g_realloc (edit->undo_stack, (edit->stack_size * 2 + 10) * sizeof (long));
1008 if (t) {
1009 edit->undo_stack = t;
1010 edit->stack_size <<= 1;
1011 edit->stack_size_mask = edit->stack_size - 1;
1012 }
1013 }
1014 }
1015 spm1 = (edit->stack_pointer - 1) & edit->stack_size_mask;
1016 if (edit->stack_disable)
1017 return;
1018
1019 #ifdef FAST_MOVE_CURSOR
1020 if (c == CURS_LEFT_LOTS || c == CURS_RIGHT_LOTS) {
1021 va_list ap;
1022 edit->undo_stack[sp] = c == CURS_LEFT_LOTS ? CURS_LEFT : CURS_RIGHT;
1023 edit->stack_pointer = (edit->stack_pointer + 1) & edit->stack_size_mask;
1024 va_start (ap, c);
1025 c = -(va_arg (ap, int));
1026 va_end (ap);
1027 } else
1028 #endif /* ! FAST_MOVE_CURSOR */
1029 if (edit->stack_bottom != sp
1030 && spm1 != edit->stack_bottom
1031 && ((sp - 2) & edit->stack_size_mask) != edit->stack_bottom) {
1032 int d;
1033 if (edit->undo_stack[spm1] < 0) {
1034 d = edit->undo_stack[(sp - 2) & edit->stack_size_mask];
1035 if (d == c) {
1036 if (edit->undo_stack[spm1] > -1000000000) {
1037 if (c < KEY_PRESS) /* --> no need to push multiple do-nothings */
1038 edit->undo_stack[spm1]--;
1039 return;
1040 }
1041 }
1042 /* #define NO_STACK_CURSMOVE_ANIHILATION */
1043 #ifndef NO_STACK_CURSMOVE_ANIHILATION
1044 else if ((c == CURS_LEFT && d == CURS_RIGHT)
1045 || (c == CURS_RIGHT && d == CURS_LEFT)) { /* a left then a right anihilate each other */
1046 if (edit->undo_stack[spm1] == -2)
1047 edit->stack_pointer = spm1;
1048 else
1049 edit->undo_stack[spm1]++;
1050 return;
1051 }
1052 #endif
1053 } else {
1054 d = edit->undo_stack[spm1];
1055 if (d == c) {
1056 if (c >= KEY_PRESS)
1057 return; /* --> no need to push multiple do-nothings */
1058 edit->undo_stack[sp] = -2;
1059 goto check_bottom;
1060 }
1061 #ifndef NO_STACK_CURSMOVE_ANIHILATION
1062 else if ((c == CURS_LEFT && d == CURS_RIGHT)
1063 || (c == CURS_RIGHT && d == CURS_LEFT)) { /* a left then a right anihilate each other */
1064 edit->stack_pointer = spm1;
1065 return;
1066 }
1067 #endif
1068 }
1069 }
1070 edit->undo_stack[sp] = c;
1071 check_bottom:
1072
1073 edit->stack_pointer = (edit->stack_pointer + 1) & edit->stack_size_mask;
1074
1075 /* if the sp wraps round and catches the stack_bottom then erase
1076 * the first set of actions on the stack to make space - by moving
1077 * stack_bottom forward one "key press" */
1078 c = (edit->stack_pointer + 2) & edit->stack_size_mask;
1079 if ((unsigned long) c == edit->stack_bottom ||
1080 (((unsigned long) c + 1) & edit->stack_size_mask) == edit->stack_bottom)
1081 do {
1082 edit->stack_bottom = (edit->stack_bottom + 1) & edit->stack_size_mask;
1083 } while (edit->undo_stack[edit->stack_bottom] < KEY_PRESS && edit->stack_bottom != edit->stack_pointer);
1084
1085 /*If a single key produced enough pushes to wrap all the way round then we would notice that the [stack_bottom] does not contain KEY_PRESS. The stack is then initialised: */
1086 if (edit->stack_pointer != edit->stack_bottom && edit->undo_stack[edit->stack_bottom] < KEY_PRESS)
1087 edit->stack_bottom = edit->stack_pointer = 0;
1088 }
1089
1090 /*
1091 TODO: if the user undos until the stack bottom, and the stack has not wrapped,
1092 then the file should be as it was when he loaded up. Then set edit->modified to 0.
1093 */
1094 static long
1095 pop_action (WEdit * edit)
1096 {
1097 long c;
1098 unsigned long sp = edit->stack_pointer;
1099 if (sp == edit->stack_bottom) {
1100 return STACK_BOTTOM;
1101 }
1102 sp = (sp - 1) & edit->stack_size_mask;
1103 if ((c = edit->undo_stack[sp]) >= 0) {
1104 /* edit->undo_stack[sp] = '@'; */
1105 edit->stack_pointer = (edit->stack_pointer - 1) & edit->stack_size_mask;
1106 return c;
1107 }
1108 if (sp == edit->stack_bottom) {
1109 return STACK_BOTTOM;
1110 }
1111 c = edit->undo_stack[(sp - 1) & edit->stack_size_mask];
1112 if (edit->undo_stack[sp] == -2) {
1113 /* edit->undo_stack[sp] = '@'; */
1114 edit->stack_pointer = sp;
1115 } else
1116 edit->undo_stack[sp]++;
1117
1118 return c;
1119 }
1120
1121 /* is called whenever a modification is made by one of the four routines below */
1122 static void edit_modification (WEdit * edit)
1123 {
1124 edit->caches_valid = 0;
1125 edit->screen_modified = 1;
1126
1127 /* raise lock when file modified */
1128 if (!edit->modified && !edit->delete_file)
1129 edit->locked = edit_lock_file (edit->filename);
1130 edit->modified = 1;
1131 }
1132
1133 /*
1134 Basic low level single character buffer alterations and movements at the cursor.
1135 Returns char passed over, inserted or removed.
1136 */
1137
1138 void
1139 edit_insert (WEdit *edit, int c)
1140 {
1141 /* check if file has grown to large */
1142 if (edit->last_byte >= SIZE_LIMIT)
1143 return;
1144
1145 /* first we must update the position of the display window */
1146 if (edit->curs1 < edit->start_display) {
1147 edit->start_display++;
1148 if (c == '\n')
1149 edit->start_line++;
1150 }
1151
1152 /* Mark file as modified, unless the file hasn't been fully loaded */
1153 if (edit->loading_done) {
1154 edit_modification (edit);
1155 }
1156
1157 /* now we must update some info on the file and check if a redraw is required */
1158 if (c == '\n') {
1159 if (edit->book_mark)
1160 book_mark_inc (edit, edit->curs_line);
1161 edit->curs_line++;
1162 edit->total_lines++;
1163 edit->force |= REDRAW_LINE_ABOVE | REDRAW_AFTER_CURSOR;
1164 }
1165
1166 /* save the reverse command onto the undo stack */
1167 edit_push_action (edit, BACKSPACE);
1168
1169 /* update markers */
1170 edit->mark1 += (edit->mark1 > edit->curs1);
1171 edit->mark2 += (edit->mark2 > edit->curs1);
1172 edit->last_get_rule += (edit->last_get_rule > edit->curs1);
1173
1174 /* add a new buffer if we've reached the end of the last one */
1175 if (!(edit->curs1 & M_EDIT_BUF_SIZE))
1176 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] =
1177 g_malloc (EDIT_BUF_SIZE);
1178
1179 /* perform the insertion */
1180 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE][edit->
1181 curs1 & M_EDIT_BUF_SIZE]
1182 = (unsigned char) c;
1183
1184 /* update file length */
1185 edit->last_byte++;
1186
1187 /* update cursor position */
1188 edit->curs1++;
1189 }
1190
1191 static void
1192 edit_insert_over (WEdit * edit)
1193 {
1194 int i;
1195
1196 for ( i = 0; i < edit->over_col; i++ ) {
1197 edit_insert (edit, ' ');
1198 }
1199 edit->over_col = 0;
1200 }
1201
1202 /* same as edit_insert and move left */
1203 void edit_insert_ahead (WEdit * edit, int c)
1204 {
1205 if (edit->last_byte >= SIZE_LIMIT)
1206 return;
1207 if (edit->curs1 < edit->start_display) {
1208 edit->start_display++;
1209 if (c == '\n')
1210 edit->start_line++;
1211 }
1212 edit_modification (edit);
1213 if (c == '\n') {
1214 if (edit->book_mark)
1215 book_mark_inc (edit, edit->curs_line);
1216 edit->total_lines++;
1217 edit->force |= REDRAW_AFTER_CURSOR;
1218 }
1219 edit_push_action (edit, DELCHAR);
1220
1221 edit->mark1 += (edit->mark1 >= edit->curs1);
1222 edit->mark2 += (edit->mark2 >= edit->curs1);
1223 edit->last_get_rule += (edit->last_get_rule >= edit->curs1);
1224
1225 if (!((edit->curs2 + 1) & M_EDIT_BUF_SIZE))
1226 edit->buffers2[(edit->curs2 + 1) >> S_EDIT_BUF_SIZE] = g_malloc (EDIT_BUF_SIZE);
1227 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE - (edit->curs2 & M_EDIT_BUF_SIZE) - 1] = c;
1228
1229 edit->last_byte++;
1230 edit->curs2++;
1231 }
1232
1233
1234 int edit_delete (WEdit * edit, const int byte_delete)
1235 {
1236 int p = 0;
1237 int cw = 1;
1238 int i;
1239
1240 if (!edit->curs2)
1241 return 0;
1242
1243 edit->mark1 -= (edit->mark1 > edit->curs1);
1244 edit->mark2 -= (edit->mark2 > edit->curs1);
1245 edit->last_get_rule -= (edit->last_get_rule > edit->curs1);
1246
1247 cw = 1;
1248 /* if byte_delete = 1 then delete only one byte not multibyte char*/
1249 if ( edit->utf8 && byte_delete == 0 ) {
1250 edit_get_utf (edit, edit->curs1, &cw);
1251 if ( cw < 1 )
1252 cw = 1;
1253 }
1254 for ( i = 1; i<= cw; i++ ) {
1255 p = edit->buffers2[(edit->curs2 - 1) >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE - ((edit->curs2 - 1) & M_EDIT_BUF_SIZE) - 1];
1256
1257 if (!(edit->curs2 & M_EDIT_BUF_SIZE)) {
1258 g_free (edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE]);
1259 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] = NULL;
1260 }
1261 edit->last_byte--;
1262 edit->curs2--;
1263 edit_push_action (edit, p + 256);
1264 }
1265
1266 edit_modification (edit);
1267 if (p == '\n') {
1268 if (edit->book_mark)
1269 book_mark_dec (edit, edit->curs_line);
1270 edit->total_lines--;
1271 edit->force |= REDRAW_AFTER_CURSOR;
1272 }
1273 if (edit->curs1 < edit->start_display) {
1274 edit->start_display--;
1275 if (p == '\n')
1276 edit->start_line--;
1277 }
1278
1279 return p;
1280 }
1281
1282
1283 static int
1284 edit_backspace (WEdit * edit, const int byte_delete)
1285 {
1286 int p = 0;
1287 int cw = 1;
1288 int i;
1289
1290 if (!edit->curs1)
1291 return 0;
1292
1293 edit->mark1 -= (edit->mark1 >= edit->curs1);
1294 edit->mark2 -= (edit->mark2 >= edit->curs1);
1295 edit->last_get_rule -= (edit->last_get_rule >= edit->curs1);
1296
1297 cw = 1;
1298 if ( edit->utf8 && byte_delete == 0 ) {
1299 edit_get_prev_utf (edit, edit->curs1, &cw);
1300 if ( cw < 1 )
1301 cw = 1;
1302 }
1303 for ( i = 1; i<= cw; i++ ) {
1304 p = *(edit->buffers1[(edit->curs1 - 1) >> S_EDIT_BUF_SIZE] + ((edit->curs1 - 1) & M_EDIT_BUF_SIZE));
1305 if (!((edit->curs1 - 1) & M_EDIT_BUF_SIZE)) {
1306 g_free (edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE]);
1307 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = NULL;
1308 }
1309 edit->last_byte--;
1310 edit->curs1--;
1311 edit_push_action (edit, p);
1312 }
1313 edit_modification (edit);
1314 if (p == '\n') {
1315 if (edit->book_mark)
1316 book_mark_dec (edit, edit->curs_line);
1317 edit->curs_line--;
1318 edit->total_lines--;
1319 edit->force |= REDRAW_AFTER_CURSOR;
1320 }
1321
1322 if (edit->curs1 < edit->start_display) {
1323 edit->start_display--;
1324 if (p == '\n')
1325 edit->start_line--;
1326 }
1327
1328 return p;
1329 }
1330
1331 #ifdef FAST_MOVE_CURSOR
1332
1333 static void memqcpy (WEdit * edit, unsigned char *dest, unsigned char *src, int n)
1334 {
1335 unsigned long next;
1336 while ((next = (unsigned long) memccpy (dest, src, '\n', n))) {
1337 edit->curs_line--;
1338 next -= (unsigned long) dest;
1339 n -= next;
1340 src += next;
1341 dest += next;
1342 }
1343 }
1344
1345 int
1346 edit_move_backward_lots (WEdit *edit, long increment)
1347 {
1348 int r, s, t;
1349 unsigned char *p;
1350
1351 if (increment > edit->curs1)
1352 increment = edit->curs1;
1353 if (increment <= 0)
1354 return -1;
1355 edit_push_action (edit, CURS_RIGHT_LOTS, increment);
1356
1357 t = r = EDIT_BUF_SIZE - (edit->curs2 & M_EDIT_BUF_SIZE);
1358 if (r > increment)
1359 r = increment;
1360 s = edit->curs1 & M_EDIT_BUF_SIZE;
1361
1362 p = 0;
1363 if (s > r) {
1364 memqcpy (edit,
1365 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] + t - r,
1366 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] + s - r,
1367 r);
1368 } else {
1369 if (s) {
1370 memqcpy (edit,
1371 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] + t -
1372 s, edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE], s);
1373 p = edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE];
1374 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = 0;
1375 }
1376 memqcpy (edit,
1377 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] + t - r,
1378 edit->buffers1[(edit->curs1 >> S_EDIT_BUF_SIZE) - 1] +
1379 EDIT_BUF_SIZE - (r - s), r - s);
1380 }
1381 increment -= r;
1382 edit->curs1 -= r;
1383 edit->curs2 += r;
1384 if (!(edit->curs2 & M_EDIT_BUF_SIZE)) {
1385 if (p)
1386 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] = p;
1387 else
1388 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] =
1389 g_malloc (EDIT_BUF_SIZE);
1390 } else {
1391 g_free (p);
1392 }
1393
1394 s = edit->curs1 & M_EDIT_BUF_SIZE;
1395 while (increment) {
1396 p = 0;
1397 r = EDIT_BUF_SIZE;
1398 if (r > increment)
1399 r = increment;
1400 t = s;
1401 if (r < t)
1402 t = r;
1403 memqcpy (edit,
1404 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] +
1405 EDIT_BUF_SIZE - t,
1406 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] + s - t,
1407 t);
1408 if (r >= s) {
1409 if (t) {
1410 p = edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE];
1411 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = 0;
1412 }
1413 memqcpy (edit,
1414 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] +
1415 EDIT_BUF_SIZE - r,
1416 edit->buffers1[(edit->curs1 >> S_EDIT_BUF_SIZE) - 1] +
1417 EDIT_BUF_SIZE - (r - s), r - s);
1418 }
1419 increment -= r;
1420 edit->curs1 -= r;
1421 edit->curs2 += r;
1422 if (!(edit->curs2 & M_EDIT_BUF_SIZE)) {
1423 if (p)
1424 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] = p;
1425 else
1426 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] =
1427 g_malloc (EDIT_BUF_SIZE);
1428 } else {
1429 g_free (p);
1430 }
1431 }
1432 return edit_get_byte (edit, edit->curs1);
1433 }
1434
1435 #endif /* ! FAST_MOVE_CURSOR */
1436
1437 /* moves the cursor right or left: increment positive or negative respectively */
1438 void edit_cursor_move (WEdit * edit, long increment)
1439 {
1440 /* this is the same as a combination of two of the above routines, with only one push onto the undo stack */
1441 int c;
1442 #ifdef FAST_MOVE_CURSOR
1443 if (increment < -256) {
1444 edit->force |= REDRAW_PAGE;
1445 edit_move_backward_lots (edit, -increment);
1446 return;
1447 }
1448 #endif /* ! FAST_MOVE_CURSOR */
1449
1450 if (increment < 0) {
1451 for (; increment < 0; increment++) {
1452 if (!edit->curs1)
1453 return;
1454
1455 edit_push_action (edit, CURS_RIGHT);
1456
1457 c = edit_get_byte (edit, edit->curs1 - 1);
1458 if (!((edit->curs2 + 1) & M_EDIT_BUF_SIZE))
1459 edit->buffers2[(edit->curs2 + 1) >> S_EDIT_BUF_SIZE] = g_malloc (EDIT_BUF_SIZE);
1460 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE - (edit->curs2 & M_EDIT_BUF_SIZE) - 1] = c;
1461 edit->curs2++;
1462 c = edit->buffers1[(edit->curs1 - 1) >> S_EDIT_BUF_SIZE][(edit->curs1 - 1) & M_EDIT_BUF_SIZE];
1463 if (!((edit->curs1 - 1) & M_EDIT_BUF_SIZE)) {
1464 g_free (edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE]);
1465 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = NULL;
1466 }
1467 edit->curs1--;
1468 if (c == '\n') {
1469 edit->curs_line--;
1470 edit->force |= REDRAW_LINE_BELOW;
1471 }
1472 }
1473
1474 } else if (increment > 0) {
1475 for (; increment > 0; increment--) {
1476 if (!edit->curs2)
1477 return;
1478
1479 edit_push_action (edit, CURS_LEFT);
1480
1481 c = edit_get_byte (edit, edit->curs1);
1482 if (!(edit->curs1 & M_EDIT_BUF_SIZE))
1483 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = g_malloc (EDIT_BUF_SIZE);
1484 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE][edit->curs1 & M_EDIT_BUF_SIZE] = c;
1485 edit->curs1++;
1486 c = edit->buffers2[(edit->curs2 - 1) >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE - ((edit->curs2 - 1) & M_EDIT_BUF_SIZE) - 1];
1487 if (!(edit->curs2 & M_EDIT_BUF_SIZE)) {
1488 g_free (edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE]);
1489 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] = 0;
1490 }
1491 edit->curs2--;
1492 if (c == '\n') {
1493 edit->curs_line++;
1494 edit->force |= REDRAW_LINE_ABOVE;
1495 }
1496 }
1497 }
1498 }
1499
1500 /* These functions return positions relative to lines */
1501
1502 /* returns index of last char on line + 1 */
1503 long edit_eol (WEdit * edit, long current)
1504 {
1505 if (current < edit->last_byte) {
1506 for (;; current++)
1507 if (edit_get_byte (edit, current) == '\n')
1508 break;
1509 } else
1510 return edit->last_byte;
1511 return current;
1512 }
1513
1514 /* returns index of first char on line */
1515 long edit_bol (WEdit * edit, long current)
1516 {
1517 if (current > 0) {
1518 for (;; current--)
1519 if (edit_get_byte (edit, current - 1) == '\n')
1520 break;
1521 } else
1522 return 0;
1523 return current;
1524 }
1525
1526
1527 int edit_count_lines (WEdit * edit, long current, int upto)
1528 {
1529 int lines = 0;
1530 if (upto > edit->last_byte)
1531 upto = edit->last_byte;
1532 if (current < 0)
1533 current = 0;
1534 while (current < upto)
1535 if (edit_get_byte (edit, current++) == '\n')
1536 lines++;
1537 return lines;
1538 }
1539
1540
1541 /* If lines is zero this returns the count of lines from current to upto. */
1542 /* If upto is zero returns index of lines forward current. */
1543 long edit_move_forward (WEdit * edit, long current, int lines, long upto)
1544 {
1545 if (upto) {
1546 return edit_count_lines (edit, current, upto);
1547 } else {
1548 int next;
1549 if (lines < 0)
1550 lines = 0;
1551 while (lines--) {
1552 next = edit_eol (edit, current) + 1;
1553 if (next > edit->last_byte)
1554 break;
1555 else
1556 current = next;
1557 }
1558 return current;
1559 }
1560 }
1561
1562
1563 /* Returns offset of 'lines' lines up from current */
1564 long edit_move_backward (WEdit * edit, long current, int lines)
1565 {
1566 if (lines < 0)
1567 lines = 0;
1568 current = edit_bol (edit, current);
1569 while((lines--) && current != 0)
1570 current = edit_bol (edit, current - 1);
1571 return current;
1572 }
1573
1574 /* If cols is zero this returns the count of columns from current to upto. */
1575 /* If upto is zero returns index of cols across from current. */
1576 long edit_move_forward3 (WEdit * edit, long current, int cols, long upto)
1577 {
1578 long p, q;
1579 int col = 0;
1580 #ifdef HAVE_CHARSET
1581 int cw = 1;
1582 int utf_ch = 0;
1583 #endif
1584 if (upto) {
1585 q = upto;
1586 cols = -10;
1587 } else
1588 q = edit->last_byte + 2;
1589 for (col = 0, p = current; p < q; p++) {
1590 int c;
1591 #ifdef HAVE_CHARSET
1592 cw = 1;
1593 utf_ch = 0;
1594 #endif
1595 if (cols != -10) {
1596 if (col == cols)
1597 return p;
1598 if (col > cols)
1599 return p - 1;
1600 }
1601 c = edit_get_byte (edit, p);
1602 #ifdef HAVE_CHARSET
1603 if (edit->utf8) {
1604 utf_ch = edit_get_utf (edit, p, &cw);
1605 if (utf8_display && g_unichar_iswide(utf_ch))
1606 col++;
1607 }
1608 #endif
1609 c = convert_to_display_c (c);
1610 if (c == '\t')
1611 col += TAB_SIZE - col % TAB_SIZE;
1612 else if (c == '\n') {
1613 if (upto)
1614 return col;
1615 else
1616 return p;
1617 } else if (c < 32 || c == 127)
1618 /* '\r' is shown as ^M, so we must advance 2 characters */
1619 /* Caret notation for control characters */
1620 col += 2;
1621 else
1622 col++;
1623 #ifdef HAVE_CHARSET
1624 if (cw > 1)
1625 col -= cw - 1;
1626 #endif
1627 }
1628 return col;
1629 }
1630
1631 /* returns the current column position of the cursor */
1632 int edit_get_col (WEdit * edit)
1633 {
1634 return edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0, edit->curs1);
1635 }
1636
1637
1638 /* Scrolling functions */
1639
1640 void edit_update_curs_row (WEdit * edit)
1641 {
1642 edit->curs_row = edit->curs_line - edit->start_line;
1643 }
1644
1645 void edit_update_curs_col (WEdit * edit)
1646 {
1647 edit->curs_col = edit_move_forward3(edit, edit_bol(edit, edit->curs1), 0, edit->curs1);
1648 }
1649
1650 int
1651 edit_get_curs_col (const WEdit *edit)
1652 {
1653 return edit->curs_col;
1654 }
1655
1656 /*moves the display start position up by i lines */
1657 void edit_scroll_upward (WEdit * edit, unsigned long i)
1658 {
1659 unsigned long lines_above = edit->start_line;
1660 if (i > lines_above)
1661 i = lines_above;
1662 if (i) {
1663 edit->start_line -= i;
1664 edit->start_display = edit_move_backward (edit, edit->start_display, i);
1665 edit->force |= REDRAW_PAGE;
1666 edit->force &= (0xfff - REDRAW_CHAR_ONLY);
1667 }
1668 edit_update_curs_row (edit);
1669 }
1670
1671
1672 /* returns 1 if could scroll, 0 otherwise */
1673 void edit_scroll_downward (WEdit * edit, int i)
1674 {
1675 int lines_below;
1676 lines_below = edit->total_lines - edit->start_line - (edit->num_widget_lines - 1);
1677 if (lines_below > 0) {
1678 if (i > lines_below)
1679 i = lines_below;
1680 edit->start_line += i;
1681 edit->start_display = edit_move_forward (edit, edit->start_display, i, 0);
1682 edit->force |= REDRAW_PAGE;
1683 edit->force &= (0xfff - REDRAW_CHAR_ONLY);
1684 }
1685 edit_update_curs_row (edit);
1686 }
1687
1688 void edit_scroll_right (WEdit * edit, int i)
1689 {
1690 edit->force |= REDRAW_PAGE;
1691 edit->force &= (0xfff - REDRAW_CHAR_ONLY);
1692 edit->start_col -= i;
1693 }
1694
1695 void edit_scroll_left (WEdit * edit, int i)
1696 {
1697 if (edit->start_col) {
1698 edit->start_col += i;
1699 if (edit->start_col > 0)
1700 edit->start_col = 0;
1701 edit->force |= REDRAW_PAGE;
1702 edit->force &= (0xfff - REDRAW_CHAR_ONLY);
1703 }
1704 }
1705
1706 /* high level cursor movement commands */
1707
1708 static int is_in_indent (WEdit *edit)
1709 {
1710 long p = edit_bol (edit, edit->curs1);
1711 while (p < edit->curs1)
1712 if (!strchr (" \t", edit_get_byte (edit, p++)))
1713 return 0;
1714 return 1;
1715 }
1716
1717 static int left_of_four_spaces (WEdit *edit);
1718
1719 void
1720 edit_move_to_prev_col (WEdit * edit, long p)
1721 {
1722 int prev = edit->prev_col;
1723 int over = edit->over_col;
1724 edit_cursor_move (edit, edit_move_forward3 (edit, p, prev + edit->over_col, 0) - edit->curs1);
1725
1726 if (option_cursor_beyond_eol) {
1727 long line_len = edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0, edit_eol(edit, edit->curs1));
1728
1729 if (line_len < prev + edit->over_col) {
1730 edit->over_col = prev + over - line_len;
1731 edit->prev_col = line_len;
1732 edit->curs_col = line_len;
1733 } else {
1734 edit->curs_col = prev + over;
1735 edit->prev_col = edit->curs_col;
1736 edit->over_col = 0;
1737 }
1738 } else {
1739 edit->over_col = 0;
1740 if (is_in_indent (edit) && option_fake_half_tabs) {
1741 edit_update_curs_col (edit);
1742 if (space_width)
1743 if (edit->curs_col % (HALF_TAB_SIZE * space_width)) {
1744 int q = edit->curs_col;
1745 edit->curs_col -= (edit->curs_col % (HALF_TAB_SIZE * space_width));
1746 p = edit_bol (edit, edit->curs1);
1747 edit_cursor_move (edit, edit_move_forward3 (edit, p, edit->curs_col, 0) - edit->curs1);
1748 if (!left_of_four_spaces (edit))
1749 edit_cursor_move (edit, edit_move_forward3 (edit, p, q, 0) - edit->curs1);
1750 }
1751 }
1752 }
1753 }
1754
1755 /* move i lines */
1756 void edit_move_up (WEdit * edit, unsigned long i, int scroll)
1757 {
1758 unsigned long p, l = edit->curs_line;
1759
1760 if (i > l)
1761 i = l;
1762 if (i) {
1763 if (i > 1)
1764 edit->force |= REDRAW_PAGE;
1765 if (scroll)
1766 edit_scroll_upward (edit, i);
1767
1768 p = edit_bol (edit, edit->curs1);
1769 edit_cursor_move (edit, (p = edit_move_backward (edit, p, i)) - edit->curs1);
1770 edit_move_to_prev_col (edit, p);
1771
1772 edit->search_start = edit->curs1;
1773 edit->found_len = 0;
1774 }
1775 }
1776
1777 static int
1778 is_blank (WEdit *edit, long offset)
1779 {
1780 long s, f;
1781 int c;
1782 s = edit_bol (edit, offset);
1783 f = edit_eol (edit, offset) - 1;
1784 while (s <= f) {
1785 c = edit_get_byte (edit, s++);
1786 if (!isspace (c))
1787 return 0;
1788 }
1789 return 1;
1790 }
1791
1792
1793 /* returns the offset of line i */
1794 static long
1795 edit_find_line (WEdit *edit, int line)
1796 {
1797 int i, j = 0;
1798 int m = 2000000000;
1799 if (!edit->caches_valid) {
1800 for (i = 0; i < N_LINE_CACHES; i++)
1801 edit->line_numbers[i] = edit->line_offsets[i] = 0;
1802 /* three offsets that we *know* are line 0 at 0 and these two: */
1803 edit->line_numbers[1] = edit->curs_line;
1804 edit->line_offsets[1] = edit_bol (edit, edit->curs1);
1805 edit->line_numbers[2] = edit->total_lines;
1806 edit->line_offsets[2] = edit_bol (edit, edit->last_byte);
1807 edit->caches_valid = 1;
1808 }
1809 if (line >= edit->total_lines)
1810 return edit->line_offsets[2];
1811 if (line <= 0)
1812 return 0;
1813 /* find the closest known point */
1814 for (i = 0; i < N_LINE_CACHES; i++) {
1815 int n;
1816 n = abs (edit->line_numbers[i] - line);
1817 if (n < m) {
1818 m = n;
1819 j = i;
1820 }
1821 }
1822 if (m == 0)
1823 return edit->line_offsets[j]; /* know the offset exactly */
1824 if (m == 1 && j >= 3)
1825 i = j; /* one line different - caller might be looping, so stay in this cache */
1826 else
1827 i = 3 + (rand () % (N_LINE_CACHES - 3));
1828 if (line > edit->line_numbers[j])
1829 edit->line_offsets[i] = edit_move_forward (edit, edit->line_offsets[j], line - edit->line_numbers[j], 0);
1830 else
1831 edit->line_offsets[i] = edit_move_backward (edit, edit->line_offsets[j], edit->line_numbers[j] - line);
1832 edit->line_numbers[i] = line;
1833 return edit->line_offsets[i];
1834 }
1835
1836 int line_is_blank (WEdit * edit, long line)
1837 {
1838 return is_blank (edit, edit_find_line (edit, line));
1839 }
1840
1841 /* moves up until a blank line is reached, or until just
1842 before a non-blank line is reached */
1843 static void edit_move_up_paragraph (WEdit * edit, int scroll)
1844 {
1845 int i;
1846 if (edit->curs_line <= 1) {
1847 i = 0;
1848 } else {
1849 if (line_is_blank (edit, edit->curs_line)) {
1850 if (line_is_blank (edit, edit->curs_line - 1)) {
1851 for (i = edit->curs_line - 1; i; i--)
1852 if (!line_is_blank (edit, i)) {
1853 i++;
1854 break;
1855 }
1856 } else {
1857 for (i = edit->curs_line - 1; i; i--)
1858 if (line_is_blank (edit, i))
1859 break;
1860 }
1861 } else {
1862 for (i = edit->curs_line - 1; i; i--)
1863 if (line_is_blank (edit, i))
1864 break;
1865 }
1866 }
1867 edit_move_up (edit, edit->curs_line - i, scroll);
1868 }
1869
1870 /* move i lines */
1871 void edit_move_down (WEdit * edit, int i, int scroll)
1872 {
1873 long p, l = edit->total_lines - edit->curs_line;
1874 if (i > l)
1875 i = l;
1876 if (i) {
1877 if (i > 1)
1878 edit->force |= REDRAW_PAGE;
1879 if (scroll)
1880 edit_scroll_downward (edit, i);
1881 p = edit_bol (edit, edit->curs1);
1882 edit_cursor_move (edit, (p = edit_move_forward (edit, p, i, 0)) - edit->curs1);
1883 edit_move_to_prev_col (edit, p);
1884
1885 edit->search_start = edit->curs1;
1886 edit->found_len = 0;
1887 }
1888 }
1889
1890 /* moves down until a blank line is reached, or until just
1891 before a non-blank line is reached */
1892 static void edit_move_down_paragraph (WEdit * edit, int scroll)
1893 {
1894 int i;
1895 if (edit->curs_line >= edit->total_lines - 1) {
1896 i = edit->total_lines;
1897 } else {
1898 if (line_is_blank (edit, edit->curs_line)) {
1899 if (line_is_blank (edit, edit->curs_line + 1)) {
1900 for (i = edit->curs_line + 1; i; i++)
1901 if (!line_is_blank (edit, i) || i > edit->total_lines) {
1902 i--;
1903 break;
1904 }
1905 } else {
1906 for (i = edit->curs_line + 1; i; i++)
1907 if (line_is_blank (edit, i) || i >= edit->total_lines)
1908 break;
1909 }
1910 } else {
1911 for (i = edit->curs_line + 1; i; i++)
1912 if (line_is_blank (edit, i) || i >= edit->total_lines)
1913 break;
1914 }
1915 }
1916 edit_move_down (edit, i - edit->curs_line, scroll);
1917 }
1918
1919 static void edit_begin_page (WEdit *edit)
1920 {
1921 edit_update_curs_row (edit);
1922 edit_move_up (edit, edit->curs_row, 0);
1923 }
1924
1925 static void edit_end_page (WEdit *edit)
1926 {
1927 edit_update_curs_row (edit);
1928 edit_move_down (edit, edit->num_widget_lines - edit->curs_row - 1, 0);
1929 }
1930
1931
1932 /* goto beginning of text */
1933 static void edit_move_to_top (WEdit * edit)
1934 {
1935 if (edit->curs_line) {
1936 edit_cursor_move (edit, -edit->curs1);
1937 edit_move_to_prev_col (edit, 0);
1938 edit->force |= REDRAW_PAGE;
1939 edit->search_start = 0;
1940 edit_update_curs_row(edit);
1941 }
1942 }
1943
1944
1945 /* goto end of text */
1946 static void edit_move_to_bottom (WEdit * edit)
1947 {
1948 if (edit->curs_line < edit->total_lines) {
1949 edit_cursor_move (edit, edit->curs2);
1950 edit->start_display = edit->last_byte;
1951 edit->start_line = edit->total_lines;
1952 edit_update_curs_row(edit);
1953 edit_scroll_upward (edit, edit->num_widget_lines - 1);
1954 edit->force |= REDRAW_PAGE;
1955 }
1956 }
1957
1958 /* goto beginning of line */
1959 static void edit_cursor_to_bol (WEdit * edit)
1960 {
1961 edit_cursor_move (edit, edit_bol (edit, edit->curs1) - edit->curs1);
1962 edit->search_start = edit->curs1;
1963 edit->prev_col = edit_get_col (edit);
1964 edit->over_col = 0;
1965 }
1966
1967 /* goto end of line */
1968 static void edit_cursor_to_eol (WEdit * edit)
1969 {
1970 edit_cursor_move (edit, edit_eol (edit, edit->curs1) - edit->curs1);
1971 edit->search_start = edit->curs1;
1972 edit->prev_col = edit_get_col (edit);
1973 edit->over_col = 0;
1974 }
1975
1976 /* move cursor to line 'line' */
1977 void edit_move_to_line (WEdit * e, long line)
1978 {
1979 if(line < e->curs_line)
1980 edit_move_up (e, e->curs_line - line, 0);
1981 else
1982 edit_move_down (e, line - e->curs_line, 0);
1983 edit_scroll_screen_over_cursor (e);
1984 }
1985
1986 /* scroll window so that first visible line is 'line' */
1987 void edit_move_display (WEdit * e, long line)
1988 {
1989 if(line < e->start_line)
1990 edit_scroll_upward (e, e->start_line - line);
1991 else
1992 edit_scroll_downward (e, line - e->start_line);
1993 }
1994
1995 /* save markers onto undo stack */
1996 void edit_push_markers (WEdit * edit)
1997 {
1998 edit_push_action (edit, MARK_1 + edit->mark1);
1999 edit_push_action (edit, MARK_2 + edit->mark2);
2000 }
2001
2002 void edit_set_markers (WEdit * edit, long m1, long m2, int c1, int c2)
2003 {
2004 edit->mark1 = m1;
2005 edit->mark2 = m2;
2006 edit->column1 = c1;
2007 edit->column2 = c2;
2008 }
2009
2010
2011 /* highlight marker toggle */
2012 void edit_mark_cmd (WEdit * edit, int unmark)
2013 {
2014 edit_push_markers (edit);
2015 if (unmark) {
2016 edit_set_markers (edit, 0, 0, 0, 0);
2017 edit->force |= REDRAW_PAGE;
2018 } else {
2019 if (edit->mark2 >= 0) {
2020 edit_set_markers (edit, edit->curs1, -1, edit->curs_col+edit->over_col, edit->curs_col+edit->over_col);
2021 edit->force |= REDRAW_PAGE;
2022 } else
2023 edit_set_markers (edit, edit->mark1, edit->curs1, edit->column1, edit->curs_col+edit->over_col);
2024 }
2025 }
2026
2027 static unsigned long
2028 my_type_of (int c)
2029 {
2030 int x, r = 0;
2031 const char *p, *q;
2032 const char option_chars_move_whole_word[] =
2033 "!=&|<>^~ !:;, !'!`!.?!\"!( !) !Aa0 !+-*/= |<> ![ !] !\\#! ";
2034
2035 if (!c)
2036 return 0;
2037 if (c == '!') {
2038 if (*option_chars_move_whole_word == '!')
2039 return 2;
2040 return 0x80000000UL;
2041 }
2042 if (g_ascii_isupper ((gchar) c))
2043 c = 'A';
2044 else if (g_ascii_islower ((gchar) c))
2045 c = 'a';
2046 else if (g_ascii_isalpha (c))
2047 c = 'a';
2048 else if (isdigit (c))
2049 c = '0';
2050 else if (isspace (c))
2051 c = ' ';
2052 q = strchr (option_chars_move_whole_word, c);
2053 if (!q)
2054 return 0xFFFFFFFFUL;
2055 do {
2056 for (x = 1, p = option_chars_move_whole_word; p < q; p++)
2057 if (*p == '!')
2058 x <<= 1;
2059 r |= x;
2060 } while ((q = strchr (q + 1, c)));
2061 return r;
2062 }
2063
2064 static void
2065 edit_left_word_move (WEdit *edit, int s)
2066 {
2067 for (;;) {
2068 int c1, c2;
2069 if (column_highlighting
2070 && edit->mark1 != edit->mark2
2071 && edit->over_col == 0
2072 && edit->curs1 == edit_bol(edit, edit->curs1))
2073 break;
2074 edit_cursor_move (edit, -1);
2075 if (!edit->curs1)
2076 break;
2077 c1 = edit_get_byte (edit, edit->curs1 - 1);
2078 c2 = edit_get_byte (edit, edit->curs1);
2079 if (!(my_type_of (c1) & my_type_of (c2)))
2080 break;
2081 if (isspace (c1) && !isspace (c2))
2082 break;
2083 if (s)
2084 if (!isspace (c1) && isspace (c2))
2085 break;
2086 }
2087 }
2088
2089 static void edit_left_word_move_cmd (WEdit * edit)
2090 {
2091 edit_left_word_move (edit, 0);
2092 edit->force |= REDRAW_PAGE;
2093 }
2094
2095 static void
2096 edit_right_word_move (WEdit *edit, int s)
2097 {
2098 for (;;) {
2099 int c1, c2;
2100 if (column_highlighting
2101 && edit->mark1 != edit->mark2
2102 && edit->over_col == 0
2103 && edit->curs1 == edit_eol(edit, edit->curs1)
2104 )
2105 break;
2106 edit_cursor_move (edit, 1);
2107 if (edit->curs1 >= edit->last_byte)
2108 break;
2109 c1 = edit_get_byte (edit, edit->curs1 - 1);
2110 c2 = edit_get_byte (edit, edit->curs1);
2111 if (!(my_type_of (c1) & my_type_of (c2)))
2112 break;
2113 if (isspace (c1) && !isspace (c2))
2114 break;
2115 if (s)
2116 if (!isspace (c1) && isspace (c2))
2117 break;
2118 }
2119 }
2120
2121 static void edit_right_word_move_cmd (WEdit * edit)
2122 {
2123 edit_right_word_move (edit, 0);
2124 edit->force |= REDRAW_PAGE;
2125 }
2126
2127 static void edit_right_char_move_cmd (WEdit * edit)
2128 {
2129 int cw = 1;
2130 int c = 0;
2131 if ( edit->utf8 ) {
2132 c = edit_get_utf (edit, edit->curs1, &cw);
2133 if ( cw < 1 )
2134 cw = 1;
2135 } else {
2136 c = edit_get_byte (edit, edit->curs1);
2137 }
2138 if (option_cursor_beyond_eol && c == '\n') {
2139 edit->over_col++;
2140 } else {
2141 edit_cursor_move (edit, cw);
2142 }
2143 }
2144
2145 static void edit_left_char_move_cmd (WEdit * edit)
2146 {
2147 int cw = 1;
2148 if (column_highlighting
2149 && edit->mark1 != edit->mark2
2150 && edit->over_col == 0
2151 && edit->curs1 == edit_bol(edit, edit->curs1))
2152 return;
2153 if ( edit->utf8 ) {
2154 edit_get_prev_utf (edit, edit->curs1, &cw);
2155 if ( cw < 1 )
2156 cw = 1;
2157 }
2158 if (option_cursor_beyond_eol && edit->over_col > 0) {
2159 edit->over_col--;
2160 } else {
2161 edit_cursor_move (edit, -cw);
2162 }
2163 }
2164
2165 static void edit_right_delete_word (WEdit * edit)
2166 {
2167 int c1, c2;
2168 for (;;) {
2169 if (edit->curs1 >= edit->last_byte)
2170 break;
2171 c1 = edit_delete (edit, 1);
2172 c2 = edit_get_byte (edit, edit->curs1);
2173 if ((isspace (c1) == 0) != (isspace (c2) == 0))
2174 break;
2175 if (!(my_type_of (c1) & my_type_of (c2)))
2176 break;
2177 }
2178 }
2179
2180 static void edit_left_delete_word (WEdit * edit)
2181 {
2182 int c1, c2;
2183 for (;;) {
2184 if (edit->curs1 <= 0)
2185 break;
2186 c1 = edit_backspace (edit, 1);
2187 c2 = edit_get_byte (edit, edit->curs1 - 1);
2188 if ((isspace (c1) == 0) != (isspace (c2) == 0))
2189 break;
2190 if (!(my_type_of (c1) & my_type_of (c2)))
2191 break;
2192 }
2193 }
2194
2195 /*
2196 the start column position is not recorded, and hence does not
2197 undo as it happed. But who would notice.
2198 */
2199 static void
2200 edit_do_undo (WEdit * edit)
2201 {
2202 long ac;
2203 long count = 0;
2204
2205 edit->stack_disable = 1; /* don't record undo's onto undo stack! */
2206 edit->over_col = 0;
2207 while ((ac = pop_action (edit)) < KEY_PRESS) {
2208 switch ((int) ac) {
2209 case STACK_BOTTOM:
2210 goto done_undo;
2211 case CURS_RIGHT:
2212 edit_cursor_move (edit, 1);
2213 break;
2214 case CURS_LEFT:
2215 edit_cursor_move (edit, -1);
2216 break;
2217 case BACKSPACE:
2218 edit_backspace (edit, 1);
2219 break;
2220 case DELCHAR:
2221 edit_delete (edit, 1);
2222 break;
2223 case COLUMN_ON:
2224 column_highlighting = 1;
2225 break;
2226 case COLUMN_OFF:
2227 column_highlighting = 0;
2228 break;
2229 }
2230 if (ac >= 256 && ac < 512)
2231 edit_insert_ahead (edit, ac - 256);
2232 if (ac >= 0 && ac < 256)
2233 edit_insert (edit, ac);
2234
2235 if (ac >= MARK_1 - 2 && ac < MARK_2 - 2) {
2236 edit->mark1 = ac - MARK_1;
2237 edit->column1 = edit_move_forward3 (edit, edit_bol (edit, edit->mark1), 0, edit->mark1);
2238 } else if (ac >= MARK_2 - 2 && ac < KEY_PRESS) {
2239 edit->mark2 = ac - MARK_2;
2240 edit->column2 = edit_move_forward3 (edit, edit_bol (edit, edit->mark2), 0, edit->mark2);
2241 }
2242 if (count++)
2243 edit->force |= REDRAW_PAGE; /* more than one pop usually means something big */
2244 }
2245
2246 if (edit->start_display > ac - KEY_PRESS) {
2247 edit->start_line -= edit_count_lines (edit, ac - KEY_PRESS, edit->start_display);
2248 edit->force |= REDRAW_PAGE;
2249 } else if (edit->start_display < ac - KEY_PRESS) {
2250 edit->start_line += edit_count_lines (edit, edit->start_display, ac - KEY_PRESS);
2251 edit->force |= REDRAW_PAGE;
2252 }
2253 edit->start_display = ac - KEY_PRESS; /* see push and pop above */
2254 edit_update_curs_row (edit);
2255
2256 done_undo:;
2257 edit->stack_disable = 0;
2258 }
2259
2260 static void edit_delete_to_line_end (WEdit * edit)
2261 {
2262 while (edit_get_byte (edit, edit->curs1) != '\n') {
2263 if (!edit->curs2)
2264 break;
2265 edit_delete (edit, 1);
2266 }
2267 }
2268
2269 static void edit_delete_to_line_begin (WEdit * edit)
2270 {
2271 while (edit_get_byte (edit, edit->curs1 - 1) != '\n') {
2272 if (!edit->curs1)
2273 break;
2274 edit_backspace (edit, 1);
2275 }
2276 }
2277
2278 void
2279 edit_delete_line (WEdit *edit)
2280 {
2281 /*
2282 * Delete right part of the line.
2283 * Note that edit_get_byte() returns '\n' when byte position is
2284 * beyond EOF.
2285 */
2286 while (edit_get_byte (edit, edit->curs1) != '\n') {
2287 (void) edit_delete (edit, 1);
2288 }
2289
2290 /*
2291 * Delete '\n' char.
2292 * Note that edit_delete() will not corrupt anything if called while
2293 * cursor position is EOF.
2294 */
2295 (void) edit_delete (edit, 1);
2296
2297 /*
2298 * Delete left part of the line.
2299 * Note, that edit_get_byte() returns '\n' when byte position is < 0.
2300 */
2301 while (edit_get_byte (edit, edit->curs1 - 1) != '\n') {
2302 (void) edit_backspace (edit, 1);
2303 };
2304 }
2305
2306 void insert_spaces_tab (WEdit * edit, int half)
2307 {
2308 int i;
2309 edit_update_curs_col (edit);
2310 i = ((edit->curs_col / (option_tab_spacing * space_width / (half + 1))) + 1) * (option_tab_spacing * space_width / (half + 1)) - edit->curs_col;
2311 while (i > 0) {
2312 edit_insert (edit, ' ');
2313 i -= space_width;
2314 }
2315 }
2316
2317 static int is_aligned_on_a_tab (WEdit * edit)
2318 {
2319 edit_update_curs_col (edit);
2320 if ((edit->curs_col % (TAB_SIZE * space_width)) && edit->curs_col % (TAB_SIZE * space_width) != (HALF_TAB_SIZE * space_width))
2321 return 0; /* not alligned on a tab */
2322 return 1;
2323 }
2324
2325 static int right_of_four_spaces (WEdit *edit)
2326 {
2327 int i, ch = 0;
2328 for (i = 1; i <= HALF_TAB_SIZE; i++)
2329 ch |= edit_get_byte (edit, edit->curs1 - i);
2330 if (ch == ' ')
2331 return is_aligned_on_a_tab (edit);
2332 return 0;
2333 }
2334
2335 static int left_of_four_spaces (WEdit *edit)
2336 {
2337 int i, ch = 0;
2338 for (i = 0; i < HALF_TAB_SIZE; i++)
2339 ch |= edit_get_byte (edit, edit->curs1 + i);
2340 if (ch == ' ')
2341 return is_aligned_on_a_tab (edit);
2342 return 0;
2343 }
2344
2345 int edit_indent_width (WEdit * edit, long p)
2346 {
2347 long q = p;
2348 while (strchr ("\t ", edit_get_byte (edit, q)) && q < edit->last_byte - 1) /* move to the end of the leading whitespace of the line */
2349 q++;
2350 return edit_move_forward3 (edit, p, 0, q); /* count the number of columns of indentation */
2351 }
2352
2353 void edit_insert_indent (WEdit * edit, int indent)
2354 {
2355 if (!option_fill_tabs_with_spaces) {
2356 while (indent >= TAB_SIZE) {
2357 edit_insert (edit, '\t');
2358 indent -= TAB_SIZE;
2359 }
2360 }
2361 while (indent-- > 0)
2362 edit_insert (edit, ' ');
2363 }
2364
2365 static void
2366 edit_auto_indent (WEdit * edit)
2367 {
2368 long p;
2369 char c;
2370 p = edit->curs1;
2371 /* use the previous line as a template */
2372 p = edit_move_backward (edit, p, 1);
2373 /* copy the leading whitespace of the line */
2374 for (;;) { /* no range check - the line _is_ \n-terminated */
2375 c = edit_get_byte (edit, p++);
2376 if (c != ' ' && c != '\t')
2377 break;
2378 edit_insert (edit, c);
2379 }
2380 }
2381
2382 static void edit_double_newline (WEdit * edit)
2383 {
2384 edit_insert (edit, '\n');
2385 if (edit_get_byte (edit, edit->curs1) == '\n')
2386 return;
2387 if (edit_get_byte (edit, edit->curs1 - 2) == '\n')
2388 return;
2389 edit->force |= REDRAW_PAGE;
2390 edit_insert (edit, '\n');
2391 }
2392
2393 static void edit_tab_cmd (WEdit * edit)
2394 {
2395 int i;
2396
2397 if (option_fake_half_tabs) {
2398 if (is_in_indent (edit)) {
2399 /*insert a half tab (usually four spaces) unless there is a
2400 half tab already behind, then delete it and insert a
2401 full tab. */
2402 if (!option_fill_tabs_with_spaces && right_of_four_spaces (edit)) {
2403 for (i = 1; i <= HALF_TAB_SIZE; i++)
2404 edit_backspace (edit, 1);
2405 edit_insert (edit, '\t');
2406 } else {
2407 insert_spaces_tab (edit, 1);
2408 }
2409 return;
2410 }
2411 }
2412 if (option_fill_tabs_with_spaces) {
2413 insert_spaces_tab (edit, 0);
2414 } else {
2415 edit_insert (edit, '\t');
2416 }
2417 return;
2418 }
2419
2420 static void check_and_wrap_line (WEdit * edit)
2421 {
2422 int curs, c;
2423 if (!option_typewriter_wrap)
2424 return;
2425 edit_update_curs_col (edit);
2426 if (edit->curs_col < option_word_wrap_line_length)
2427 return;
2428 curs = edit->curs1;
2429 for (;;) {
2430 curs--;
2431 c = edit_get_byte (edit, curs);
2432 if (c == '\n' || curs <= 0) {
2433 edit_insert (edit, '\n');
2434 return;
2435 }
2436 if (c == ' ' || c == '\t') {
2437 int current = edit->curs1;
2438 edit_cursor_move (edit, curs - edit->curs1 + 1);
2439 edit_insert (edit, '\n');
2440 edit_cursor_move (edit, current - edit->curs1 + 1);
2441 return;
2442 }
2443 }
2444 }
2445
2446 static void edit_execute_macro (WEdit *edit, struct macro macro[], int n);
2447
2448 void edit_push_key_press (WEdit * edit)
2449 {
2450 edit_push_action (edit, KEY_PRESS + edit->start_display);
2451 if (edit->mark2 == -1)
2452 edit_push_action (edit, MARK_1 + edit->mark1);
2453 }
2454
2455 /* this find the matching bracket in either direction, and sets edit->bracket */
2456 static long edit_get_bracket (WEdit * edit, int in_screen, unsigned long furthest_bracket_search)
2457 {
2458 const char * const b = "{}{[][()(", *p;
2459 int i = 1, a, inc = -1, c, d, n = 0;
2460 unsigned long j = 0;
2461 long q;
2462 edit_update_curs_row (edit);
2463 c = edit_get_byte (edit, edit->curs1);
2464 p = strchr (b, c);
2465 /* no limit */
2466 if (!furthest_bracket_search)
2467 furthest_bracket_search--;
2468 /* not on a bracket at all */
2469 if (!p)
2470 return -1;
2471 /* the matching bracket */
2472 d = p[1];
2473 /* going left or right? */
2474 if (strchr ("{[(", c))
2475 inc = 1;
2476 for (q = edit->curs1 + inc;; q += inc) {
2477 /* out of buffer? */
2478 if (q >= edit->last_byte || q < 0)
2479 break;
2480 a = edit_get_byte (edit, q);
2481 /* don't want to eat CPU */
2482 if (j++ > furthest_bracket_search)
2483 break;
2484 /* out of screen? */
2485 if (in_screen) {
2486 if (q < edit->start_display)
2487 break;
2488 /* count lines if searching downward */
2489 if (inc > 0 && a == '\n')
2490 if (n++ >= edit->num_widget_lines - edit->curs_row) /* out of screen */
2491 break;
2492 }
2493 /* count bracket depth */
2494 i += (a == c) - (a == d);
2495 /* return if bracket depth is zero */
2496 if (!i)
2497 return q;
2498 }
2499 /* no match */
2500 return -1;
2501 }
2502
2503 static long last_bracket = -1;
2504
2505 void edit_find_bracket (WEdit * edit)
2506 {
2507 edit->bracket = edit_get_bracket (edit, 1, 10000);
2508 if (last_bracket != edit->bracket)
2509 edit->force |= REDRAW_PAGE;
2510 last_bracket = edit->bracket;
2511 }
2512
2513 static void edit_goto_matching_bracket (WEdit *edit)
2514 {
2515 long q;
2516 q = edit_get_bracket (edit, 0, 0);
2517 if (q < 0)
2518 return;
2519 edit->bracket = edit->curs1;
2520 edit->force |= REDRAW_PAGE;
2521 edit_cursor_move (edit, q - edit->curs1);
2522 }
2523
2524 /*
2525 * This executes a command as though the user initiated it through a key
2526 * press. Callback with WIDGET_KEY as a message calls this after
2527 * translating the key press. This function can be used to pass any
2528 * command to the editor. Note that the screen wouldn't update
2529 * automatically. Either of command or char_for_insertion must be
2530 * passed as -1. Commands are executed, and char_for_insertion is
2531 * inserted at the cursor.
2532 */
2533 void
2534 edit_execute_key_command (WEdit *edit, unsigned long command, int char_for_insertion)
2535 {
2536 if (command == CK_Begin_Record_Macro) {
2537 edit->macro_i = 0;
2538 edit->force |= REDRAW_CHAR_ONLY | REDRAW_LINE;
2539 return;
2540 }
2541 if (command == CK_End_Record_Macro && edit->macro_i != -1) {
2542 edit->force |= REDRAW_COMPLETELY;
2543 edit_save_macro_cmd (edit, edit->macro, edit->macro_i);
2544 edit->macro_i = -1;
2545 return;
2546 }
2547 if (edit->macro_i >= 0 && edit->macro_i < MAX_MACRO_LENGTH - 1) {
2548 edit->macro[edit->macro_i].command = command;
2549 edit->macro[edit->macro_i++].ch = char_for_insertion;
2550 }
2551 /* record the beginning of a set of editing actions initiated by a key press */
2552 if (command != CK_Undo && command != CK_Ext_Mode)
2553 edit_push_key_press (edit);
2554
2555 edit_execute_cmd (edit, command, char_for_insertion);
2556 if (column_highlighting)
2557 edit->force |= REDRAW_PAGE;
2558 }
2559
2560 static const char * const shell_cmd[] = SHELL_COMMANDS_i;
2561
2562 /*
2563 This executes a command at a lower level than macro recording.
2564 It also does not push a key_press onto the undo stack. This means
2565 that if it is called many times, a single undo command will undo
2566 all of them. It also does not check for the Undo command.
2567 */
2568 void
2569 edit_execute_cmd (WEdit *edit, int command, int char_for_insertion)
2570 {
2571 edit->force |= REDRAW_LINE;
2572
2573 /* The next key press will unhighlight the found string, so update
2574 * the whole page */
2575 if (edit->found_len || column_highlighting)
2576 edit->force |= REDRAW_PAGE;
2577
2578 if (command / 100 == 6) { /* a highlight command like shift-arrow */
2579 column_highlighting = 0;
2580 if (!edit->highlight
2581 || (edit->mark2 != -1 && edit->mark1 != edit->mark2)) {
2582 edit_mark_cmd (edit, 1); /* clear */
2583 edit_mark_cmd (edit, 0); /* marking on */
2584 }
2585 edit->highlight = 1;
2586 } else { /* any other command */
2587 if (edit->highlight)
2588 edit_mark_cmd (edit, 0); /* clear */
2589 edit->highlight = 0;
2590 }
2591
2592 /* first check for undo */
2593 if (command == CK_Undo) {
2594 edit_do_undo (edit);
2595 edit->found_len = 0;
2596 edit->prev_col = edit_get_col (edit);
2597 edit->search_start = edit->curs1;
2598 return;
2599 }
2600
2601 /* An ordinary key press */
2602 if (char_for_insertion >= 0) {
2603 if (edit->overwrite) {
2604 if (edit_get_byte (edit, edit->curs1) != '\n')
2605 edit_delete (edit, 0);
2606 }
2607 if ( option_cursor_beyond_eol && edit->over_col > 0 )
2608 edit_insert_over (edit);
2609 #ifdef HAVE_CHARSET
2610 if ( char_for_insertion > 255 && utf8_display == 0 ) {
2611 unsigned char str[6 + 1];
2612 size_t i = 0;
2613 int res = g_unichar_to_utf8 (char_for_insertion, (char *)str);
2614 if ( res == 0 ) {
2615 str[0] = '.';
2616 str[1] = '\0';
2617 } else {
2618 str[res] = '\0';
2619 }
2620 while ( str[i] != 0 && i<=6) {
2621 char_for_insertion = str[i];
2622 edit_insert (edit, char_for_insertion);
2623 i++;
2624 }
2625 } else {
2626 #endif
2627 edit_insert (edit, char_for_insertion);
2628 #ifdef HAVE_CHARSET
2629 }
2630 #endif
2631 if (option_auto_para_formatting) {
2632 format_paragraph (edit, 0);
2633 edit->force |= REDRAW_PAGE;
2634 } else
2635 check_and_wrap_line (edit);
2636 edit->found_len = 0;
2637 edit->prev_col = edit_get_col (edit);
2638 edit->search_start = edit->curs1;
2639 edit_find_bracket (edit);
2640 return;
2641 }
2642
2643 switch (command) {
2644 case CK_Begin_Page:
2645 case CK_End_Page:
2646 case CK_Begin_Page_Highlight:
2647 case CK_End_Page_Highlight:
2648 case CK_Word_Left:
2649 case CK_Word_Right:
2650 case CK_Up:
2651 case CK_Down:
2652 case CK_Left:
2653 case CK_Right:
2654 if ( edit->mark2 >= 0 ) {
2655 if ( !option_persistent_selections ) {
2656 if (column_highlighting)
2657 edit_push_action (edit, COLUMN_ON);
2658 column_highlighting = 0;
2659 edit_mark_cmd (edit, 1);
2660 }
2661 }
2662 }
2663
2664 switch (command) {
2665 case CK_Begin_Page:
2666 case CK_End_Page:
2667 case CK_Begin_Page_Highlight:
2668 case CK_End_Page_Highlight:
2669 case CK_Word_Left:
2670 case CK_Word_Right:
2671 case CK_Up:
2672 case CK_Down:
2673 case CK_Word_Left_Highlight:
2674 case CK_Word_Right_Highlight:
2675 case CK_Up_Highlight:
2676 case CK_Down_Highlight:
2677 case CK_Up_Alt_Highlight:
2678 case CK_Down_Alt_Highlight:
2679 if (edit->mark2 == -1)
2680 break; /*marking is following the cursor: may need to highlight a whole line */
2681 case CK_Left:
2682 case CK_Right:
2683 case CK_Left_Highlight:
2684 case CK_Right_Highlight:
2685 edit->force |= REDRAW_CHAR_ONLY;
2686 }
2687
2688 /* basic cursor key commands */
2689 switch (command) {
2690 case CK_BackSpace:
2691 /* if non persistent selection and text selected */
2692 if ( !option_persistent_selections ) {
2693 if ( edit->mark1 != edit->mark2 ) {
2694 edit_block_delete_cmd (edit);
2695 break;
2696 }
2697 }
2698 if ( option_cursor_beyond_eol && edit->over_col > 0 ) {
2699 edit->over_col--;
2700 break;
2701 }
2702 if (option_backspace_through_tabs && is_in_indent (edit)) {
2703 while (edit_get_byte (edit, edit->curs1 - 1) != '\n'
2704 && edit->curs1 > 0)
2705 edit_backspace (edit, 1);
2706 break;
2707 } else {
2708 if (option_fake_half_tabs) {
2709 int i;
2710 if (is_in_indent (edit) && right_of_four_spaces (edit)) {
2711 for (i = 0; i < HALF_TAB_SIZE; i++)
2712 edit_backspace (edit, 1);
2713 break;
2714 }
2715 }
2716 }
2717 edit_backspace (edit, 0);
2718 break;
2719 case CK_Delete:
2720 /* if non persistent selection and text selected */
2721 if ( !option_persistent_selections ) {
2722 if ( edit->mark1 != edit->mark2 ) {
2723 edit_block_delete_cmd (edit);
2724 break;
2725 }
2726 }
2727
2728 if ( option_cursor_beyond_eol && edit->over_col > 0 )
2729 edit_insert_over (edit);
2730
2731 if (option_fake_half_tabs) {
2732 int i;
2733 if (is_in_indent (edit) && left_of_four_spaces (edit)) {
2734 for (i = 1; i <= HALF_TAB_SIZE; i++)
2735 edit_delete (edit, 1);
2736 break;
2737 }
2738 }
2739 edit_delete (edit, 0);
2740 break;
2741 case CK_Delete_Word_Left:
2742 edit->over_col = 0;
2743 edit_left_delete_word (edit);
2744 break;
2745 case CK_Delete_Word_Right:
2746 if ( option_cursor_beyond_eol && edit->over_col > 0 )
2747 edit_insert_over (edit);
2748
2749 edit_right_delete_word (edit);
2750 break;
2751 case CK_Delete_Line:
2752 edit_delete_line (edit);
2753 break;
2754 case CK_Delete_To_Line_End:
2755 edit_delete_to_line_end (edit);
2756 break;
2757 case CK_Delete_To_Line_Begin:
2758 edit_delete_to_line_begin (edit);
2759 break;
2760 case CK_Enter:
2761 edit->over_col = 0;
2762 if (option_auto_para_formatting) {
2763 edit_double_newline (edit);
2764 if (option_return_does_auto_indent)
2765 edit_auto_indent (edit);
2766 format_paragraph (edit, 0);
2767 } else {
2768 edit_insert (edit, '\n');
2769 if (option_return_does_auto_indent) {
2770 edit_auto_indent (edit);
2771 }
2772 }
2773 break;
2774 case CK_Return:
2775 edit_insert (edit, '\n');
2776 break;
2777
2778 case CK_Page_Up_Alt_Highlight:
2779 column_highlighting = 1;
2780 case CK_Page_Up:
2781 case CK_Page_Up_Highlight:
2782 edit_move_up (edit, edit->num_widget_lines - 1, 1);
2783 break;
2784 case CK_Page_Down_Alt_Highlight:
2785 column_highlighting = 1;
2786 case CK_Page_Down:
2787 case CK_Page_Down_Highlight:
2788 edit_move_down (edit, edit->num_widget_lines - 1, 1);
2789 break;
2790 case CK_Left_Alt_Highlight:
2791 column_highlighting = 1;
2792 case CK_Left:
2793 case CK_Left_Highlight:
2794 if (option_fake_half_tabs) {
2795 if (is_in_indent (edit) && right_of_four_spaces (edit)) {
2796 if ( option_cursor_beyond_eol && edit->over_col > 0)
2797 edit->over_col--;
2798 else
2799 edit_cursor_move (edit, -HALF_TAB_SIZE);
2800 edit->force &= (0xFFF - REDRAW_CHAR_ONLY);
2801 break;
2802 }
2803 }
2804 edit_left_char_move_cmd (edit);
2805 break;
2806 case CK_Right_Alt_Highlight:
2807 column_highlighting = 1;
2808 case CK_Right:
2809 case CK_Right_Highlight:
2810 if (option_fake_half_tabs) {
2811 if (is_in_indent (edit) && left_of_four_spaces (edit)) {
2812 edit_cursor_move (edit, HALF_TAB_SIZE);
2813 edit->force &= (0xFFF - REDRAW_CHAR_ONLY);
2814 break;
2815 }
2816 }
2817 edit_right_char_move_cmd (edit);
2818 break;
2819 case CK_Begin_Page:
2820 case CK_Begin_Page_Highlight:
2821 edit_begin_page (edit);
2822 break;
2823 case CK_End_Page:
2824 case CK_End_Page_Highlight:
2825 edit_end_page (edit);
2826 break;
2827 case CK_Word_Left:
2828 case CK_Word_Left_Highlight:
2829 edit->over_col = 0;
2830 edit_left_word_move_cmd (edit);
2831 break;
2832 case CK_Word_Right:
2833 case CK_Word_Right_Highlight:
2834 edit->over_col = 0;
2835 edit_right_word_move_cmd (edit);
2836 break;
2837 case CK_Up_Alt_Highlight:
2838 column_highlighting = 1;
2839 case CK_Up:
2840 case CK_Up_Highlight:
2841 edit_move_up (edit, 1, 0);
2842 break;
2843 case CK_Down_Alt_Highlight:
2844 column_highlighting = 1;
2845 case CK_Down:
2846 case CK_Down_Highlight:
2847 edit_move_down (edit, 1, 0);
2848 break;
2849 case CK_Paragraph_Up_Alt_Highlight:
2850 column_highlighting = 1;
2851 case CK_Paragraph_Up:
2852 case CK_Paragraph_Up_Highlight:
2853 edit_move_up_paragraph (edit, 0);
2854 break;
2855 case CK_Paragraph_Down_Alt_Highlight:
2856 column_highlighting = 1;
2857 case CK_Paragraph_Down:
2858 case CK_Paragraph_Down_Highlight:
2859 edit_move_down_paragraph (edit, 0);
2860 break;
2861 case CK_Scroll_Up_Alt_Highlight:
2862 column_highlighting = 1;
2863 case CK_Scroll_Up:
2864 case CK_Scroll_Up_Highlight:
2865 edit_move_up (edit, 1, 1);
2866 break;
2867 case CK_Scroll_Down_Alt_Highlight:
2868 column_highlighting = 1;
2869 case CK_Scroll_Down:
2870 case CK_Scroll_Down_Highlight:
2871 edit_move_down (edit, 1, 1);
2872 break;
2873 case CK_Home:
2874 case CK_Home_Highlight:
2875 edit_cursor_to_bol (edit);
2876 break;
2877 case CK_End:
2878 case CK_End_Highlight:
2879 edit_cursor_to_eol (edit);
2880 break;
2881 case CK_Tab:
2882 /* if text marked shift block */
2883 if ( edit->mark1 != edit->mark2 && !option_persistent_selections ) {
2884 if (edit->mark2 < 0)
2885 edit_mark_cmd (edit, 0);
2886 edit_move_block_to_right (edit);
2887 } else {
2888 if ( option_cursor_beyond_eol )
2889 edit_insert_over (edit);
2890 edit_tab_cmd (edit);
2891 if (option_auto_para_formatting) {
2892 format_paragraph (edit, 0);
2893 edit->force |= REDRAW_PAGE;
2894 } else {
2895 check_and_wrap_line (edit);
2896 }
2897 }
2898 break;
2899
2900 case CK_Toggle_Insert:
2901 edit->overwrite = (edit->overwrite == 0);
2902 break;
2903
2904 case CK_Mark:
2905 if (edit->mark2 >= 0) {
2906 if (column_highlighting)
2907 edit_push_action (edit, COLUMN_ON);
2908 column_highlighting = 0;
2909 }
2910 edit_mark_cmd (edit, 0);
2911 break;
2912 case CK_Column_Mark:
2913 if (!column_highlighting)
2914 edit_push_action (edit, COLUMN_OFF);
2915 column_highlighting = 1;
2916 edit_mark_cmd (edit, 0);
2917 break;
2918 case CK_Unmark:
2919 if (column_highlighting)
2920 edit_push_action (edit, COLUMN_ON);
2921 column_highlighting = 0;
2922 edit_mark_cmd (edit, 1);
2923 break;
2924
2925 case CK_Toggle_Line_State:
2926 option_line_state = !option_line_state;
2927 if ( option_line_state ) {
2928 option_line_state_width = LINE_STATE_WIDTH;
2929 } else {
2930 option_line_state_width = 0;
2931 }
2932 edit->force |= REDRAW_PAGE;
2933 break;
2934
2935 case CK_Toggle_Bookmark:
2936 book_mark_clear (edit, edit->curs_line, BOOK_MARK_FOUND_COLOR);
2937 if (book_mark_query_color (edit, edit->curs_line, BOOK_MARK_COLOR))
2938 book_mark_clear (edit, edit->curs_line, BOOK_MARK_COLOR);
2939 else
2940 book_mark_insert (edit, edit->curs_line, BOOK_MARK_COLOR);
2941 break;
2942 case CK_Flush_Bookmarks:
2943 book_mark_flush (edit, BOOK_MARK_COLOR);
2944 book_mark_flush (edit, BOOK_MARK_FOUND_COLOR);
2945 edit->force |= REDRAW_PAGE;
2946 break;
2947 case CK_Next_Bookmark:
2948 if (edit->book_mark) {
2949 struct _book_mark *p;
2950 p = (struct _book_mark *) book_mark_find (edit,
2951 edit->curs_line);
2952 if (p->next) {
2953 p = p->next;
2954 if (p->line >= edit->start_line + edit->num_widget_lines
2955 || p->line < edit->start_line)
2956 edit_move_display (edit,
2957 p->line -
2958 edit->num_widget_lines / 2);
2959 edit_move_to_line (edit, p->line);
2960 }
2961 }
2962 break;
2963 case CK_Prev_Bookmark:
2964 if (edit->book_mark) {
2965 struct _book_mark *p;
2966 p = (struct _book_mark *) book_mark_find (edit,
2967 edit->curs_line);
2968 while (p->line == edit->curs_line)
2969 if (p->prev)
2970 p = p->prev;
2971 if (p->line >= 0) {
2972 if (p->line >= edit->start_line + edit->num_widget_lines
2973 || p->line < edit->start_line)
2974 edit_move_display (edit,
2975 p->line -
2976 edit->num_widget_lines / 2);
2977 edit_move_to_line (edit, p->line);
2978 }
2979 }
2980 break;
2981
2982 case CK_Beginning_Of_Text:
2983 case CK_Beginning_Of_Text_Highlight:
2984 edit_move_to_top (edit);
2985 break;
2986 case CK_End_Of_Text:
2987 case CK_End_Of_Text_Highlight:
2988 edit_move_to_bottom (edit);
2989 break;
2990
2991 case CK_Copy:
2992 if ( option_cursor_beyond_eol && edit->over_col > 0 )
2993 edit_insert_over (edit);
2994 edit_block_copy_cmd (edit);
2995 break;
2996 case CK_Remove:
2997 edit_block_delete_cmd (edit);
2998 break;
2999 case CK_Move:
3000 if ( option_cursor_beyond_eol && edit->over_col > 0 )
3001 edit_insert_over (edit);
3002 edit_block_move_cmd (edit);
3003 break;
3004
3005 case CK_Shift_Block_Left:
3006 if (edit->mark1 != edit->mark2)
3007 edit_move_block_to_left (edit);
3008 break;
3009 case CK_Shift_Block_Right:
3010 if (edit->mark1 != edit->mark2)
3011 edit_move_block_to_right (edit);
3012 break;
3013 case CK_XStore:
3014 edit_copy_to_X_buf_cmd (edit);
3015 break;
3016 case CK_XCut:
3017 edit_cut_to_X_buf_cmd (edit);
3018 break;
3019 case CK_XPaste:
3020 if ( option_cursor_beyond_eol && edit->over_col > 0 )
3021 edit_insert_over (edit);
3022 edit_paste_from_X_buf_cmd (edit);
3023 break;
3024 case CK_Selection_History:
3025 edit_paste_from_history (edit);
3026 break;
3027
3028 case CK_Save_As:
3029 edit_save_as_cmd (edit);
3030 break;
3031 case CK_Save:
3032 edit_save_confirm_cmd (edit);
3033 break;
3034 case CK_Load:
3035 edit_load_cmd (edit, EDIT_FILE_COMMON);
3036 break;
3037 case CK_Save_Block:
3038 edit_save_block_cmd (edit);
3039 break;
3040 case CK_Insert_File:
3041 edit_insert_file_cmd (edit);
3042 break;
3043
3044 case CK_Load_Prev_File:
3045 edit_load_back_cmd (edit);
3046 break;
3047 case CK_Load_Next_File:
3048 edit_load_forward_cmd (edit);
3049 break;
3050
3051 case CK_Load_Syntax_File:
3052 edit_load_cmd (edit, EDIT_FILE_SYNTAX);
3053 break;
3054 case CK_Choose_Syntax:
3055 edit_syntax_dialog ();
3056 break;
3057
3058 case CK_Load_Menu_File:
3059 edit_load_cmd (edit, EDIT_FILE_MENU);
3060 break;
3061
3062 case CK_Toggle_Syntax:
3063 if ((option_syntax_highlighting ^= 1) == 1)
3064 edit_load_syntax (edit, NULL, option_syntax_type);
3065 edit->force |= REDRAW_PAGE;
3066 break;
3067
3068 case CK_Toggle_Tab_TWS:
3069 enable_show_tabs_tws ^= 1;
3070 edit->force |= REDRAW_PAGE;
3071 break;
3072
3073 case CK_Find:
3074 edit_search_cmd (edit, 0);
3075 break;
3076 case CK_Find_Again:
3077 edit_search_cmd (edit, 1);
3078 break;
3079 case CK_Replace:
3080 edit_replace_cmd (edit, 0);
3081 break;
3082 case CK_Replace_Again:
3083 edit_replace_cmd (edit, 1);
3084 break;
3085 case CK_Complete_Word:
3086 /* if text marked shift block */
3087 if ( edit->mark1 != edit->mark2 && !option_persistent_selections ) {
3088 edit_move_block_to_left (edit);
3089 } else {
3090 edit_complete_word_cmd (edit);
3091 }
3092 break;
3093 case CK_Find_Definition:
3094 edit_get_match_keyword_cmd (edit);
3095 break;
3096 case CK_Quit:
3097 dlg_stop (edit->widget.parent);
3098 break;
3099 case CK_New:
3100 edit_new_cmd (edit);
3101 break;
3102 case CK_Help:
3103 edit_help_cmd (edit);
3104 break;
3105 case CK_Refresh:
3106 edit_refresh_cmd (edit);
3107 break;
3108 case CK_SaveSetupCmd:
3109 save_setup_cmd ();
3110 break;
3111 case CK_About:
3112 query_dialog (_(" About "),
3113 _("\n Cooledit v3.11.5\n\n"
3114 " Copyright (C) 1996 the Free Software Foundation\n\n"
3115 " A user friendly text editor written\n"
3116 " for the Midnight Commander.\n"), D_NORMAL,
3117 1, _("&OK"));
3118 break;
3119 case CK_LearnKeys:
3120 learn_keys ();
3121 break;
3122 case CK_Edit_Options:
3123 edit_options_dialog ();
3124 break;
3125 case CK_Edit_Save_Mode:
3126 menu_save_mode_cmd ();
3127 break;
3128 case CK_Date:
3129 {
3130 char s[BUF_MEDIUM];
3131 /* fool gcc to prevent a Y2K warning */
3132 char time_format[] = "_c";
3133 time_format[0] = '%';
3134
3135 FMT_LOCALTIME_CURRENT(s, sizeof(s), time_format);
3136 edit_print_string (edit, s);
3137 edit->force |= REDRAW_PAGE;
3138 break;
3139 }
3140 break;
3141 case CK_Goto:
3142 edit_goto_cmd (edit);
3143 break;
3144 case CK_Paragraph_Format:
3145 format_paragraph (edit, 1);
3146 edit->force |= REDRAW_PAGE;
3147 break;
3148 case CK_Delete_Macro:
3149 edit_delete_macro_cmd (edit);
3150 break;
3151 case CK_Match_Bracket:
3152 edit_goto_matching_bracket (edit);
3153 break;
3154 case CK_User_Menu:
3155 user_menu (edit);
3156 break;
3157 case CK_Sort:
3158 edit_sort_cmd (edit);
3159 break;
3160 case CK_ExtCmd:
3161 edit_ext_cmd (edit);
3162 break;
3163 case CK_Mail:
3164 edit_mail_dialog (edit);
3165 break;
3166 case CK_Shell:
3167 view_other_cmd ();
3168 break;
3169 case CK_SelectCodepage:
3170 edit_select_codepage_cmd (edit);
3171 break;
3172 case CK_Insert_Literal:
3173 edit_insert_literal_cmd (edit);
3174 break;
3175 case CK_Execute_Macro:
3176 edit_execute_macro_cmd (edit);
3177 break;
3178 case CK_Begin_End_Macro:
3179 edit_begin_end_macro_cmd (edit);
3180 break;
3181 case CK_Ext_Mode:
3182 edit->extmod = 1;
3183 break;
3184 default:
3185 break;
3186 }
3187
3188 /* CK_Pipe_Block */
3189 if ((command / 1000) == 1) /* a shell command */
3190 edit_block_process_cmd (edit, shell_cmd[command - 1000], 1);
3191 if (command > CK_Macro (0) && command <= CK_Last_Macro) { /* a macro command */
3192 struct macro m[MAX_MACRO_LENGTH];
3193 int nm;
3194 if (edit_load_macro_cmd (edit, m, &nm, command - 2000))
3195 edit_execute_macro (edit, m, nm);
3196 }
3197
3198 /* keys which must set the col position, and the search vars */
3199 switch (command) {
3200 case CK_Find:
3201 case CK_Find_Again:
3202 case CK_Replace:
3203 case CK_Replace_Again:
3204 case CK_Complete_Word:
3205 edit->prev_col = edit_get_col (edit);
3206 break;
3207 case CK_Up:
3208 case CK_Up_Highlight:
3209 case CK_Up_Alt_Highlight:
3210 case CK_Down:
3211 case CK_Down_Highlight:
3212 case CK_Down_Alt_Highlight:
3213 case CK_Page_Up:
3214 case CK_Page_Up_Highlight:
3215 case CK_Page_Up_Alt_Highlight:
3216 case CK_Page_Down:
3217 case CK_Page_Down_Highlight:
3218 case CK_Page_Down_Alt_Highlight:
3219 case CK_Beginning_Of_Text:
3220 case CK_Beginning_Of_Text_Highlight:
3221 case CK_End_Of_Text:
3222 case CK_End_Of_Text_Highlight:
3223 case CK_Paragraph_Up:
3224 case CK_Paragraph_Up_Highlight:
3225 case CK_Paragraph_Up_Alt_Highlight:
3226 case CK_Paragraph_Down:
3227 case CK_Paragraph_Down_Highlight:
3228 case CK_Paragraph_Down_Alt_Highlight:
3229 case CK_Scroll_Up:
3230 case CK_Scroll_Up_Highlight:
3231 case CK_Scroll_Up_Alt_Highlight:
3232 case CK_Scroll_Down:
3233 case CK_Scroll_Down_Highlight:
3234 case CK_Scroll_Down_Alt_Highlight:
3235 edit->search_start = edit->curs1;
3236 edit->found_len = 0;
3237 break;
3238 default:
3239 edit->found_len = 0;
3240 edit->prev_col = edit_get_col (edit);
3241 edit->search_start = edit->curs1;
3242 }
3243 edit_find_bracket (edit);
3244
3245 if (option_auto_para_formatting) {
3246 switch (command) {
3247 case CK_BackSpace:
3248 case CK_Delete:
3249 case CK_Delete_Word_Left:
3250 case CK_Delete_Word_Right:
3251 case CK_Delete_To_Line_End:
3252 case CK_Delete_To_Line_Begin:
3253 format_paragraph (edit, 0);
3254 edit->force |= REDRAW_PAGE;
3255 }
3256 }
3257 }
3258
3259
3260 static void
3261 edit_execute_macro (WEdit *edit, struct macro macro[], int n)
3262 {
3263 int i = 0;
3264
3265 if (edit->macro_depth++ > 256) {
3266 edit_error_dialog (_("Error"), _("Macro recursion is too deep"));
3267 edit->macro_depth--;
3268 return;
3269 }
3270 edit->force |= REDRAW_PAGE;
3271 for (; i < n; i++) {
3272 edit_execute_cmd (edit, macro[i].command, macro[i].ch);
3273 }
3274 edit_update_screen (edit);
3275 edit->macro_depth--;
3276 }
3277
3278 /* User edit menu, like user menu (F2) but only in editor. */
3279 static void
3280 user_menu (WEdit * edit)
3281 {
3282 FILE *fd;
3283 int nomark;
3284 struct stat status;
3285 long start_mark, end_mark;
3286 char *block_file = concat_dir_and_file (home_dir, EDIT_BLOCK_FILE);
3287 int rc = 0;
3288
3289 nomark = eval_marks (edit, &start_mark, &end_mark);
3290 if (!nomark) /* remember marked or not */
3291 edit_save_block (edit, block_file, start_mark, end_mark);
3292
3293 /* run shell scripts from menu */
3294 user_menu_cmd (edit);
3295
3296 if (mc_stat (block_file, &status) != 0 || !status.st_size) {
3297 /* no block messages */
3298 goto cleanup;
3299 }
3300
3301 if (!nomark) {
3302 /* i.e. we have marked block */
3303 rc = edit_block_delete_cmd (edit);
3304 }
3305
3306 if (!rc) {
3307 edit_insert_file (edit, block_file);
3308 }
3309
3310 /* truncate block file */
3311 if ((fd = fopen (block_file, "w"))) {
3312 fclose (fd);
3313 }
3314
3315 edit_refresh_cmd (edit);
3316 edit->force |= REDRAW_COMPLETELY;
3317
3318 cleanup:
3319 g_free (block_file);
3320 }
3321
3322 void
3323 edit_stack_init (void)
3324 {
3325 for (edit_stack_iterator = 0;
3326 edit_stack_iterator < MAX_HISTORY_MOVETO;
3327 edit_stack_iterator++ ) {
3328 edit_history_moveto[edit_stack_iterator].filename = NULL;
3329 edit_history_moveto[edit_stack_iterator].line = -1;
3330 }
3331
3332 edit_stack_iterator = 0;
3333 }
3334
3335 void
3336 edit_stack_free (void)
3337 {
3338 for (edit_stack_iterator = 0;
3339 edit_stack_iterator < MAX_HISTORY_MOVETO;
3340 edit_stack_iterator++)
3341 g_free (edit_history_moveto[edit_stack_iterator].filename);
3342 }