← Back to branch summary

~martin-decky/helenos/rcu

« back to all changes in this revision

Viewing changes to uspace/app/edit/edit.c

  • Committer: Martin Sucha
  • Date: 2011-07-08 17:01:01 UTC
  • mfrom: (1095 main-clone)
  • mto: This revision was merged to the branch mainline in revision 1123.
  • Revision ID: sucha14@st.fmph.uniba.sk-20110708170101-eosjw1koauuvmzkz
Merge mainline changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
uspace/app/edit/edit.c
93
93
        sheet_t sh;
94
94
} doc_t;
95
95
 
96
 
static int con;
 
96
static console_ctrl_t *con;
97
97
static doc_t doc;
98
98
static bool done;
99
99
static pane_t pane;
114
114
static void cursor_hide(void);
115
115
static void cursor_setvis(bool visible);
116
116
 
117
 
static void key_handle_unmod(console_event_t const *ev);
118
 
static void key_handle_ctrl(console_event_t const *ev);
119
 
static void key_handle_shift(console_event_t const *ev);
 
117
static void key_handle_unmod(kbd_event_t const *ev);
 
118
static void key_handle_ctrl(kbd_event_t const *ev);
 
119
static void key_handle_shift(kbd_event_t const *ev);
120
120
static void key_handle_movement(unsigned int key, bool shift);
121
121
 
122
122
static int file_save(char const *fname);
157
157
 
158
158
int main(int argc, char *argv[])
159
159
{
160
 
        console_event_t ev;
 
160
        kbd_event_t ev;
161
161
        coord_t coord;
162
162
        bool new_file;
163
163
 
164
164
        spt_t pt;
165
165
 
166
 
        con = fphone(stdout);
 
166
        con = console_init(stdin, stdout);
167
167
        console_clear(con);
168
168
 
169
169
        console_get_size(con, &scr_columns, &scr_rows);
218
218
        done = false;
219
219
 
220
220
        while (!done) {
221
 
                console_get_event(con, &ev);
 
221
                console_get_kbd_event(con, &ev);
222
222
                pane.rflags = 0;
223
223
 
224
224
                if (ev.type == KEY_PRESS) {
276
276
}
277
277
 
278
278
/** Handle key without modifier. */
279
 
static void key_handle_unmod(console_event_t const *ev)
 
279
static void key_handle_unmod(kbd_event_t const *ev)
280
280
{
281
281
        switch (ev->key) {
282
282
        case KC_ENTER:
319
319
}
320
320
 
321
321
/** Handle Shift-key combination. */
322
 
static void key_handle_shift(console_event_t const *ev)
 
322
static void key_handle_shift(kbd_event_t const *ev)
323
323
{
324
324
        switch (ev->key) {
325
325
        case KC_LEFT:
343
343
}
344
344
 
345
345
/** Handle Ctrl-key combination. */
346
 
static void key_handle_ctrl(console_event_t const *ev)
 
346
static void key_handle_ctrl(kbd_event_t const *ev)
347
347
{
348
348
        switch (ev->key) {
349
349
        case KC_Q:
496
496
/** Ask for a file name. */
497
497
static char *filename_prompt(char const *prompt, char const *init_value)
498
498
{
499
 
        console_event_t ev;
 
499
        kbd_event_t ev;
500
500
        char *str;
501
501
        wchar_t buffer[INFNAME_MAX_LEN + 1];
502
502
        int max_len;
516
516
        done = false;
517
517
 
518
518
        while (!done) {
519
 
                console_get_event(con, &ev);
 
519
                console_get_kbd_event(con, &ev);
520
520
 
521
521
                if (ev.type == KEY_PRESS) {
522
522
                        /* Handle key press. */
530
530
                                case KC_BACKSPACE:
531
531
                                        if (nc > 0) {
532
532
                                                putchar('\b');
533
 
                                                fflush(stdout);
 
533
                                                console_flush(con);
534
534
                                                --nc;
535
535
                                        }
536
536
                                        break;
540
540
                                default:
541
541
                                        if (ev.c >= 32 && nc < max_len) {
542
542
                                                putchar(ev.c);
543
 
                                                fflush(stdout);
 
543
                                                console_flush(con);
544
544
                                                buffer[nc++] = ev.c;
545
545
                                        }
546
546
                                        break;
688
688
                console_set_pos(con, 0, i);
689
689
                for (j = 0; j < scr_columns; ++j)
690
690
                        putchar(' ');
691
 
                fflush(stdout);
 
691
                console_flush(con);
692
692
        }
693
693
 
694
694
        pane.rflags |= (REDRAW_STATUS | REDRAW_CARET);
756
756
 
757
757
                if (coord_cmp(&csel_start, &rbc) <= 0 &&
758
758
                    coord_cmp(&rbc, &csel_end) < 0) {
759
 
                        fflush(stdout);
 
759
                        console_flush(con);
760
760
                        console_set_style(con, STYLE_SELECTED);
761
 
                        fflush(stdout);
 
761
                        console_flush(con);
762
762
                }
763
763
 
764
764
                console_set_pos(con, 0, i);
767
767
                s_column = pane.sh_column;
768
768
                while (pos < size) {
769
769
                        if ((csel_start.row == rbc.row) && (csel_start.column == s_column)) {
770
 
                                fflush(stdout);
 
770
                                console_flush(con);
771
771
                                console_set_style(con, STYLE_SELECTED);
772
 
                                fflush(stdout);
 
772
                                console_flush(con);
773
773
                        }
774
774
        
775
775
                        if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
776
 
                                fflush(stdout);
 
776
                                console_flush(con);
777
777
                                console_set_style(con, STYLE_NORMAL);
778
 
                                fflush(stdout);
 
778
                                console_flush(con);
779
779
                        }
780
780
        
781
781
                        c = str_decode(row_buf, &pos, size);
793
793
                }
794
794
 
795
795
                if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
796
 
                        fflush(stdout);
 
796
                        console_flush(con);
797
797
                        console_set_style(con, STYLE_NORMAL);
798
 
                        fflush(stdout);
 
798
                        console_flush(con);
799
799
                }
800
800
 
801
801
                /* Fill until the end of display area. */
807
807
 
808
808
                for (j = 0; j < fill; ++j)
809
809
                        putchar(' ');
810
 
                fflush(stdout);
 
810
                console_flush(con);
811
811
                console_set_style(con, STYLE_NORMAL);
812
812
        }
813
813
 
832
832
        
833
833
        int pos = scr_columns - 1 - n;
834
834
        printf("%*s", pos, "");
835
 
        fflush(stdout);
 
835
        console_flush(con);
836
836
        console_set_style(con, STYLE_NORMAL);
837
837
 
838
838
        pane.rflags |= REDRAW_CARET;
1157
1157
        
1158
1158
        int pos = -(scr_columns - 3);
1159
1159
        printf(" %*s ", pos, str);
1160
 
        fflush(stdout);
 
1160
        console_flush(con);
1161
1161
        console_set_style(con, STYLE_NORMAL);
1162
1162
 
1163
1163
        pane.rflags |= REDRAW_CARET;