source: mainline/uspace/app/edit/edit.c@ 0902edfe

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 0902edfe was 0902edfe, checked in by Jiri Svoboda <jiri@…>, 16 years ago

Editor copy and paste. Clipboard API with task-local implementation.
  • Property mode set to 100644
File size: 23.3 KB
Line 
1/*
2 * Copyright (c) 2009 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup edit
30 * @brief Text editor.
31 * @{
32 */
33/**
34 * @file
35 */
36
37#include <stdio.h>
38#include <stdlib.h>
39#include <sys/types.h>
40#include <vfs/vfs.h>
41#include <io/console.h>
42#include <io/color.h>
43#include <io/keycode.h>
44#include <errno.h>
45#include <align.h>
46#include <macros.h>
47#include <clipboard.h>
48#include <bool.h>
49
50#include "sheet.h"
51
52enum redraw_flags {
53 REDRAW_TEXT = (1 << 0),
54 REDRAW_ROW = (1 << 1),
55 REDRAW_STATUS = (1 << 2),
56 REDRAW_CARET = (1 << 3)
57};
58
59/** Pane
60 *
61 * A rectangular area of the screen used to edit a document. Different
62 * panes can be possibly used to edit the same document.
63 */
64typedef struct {
65 /* Pane dimensions */
66 int rows, columns;
67
68 /* Position of the visible area */
69 int sh_row, sh_column;
70
71 /** Bitmask of components that need redrawing */
72 enum redraw_flags rflags;
73
74 /** Current position of the caret */
75 tag_t caret_pos;
76
77 /** Start of selection */
78 tag_t sel_start;
79
80 /**
81 * Ideal column where the caret should try to get. This is used
82 * for maintaining the same column during vertical movement.
83 */
84 int ideal_column;
85} pane_t;
86
87/** Document
88 *
89 * Associates a sheet with a file where it can be saved to.
90 */
91typedef struct {
92 char *file_name;
93 sheet_t sh;
94} doc_t;
95
96static int con;
97static doc_t doc;
98static bool done;
99static pane_t pane;
100
101static int scr_rows, scr_columns;
102
103#define ROW_BUF_SIZE 4096
104#define BUF_SIZE 64
105#define TAB_WIDTH 8
106#define ED_INFTY 65536
107
108/** Maximum filename length that can be entered. */
109#define INFNAME_MAX_LEN 128
110
111static void key_handle_unmod(console_event_t const *ev);
112static void key_handle_ctrl(console_event_t const *ev);
113static void key_handle_shift(console_event_t const *ev);
114static void key_handle_movement(unsigned int key, bool shift);
115
116static int file_save(char const *fname);
117static void file_save_as(void);
118static int file_insert(char *fname);
119static int file_save_range(char const *fname, spt_t const *spos,
120 spt_t const *epos);
121static char *filename_prompt(char const *prompt, char const *init_value);
122static char *range_get_str(spt_t const *spos, spt_t const *epos);
123
124static void pane_text_display(void);
125static void pane_row_display(void);
126static void pane_row_range_display(int r0, int r1);
127static void pane_status_display(void);
128static void pane_caret_display(void);
129
130static void insert_char(wchar_t c);
131static void delete_char_before(void);
132static void delete_char_after(void);
133static void caret_update(void);
134static void caret_move(int drow, int dcolumn, enum dir_spec align_dir);
135
136static bool selection_active(void);
137static void selection_get_points(spt_t *pa, spt_t *pb);
138static void selection_delete(void);
139static void selection_copy(void);
140static void insert_clipboard_data(void);
141
142static void pt_get_sof(spt_t *pt);
143static void pt_get_eof(spt_t *pt);
144static int tag_cmp(tag_t const *a, tag_t const *b);
145static int spt_cmp(spt_t const *a, spt_t const *b);
146static int coord_cmp(coord_t const *a, coord_t const *b);
147
148static void status_display(char const *str);
149
150
151int main(int argc, char *argv[])
152{
153 console_event_t ev;
154 coord_t coord;
155 bool new_file;
156
157 spt_t pt;
158
159 con = fphone(stdout);
160 console_clear(con);
161
162 console_get_size(con, &scr_columns, &scr_rows);
163
164 pane.rows = scr_rows - 1;
165 pane.columns = scr_columns;
166 pane.sh_row = 1;
167 pane.sh_column = 1;
168
169 /* Start with an empty sheet. */
170 sheet_init(&doc.sh);
171
172 /* Place caret at the beginning of file. */
173 coord.row = coord.column = 1;
174 sheet_get_cell_pt(&doc.sh, &coord, dir_before, &pt);
175 sheet_place_tag(&doc.sh, &pt, &pane.caret_pos);
176 pane.ideal_column = coord.column;
177
178 if (argc == 2) {
179 doc.file_name = str_dup(argv[1]);
180 } else if (argc > 1) {
181 printf("Invalid arguments.\n");
182 return -2;
183 } else {
184 doc.file_name = NULL;
185 }
186
187 new_file = false;
188
189 if (doc.file_name == NULL || file_insert(doc.file_name) != EOK)
190 new_file = true;
191
192 /* Move to beginning of file. */
193 caret_move(-ED_INFTY, -ED_INFTY, dir_before);
194
195 /* Place selection start tag. */
196 tag_get_pt(&pane.caret_pos, &pt);
197 sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
198
199 /* Initial display */
200 console_clear(con);
201 pane_text_display();
202 pane_status_display();
203 if (new_file && doc.file_name != NULL)
204 status_display("File not found. Starting empty file.");
205 pane_caret_display();
206
207
208 done = false;
209
210 while (!done) {
211 console_get_event(con, &ev);
212 pane.rflags = 0;
213
214 if (ev.type == KEY_PRESS) {
215 /* Handle key press. */
216 if (((ev.mods & KM_ALT) == 0) &&
217 ((ev.mods & KM_SHIFT) == 0) &&
218 (ev.mods & KM_CTRL) != 0) {
219 key_handle_ctrl(&ev);
220 } else if (((ev.mods & KM_ALT) == 0) &&
221 ((ev.mods & KM_CTRL) == 0) &&
222 (ev.mods & KM_SHIFT) != 0) {
223 key_handle_shift(&ev);
224 } else if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
225 key_handle_unmod(&ev);
226 }
227 }
228
229 /* Redraw as necessary. */
230
231 if (pane.rflags & REDRAW_TEXT)
232 pane_text_display();
233 if (pane.rflags & REDRAW_ROW)
234 pane_row_display();
235 if (pane.rflags & REDRAW_STATUS)
236 pane_status_display();
237 if (pane.rflags & REDRAW_CARET)
238 pane_caret_display();
239 }
240
241 console_clear(con);
242
243 return 0;
244}
245
246/** Handle key without modifier. */
247static void key_handle_unmod(console_event_t const *ev)
248{
249 switch (ev->key) {
250 case KC_ENTER:
251 selection_delete();
252 insert_char('\n');
253 caret_update();
254 break;
255 case KC_LEFT:
256 case KC_RIGHT:
257 case KC_UP:
258 case KC_DOWN:
259 case KC_HOME:
260 case KC_END:
261 case KC_PAGE_UP:
262 case KC_PAGE_DOWN:
263 key_handle_movement(ev->key, false);
264 break;
265 case KC_BACKSPACE:
266 if (selection_active())
267 selection_delete();
268 else
269 delete_char_before();
270 caret_update();
271 break;
272 case KC_DELETE:
273 if (selection_active())
274 selection_delete();
275 else
276 delete_char_after();
277 caret_update();
278 break;
279 default:
280 if (ev->c >= 32 || ev->c == '\t') {
281 selection_delete();
282 insert_char(ev->c);
283 caret_update();
284 }
285 break;
286 }
287}
288
289/** Handle Shift-key combination. */
290static void key_handle_shift(console_event_t const *ev)
291{
292 switch (ev->key) {
293 case KC_LEFT:
294 case KC_RIGHT:
295 case KC_UP:
296 case KC_DOWN:
297 case KC_HOME:
298 case KC_END:
299 case KC_PAGE_UP:
300 case KC_PAGE_DOWN:
301 key_handle_movement(ev->key, true);
302 break;
303 default:
304 if (ev->c >= 32 || ev->c == '\t') {
305 selection_delete();
306 insert_char(ev->c);
307 caret_update();
308 }
309 break;
310 }
311}
312
313/** Handle Ctrl-key combination. */
314static void key_handle_ctrl(console_event_t const *ev)
315{
316 switch (ev->key) {
317 case KC_Q:
318 done = true;
319 break;
320 case KC_S:
321 if (doc.file_name != NULL)
322 file_save(doc.file_name);
323 else
324 file_save_as();
325 break;
326 case KC_E:
327 file_save_as();
328 break;
329 case KC_C:
330 selection_copy();
331 break;
332 case KC_V:
333 selection_delete();
334 insert_clipboard_data();
335 pane.rflags |= REDRAW_TEXT;
336 caret_update();
337 break;
338 default:
339 break;
340 }
341}
342
343static void key_handle_movement(unsigned int key, bool select)
344{
345 spt_t pt;
346 spt_t caret_pt;
347 coord_t c_old, c_new;
348 bool had_sel;
349
350 /* Check if we had selection before. */
351 tag_get_pt(&pane.caret_pos, &caret_pt);
352 tag_get_pt(&pane.sel_start, &pt);
353 had_sel = !spt_equal(&caret_pt, &pt);
354
355 switch (key) {
356 case KC_LEFT:
357 caret_move(0, -1, dir_before);
358 break;
359 case KC_RIGHT:
360 caret_move(0, 0, dir_after);
361 break;
362 case KC_UP:
363 caret_move(-1, 0, dir_before);
364 break;
365 case KC_DOWN:
366 caret_move(+1, 0, dir_before);
367 break;
368 case KC_HOME:
369 caret_move(0, -ED_INFTY, dir_before);
370 break;
371 case KC_END:
372 caret_move(0, +ED_INFTY, dir_before);
373 break;
374 case KC_PAGE_UP:
375 caret_move(-pane.rows, 0, dir_before);
376 break;
377 case KC_PAGE_DOWN:
378 caret_move(+pane.rows, 0, dir_before);
379 break;
380 default:
381 break;
382 }
383
384 if (select == false) {
385 /* Move sel_start to the same point as caret. */
386 sheet_remove_tag(&doc.sh, &pane.sel_start);
387 tag_get_pt(&pane.caret_pos, &pt);
388 sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
389 }
390
391 if (select) {
392 tag_get_pt(&pane.caret_pos, &pt);
393 spt_get_coord(&caret_pt, &c_old);
394 spt_get_coord(&pt, &c_new);
395
396 if (c_old.row == c_new.row)
397 pane.rflags |= REDRAW_ROW;
398 else
399 pane.rflags |= REDRAW_TEXT;
400
401 } else if (had_sel == true) {
402 /* Redraw because text was unselected. */
403 pane.rflags |= REDRAW_TEXT;
404 }
405}
406
407/** Save the document. */
408static int file_save(char const *fname)
409{
410 spt_t sp, ep;
411 int rc;
412
413 status_display("Saving...");
414 pt_get_sof(&sp);
415 pt_get_eof(&ep);
416
417 rc = file_save_range(fname, &sp, &ep);
418
419 switch (rc) {
420 case EINVAL:
421 status_display("Error opening file!");
422 break;
423 case EIO:
424 status_display("Error writing data!");
425 break;
426 default:
427 status_display("File saved.");
428 break;
429 }
430
431 return rc;
432}
433
434/** Change document name and save. */
435static void file_save_as(void)
436{
437 char *old_fname, *fname;
438 int rc;
439
440 old_fname = (doc.file_name != NULL) ? doc.file_name : "";
441 fname = filename_prompt("Save As", old_fname);
442 if (fname == NULL) {
443 status_display("Save cancelled.");
444 return;
445 }
446
447 rc = file_save(fname);
448 if (rc != EOK)
449 return;
450
451 if (doc.file_name != NULL)
452 free(doc.file_name);
453 doc.file_name = fname;
454}
455
456/** Ask for a file name. */
457static char *filename_prompt(char const *prompt, char const *init_value)
458{
459 console_event_t ev;
460 char *str;
461 wchar_t buffer[INFNAME_MAX_LEN + 1];
462 int max_len;
463 int nc;
464 bool done;
465
466 asprintf(&str, "%s: %s", prompt, init_value);
467 status_display(str);
468 console_goto(con, 1 + str_length(str), scr_rows - 1);
469 free(str);
470
471 console_set_color(con, COLOR_WHITE, COLOR_BLACK, 0);
472
473 max_len = min(INFNAME_MAX_LEN, scr_columns - 4 - str_length(prompt));
474 str_to_wstr(buffer, max_len + 1, init_value);
475 nc = wstr_length(buffer);
476 done = false;
477
478 while (!done) {
479 console_get_event(con, &ev);
480
481 if (ev.type == KEY_PRESS) {
482 /* Handle key press. */
483 if (((ev.mods & KM_ALT) == 0) &&
484 (ev.mods & KM_CTRL) != 0) {
485 ;
486 } else if ((ev.mods & (KM_CTRL | KM_ALT)) == 0) {
487 switch (ev.key) {
488 case KC_ESCAPE:
489 return NULL;
490 case KC_BACKSPACE:
491 if (nc > 0) {
492 putchar('\b');
493 fflush(stdout);
494 --nc;
495 }
496 break;
497 case KC_ENTER:
498 done = true;
499 break;
500 default:
501 if (ev.c >= 32 && nc < max_len) {
502 putchar(ev.c);
503 fflush(stdout);
504 buffer[nc++] = ev.c;
505 }
506 break;
507 }
508 }
509 }
510 }
511
512 buffer[nc] = '\0';
513 str = wstr_to_astr(buffer);
514
515 console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
516
517 return str;
518}
519
520/** Insert file at caret position.
521 *
522 * Reads in the contents of a file and inserts them at the current position
523 * of the caret.
524 */
525static int file_insert(char *fname)
526{
527 FILE *f;
528 wchar_t c;
529 char buf[BUF_SIZE];
530 int bcnt;
531 int n_read;
532 size_t off;
533
534 f = fopen(fname, "rt");
535 if (f == NULL)
536 return EINVAL;
537
538 bcnt = 0;
539
540 while (true) {
541 if (bcnt < STR_BOUNDS(1)) {
542 n_read = fread(buf + bcnt, 1, BUF_SIZE - bcnt, f);
543 bcnt += n_read;
544 }
545
546 off = 0;
547 c = str_decode(buf, &off, bcnt);
548 if (c == '\0')
549 break;
550
551 bcnt -= off;
552 memcpy(buf, buf + off, bcnt);
553
554 insert_char(c);
555 }
556
557 fclose(f);
558
559 return EOK;
560}
561
562/** Save a range of text into a file. */
563static int file_save_range(char const *fname, spt_t const *spos,
564 spt_t const *epos)
565{
566 FILE *f;
567 char buf[BUF_SIZE];
568 spt_t sp, bep;
569 size_t bytes, n_written;
570
571 f = fopen(fname, "wt");
572 if (f == NULL)
573 return EINVAL;
574
575 sp = *spos;
576
577 do {
578 sheet_copy_out(&doc.sh, &sp, epos, buf, BUF_SIZE, &bep);
579 bytes = str_size(buf);
580
581 n_written = fwrite(buf, 1, bytes, f);
582 if (n_written != bytes) {
583 return EIO;
584 }
585
586 sp = bep;
587 } while (!spt_equal(&bep, epos));
588
589 if (fclose(f) != EOK)
590 return EIO;
591
592 return EOK;
593}
594
595/** Return contents of range as a new string. */
596static char *range_get_str(spt_t const *spos, spt_t const *epos)
597{
598 char *buf;
599 spt_t sp, bep;
600 size_t bytes;
601 size_t buf_size, bpos;
602
603 buf_size = 1;
604
605 buf = malloc(buf_size);
606 if (buf == NULL)
607 return NULL;
608
609 bpos = 0;
610 sp = *spos;
611
612 while (true) {
613 sheet_copy_out(&doc.sh, &sp, epos, &buf[bpos], buf_size - bpos,
614 &bep);
615 bytes = str_size(&buf[bpos]);
616 bpos += bytes;
617 sp = bep;
618
619 if (spt_equal(&bep, epos))
620 break;
621
622 buf_size *= 2;
623 buf = realloc(buf, buf_size);
624 if (buf == NULL)
625 return NULL;
626 }
627
628 return buf;
629}
630
631static void pane_text_display(void)
632{
633 int sh_rows, rows;
634 int i, j;
635
636 sheet_get_num_rows(&doc.sh, &sh_rows);
637 rows = min(sh_rows - pane.sh_row + 1, pane.rows);
638
639 /* Draw rows from the sheet. */
640
641 console_goto(con, 0, 0);
642 pane_row_range_display(0, rows);
643
644 /* Clear the remaining rows if file is short. */
645
646 for (i = rows; i < pane.rows; ++i) {
647 console_goto(con, 0, i);
648 for (j = 0; j < scr_columns; ++j)
649 putchar(' ');
650 fflush(stdout);
651 }
652
653 pane.rflags |= (REDRAW_STATUS | REDRAW_CARET);
654 pane.rflags &= ~REDRAW_ROW;
655}
656
657/** Display just the row where the caret is. */
658static void pane_row_display(void)
659{
660 spt_t caret_pt;
661 coord_t coord;
662 int ridx;
663
664 tag_get_pt(&pane.caret_pos, &caret_pt);
665 spt_get_coord(&caret_pt, &coord);
666
667 ridx = coord.row - pane.sh_row;
668 pane_row_range_display(ridx, ridx + 1);
669 pane.rflags |= (REDRAW_STATUS | REDRAW_CARET);
670}
671
672static void pane_row_range_display(int r0, int r1)
673{
674 int i, j, fill;
675 spt_t rb, re, dep, pt;
676 coord_t rbc, rec;
677 char row_buf[ROW_BUF_SIZE];
678 wchar_t c;
679 size_t pos, size;
680 unsigned s_column;
681 coord_t csel_start, csel_end, ctmp;
682
683 /* Determine selection start and end. */
684
685 tag_get_pt(&pane.sel_start, &pt);
686 spt_get_coord(&pt, &csel_start);
687
688 tag_get_pt(&pane.caret_pos, &pt);
689 spt_get_coord(&pt, &csel_end);
690
691 if (coord_cmp(&csel_start, &csel_end) > 0) {
692 ctmp = csel_start;
693 csel_start = csel_end;
694 csel_end = ctmp;
695 }
696
697 /* Draw rows from the sheet. */
698
699 console_goto(con, 0, 0);
700 for (i = r0; i < r1; ++i) {
701 /* Starting point for row display */
702 rbc.row = pane.sh_row + i;
703 rbc.column = pane.sh_column;
704 sheet_get_cell_pt(&doc.sh, &rbc, dir_before, &rb);
705
706 /* Ending point for row display */
707 rec.row = pane.sh_row + i;
708 rec.column = pane.sh_column + pane.columns;
709 sheet_get_cell_pt(&doc.sh, &rec, dir_before, &re);
710
711 /* Copy the text of the row to the buffer. */
712 sheet_copy_out(&doc.sh, &rb, &re, row_buf, ROW_BUF_SIZE, &dep);
713
714 /* Display text from the buffer. */
715
716 if (coord_cmp(&csel_start, &rbc) <= 0 &&
717 coord_cmp(&rbc, &csel_end) < 0) {
718 fflush(stdout);
719 console_set_color(con, COLOR_BLACK, COLOR_RED, 0);
720 fflush(stdout);
721 }
722
723 console_goto(con, 0, i);
724 size = str_size(row_buf);
725 pos = 0;
726 s_column = 1;
727 while (pos < size) {
728 if (csel_start.row == rbc.row && csel_start.column == s_column) {
729 fflush(stdout);
730 console_set_color(con, COLOR_BLACK, COLOR_RED, 0);
731 fflush(stdout);
732 }
733
734 if (csel_end.row == rbc.row && csel_end.column == s_column) {
735 fflush(stdout);
736 console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
737 fflush(stdout);
738 }
739
740 c = str_decode(row_buf, &pos, size);
741 if (c != '\t') {
742 printf("%lc", c);
743 s_column += 1;
744 } else {
745 fill = 1 + ALIGN_UP(s_column, TAB_WIDTH)
746 - s_column;
747
748 for (j = 0; j < fill; ++j)
749 putchar(' ');
750 s_column += fill;
751 }
752 }
753
754 if (csel_end.row == rbc.row && csel_end.column == s_column) {
755 fflush(stdout);
756 console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
757 fflush(stdout);
758 }
759
760 /* Fill until the end of display area. */
761
762 if (str_length(row_buf) < (unsigned) scr_columns)
763 fill = scr_columns - str_length(row_buf);
764 else
765 fill = 0;
766
767 for (j = 0; j < fill; ++j)
768 putchar(' ');
769 fflush(stdout);
770 console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
771 }
772
773 pane.rflags |= REDRAW_CARET;
774}
775
776/** Display pane status in the status line. */
777static void pane_status_display(void)
778{
779 spt_t caret_pt;
780 coord_t coord;
781 char *fname;
782 int n;
783
784 tag_get_pt(&pane.caret_pos, &caret_pt);
785 spt_get_coord(&caret_pt, &coord);
786
787 fname = (doc.file_name != NULL) ? doc.file_name : "<unnamed>";
788
789 console_goto(con, 0, scr_rows - 1);
790 console_set_color(con, COLOR_WHITE, COLOR_BLACK, 0);
791 n = printf(" %d, %d: File '%s'. Ctrl-Q Quit Ctrl-S Save "
792 "Ctrl-E Save As", coord.row, coord.column, fname);
793 printf("%*s", scr_columns - 1 - n, "");
794 fflush(stdout);
795 console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
796
797 pane.rflags |= REDRAW_CARET;
798}
799
800/** Set cursor to reflect position of the caret. */
801static void pane_caret_display(void)
802{
803 spt_t caret_pt;
804 coord_t coord;
805
806 tag_get_pt(&pane.caret_pos, &caret_pt);
807
808 spt_get_coord(&caret_pt, &coord);
809 console_goto(con, coord.column - pane.sh_column,
810 coord.row - pane.sh_row);
811}
812
813/** Insert a character at caret position. */
814static void insert_char(wchar_t c)
815{
816 spt_t pt;
817 char cbuf[STR_BOUNDS(1) + 1];
818 size_t offs;
819
820 tag_get_pt(&pane.caret_pos, &pt);
821
822 offs = 0;
823 chr_encode(c, cbuf, &offs, STR_BOUNDS(1) + 1);
824 cbuf[offs] = '\0';
825
826 (void) sheet_insert(&doc.sh, &pt, dir_before, cbuf);
827
828 pane.rflags |= REDRAW_ROW;
829 if (c == '\n')
830 pane.rflags |= REDRAW_TEXT;
831}
832
833/** Delete the character before the caret. */
834static void delete_char_before(void)
835{
836 spt_t sp, ep;
837 coord_t coord;
838
839 tag_get_pt(&pane.caret_pos, &ep);
840 spt_get_coord(&ep, &coord);
841
842 coord.column -= 1;
843 sheet_get_cell_pt(&doc.sh, &coord, dir_before, &sp);
844
845 (void) sheet_delete(&doc.sh, &sp, &ep);
846
847 pane.rflags |= REDRAW_ROW;
848 if (coord.column < 1)
849 pane.rflags |= REDRAW_TEXT;
850}
851
852/** Delete the character after the caret. */
853static void delete_char_after(void)
854{
855 spt_t sp, ep;
856 coord_t sc, ec;
857
858 tag_get_pt(&pane.caret_pos, &sp);
859 spt_get_coord(&sp, &sc);
860
861 sheet_get_cell_pt(&doc.sh, &sc, dir_after, &ep);
862 spt_get_coord(&ep, &ec);
863
864 (void) sheet_delete(&doc.sh, &sp, &ep);
865
866 pane.rflags |= REDRAW_ROW;
867 if (ec.row != sc.row)
868 pane.rflags |= REDRAW_TEXT;
869}
870
871/** Scroll pane after caret has moved.
872 *
873 * After modifying the position of the caret, this is called to scroll
874 * the pane to ensure that the caret is in the visible area.
875 */
876static void caret_update(void)
877{
878 spt_t pt;
879 coord_t coord;
880
881 tag_get_pt(&pane.caret_pos, &pt);
882 spt_get_coord(&pt, &coord);
883
884 /* Scroll pane vertically. */
885
886 if (coord.row < pane.sh_row) {
887 pane.sh_row = coord.row;
888 pane.rflags |= REDRAW_TEXT;
889 }
890
891 if (coord.row > pane.sh_row + pane.rows - 1) {
892 pane.sh_row = coord.row - pane.rows + 1;
893 pane.rflags |= REDRAW_TEXT;
894 }
895
896 /* Scroll pane horizontally. */
897
898 if (coord.column < pane.sh_column) {
899 pane.sh_column = coord.column;
900 pane.rflags |= REDRAW_TEXT;
901 }
902
903 if (coord.column > pane.sh_column + pane.columns - 1) {
904 pane.sh_column = coord.column - pane.columns + 1;
905 pane.rflags |= REDRAW_TEXT;
906 }
907
908 pane.rflags |= (REDRAW_CARET | REDRAW_STATUS);
909}
910
911/** Change the caret position.
912 *
913 * Moves caret relatively to the current position. Looking at the first
914 * character cell after the caret and moving by @a drow and @a dcolumn, we get
915 * to a new character cell, and thus a new character. Then we either go to the
916 * point before the the character or after it, depending on @a align_dir.
917 */
918static void caret_move(int drow, int dcolumn, enum dir_spec align_dir)
919{
920 spt_t pt;
921 coord_t coord;
922 int num_rows;
923 bool pure_vertical;
924
925 tag_get_pt(&pane.caret_pos, &pt);
926 spt_get_coord(&pt, &coord);
927 coord.row += drow; coord.column += dcolumn;
928
929 /* Clamp coordinates. */
930 if (drow < 0 && coord.row < 1) coord.row = 1;
931 if (dcolumn < 0 && coord.column < 1) coord.column = 1;
932 if (drow > 0) {
933 sheet_get_num_rows(&doc.sh, &num_rows);
934 if (coord.row > num_rows) coord.row = num_rows;
935 }
936
937 /* For purely vertical movement try attaining @c ideal_column. */
938 pure_vertical = (dcolumn == 0 && align_dir == dir_before);
939 if (pure_vertical)
940 coord.column = pane.ideal_column;
941
942 /*
943 * Select the point before or after the character at the designated
944 * coordinates. The character can be wider than one cell (e.g. tab).
945 */
946 sheet_get_cell_pt(&doc.sh, &coord, align_dir, &pt);
947 sheet_remove_tag(&doc.sh, &pane.caret_pos);
948 sheet_place_tag(&doc.sh, &pt, &pane.caret_pos);
949
950 /* For non-vertical movement set the new value for @c ideal_column. */
951 if (!pure_vertical) {
952 spt_get_coord(&pt, &coord);
953 pane.ideal_column = coord.column;
954 }
955
956 caret_update();
957}
958
959/** Check for non-empty selection. */
960static bool selection_active(void)
961{
962 return (tag_cmp(&pane.caret_pos, &pane.sel_start) != 0);
963}
964
965static void selection_get_points(spt_t *pa, spt_t *pb)
966{
967 spt_t pt;
968
969 tag_get_pt(&pane.sel_start, pa);
970 tag_get_pt(&pane.caret_pos, pb);
971
972 if (spt_cmp(pa, pb) > 0) {
973 pt = *pa;
974 *pa = *pb;
975 *pb = pt;
976 }
977}
978
979/** Delete selected text. */
980static void selection_delete(void)
981{
982 spt_t pa, pb;
983 coord_t ca, cb;
984 int rel;
985
986 tag_get_pt(&pane.sel_start, &pa);
987 tag_get_pt(&pane.caret_pos, &pb);
988 spt_get_coord(&pa, &ca);
989 spt_get_coord(&pb, &cb);
990 rel = coord_cmp(&ca, &cb);
991
992 if (rel == 0)
993 return;
994
995 if (rel < 0)
996 sheet_delete(&doc.sh, &pa, &pb);
997 else
998 sheet_delete(&doc.sh, &pb, &pa);
999
1000 if (ca.row == cb.row)
1001 pane.rflags |= REDRAW_ROW;
1002 else
1003 pane.rflags |= REDRAW_TEXT;
1004}
1005
1006static void selection_copy(void)
1007{
1008 spt_t pa, pb;
1009 char *str;
1010
1011 selection_get_points(&pa, &pb);
1012 str = range_get_str(&pa, &pb);
1013 if (str == NULL || clipboard_put_str(str) != EOK) {
1014 status_display("Copying to clipboard failed!");
1015 }
1016 free(str);
1017}
1018
1019static void insert_clipboard_data(void)
1020{
1021 char *str;
1022 size_t off;
1023 wchar_t c;
1024 int rc;
1025
1026 rc = clipboard_get_str(&str);
1027 if (rc != EOK || str == NULL)
1028 return;
1029
1030 off = 0;
1031
1032 while (true) {
1033 c = str_decode(str, &off, STR_NO_LIMIT);
1034 if (c == '\0')
1035 break;
1036
1037 insert_char(c);
1038 }
1039
1040 free(str);
1041}
1042
1043/** Get start-of-file s-point. */
1044static void pt_get_sof(spt_t *pt)
1045{
1046 coord_t coord;
1047
1048 coord.row = coord.column = 1;
1049 sheet_get_cell_pt(&doc.sh, &coord, dir_before, pt);
1050}
1051
1052/** Get end-of-file s-point. */
1053static void pt_get_eof(spt_t *pt)
1054{
1055 coord_t coord;
1056 int num_rows;
1057
1058 sheet_get_num_rows(&doc.sh, &num_rows);
1059 coord.row = num_rows + 1;
1060 coord.column = 1;
1061
1062 sheet_get_cell_pt(&doc.sh, &coord, dir_after, pt);
1063}
1064
1065/** Compare tags. */
1066static int tag_cmp(tag_t const *a, tag_t const *b)
1067{
1068 spt_t pa, pb;
1069
1070 tag_get_pt(a, &pa);
1071 tag_get_pt(b, &pb);
1072
1073 return spt_cmp(&pa, &pb);
1074}
1075
1076/** Compare s-points. */
1077static int spt_cmp(spt_t const *a, spt_t const *b)
1078{
1079 coord_t ca, cb;
1080
1081 spt_get_coord(a, &ca);
1082 spt_get_coord(b, &cb);
1083
1084 return coord_cmp(&ca, &cb);
1085}
1086
1087/** Compare coordinats. */
1088static int coord_cmp(coord_t const *a, coord_t const *b)
1089{
1090 if (a->row - b->row != 0)
1091 return a->row - b->row;
1092
1093 return a->column - b->column;
1094}
1095
1096/** Display text in the status line. */
1097static void status_display(char const *str)
1098{
1099 console_goto(con, 0, scr_rows - 1);
1100 console_set_color(con, COLOR_WHITE, COLOR_BLACK, 0);
1101 printf(" %*s ", -(scr_columns - 3), str);
1102 fflush(stdout);
1103 console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);
1104
1105 pane.rflags |= REDRAW_CARET;
1106}
1107
1108/** @}
1109 */
Note: See TracBrowser for help on using the repository browser.