source: mainline/uspace/app/edit/edit.c@ 3061bc1

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 3061bc1 was 1b20da0, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 7 years ago

style: Remove trailing whitespace on non-empty lines, in certain file types.

Command used: tools/srepl '\([^[:space:]]\)\s\+$' '\1' -- *.c *.h *.py *.sh *.s *.S *.ag
  • Property mode set to 100644
File size: 35.8 KB
Line 
1/*
2 * Copyright (c) 2009 Jiri Svoboda
3 * Copyright (c) 2012 Martin Sucha
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup edit
31 * @brief Text editor.
32 * @{
33 */
34/**
35 * @file
36 */
37
38#include <stdio.h>
39#include <stdlib.h>
40#include <stddef.h>
41#include <stdbool.h>
42#include <vfs/vfs.h>
43#include <io/console.h>
44#include <io/style.h>
45#include <io/keycode.h>
46#include <errno.h>
47#include <align.h>
48#include <macros.h>
49#include <clipboard.h>
50#include <types/common.h>
51
52#include "sheet.h"
53#include "search.h"
54
55enum redraw_flags {
56 REDRAW_TEXT = (1 << 0),
57 REDRAW_ROW = (1 << 1),
58 REDRAW_STATUS = (1 << 2),
59 REDRAW_CARET = (1 << 3)
60};
61
62/** Pane
63 *
64 * A rectangular area of the screen used to edit a document. Different
65 * panes can be possibly used to edit the same document.
66 */
67typedef struct {
68 /* Pane dimensions */
69 int rows, columns;
70
71 /* Position of the visible area */
72 int sh_row, sh_column;
73
74 /** Bitmask of components that need redrawing */
75 enum redraw_flags rflags;
76
77 /** Current position of the caret */
78 tag_t caret_pos;
79
80 /** Start of selection */
81 tag_t sel_start;
82
83 /** Active keyboard modifiers */
84 keymod_t keymod;
85
86 /**
87 * Ideal column where the caret should try to get. This is used
88 * for maintaining the same column during vertical movement.
89 */
90 int ideal_column;
91
92 char *previous_search;
93 bool previous_search_reverse;
94} pane_t;
95
96/** Document
97 *
98 * Associates a sheet with a file where it can be saved to.
99 */
100typedef struct {
101 char *file_name;
102 sheet_t *sh;
103} doc_t;
104
105static console_ctrl_t *con;
106static doc_t doc;
107static bool done;
108static pane_t pane;
109static bool cursor_visible;
110
111static sysarg_t scr_rows;
112static sysarg_t scr_columns;
113
114#define ROW_BUF_SIZE 4096
115#define BUF_SIZE 64
116#define TAB_WIDTH 8
117
118/** Maximum filename length that can be entered. */
119#define INFNAME_MAX_LEN 128
120
121static void cursor_show(void);
122static void cursor_hide(void);
123static void cursor_setvis(bool visible);
124
125static void key_handle_press(kbd_event_t *ev);
126static void key_handle_unmod(kbd_event_t const *ev);
127static void key_handle_ctrl(kbd_event_t const *ev);
128static void key_handle_shift(kbd_event_t const *ev);
129static void key_handle_shift_ctrl(kbd_event_t const *ev);
130static void key_handle_movement(unsigned int key, bool shift);
131
132static void pos_handle(pos_event_t *ev);
133
134static errno_t file_save(char const *fname);
135static void file_save_as(void);
136static errno_t file_insert(char *fname);
137static errno_t file_save_range(char const *fname, spt_t const *spos,
138 spt_t const *epos);
139static char *range_get_str(spt_t const *spos, spt_t const *epos);
140
141static char *prompt(char const *prompt, char const *init_value);
142
143static void pane_text_display(void);
144static void pane_row_display(void);
145static void pane_row_range_display(int r0, int r1);
146static void pane_status_display(void);
147static void pane_caret_display(void);
148
149static void insert_char(wchar_t c);
150static void delete_char_before(void);
151static void delete_char_after(void);
152static void caret_update(void);
153static void caret_move_relative(int drow, int dcolumn, enum dir_spec align_dir, bool select);
154static void caret_move_absolute(int row, int column, enum dir_spec align_dir, bool select);
155static void caret_move(spt_t spt, bool select, bool update_ideal_column);
156static void caret_move_word_left(bool select);
157static void caret_move_word_right(bool select);
158static void caret_go_to_line_ask(void);
159
160static bool selection_active(void);
161static void selection_sel_all(void);
162static void selection_sel_range(spt_t pa, spt_t pb);
163static void selection_get_points(spt_t *pa, spt_t *pb);
164static void selection_delete(void);
165static void selection_copy(void);
166static void insert_clipboard_data(void);
167
168static void search(char *pattern, bool reverse);
169static void search_prompt(bool reverse);
170static void search_repeat(void);
171
172static void pt_get_sof(spt_t *pt);
173static void pt_get_eof(spt_t *pt);
174static void pt_get_sol(spt_t *cpt, spt_t *spt);
175static void pt_get_eol(spt_t *cpt, spt_t *ept);
176static bool pt_is_word_beginning(spt_t *pt);
177static bool pt_is_delimiter(spt_t *pt);
178static bool pt_is_punctuation(spt_t *pt);
179static spt_t pt_find_word_left(spt_t spt);
180static spt_t pt_find_word_left(spt_t spt);
181
182static int tag_cmp(tag_t const *a, tag_t const *b);
183static int spt_cmp(spt_t const *a, spt_t const *b);
184static int coord_cmp(coord_t const *a, coord_t const *b);
185
186static void status_display(char const *str);
187
188
189int main(int argc, char *argv[])
190{
191 cons_event_t ev;
192 bool new_file;
193 errno_t rc;
194
195 con = console_init(stdin, stdout);
196 console_clear(con);
197
198 console_get_size(con, &scr_columns, &scr_rows);
199
200 pane.rows = scr_rows - 1;
201 pane.columns = scr_columns;
202 pane.sh_row = 1;
203 pane.sh_column = 1;
204
205 /* Start with an empty sheet. */
206 rc = sheet_create(&doc.sh);
207 if (rc != EOK) {
208 printf("Out of memory.\n");
209 return -1;
210 }
211
212 /* Place caret at the beginning of file. */
213 spt_t sof;
214 pt_get_sof(&sof);
215 sheet_place_tag(doc.sh, &sof, &pane.caret_pos);
216 pane.ideal_column = 1;
217
218 if (argc == 2) {
219 doc.file_name = str_dup(argv[1]);
220 } else if (argc > 1) {
221 printf("Invalid arguments.\n");
222 return -2;
223 } else {
224 doc.file_name = NULL;
225 }
226
227 new_file = false;
228
229 if (doc.file_name == NULL || file_insert(doc.file_name) != EOK)
230 new_file = true;
231
232 /* Place selection start tag. */
233 sheet_place_tag(doc.sh, &sof, &pane.sel_start);
234
235 /* Move to beginning of file. */
236 pt_get_sof(&sof);
237 caret_move(sof, true, true);
238
239 /* Initial display */
240 cursor_visible = true;
241
242 cursor_hide();
243 console_clear(con);
244 pane_text_display();
245 pane_status_display();
246 if (new_file && doc.file_name != NULL)
247 status_display("File not found. Starting empty file.");
248 pane_caret_display();
249 cursor_show();
250
251 done = false;
252
253 while (!done) {
254 console_get_event(con, &ev);
255 pane.rflags = 0;
256
257 switch (ev.type) {
258 case CEV_KEY:
259 pane.keymod = ev.ev.key.mods;
260 if (ev.ev.key.type == KEY_PRESS)
261 key_handle_press(&ev.ev.key);
262 break;
263 case CEV_POS:
264 pos_handle(&ev.ev.pos);
265 break;
266 }
267
268 /* Redraw as necessary. */
269
270 cursor_hide();
271
272 if (pane.rflags & REDRAW_TEXT)
273 pane_text_display();
274 if (pane.rflags & REDRAW_ROW)
275 pane_row_display();
276 if (pane.rflags & REDRAW_STATUS)
277 pane_status_display();
278 if (pane.rflags & REDRAW_CARET)
279 pane_caret_display();
280
281 cursor_show();
282 }
283
284 console_clear(con);
285
286 return 0;
287}
288
289/* Handle key press. */
290static void key_handle_press(kbd_event_t *ev)
291{
292 if (((ev->mods & KM_ALT) == 0) &&
293 ((ev->mods & KM_SHIFT) == 0) &&
294 (ev->mods & KM_CTRL) != 0) {
295 key_handle_ctrl(ev);
296 } else if (((ev->mods & KM_ALT) == 0) &&
297 ((ev->mods & KM_CTRL) == 0) &&
298 (ev->mods & KM_SHIFT) != 0) {
299 key_handle_shift(ev);
300 } else if (((ev->mods & KM_ALT) == 0) &&
301 ((ev->mods & KM_CTRL) != 0) &&
302 (ev->mods & KM_SHIFT) != 0) {
303 key_handle_shift_ctrl(ev);
304 } else if ((ev->mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
305 key_handle_unmod(ev);
306 }
307}
308
309static void cursor_show(void)
310{
311 cursor_setvis(true);
312}
313
314static void cursor_hide(void)
315{
316 cursor_setvis(false);
317}
318
319static void cursor_setvis(bool visible)
320{
321 if (cursor_visible != visible) {
322 console_cursor_visibility(con, visible);
323 cursor_visible = visible;
324 }
325}
326
327/** Handle key without modifier. */
328static void key_handle_unmod(kbd_event_t const *ev)
329{
330 switch (ev->key) {
331 case KC_ENTER:
332 selection_delete();
333 insert_char('\n');
334 caret_update();
335 break;
336 case KC_LEFT:
337 case KC_RIGHT:
338 case KC_UP:
339 case KC_DOWN:
340 case KC_HOME:
341 case KC_END:
342 case KC_PAGE_UP:
343 case KC_PAGE_DOWN:
344 key_handle_movement(ev->key, false);
345 break;
346 case KC_BACKSPACE:
347 if (selection_active())
348 selection_delete();
349 else
350 delete_char_before();
351 caret_update();
352 break;
353 case KC_DELETE:
354 if (selection_active())
355 selection_delete();
356 else
357 delete_char_after();
358 caret_update();
359 break;
360 default:
361 if (ev->c >= 32 || ev->c == '\t') {
362 selection_delete();
363 insert_char(ev->c);
364 caret_update();
365 }
366 break;
367 }
368}
369
370/** Handle Shift-key combination. */
371static void key_handle_shift(kbd_event_t const *ev)
372{
373 switch (ev->key) {
374 case KC_LEFT:
375 case KC_RIGHT:
376 case KC_UP:
377 case KC_DOWN:
378 case KC_HOME:
379 case KC_END:
380 case KC_PAGE_UP:
381 case KC_PAGE_DOWN:
382 key_handle_movement(ev->key, true);
383 break;
384 default:
385 if (ev->c >= 32 || ev->c == '\t') {
386 selection_delete();
387 insert_char(ev->c);
388 caret_update();
389 }
390 break;
391 }
392}
393
394/** Handle Ctrl-key combination. */
395static void key_handle_ctrl(kbd_event_t const *ev)
396{
397 spt_t pt;
398 switch (ev->key) {
399 case KC_Q:
400 done = true;
401 break;
402 case KC_S:
403 if (doc.file_name != NULL)
404 file_save(doc.file_name);
405 else
406 file_save_as();
407 break;
408 case KC_E:
409 file_save_as();
410 break;
411 case KC_C:
412 selection_copy();
413 break;
414 case KC_V:
415 selection_delete();
416 insert_clipboard_data();
417 pane.rflags |= REDRAW_TEXT;
418 caret_update();
419 break;
420 case KC_X:
421 selection_copy();
422 selection_delete();
423 pane.rflags |= REDRAW_TEXT;
424 caret_update();
425 break;
426 case KC_A:
427 selection_sel_all();
428 break;
429 case KC_RIGHT:
430 caret_move_word_right(false);
431 break;
432 case KC_LEFT:
433 caret_move_word_left(false);
434 break;
435 case KC_L:
436 caret_go_to_line_ask();
437 break;
438 case KC_F:
439 search_prompt(false);
440 break;
441 case KC_N:
442 search_repeat();
443 break;
444 case KC_HOME:
445 pt_get_sof(&pt);
446 caret_move(pt, false, true);
447 break;
448 case KC_END:
449 pt_get_eof(&pt);
450 caret_move(pt, false, true);
451 break;
452 default:
453 break;
454 }
455}
456
457static void key_handle_shift_ctrl(kbd_event_t const *ev)
458{
459 spt_t pt;
460 switch(ev->key) {
461 case KC_LEFT:
462 caret_move_word_left(true);
463 break;
464 case KC_RIGHT:
465 caret_move_word_right(true);
466 break;
467 case KC_F:
468 search_prompt(true);
469 break;
470 case KC_HOME:
471 pt_get_sof(&pt);
472 caret_move(pt, true, true);
473 break;
474 case KC_END:
475 pt_get_eof(&pt);
476 caret_move(pt, true, true);
477 break;
478 default:
479 break;
480 }
481}
482
483static void pos_handle(pos_event_t *ev)
484{
485 coord_t bc;
486 spt_t pt;
487 bool select;
488
489 if (ev->type == POS_PRESS && ev->vpos < (unsigned)pane.rows) {
490 bc.row = pane.sh_row + ev->vpos;
491 bc.column = pane.sh_column + ev->hpos;
492 sheet_get_cell_pt(doc.sh, &bc, dir_before, &pt);
493
494 select = (pane.keymod & KM_SHIFT) != 0;
495
496 caret_move(pt, select, true);
497 }
498}
499
500/** Move caret while preserving or resetting selection. */
501static void caret_move(spt_t new_caret_pt, bool select, bool update_ideal_column)
502{
503 spt_t old_caret_pt, old_sel_pt;
504 coord_t c_old, c_new;
505 bool had_sel;
506
507 /* Check if we had selection before. */
508 tag_get_pt(&pane.caret_pos, &old_caret_pt);
509 tag_get_pt(&pane.sel_start, &old_sel_pt);
510 had_sel = !spt_equal(&old_caret_pt, &old_sel_pt);
511
512 /* Place tag of the caret */
513 sheet_remove_tag(doc.sh, &pane.caret_pos);
514 sheet_place_tag(doc.sh, &new_caret_pt, &pane.caret_pos);
515
516 if (select == false) {
517 /* Move sel_start to the same point as caret. */
518 sheet_remove_tag(doc.sh, &pane.sel_start);
519 sheet_place_tag(doc.sh, &new_caret_pt, &pane.sel_start);
520 }
521
522 spt_get_coord(&new_caret_pt, &c_new);
523 if (select) {
524 spt_get_coord(&old_caret_pt, &c_old);
525
526 if (c_old.row == c_new.row)
527 pane.rflags |= REDRAW_ROW;
528 else
529 pane.rflags |= REDRAW_TEXT;
530
531 } else if (had_sel == true) {
532 /* Redraw because text was unselected. */
533 pane.rflags |= REDRAW_TEXT;
534 }
535
536 if (update_ideal_column)
537 pane.ideal_column = c_new.column;
538
539 caret_update();
540}
541
542static void key_handle_movement(unsigned int key, bool select)
543{
544 spt_t pt;
545 switch (key) {
546 case KC_LEFT:
547 caret_move_relative(0, -1, dir_before, select);
548 break;
549 case KC_RIGHT:
550 caret_move_relative(0, 0, dir_after, select);
551 break;
552 case KC_UP:
553 caret_move_relative(-1, 0, dir_before, select);
554 break;
555 case KC_DOWN:
556 caret_move_relative(+1, 0, dir_before, select);
557 break;
558 case KC_HOME:
559 tag_get_pt(&pane.caret_pos, &pt);
560 pt_get_sol(&pt, &pt);
561 caret_move(pt, select, true);
562 break;
563 case KC_END:
564 tag_get_pt(&pane.caret_pos, &pt);
565 pt_get_eol(&pt, &pt);
566 caret_move(pt, select, true);
567 break;
568 case KC_PAGE_UP:
569 caret_move_relative(-pane.rows, 0, dir_before, select);
570 break;
571 case KC_PAGE_DOWN:
572 caret_move_relative(+pane.rows, 0, dir_before, select);
573 break;
574 default:
575 break;
576 }
577}
578
579/** Save the document. */
580static errno_t file_save(char const *fname)
581{
582 spt_t sp, ep;
583 errno_t rc;
584
585 status_display("Saving...");
586 pt_get_sof(&sp);
587 pt_get_eof(&ep);
588
589 rc = file_save_range(fname, &sp, &ep);
590
591 switch (rc) {
592 case EINVAL:
593 status_display("Error opening file!");
594 break;
595 case EIO:
596 status_display("Error writing data!");
597 break;
598 default:
599 status_display("File saved.");
600 break;
601 }
602
603 return rc;
604}
605
606/** Change document name and save. */
607static void file_save_as(void)
608{
609 const char *old_fname = (doc.file_name != NULL) ? doc.file_name : "";
610 char *fname;
611
612 fname = prompt("Save As", old_fname);
613 if (fname == NULL) {
614 status_display("Save cancelled.");
615 return;
616 }
617
618 errno_t rc = file_save(fname);
619 if (rc != EOK)
620 return;
621
622 if (doc.file_name != NULL)
623 free(doc.file_name);
624 doc.file_name = fname;
625}
626
627/** Ask for a string. */
628static char *prompt(char const *prompt, char const *init_value)
629{
630 cons_event_t ev;
631 kbd_event_t *kev;
632 char *str;
633 wchar_t buffer[INFNAME_MAX_LEN + 1];
634 int max_len;
635 int nc;
636 bool done;
637
638 asprintf(&str, "%s: %s", prompt, init_value);
639 status_display(str);
640 console_set_pos(con, 1 + str_length(str), scr_rows - 1);
641 free(str);
642
643 console_set_style(con, STYLE_INVERTED);
644
645 max_len = min(INFNAME_MAX_LEN, scr_columns - 4 - str_length(prompt));
646 str_to_wstr(buffer, max_len + 1, init_value);
647 nc = wstr_length(buffer);
648 done = false;
649
650 while (!done) {
651 console_get_event(con, &ev);
652
653 if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
654 kev = &ev.ev.key;
655
656 /* Handle key press. */
657 if (((kev->mods & KM_ALT) == 0) &&
658 (kev->mods & KM_CTRL) != 0) {
659 ;
660 } else if ((kev->mods & (KM_CTRL | KM_ALT)) == 0) {
661 switch (kev->key) {
662 case KC_ESCAPE:
663 return NULL;
664 case KC_BACKSPACE:
665 if (nc > 0) {
666 putchar('\b');
667 console_flush(con);
668 --nc;
669 }
670 break;
671 case KC_ENTER:
672 done = true;
673 break;
674 default:
675 if (kev->c >= 32 && nc < max_len) {
676 putchar(kev->c);
677 console_flush(con);
678 buffer[nc++] = kev->c;
679 }
680 break;
681 }
682 }
683 }
684 }
685
686 buffer[nc] = '\0';
687 str = wstr_to_astr(buffer);
688
689 console_set_style(con, STYLE_NORMAL);
690
691 return str;
692}
693
694/** Insert file at caret position.
695 *
696 * Reads in the contents of a file and inserts them at the current position
697 * of the caret.
698 */
699static errno_t file_insert(char *fname)
700{
701 FILE *f;
702 wchar_t c;
703 char buf[BUF_SIZE];
704 int bcnt;
705 int n_read;
706 size_t off;
707
708 f = fopen(fname, "rt");
709 if (f == NULL)
710 return EINVAL;
711
712 bcnt = 0;
713
714 while (true) {
715 if (bcnt < STR_BOUNDS(1)) {
716 n_read = fread(buf + bcnt, 1, BUF_SIZE - bcnt, f);
717 bcnt += n_read;
718 }
719
720 off = 0;
721 c = str_decode(buf, &off, bcnt);
722 if (c == '\0')
723 break;
724
725 bcnt -= off;
726 memcpy(buf, buf + off, bcnt);
727
728 insert_char(c);
729 }
730
731 fclose(f);
732
733 return EOK;
734}
735
736/** Save a range of text into a file. */
737static errno_t file_save_range(char const *fname, spt_t const *spos,
738 spt_t const *epos)
739{
740 FILE *f;
741 char buf[BUF_SIZE];
742 spt_t sp, bep;
743 size_t bytes, n_written;
744
745 f = fopen(fname, "wt");
746 if (f == NULL)
747 return EINVAL;
748
749 sp = *spos;
750
751 do {
752 sheet_copy_out(doc.sh, &sp, epos, buf, BUF_SIZE, &bep);
753 bytes = str_size(buf);
754
755 n_written = fwrite(buf, 1, bytes, f);
756 if (n_written != bytes) {
757 return EIO;
758 }
759
760 sp = bep;
761 } while (!spt_equal(&bep, epos));
762
763 if (fclose(f) < 0)
764 return EIO;
765
766 return EOK;
767}
768
769/** Return contents of range as a new string. */
770static char *range_get_str(spt_t const *spos, spt_t const *epos)
771{
772 char *buf;
773 spt_t sp, bep;
774 size_t bytes;
775 size_t buf_size, bpos;
776
777 buf_size = 1;
778
779 buf = malloc(buf_size);
780 if (buf == NULL)
781 return NULL;
782
783 bpos = 0;
784 sp = *spos;
785
786 while (true) {
787 sheet_copy_out(doc.sh, &sp, epos, &buf[bpos], buf_size - bpos,
788 &bep);
789 bytes = str_size(&buf[bpos]);
790 bpos += bytes;
791 sp = bep;
792
793 if (spt_equal(&bep, epos))
794 break;
795
796 buf_size *= 2;
797 buf = realloc(buf, buf_size);
798 if (buf == NULL)
799 return NULL;
800 }
801
802 return buf;
803}
804
805static void pane_text_display(void)
806{
807 int sh_rows, rows;
808
809 sheet_get_num_rows(doc.sh, &sh_rows);
810 rows = min(sh_rows - pane.sh_row + 1, pane.rows);
811
812 /* Draw rows from the sheet. */
813
814 console_set_pos(con, 0, 0);
815 pane_row_range_display(0, rows);
816
817 /* Clear the remaining rows if file is short. */
818
819 int i;
820 sysarg_t j;
821 for (i = rows; i < pane.rows; ++i) {
822 console_set_pos(con, 0, i);
823 for (j = 0; j < scr_columns; ++j)
824 putchar(' ');
825 console_flush(con);
826 }
827
828 pane.rflags |= (REDRAW_STATUS | REDRAW_CARET);
829 pane.rflags &= ~REDRAW_ROW;
830}
831
832/** Display just the row where the caret is. */
833static void pane_row_display(void)
834{
835 spt_t caret_pt;
836 coord_t coord;
837 int ridx;
838
839 tag_get_pt(&pane.caret_pos, &caret_pt);
840 spt_get_coord(&caret_pt, &coord);
841
842 ridx = coord.row - pane.sh_row;
843 pane_row_range_display(ridx, ridx + 1);
844 pane.rflags |= (REDRAW_STATUS | REDRAW_CARET);
845}
846
847static void pane_row_range_display(int r0, int r1)
848{
849 int i, j, fill;
850 spt_t rb, re, dep, pt;
851 coord_t rbc, rec;
852 char row_buf[ROW_BUF_SIZE];
853 wchar_t c;
854 size_t pos, size;
855 int s_column;
856 coord_t csel_start, csel_end, ctmp;
857
858 /* Determine selection start and end. */
859
860 tag_get_pt(&pane.sel_start, &pt);
861 spt_get_coord(&pt, &csel_start);
862
863 tag_get_pt(&pane.caret_pos, &pt);
864 spt_get_coord(&pt, &csel_end);
865
866 if (coord_cmp(&csel_start, &csel_end) > 0) {
867 ctmp = csel_start;
868 csel_start = csel_end;
869 csel_end = ctmp;
870 }
871
872 /* Draw rows from the sheet. */
873
874 console_set_pos(con, 0, 0);
875 for (i = r0; i < r1; ++i) {
876 /* Starting point for row display */
877 rbc.row = pane.sh_row + i;
878 rbc.column = pane.sh_column;
879 sheet_get_cell_pt(doc.sh, &rbc, dir_before, &rb);
880
881 /* Ending point for row display */
882 rec.row = pane.sh_row + i;
883 rec.column = pane.sh_column + pane.columns;
884 sheet_get_cell_pt(doc.sh, &rec, dir_before, &re);
885
886 /* Copy the text of the row to the buffer. */
887 sheet_copy_out(doc.sh, &rb, &re, row_buf, ROW_BUF_SIZE, &dep);
888
889 /* Display text from the buffer. */
890
891 if (coord_cmp(&csel_start, &rbc) <= 0 &&
892 coord_cmp(&rbc, &csel_end) < 0) {
893 console_flush(con);
894 console_set_style(con, STYLE_SELECTED);
895 console_flush(con);
896 }
897
898 console_set_pos(con, 0, i);
899 size = str_size(row_buf);
900 pos = 0;
901 s_column = pane.sh_column;
902 while (pos < size) {
903 if ((csel_start.row == rbc.row) && (csel_start.column == s_column)) {
904 console_flush(con);
905 console_set_style(con, STYLE_SELECTED);
906 console_flush(con);
907 }
908
909 if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
910 console_flush(con);
911 console_set_style(con, STYLE_NORMAL);
912 console_flush(con);
913 }
914
915 c = str_decode(row_buf, &pos, size);
916 if (c != '\t') {
917 printf("%lc", (wint_t) c);
918 s_column += 1;
919 } else {
920 fill = 1 + ALIGN_UP(s_column, TAB_WIDTH)
921 - s_column;
922
923 for (j = 0; j < fill; ++j)
924 putchar(' ');
925 s_column += fill;
926 }
927 }
928
929 if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
930 console_flush(con);
931 console_set_style(con, STYLE_NORMAL);
932 console_flush(con);
933 }
934
935 /* Fill until the end of display area. */
936
937 if ((unsigned)s_column - 1 < scr_columns)
938 fill = scr_columns - (s_column - 1);
939 else
940 fill = 0;
941
942 for (j = 0; j < fill; ++j)
943 putchar(' ');
944 console_flush(con);
945 console_set_style(con, STYLE_NORMAL);
946 }
947
948 pane.rflags |= REDRAW_CARET;
949}
950
951/** Display pane status in the status line. */
952static void pane_status_display(void)
953{
954 spt_t caret_pt;
955 coord_t coord;
956 int last_row;
957 char *fname;
958 char *p;
959 char *text;
960 size_t n;
961 int pos;
962 size_t nextra;
963 size_t fnw;
964
965 tag_get_pt(&pane.caret_pos, &caret_pt);
966 spt_get_coord(&caret_pt, &coord);
967
968 sheet_get_num_rows(doc.sh, &last_row);
969
970 if (doc.file_name != NULL) {
971 /* Remove directory component */
972 p = str_rchr(doc.file_name, '/');
973 if (p != NULL)
974 fname = str_dup(p + 1);
975 else
976 fname = str_dup(doc.file_name);
977 } else {
978 fname = str_dup("<unnamed>");
979 }
980
981 if (fname == NULL)
982 return;
983
984 console_set_pos(con, 0, scr_rows - 1);
985 console_set_style(con, STYLE_INVERTED);
986
987 /*
988 * Make sure the status fits on the screen. This loop should
989 * be executed at most twice.
990 */
991 while (true) {
992 int rc = asprintf(&text, " %d, %d (%d): File '%s'. Ctrl-Q Quit Ctrl-S Save "
993 "Ctrl-E Save As", coord.row, coord.column, last_row, fname);
994 if (rc < 0) {
995 n = 0;
996 goto finish;
997 }
998
999 /* If it already fits, we're done */
1000 n = str_width(text);
1001 if (n <= scr_columns - 2)
1002 break;
1003
1004 /* Compute number of excess characters */
1005 nextra = n - (scr_columns - 2);
1006 /** With of the file name part */
1007 fnw = str_width(fname);
1008
1009 /*
1010 * If reducing file name to two characters '..' won't help,
1011 * just give up and print a blank status.
1012 */
1013 if (nextra > fnw - 2)
1014 goto finish;
1015
1016 /* Compute position where we overwrite with '..\0' */
1017 if (fnw >= nextra + 2) {
1018 p = fname + str_lsize(fname, fnw - nextra - 2);
1019 } else {
1020 p = fname;
1021 }
1022
1023 /* Shorten the string */
1024 p[0] = p[1] = '.';
1025 p[2] = '\0';
1026
1027 /* Need to format the string once more. */
1028 free(text);
1029 }
1030
1031 printf("%s", text);
1032 free(text);
1033 free(fname);
1034finish:
1035 /* Fill the rest of the line */
1036 pos = scr_columns - 1 - n;
1037 printf("%*s", pos, "");
1038 console_flush(con);
1039 console_set_style(con, STYLE_NORMAL);
1040
1041 pane.rflags |= REDRAW_CARET;
1042}
1043
1044/** Set cursor to reflect position of the caret. */
1045static void pane_caret_display(void)
1046{
1047 spt_t caret_pt;
1048 coord_t coord;
1049
1050 tag_get_pt(&pane.caret_pos, &caret_pt);
1051
1052 spt_get_coord(&caret_pt, &coord);
1053 console_set_pos(con, coord.column - pane.sh_column,
1054 coord.row - pane.sh_row);
1055}
1056
1057/** Insert a character at caret position. */
1058static void insert_char(wchar_t c)
1059{
1060 spt_t pt;
1061 char cbuf[STR_BOUNDS(1) + 1];
1062 size_t offs;
1063
1064 tag_get_pt(&pane.caret_pos, &pt);
1065
1066 offs = 0;
1067 chr_encode(c, cbuf, &offs, STR_BOUNDS(1) + 1);
1068 cbuf[offs] = '\0';
1069
1070 (void) sheet_insert(doc.sh, &pt, dir_before, cbuf);
1071
1072 pane.rflags |= REDRAW_ROW;
1073 if (c == '\n')
1074 pane.rflags |= REDRAW_TEXT;
1075}
1076
1077/** Delete the character before the caret. */
1078static void delete_char_before(void)
1079{
1080 spt_t sp, ep;
1081 coord_t coord;
1082
1083 tag_get_pt(&pane.caret_pos, &ep);
1084 spt_get_coord(&ep, &coord);
1085
1086 coord.column -= 1;
1087 sheet_get_cell_pt(doc.sh, &coord, dir_before, &sp);
1088
1089 (void) sheet_delete(doc.sh, &sp, &ep);
1090
1091 pane.rflags |= REDRAW_ROW;
1092 if (coord.column < 1)
1093 pane.rflags |= REDRAW_TEXT;
1094}
1095
1096/** Delete the character after the caret. */
1097static void delete_char_after(void)
1098{
1099 spt_t sp, ep;
1100 coord_t sc, ec;
1101
1102 tag_get_pt(&pane.caret_pos, &sp);
1103 spt_get_coord(&sp, &sc);
1104
1105 sheet_get_cell_pt(doc.sh, &sc, dir_after, &ep);
1106 spt_get_coord(&ep, &ec);
1107
1108 (void) sheet_delete(doc.sh, &sp, &ep);
1109
1110 pane.rflags |= REDRAW_ROW;
1111 if (ec.row != sc.row)
1112 pane.rflags |= REDRAW_TEXT;
1113}
1114
1115/** Scroll pane after caret has moved.
1116 *
1117 * After modifying the position of the caret, this is called to scroll
1118 * the pane to ensure that the caret is in the visible area.
1119 */
1120static void caret_update(void)
1121{
1122 spt_t pt;
1123 coord_t coord;
1124
1125 tag_get_pt(&pane.caret_pos, &pt);
1126 spt_get_coord(&pt, &coord);
1127
1128 /* Scroll pane vertically. */
1129
1130 if (coord.row < pane.sh_row) {
1131 pane.sh_row = coord.row;
1132 pane.rflags |= REDRAW_TEXT;
1133 }
1134
1135 if (coord.row > pane.sh_row + pane.rows - 1) {
1136 pane.sh_row = coord.row - pane.rows + 1;
1137 pane.rflags |= REDRAW_TEXT;
1138 }
1139
1140 /* Scroll pane horizontally. */
1141
1142 if (coord.column < pane.sh_column) {
1143 pane.sh_column = coord.column;
1144 pane.rflags |= REDRAW_TEXT;
1145 }
1146
1147 if (coord.column > pane.sh_column + pane.columns - 1) {
1148 pane.sh_column = coord.column - pane.columns + 1;
1149 pane.rflags |= REDRAW_TEXT;
1150 }
1151
1152 pane.rflags |= (REDRAW_CARET | REDRAW_STATUS);
1153}
1154
1155/** Relatively move caret position.
1156 *
1157 * Moves caret relatively to the current position. Looking at the first
1158 * character cell after the caret and moving by @a drow and @a dcolumn, we get
1159 * to a new character cell, and thus a new character. Then we either go to the
1160 * point before the the character or after it, depending on @a align_dir.
1161 *
1162 * @param select true if the selection tag should stay where it is
1163 */
1164static void caret_move_relative(int drow, int dcolumn, enum dir_spec align_dir,
1165 bool select)
1166{
1167 spt_t pt;
1168 coord_t coord;
1169 int num_rows;
1170 bool pure_vertical;
1171
1172 tag_get_pt(&pane.caret_pos, &pt);
1173 spt_get_coord(&pt, &coord);
1174 coord.row += drow; coord.column += dcolumn;
1175
1176 /* Clamp coordinates. */
1177 if (drow < 0 && coord.row < 1) coord.row = 1;
1178 if (dcolumn < 0 && coord.column < 1) {
1179 if (coord.row < 2)
1180 coord.column = 1;
1181 else {
1182 coord.row--;
1183 sheet_get_row_width(doc.sh, coord.row, &coord.column);
1184 }
1185 }
1186 if (drow > 0) {
1187 sheet_get_num_rows(doc.sh, &num_rows);
1188 if (coord.row > num_rows) coord.row = num_rows;
1189 }
1190
1191 /* For purely vertical movement try attaining @c ideal_column. */
1192 pure_vertical = (dcolumn == 0 && align_dir == dir_before);
1193 if (pure_vertical)
1194 coord.column = pane.ideal_column;
1195
1196 /*
1197 * Select the point before or after the character at the designated
1198 * coordinates. The character can be wider than one cell (e.g. tab).
1199 */
1200 sheet_get_cell_pt(doc.sh, &coord, align_dir, &pt);
1201
1202 /* For non-vertical movement set the new value for @c ideal_column. */
1203 caret_move(pt, select, !pure_vertical);
1204}
1205
1206/** Absolutely move caret position.
1207 *
1208 * Moves caret to a specified position. We get to a new character cell, and
1209 * thus a new character. Then we either go to the point before the the character
1210 * or after it, depending on @a align_dir.
1211 *
1212 * @param select true if the selection tag should stay where it is
1213 */
1214static void caret_move_absolute(int row, int column, enum dir_spec align_dir,
1215 bool select)
1216{
1217 coord_t coord;
1218 coord.row = row;
1219 coord.column = column;
1220
1221 spt_t pt;
1222 sheet_get_cell_pt(doc.sh, &coord, align_dir, &pt);
1223
1224 caret_move(pt, select, true);
1225}
1226
1227/** Find beginning of a word to the left of spt */
1228static spt_t pt_find_word_left(spt_t spt)
1229{
1230 do {
1231 spt_prev_char(spt, &spt);
1232 } while (!pt_is_word_beginning(&spt));
1233 return spt;
1234}
1235
1236/** Find beginning of a word to the right of spt */
1237static spt_t pt_find_word_right(spt_t spt)
1238{
1239 do {
1240 spt_next_char(spt, &spt);
1241 } while (!pt_is_word_beginning(&spt));
1242 return spt;
1243}
1244
1245static void caret_move_word_left(bool select)
1246{
1247 spt_t pt;
1248 tag_get_pt(&pane.caret_pos, &pt);
1249 spt_t word_left = pt_find_word_left(pt);
1250 caret_move(word_left, select, true);
1251}
1252
1253static void caret_move_word_right(bool select)
1254{
1255 spt_t pt;
1256 tag_get_pt(&pane.caret_pos, &pt);
1257 spt_t word_right = pt_find_word_right(pt);
1258 caret_move(word_right, select, true);
1259}
1260
1261/** Ask for line and go to it. */
1262static void caret_go_to_line_ask(void)
1263{
1264 char *sline;
1265
1266 sline = prompt("Go to line", "");
1267 if (sline == NULL) {
1268 status_display("Go to line cancelled.");
1269 return;
1270 }
1271
1272 char *endptr;
1273 int line = strtol(sline, &endptr, 10);
1274 if (*endptr != '\0') {
1275 free(sline);
1276 status_display("Invalid number entered.");
1277 return;
1278 }
1279 free(sline);
1280
1281 caret_move_absolute(line, pane.ideal_column, dir_before, false);
1282}
1283
1284/* Search operations */
1285static errno_t search_spt_producer(void *data, wchar_t *ret)
1286{
1287 assert(data != NULL);
1288 assert(ret != NULL);
1289 spt_t *spt = data;
1290 *ret = spt_next_char(*spt, spt);
1291 return EOK;
1292}
1293
1294static errno_t search_spt_reverse_producer(void *data, wchar_t *ret)
1295{
1296 assert(data != NULL);
1297 assert(ret != NULL);
1298 spt_t *spt = data;
1299 *ret = spt_prev_char(*spt, spt);
1300 return EOK;
1301}
1302
1303static errno_t search_spt_mark(void *data, void **mark)
1304{
1305 assert(data != NULL);
1306 assert(mark != NULL);
1307 spt_t *spt = data;
1308 spt_t *new = calloc(1, sizeof(spt_t));
1309 *mark = new;
1310 if (new == NULL)
1311 return ENOMEM;
1312 *new = *spt;
1313 return EOK;
1314}
1315
1316static void search_spt_mark_free(void *data)
1317{
1318 free(data);
1319}
1320
1321static search_ops_t search_spt_ops = {
1322 .equals = char_exact_equals,
1323 .producer = search_spt_producer,
1324 .mark = search_spt_mark,
1325 .mark_free = search_spt_mark_free,
1326};
1327
1328static search_ops_t search_spt_reverse_ops = {
1329 .equals = char_exact_equals,
1330 .producer = search_spt_reverse_producer,
1331 .mark = search_spt_mark,
1332 .mark_free = search_spt_mark_free,
1333};
1334
1335/** Ask for line and go to it. */
1336static void search_prompt(bool reverse)
1337{
1338 char *pattern;
1339
1340 const char *prompt_text = "Find next";
1341 if (reverse)
1342 prompt_text = "Find previous";
1343
1344 const char *default_value = "";
1345 if (pane.previous_search)
1346 default_value = pane.previous_search;
1347
1348 pattern = prompt(prompt_text, default_value);
1349 if (pattern == NULL) {
1350 status_display("Search cancelled.");
1351 return;
1352 }
1353
1354 if (pane.previous_search)
1355 free(pane.previous_search);
1356 pane.previous_search = pattern;
1357 pane.previous_search_reverse = reverse;
1358
1359 search(pattern, reverse);
1360}
1361
1362static void search_repeat(void)
1363{
1364 if (pane.previous_search == NULL) {
1365 status_display("No previous search to repeat.");
1366 return;
1367 }
1368
1369 search(pane.previous_search, pane.previous_search_reverse);
1370}
1371
1372static void search(char *pattern, bool reverse)
1373{
1374 status_display("Searching...");
1375
1376 spt_t sp, producer_pos;
1377 tag_get_pt(&pane.caret_pos, &sp);
1378
1379 /* Start searching on the position before/after caret */
1380 if (!reverse) {
1381 spt_next_char(sp, &sp);
1382 }
1383 else {
1384 spt_prev_char(sp, &sp);
1385 }
1386 producer_pos = sp;
1387
1388 search_ops_t ops = search_spt_ops;
1389 if (reverse)
1390 ops = search_spt_reverse_ops;
1391
1392 search_t *search = search_init(pattern, &producer_pos, ops, reverse);
1393 if (search == NULL) {
1394 status_display("Failed initializing search.");
1395 return;
1396 }
1397
1398 match_t match;
1399 errno_t rc = search_next_match(search, &match);
1400 if (rc != EOK) {
1401 status_display("Failed searching.");
1402 search_fini(search);
1403 }
1404
1405 if (match.end) {
1406 status_display("Match found.");
1407 assert(match.end != NULL);
1408 spt_t *end = match.end;
1409 caret_move(*end, false, true);
1410 while (match.length > 0) {
1411 match.length--;
1412 if (reverse) {
1413 spt_next_char(*end, end);
1414 }
1415 else {
1416 spt_prev_char(*end, end);
1417 }
1418 }
1419 caret_move(*end, true, true);
1420 free(end);
1421 }
1422 else {
1423 status_display("Not found.");
1424 }
1425
1426 search_fini(search);
1427}
1428
1429/** Check for non-empty selection. */
1430static bool selection_active(void)
1431{
1432 return (tag_cmp(&pane.caret_pos, &pane.sel_start) != 0);
1433}
1434
1435static void selection_get_points(spt_t *pa, spt_t *pb)
1436{
1437 spt_t pt;
1438
1439 tag_get_pt(&pane.sel_start, pa);
1440 tag_get_pt(&pane.caret_pos, pb);
1441
1442 if (spt_cmp(pa, pb) > 0) {
1443 pt = *pa;
1444 *pa = *pb;
1445 *pb = pt;
1446 }
1447}
1448
1449/** Delete selected text. */
1450static void selection_delete(void)
1451{
1452 spt_t pa, pb;
1453 coord_t ca, cb;
1454 int rel;
1455
1456 tag_get_pt(&pane.sel_start, &pa);
1457 tag_get_pt(&pane.caret_pos, &pb);
1458 spt_get_coord(&pa, &ca);
1459 spt_get_coord(&pb, &cb);
1460 rel = coord_cmp(&ca, &cb);
1461
1462 if (rel == 0)
1463 return;
1464
1465 if (rel < 0)
1466 sheet_delete(doc.sh, &pa, &pb);
1467 else
1468 sheet_delete(doc.sh, &pb, &pa);
1469
1470 if (ca.row == cb.row)
1471 pane.rflags |= REDRAW_ROW;
1472 else
1473 pane.rflags |= REDRAW_TEXT;
1474}
1475
1476/** Select all text in the editor */
1477static void selection_sel_all(void)
1478{
1479 spt_t spt, ept;
1480
1481 pt_get_sof(&spt);
1482 pt_get_eof(&ept);
1483
1484 selection_sel_range(spt, ept);
1485}
1486
1487/** Select select all text in a given range with the given direction */
1488static void selection_sel_range(spt_t pa, spt_t pb)
1489{
1490 sheet_remove_tag(doc.sh, &pane.sel_start);
1491 sheet_place_tag(doc.sh, &pa, &pane.sel_start);
1492 sheet_remove_tag(doc.sh, &pane.caret_pos);
1493 sheet_place_tag(doc.sh, &pb, &pane.caret_pos);
1494
1495 pane.rflags |= REDRAW_TEXT;
1496 caret_update();
1497}
1498
1499static void selection_copy(void)
1500{
1501 spt_t pa, pb;
1502 char *str;
1503
1504 selection_get_points(&pa, &pb);
1505 str = range_get_str(&pa, &pb);
1506 if (str == NULL || clipboard_put_str(str) != EOK) {
1507 status_display("Copying to clipboard failed!");
1508 }
1509 free(str);
1510}
1511
1512static void insert_clipboard_data(void)
1513{
1514 char *str;
1515 size_t off;
1516 wchar_t c;
1517 errno_t rc;
1518
1519 rc = clipboard_get_str(&str);
1520 if (rc != EOK || str == NULL)
1521 return;
1522
1523 off = 0;
1524
1525 while (true) {
1526 c = str_decode(str, &off, STR_NO_LIMIT);
1527 if (c == '\0')
1528 break;
1529
1530 insert_char(c);
1531 }
1532
1533 free(str);
1534}
1535
1536/** Get start-of-file s-point. */
1537static void pt_get_sof(spt_t *pt)
1538{
1539 coord_t coord;
1540
1541 coord.row = coord.column = 1;
1542 sheet_get_cell_pt(doc.sh, &coord, dir_before, pt);
1543}
1544
1545/** Get end-of-file s-point. */
1546static void pt_get_eof(spt_t *pt)
1547{
1548 coord_t coord;
1549 int num_rows;
1550
1551 sheet_get_num_rows(doc.sh, &num_rows);
1552 coord.row = num_rows + 1;
1553 coord.column = 1;
1554
1555 sheet_get_cell_pt(doc.sh, &coord, dir_after, pt);
1556}
1557
1558/** Get start-of-line s-point for given s-point cpt */
1559static void pt_get_sol(spt_t *cpt, spt_t *spt)
1560{
1561 coord_t coord;
1562
1563 spt_get_coord(cpt, &coord);
1564 coord.column = 1;
1565
1566 sheet_get_cell_pt(doc.sh, &coord, dir_before, spt);
1567}
1568
1569/** Get end-of-line s-point for given s-point cpt */
1570static void pt_get_eol(spt_t *cpt, spt_t *ept)
1571{
1572 coord_t coord;
1573 int row_width;
1574
1575 spt_get_coord(cpt, &coord);
1576 sheet_get_row_width(doc.sh, coord.row, &row_width);
1577 coord.column = row_width - 1;
1578
1579 sheet_get_cell_pt(doc.sh, &coord, dir_after, ept);
1580}
1581
1582/** Check whether the spt is at a beginning of a word */
1583static bool pt_is_word_beginning(spt_t *pt)
1584{
1585 spt_t lp, sfp, efp, slp, elp;
1586 coord_t coord;
1587
1588 pt_get_sof(&sfp);
1589 pt_get_eof(&efp);
1590 pt_get_sol(pt, &slp);
1591 pt_get_eol(pt, &elp);
1592
1593 /* the spt is at the beginning or end of the file or line */
1594 if ((spt_cmp(&sfp, pt) == 0) || (spt_cmp(&efp, pt) == 0)
1595 || (spt_cmp(&slp, pt) == 0) || (spt_cmp(&elp, pt) == 0))
1596 return true;
1597
1598 /* the spt is a delimiter */
1599 if (pt_is_delimiter(pt))
1600 return false;
1601
1602 spt_get_coord(pt, &coord);
1603
1604 coord.column -= 1;
1605 sheet_get_cell_pt(doc.sh, &coord, dir_before, &lp);
1606
1607 return pt_is_delimiter(&lp)
1608 || (pt_is_punctuation(pt) && !pt_is_punctuation(&lp))
1609 || (pt_is_punctuation(&lp) && !pt_is_punctuation(pt));
1610}
1611
1612static wchar_t get_first_wchar(const char *str)
1613{
1614 size_t offset = 0;
1615 return str_decode(str, &offset, str_size(str));
1616}
1617
1618static bool pt_is_delimiter(spt_t *pt)
1619{
1620 spt_t rp;
1621 coord_t coord;
1622 char *ch = NULL;
1623
1624 spt_get_coord(pt, &coord);
1625
1626 coord.column += 1;
1627 sheet_get_cell_pt(doc.sh, &coord, dir_after, &rp);
1628
1629 ch = range_get_str(pt, &rp);
1630 if (ch == NULL)
1631 return false;
1632
1633 wchar_t first_char = get_first_wchar(ch);
1634 switch(first_char) {
1635 case ' ':
1636 case '\t':
1637 case '\n':
1638 return true;
1639 default:
1640 return false;
1641 }
1642}
1643
1644static bool pt_is_punctuation(spt_t *pt)
1645{
1646 spt_t rp;
1647 coord_t coord;
1648 char *ch = NULL;
1649
1650 spt_get_coord(pt, &coord);
1651
1652 coord.column += 1;
1653 sheet_get_cell_pt(doc.sh, &coord, dir_after, &rp);
1654
1655 ch = range_get_str(pt, &rp);
1656 if (ch == NULL)
1657 return false;
1658
1659 wchar_t first_char = get_first_wchar(ch);
1660 switch(first_char) {
1661 case ',':
1662 case '.':
1663 case ';':
1664 case ':':
1665 case '/':
1666 case '?':
1667 case '\\':
1668 case '|':
1669 case '_':
1670 case '+':
1671 case '-':
1672 case '*':
1673 case '=':
1674 case '<':
1675 case '>':
1676 return true;
1677 default:
1678 return false;
1679 }
1680}
1681
1682/** Compare tags. */
1683static int tag_cmp(tag_t const *a, tag_t const *b)
1684{
1685 spt_t pa, pb;
1686
1687 tag_get_pt(a, &pa);
1688 tag_get_pt(b, &pb);
1689
1690 return spt_cmp(&pa, &pb);
1691}
1692
1693/** Compare s-points. */
1694static int spt_cmp(spt_t const *a, spt_t const *b)
1695{
1696 coord_t ca, cb;
1697
1698 spt_get_coord(a, &ca);
1699 spt_get_coord(b, &cb);
1700
1701 return coord_cmp(&ca, &cb);
1702}
1703
1704/** Compare coordinats. */
1705static int coord_cmp(coord_t const *a, coord_t const *b)
1706{
1707 if (a->row - b->row != 0)
1708 return a->row - b->row;
1709
1710 return a->column - b->column;
1711}
1712
1713/** Display text in the status line. */
1714static void status_display(char const *str)
1715{
1716 console_set_pos(con, 0, scr_rows - 1);
1717 console_set_style(con, STYLE_INVERTED);
1718
1719 int pos = -(scr_columns - 3);
1720 printf(" %*s ", pos, str);
1721 console_flush(con);
1722 console_set_style(con, STYLE_NORMAL);
1723
1724 pane.rflags |= REDRAW_CARET;
1725}
1726
1727/** @}
1728 */
Note: See TracBrowser for help on using the repository browser.