source: mainline/uspace/app/terminal/terminal.c@ 2cf8f994

Last change on this file since 2cf8f994 was 2cf8f994, checked in by Jiri Svoboda <jiri@…>, 15 months ago

Improve terminal behavior in console mode.
  • Property mode set to 100644
File size: 29.5 KB
Line 
1/*
2 * Copyright (c) 2024 Jiri Svoboda
3 * Copyright (c) 2012 Petr Koupy
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 terminal
31 * @{
32 */
33/**
34 * @file Terminal application
35 */
36
37#include <adt/list.h>
38#include <adt/prodcons.h>
39#include <as.h>
40#include <errno.h>
41#include <fbfont/font-8x16.h>
42#include <fibril.h>
43#include <gfx/bitmap.h>
44#include <gfx/context.h>
45#include <gfx/render.h>
46#include <io/con_srv.h>
47#include <io/concaps.h>
48#include <io/console.h>
49#include <io/pixelmap.h>
50#include <macros.h>
51#include <stdarg.h>
52#include <stdio.h>
53#include <stdlib.h>
54#include <str_error.h>
55#include <str.h>
56#include <task.h>
57#include <ui/resource.h>
58#include <ui/ui.h>
59#include <ui/wdecor.h>
60#include <ui/window.h>
61
62#include "terminal.h"
63
64#define NAME "terminal"
65#define NAMESPACE "terminal"
66
67#define LOCFS_MOUNT_POINT "/loc"
68
69#define APP_GETTERM "/app/getterm"
70
71#define TERM_CAPS \
72 (CONSOLE_CAP_STYLE | CONSOLE_CAP_INDEXED | CONSOLE_CAP_RGB)
73
74#define SCROLLBACK_MAX_LINES 1000
75#define MIN_WINDOW_COLS 8
76#define MIN_WINDOW_ROWS 4
77
78static LIST_INITIALIZE(terms);
79
80#define COLOR_BRIGHT 8
81
82static const pixel_t _basic_colors[16] = {
83 [COLOR_BLACK] = PIXEL(255, 0, 0, 0),
84 [COLOR_RED] = PIXEL(255, 170, 0, 0),
85 [COLOR_GREEN] = PIXEL(255, 0, 170, 0),
86 [COLOR_YELLOW] = PIXEL(255, 170, 85, 0),
87 [COLOR_BLUE] = PIXEL(255, 0, 0, 170),
88 [COLOR_MAGENTA] = PIXEL(255, 170, 0, 170),
89 [COLOR_CYAN] = PIXEL(255, 0, 170, 170),
90 [COLOR_WHITE] = PIXEL(255, 170, 170, 170),
91
92 [COLOR_BLACK | COLOR_BRIGHT] = PIXEL(255, 85, 85, 85),
93 [COLOR_RED | COLOR_BRIGHT] = PIXEL(255, 255, 85, 85),
94 [COLOR_GREEN | COLOR_BRIGHT] = PIXEL(255, 85, 255, 85),
95 [COLOR_YELLOW | COLOR_BRIGHT] = PIXEL(255, 255, 255, 85),
96 [COLOR_BLUE | COLOR_BRIGHT] = PIXEL(255, 85, 85, 255),
97 [COLOR_MAGENTA | COLOR_BRIGHT] = PIXEL(255, 255, 85, 255),
98 [COLOR_CYAN | COLOR_BRIGHT] = PIXEL(255, 85, 255, 255),
99 [COLOR_WHITE | COLOR_BRIGHT] = PIXEL(255, 255, 255, 255),
100};
101
102static errno_t term_open(con_srvs_t *, con_srv_t *);
103static errno_t term_close(con_srv_t *);
104static errno_t term_read(con_srv_t *, void *, size_t, size_t *);
105static errno_t term_write(con_srv_t *, void *, size_t, size_t *);
106static void term_sync(con_srv_t *);
107static void term_clear(con_srv_t *);
108static void term_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
109static errno_t term_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
110static errno_t term_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
111static errno_t term_get_color_cap(con_srv_t *, console_caps_t *);
112static void term_set_style(con_srv_t *, console_style_t);
113static void term_set_color(con_srv_t *, console_color_t, console_color_t,
114 console_color_attr_t);
115static void term_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
116static void term_set_cursor_visibility(con_srv_t *, bool);
117static errno_t term_set_caption(con_srv_t *, const char *);
118static errno_t term_get_event(con_srv_t *, cons_event_t *);
119static errno_t term_map(con_srv_t *, sysarg_t, sysarg_t, charfield_t **);
120static void term_unmap(con_srv_t *);
121static void term_buf_update(con_srv_t *, sysarg_t, sysarg_t, sysarg_t,
122 sysarg_t);
123
124static con_ops_t con_ops = {
125 .open = term_open,
126 .close = term_close,
127 .read = term_read,
128 .write = term_write,
129 .sync = term_sync,
130 .clear = term_clear,
131 .set_pos = term_set_pos,
132 .get_pos = term_get_pos,
133 .get_size = term_get_size,
134 .get_color_cap = term_get_color_cap,
135 .set_style = term_set_style,
136 .set_color = term_set_color,
137 .set_rgb_color = term_set_rgb_color,
138 .set_cursor_visibility = term_set_cursor_visibility,
139 .set_caption = term_set_caption,
140 .get_event = term_get_event,
141 .map = term_map,
142 .unmap = term_unmap,
143 .update = term_buf_update
144};
145
146static void terminal_close_event(ui_window_t *, void *);
147static void terminal_focus_event(ui_window_t *, void *, unsigned);
148static void terminal_resize_event(ui_window_t *, void *);
149static void terminal_kbd_event(ui_window_t *, void *, kbd_event_t *);
150static void terminal_pos_event(ui_window_t *, void *, pos_event_t *);
151static void terminal_unfocus_event(ui_window_t *, void *, unsigned);
152static void terminal_maximize_event(ui_window_t *, void *);
153static void terminal_unmaximize_event(ui_window_t *, void *);
154
155static ui_window_cb_t terminal_window_cb = {
156 .close = terminal_close_event,
157 .focus = terminal_focus_event,
158 .resize = terminal_resize_event,
159 .kbd = terminal_kbd_event,
160 .pos = terminal_pos_event,
161 .unfocus = terminal_unfocus_event,
162 .maximize = terminal_maximize_event,
163 .unmaximize = terminal_unmaximize_event,
164};
165
166static errno_t terminal_wait_fibril(void *);
167
168static terminal_t *srv_to_terminal(con_srv_t *srv)
169{
170 return srv->srvs->sarg;
171}
172
173static errno_t getterm(task_wait_t *wait, const char *svc, const char *app)
174{
175 return task_spawnl(NULL, wait, APP_GETTERM, APP_GETTERM, svc,
176 LOCFS_MOUNT_POINT, "--msg", "--wait", "--", app, NULL);
177}
178
179static pixel_t termui_color_to_pixel(termui_color_t c)
180{
181 uint8_t r, g, b;
182 termui_color_to_rgb(c, &r, &g, &b);
183 return PIXEL(255, r, g, b);
184}
185
186static termui_color_t termui_color_from_pixel(pixel_t pixel)
187{
188 return termui_color_from_rgb(RED(pixel), GREEN(pixel), BLUE(pixel));
189}
190
191static termui_cell_t charfield_to_termui_cell(terminal_t *term, const charfield_t *cf)
192{
193 termui_cell_t cell = { };
194
195 cell.glyph_idx = fb_font_glyph(cf->ch, NULL);
196
197 switch (cf->attrs.type) {
198 case CHAR_ATTR_STYLE:
199 switch (cf->attrs.val.style) {
200 case STYLE_NORMAL:
201 cell.bgcolor = term->default_bgcolor;
202 cell.fgcolor = term->default_fgcolor;
203 break;
204 case STYLE_EMPHASIS:
205 cell.bgcolor = term->emphasis_bgcolor;
206 cell.fgcolor = term->emphasis_fgcolor;
207 break;
208 case STYLE_INVERTED:
209 cell.bgcolor = term->default_bgcolor;
210 cell.fgcolor = term->default_fgcolor;
211 cell.inverted = 1;
212 break;
213 case STYLE_SELECTED:
214 cell.bgcolor = term->selection_bgcolor;
215 cell.fgcolor = term->selection_fgcolor;
216 break;
217 }
218 break;
219
220 case CHAR_ATTR_INDEX:
221 char_attr_index_t index = cf->attrs.val.index;
222
223 int bright = (index.attr & CATTR_BRIGHT) ? COLOR_BRIGHT : 0;
224 pixel_t bgcolor = _basic_colors[index.bgcolor];
225 pixel_t fgcolor = _basic_colors[index.fgcolor | bright];
226 cell.bgcolor = termui_color_from_pixel(bgcolor);
227 cell.fgcolor = termui_color_from_pixel(fgcolor);
228
229 if (index.attr & CATTR_BLINK)
230 cell.blink = 1;
231
232 break;
233
234 case CHAR_ATTR_RGB:
235 cell.bgcolor = termui_color_from_pixel(cf->attrs.val.rgb.bgcolor);
236 cell.fgcolor = termui_color_from_pixel(cf->attrs.val.rgb.fgcolor);
237 break;
238 }
239
240 return cell;
241}
242
243static void term_update_region(terminal_t *term, sysarg_t x, sysarg_t y,
244 sysarg_t w, sysarg_t h)
245{
246 gfx_rect_t rect;
247 gfx_rect_t nupdate;
248
249 rect.p0.x = x;
250 rect.p0.y = y;
251 rect.p1.x = x + w;
252 rect.p1.y = y + h;
253
254 gfx_rect_envelope(&term->update, &rect, &nupdate);
255 term->update = nupdate;
256}
257
258static void term_draw_cell(terminal_t *term, pixelmap_t *pixelmap, int col, int row, const termui_cell_t *cell)
259{
260 termui_color_t bg = cell->bgcolor;
261 if (bg == TERMUI_COLOR_DEFAULT)
262 bg = term->default_bgcolor;
263
264 termui_color_t fg = cell->fgcolor;
265 if (fg == TERMUI_COLOR_DEFAULT)
266 fg = term->default_fgcolor;
267
268 pixel_t bgcolor = termui_color_to_pixel(bg);
269 pixel_t fgcolor = termui_color_to_pixel(fg);
270
271 int bx = col * FONT_WIDTH;
272 int by = row * FONT_SCANLINES;
273
274 // TODO: support bold/italic/underline/strike/blink styling
275
276 if (cell->inverted ^ cell->cursor) {
277 pixel_t tmp = bgcolor;
278 bgcolor = fgcolor;
279 fgcolor = tmp;
280 }
281
282 uint32_t glyph = cell->glyph_idx;
283 assert(glyph < FONT_GLYPHS);
284
285 if (glyph == 0)
286 glyph = fb_font_glyph(U' ', NULL);
287
288 for (unsigned int y = 0; y < FONT_SCANLINES; y++) {
289 pixel_t *dst = pixelmap_pixel_at(pixelmap, bx, by + y);
290 pixel_t *dst_max = pixelmap_pixel_at(pixelmap, bx + FONT_WIDTH - 1, by + y);
291 if (!dst || !dst_max)
292 continue;
293 int count = FONT_WIDTH;
294 while (count-- != 0) {
295 *dst++ = (fb_font[glyph][y] & (1 << count)) ? fgcolor : bgcolor;
296 }
297 }
298
299 term_update_region(term, bx, by, FONT_WIDTH, FONT_SCANLINES);
300}
301
302static void term_render(terminal_t *term)
303{
304 (void) gfx_bitmap_render(term->bmp, &term->update, &term->off);
305
306 term->update.p0.x = 0;
307 term->update.p0.y = 0;
308 term->update.p1.x = 0;
309 term->update.p1.y = 0;
310}
311
312static void termui_refresh_cb(void *userdata)
313{
314 terminal_t *term = userdata;
315
316 termui_force_viewport_update(term->termui, 0, termui_get_rows(term->termui));
317}
318
319static void termui_scroll_cb(void *userdata, int delta)
320{
321 (void) delta;
322
323 // Until we have support for hardware accelerated scrolling, just redraw everything.
324 termui_refresh_cb(userdata);
325}
326
327static pixelmap_t term_get_pixelmap(terminal_t *term)
328{
329 pixelmap_t pixelmap = { };
330 gfx_bitmap_alloc_t alloc;
331
332 errno_t rc = gfx_bitmap_get_alloc(term->bmp, &alloc);
333 if (rc != EOK)
334 return pixelmap;
335
336 pixelmap.width = term->w;
337 pixelmap.height = term->h;
338 pixelmap.data = alloc.pixels;
339 return pixelmap;
340}
341
342static void term_clear_bitmap(terminal_t *term, pixel_t color)
343{
344 pixelmap_t pixelmap = term_get_pixelmap(term);
345 if (pixelmap.data == NULL)
346 return;
347
348 sysarg_t pixels = pixelmap.height * pixelmap.width;
349 for (sysarg_t i = 0; i < pixels; i++)
350 pixelmap.data[i] = color;
351
352 term_update_region(term, 0, 0, pixelmap.width, pixelmap.height);
353}
354
355static void termui_update_cb(void *userdata, int col, int row, const termui_cell_t *cell, int len)
356{
357 terminal_t *term = userdata;
358
359 pixelmap_t pixelmap = term_get_pixelmap(term);
360 if (pixelmap.data == NULL)
361 return;
362
363 for (int i = 0; i < len; i++)
364 term_draw_cell(term, &pixelmap, col + i, row, &cell[i]);
365}
366
367static errno_t term_open(con_srvs_t *srvs, con_srv_t *srv)
368{
369 return EOK;
370}
371
372static errno_t term_close(con_srv_t *srv)
373{
374 return EOK;
375}
376
377static errno_t term_read(con_srv_t *srv, void *buf, size_t size, size_t *nread)
378{
379 terminal_t *term = srv_to_terminal(srv);
380 uint8_t *bbuf = buf;
381 size_t pos = 0;
382
383 /*
384 * Read input from keyboard and copy it to the buffer.
385 * We need to handle situation when wchar is split by 2 following
386 * reads.
387 */
388 while (pos < size) {
389 /* Copy to the buffer remaining characters. */
390 while ((pos < size) && (term->char_remains_len > 0)) {
391 bbuf[pos] = term->char_remains[0];
392 pos++;
393
394 /* Unshift the array. */
395 for (size_t i = 1; i < term->char_remains_len; i++)
396 term->char_remains[i - 1] = term->char_remains[i];
397
398 term->char_remains_len--;
399 }
400
401 /* Still not enough? Then get another key from the queue. */
402 if (pos < size) {
403 link_t *link = prodcons_consume(&term->input_pc);
404 cons_event_t *event = list_get_instance(link, cons_event_t, link);
405
406 /* Accept key presses of printable chars only. */
407 if (event->type == CEV_KEY && event->ev.key.type == KEY_PRESS &&
408 event->ev.key.c != 0) {
409 char32_t tmp[2] = {
410 event->ev.key.c,
411 0
412 };
413
414 wstr_to_str(term->char_remains, UTF8_CHAR_BUFFER_SIZE, tmp);
415 term->char_remains_len = str_size(term->char_remains);
416 }
417
418 free(event);
419 }
420 }
421
422 *nread = size;
423 return EOK;
424}
425
426static void term_write_char(terminal_t *term, wchar_t ch)
427{
428 switch (ch) {
429 case L'\n':
430 termui_put_crlf(term->termui);
431 break;
432 case L'\r':
433 termui_put_cr(term->termui);
434 break;
435 case L'\t':
436 termui_put_tab(term->termui);
437 break;
438 case L'\b':
439 termui_put_backspace(term->termui);
440 break;
441 default:
442 // TODO: For some languages, we might need support for combining
443 // characters. Currently, we assume every unicode code point is
444 // an individual printed character, which is not always the case.
445 termui_put_glyph(term->termui, fb_font_glyph(ch, NULL), 1);
446 break;
447 }
448}
449
450static errno_t term_write(con_srv_t *srv, void *data, size_t size, size_t *nwritten)
451{
452 terminal_t *term = srv_to_terminal(srv);
453
454 fibril_mutex_lock(&term->mtx);
455
456 size_t off = 0;
457 while (off < size)
458 term_write_char(term, str_decode(data, &off, size));
459
460 fibril_mutex_unlock(&term->mtx);
461
462 term_render(term);
463 gfx_update(term->gc);
464 *nwritten = size;
465
466 return EOK;
467}
468
469static void term_sync(con_srv_t *srv)
470{
471 terminal_t *term = srv_to_terminal(srv);
472
473 term_render(term);
474 gfx_update(term->gc);
475}
476
477static void term_clear(con_srv_t *srv)
478{
479 terminal_t *term = srv_to_terminal(srv);
480
481 fibril_mutex_lock(&term->mtx);
482 termui_clear_screen(term->termui);
483 fibril_mutex_unlock(&term->mtx);
484
485 term_render(term);
486 gfx_update(term->gc);
487}
488
489static void term_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
490{
491 terminal_t *term = srv_to_terminal(srv);
492
493 fibril_mutex_lock(&term->mtx);
494 termui_set_pos(term->termui, col, row);
495 fibril_mutex_unlock(&term->mtx);
496
497 term_render(term);
498 gfx_update(term->gc);
499}
500
501static errno_t term_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
502{
503 terminal_t *term = srv_to_terminal(srv);
504
505 fibril_mutex_lock(&term->mtx);
506 int irow, icol;
507 termui_get_pos(term->termui, &icol, &irow);
508 fibril_mutex_unlock(&term->mtx);
509
510 *col = icol;
511 *row = irow;
512
513 return EOK;
514}
515
516static errno_t term_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
517{
518 terminal_t *term = srv_to_terminal(srv);
519
520 fibril_mutex_lock(&term->mtx);
521 *cols = termui_get_cols(term->termui);
522 *rows = termui_get_rows(term->termui);
523 fibril_mutex_unlock(&term->mtx);
524
525 return EOK;
526}
527
528static errno_t term_get_color_cap(con_srv_t *srv, console_caps_t *caps)
529{
530 (void) srv;
531 *caps = TERM_CAPS;
532
533 return EOK;
534}
535
536static void term_set_style(con_srv_t *srv, console_style_t style)
537{
538 terminal_t *term = srv_to_terminal(srv);
539
540 termui_cell_t cellstyle = { };
541
542 switch (style) {
543 case STYLE_NORMAL:
544 cellstyle.bgcolor = term->default_bgcolor;
545 cellstyle.fgcolor = term->default_fgcolor;
546 break;
547 case STYLE_EMPHASIS:
548 cellstyle.bgcolor = term->emphasis_bgcolor;
549 cellstyle.fgcolor = term->emphasis_fgcolor;
550 break;
551 case STYLE_INVERTED:
552 cellstyle.bgcolor = term->default_bgcolor;
553 cellstyle.fgcolor = term->default_fgcolor;
554 cellstyle.inverted = 1;
555 break;
556 case STYLE_SELECTED:
557 cellstyle.bgcolor = term->selection_bgcolor;
558 cellstyle.fgcolor = term->selection_fgcolor;
559 break;
560 }
561
562 fibril_mutex_lock(&term->mtx);
563 termui_set_style(term->termui, cellstyle);
564 fibril_mutex_unlock(&term->mtx);
565}
566
567static void term_set_color(con_srv_t *srv, console_color_t bgcolor,
568 console_color_t fgcolor, console_color_attr_t attr)
569{
570 terminal_t *term = srv_to_terminal(srv);
571
572 int bright = (attr & CATTR_BRIGHT) ? COLOR_BRIGHT : 0;
573
574 termui_cell_t cellstyle = { };
575 cellstyle.bgcolor = termui_color_from_pixel(_basic_colors[bgcolor]);
576 cellstyle.fgcolor = termui_color_from_pixel(_basic_colors[fgcolor | bright]);
577
578 if (attr & CATTR_BLINK)
579 cellstyle.blink = 1;
580
581 fibril_mutex_lock(&term->mtx);
582 termui_set_style(term->termui, cellstyle);
583 fibril_mutex_unlock(&term->mtx);
584}
585
586static void term_set_rgb_color(con_srv_t *srv, pixel_t bgcolor,
587 pixel_t fgcolor)
588{
589 terminal_t *term = srv_to_terminal(srv);
590 termui_cell_t cellstyle = {
591 .bgcolor = termui_color_from_pixel(bgcolor),
592 .fgcolor = termui_color_from_pixel(fgcolor),
593 };
594
595 fibril_mutex_lock(&term->mtx);
596 termui_set_style(term->termui, cellstyle);
597 fibril_mutex_unlock(&term->mtx);
598}
599
600static void term_set_cursor_visibility(con_srv_t *srv, bool visible)
601{
602 terminal_t *term = srv_to_terminal(srv);
603
604 fibril_mutex_lock(&term->mtx);
605 termui_set_cursor_visibility(term->termui, visible);
606 fibril_mutex_unlock(&term->mtx);
607
608 term_render(term);
609 gfx_update(term->gc);
610}
611
612static errno_t term_set_caption(con_srv_t *srv, const char *caption)
613{
614 terminal_t *term = srv_to_terminal(srv);
615 const char *cap;
616
617 fibril_mutex_lock(&term->mtx);
618
619 if (str_size(caption) > 0)
620 cap = caption;
621 else
622 cap = "Terminal";
623
624 ui_window_set_caption(term->window, cap);
625 fibril_mutex_unlock(&term->mtx);
626
627 term_render(term);
628 gfx_update(term->gc);
629 return EOK;
630}
631
632static errno_t term_get_event(con_srv_t *srv, cons_event_t *event)
633{
634 terminal_t *term = srv_to_terminal(srv);
635 link_t *link = prodcons_consume(&term->input_pc);
636 cons_event_t *ev = list_get_instance(link, cons_event_t, link);
637
638 *event = *ev;
639 free(ev);
640 return EOK;
641}
642
643/** Create shared buffer for efficient rendering.
644 *
645 * @param srv Console server
646 * @param cols Number of columns in buffer
647 * @param rows Number of rows in buffer
648 * @param rbuf Place to store pointer to new sharable buffer
649 *
650 * @return EOK on sucess or an error code
651 */
652static errno_t term_map(con_srv_t *srv, sysarg_t cols, sysarg_t rows,
653 charfield_t **rbuf)
654{
655 terminal_t *term = srv_to_terminal(srv);
656 void *buf;
657
658 fibril_mutex_lock(&term->mtx);
659
660 if (term->ubuf != NULL) {
661 fibril_mutex_unlock(&term->mtx);
662 return EBUSY;
663 }
664
665 buf = as_area_create(AS_AREA_ANY, cols * rows * sizeof(charfield_t),
666 AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE, AS_AREA_UNPAGED);
667 if (buf == AS_MAP_FAILED) {
668 fibril_mutex_unlock(&term->mtx);
669 return ENOMEM;
670 }
671
672 term->ucols = cols;
673 term->urows = rows;
674 term->ubuf = buf;
675
676 /* Scroll back to active screen. */
677 termui_history_scroll(term->termui, INT_MAX);
678
679 fibril_mutex_unlock(&term->mtx);
680
681 *rbuf = buf;
682 return EOK;
683}
684
685/** Delete shared buffer.
686 *
687 * @param srv Console server
688 */
689static void term_unmap(con_srv_t *srv)
690{
691 terminal_t *term = srv_to_terminal(srv);
692 void *buf;
693
694 fibril_mutex_lock(&term->mtx);
695
696 buf = term->ubuf;
697 term->ubuf = NULL;
698
699 termui_wipe_screen(term->termui, 0);
700
701 fibril_mutex_unlock(&term->mtx);
702
703 /* Update terminal */
704 term_render(term);
705 gfx_update(term->gc);
706
707 if (buf != NULL)
708 as_area_destroy(buf);
709}
710
711/** Update area of terminal from shared buffer.
712 *
713 * @param srv Console server
714 * @param c0 Column coordinate of top-left corner (inclusive)
715 * @param r0 Row coordinate of top-left corner (inclusive)
716 * @param c1 Column coordinate of bottom-right corner (exclusive)
717 * @param r1 Row coordinate of bottom-right corner (exclusive)
718 */
719static void term_buf_update(con_srv_t *srv, sysarg_t c0, sysarg_t r0,
720 sysarg_t c1, sysarg_t r1)
721{
722 terminal_t *term = srv_to_terminal(srv);
723
724 fibril_mutex_lock(&term->mtx);
725
726 if (term->ubuf == NULL) {
727 fibril_mutex_unlock(&term->mtx);
728 return;
729 }
730
731 /* Make sure we have meaningful coordinates, within bounds */
732 c1 = min(c1, term->ucols);
733 c1 = min(c1, (sysarg_t) termui_get_cols(term->termui));
734 r1 = min(r1, term->urows);
735 r1 = min(r1, (sysarg_t) termui_get_rows(term->termui));
736
737 if (c0 >= c1 || r0 >= r1) {
738 fibril_mutex_unlock(&term->mtx);
739 return;
740 }
741
742 /* Update front buffer from user buffer */
743
744 for (sysarg_t row = r0; row < r1; row++) {
745 termui_cell_t *cells = termui_get_active_row(term->termui, row);
746
747 for (sysarg_t col = c0; col < c1; col++) {
748 cells[col] = charfield_to_termui_cell(term, &term->ubuf[row * term->ucols + col]);
749 }
750
751 termui_update_cb(term, c0, row, &cells[c0], c1 - c0);
752 }
753
754 fibril_mutex_unlock(&term->mtx);
755
756 /* Update terminal */
757 term_render(term);
758 gfx_update(term->gc);
759}
760
761static errno_t terminal_window_resize(terminal_t *term)
762{
763 gfx_rect_t rect;
764 ui_window_get_app_rect(term->window, &rect);
765
766 int width = rect.p1.x - rect.p0.x;
767 int height = rect.p1.y - rect.p0.y;
768
769 if (!term->gc)
770 term->gc = ui_window_get_gc(term->window);
771 else
772 assert(term->gc == ui_window_get_gc(term->window));
773
774 if (!term->ui_res)
775 term->ui_res = ui_window_get_res(term->window);
776 else
777 assert(term->ui_res == ui_window_get_res(term->window));
778
779 gfx_bitmap_t *new_bmp;
780 gfx_bitmap_params_t params;
781 gfx_bitmap_params_init(&params);
782 params.rect.p0.x = 0;
783 params.rect.p0.y = 0;
784 params.rect.p1.x = width;
785 params.rect.p1.y = height;
786
787 errno_t rc = gfx_bitmap_create(term->gc, &params, NULL, &new_bmp);
788 if (rc != EOK) {
789 fprintf(stderr, "Error allocating new screen bitmap: %s\n", str_error(rc));
790 return rc;
791 }
792
793 if (term->bmp) {
794 rc = gfx_bitmap_destroy(term->bmp);
795 if (rc != EOK)
796 fprintf(stderr, "Error deallocating old screen bitmap: %s\n", str_error(rc));
797 }
798
799 term->bmp = new_bmp;
800 term->w = width;
801 term->h = height;
802
803 term_clear_bitmap(term, termui_color_to_pixel(term->default_bgcolor));
804
805 return EOK;
806}
807
808void terminal_destroy(terminal_t *term)
809{
810 list_remove(&term->link);
811
812 termui_destroy(term->termui);
813
814 if (term->ubuf)
815 as_area_destroy(term->ubuf);
816
817 ui_destroy(term->ui);
818 free(term);
819}
820
821static void terminal_queue_cons_event(terminal_t *term, cons_event_t *ev)
822{
823 /* Got key press/release event */
824 cons_event_t *event =
825 (cons_event_t *) malloc(sizeof(cons_event_t));
826 if (event == NULL)
827 return;
828
829 *event = *ev;
830 link_initialize(&event->link);
831
832 prodcons_produce(&term->input_pc, &event->link);
833}
834
835/** Handle window close event. */
836static void terminal_close_event(ui_window_t *window, void *arg)
837{
838 terminal_t *term = (terminal_t *) arg;
839
840 ui_quit(term->ui);
841}
842
843/** Handle window focus event. */
844static void terminal_focus_event(ui_window_t *window, void *arg,
845 unsigned nfocus)
846{
847 terminal_t *term = (terminal_t *) arg;
848
849 (void)nfocus;
850 term->is_focused = true;
851 term_render(term);
852 gfx_update(term->gc);
853}
854
855static void terminal_resize_handler(ui_window_t *window, void *arg)
856{
857 terminal_t *term = (terminal_t *) arg;
858
859 fibril_mutex_lock(&term->mtx);
860
861 errno_t rc = terminal_window_resize(term);
862 if (rc == EOK) {
863 (void) termui_resize(term->termui, term->w / FONT_WIDTH, term->h / FONT_SCANLINES, SCROLLBACK_MAX_LINES);
864 termui_refresh_cb(term);
865 term_render(term);
866 gfx_update(term->gc);
867
868 cons_event_t event = { .type = CEV_RESIZE };
869 terminal_queue_cons_event(term, &event);
870 }
871
872 fibril_mutex_unlock(&term->mtx);
873}
874
875static void terminal_resize_event(ui_window_t *window, void *arg)
876{
877 ui_window_def_resize(window);
878 terminal_resize_handler(window, arg);
879}
880
881static void terminal_maximize_event(ui_window_t *window, void *arg)
882{
883 ui_window_def_maximize(window);
884 terminal_resize_handler(window, arg);
885}
886
887static void terminal_unmaximize_event(ui_window_t *window, void *arg)
888{
889 ui_window_def_unmaximize(window);
890 terminal_resize_handler(window, arg);
891}
892
893/** Handle window keyboard event */
894static void terminal_kbd_event(ui_window_t *window, void *arg,
895 kbd_event_t *kbd_event)
896{
897 terminal_t *term = (terminal_t *) arg;
898 cons_event_t event;
899
900 event.type = CEV_KEY;
901 event.ev.key = *kbd_event;
902
903 const int PAGE_ROWS = (termui_get_rows(term->termui) * 2) / 3;
904
905 fibril_mutex_lock(&term->mtx);
906
907 if (!term->ubuf && kbd_event->type == KEY_PRESS &&
908 (kbd_event->key == KC_PAGE_UP || kbd_event->key == KC_PAGE_DOWN)) {
909
910 termui_history_scroll(term->termui,
911 (kbd_event->key == KC_PAGE_UP) ? -PAGE_ROWS : PAGE_ROWS);
912
913 term_render(term);
914 gfx_update(term->gc);
915 } else {
916 terminal_queue_cons_event(term, &event);
917 }
918
919 fibril_mutex_unlock(&term->mtx);
920}
921
922/** Handle window position event */
923static void terminal_pos_event(ui_window_t *window, void *arg, pos_event_t *event)
924{
925 cons_event_t cevent;
926 terminal_t *term = (terminal_t *) arg;
927
928 switch (event->type) {
929 case POS_UPDATE:
930 return;
931
932 case POS_PRESS:
933 case POS_RELEASE:
934 case POS_DCLICK:
935 }
936
937 /* Ignore mouse events when we're in scrollback mode. */
938 if (termui_scrollback_is_active(term->termui))
939 return;
940
941 sysarg_t sx = term->off.x;
942 sysarg_t sy = term->off.y;
943
944 if (event->hpos < sx || event->vpos < sy)
945 return;
946
947 cevent.type = CEV_POS;
948 cevent.ev.pos.type = event->type;
949 cevent.ev.pos.pos_id = event->pos_id;
950 cevent.ev.pos.btn_num = event->btn_num;
951
952 cevent.ev.pos.hpos = (event->hpos - sx) / FONT_WIDTH;
953 cevent.ev.pos.vpos = (event->vpos - sy) / FONT_SCANLINES;
954
955 /* Filter out events outside the terminal area. */
956 int cols = termui_get_cols(term->termui);
957 int rows = termui_get_rows(term->termui);
958
959 if (cevent.ev.pos.hpos < (sysarg_t) cols && cevent.ev.pos.vpos < (sysarg_t) rows)
960 terminal_queue_cons_event(term, &cevent);
961}
962
963/** Handle window unfocus event. */
964static void terminal_unfocus_event(ui_window_t *window, void *arg,
965 unsigned nfocus)
966{
967 terminal_t *term = (terminal_t *) arg;
968
969 if (nfocus == 0) {
970 term->is_focused = false;
971 term_render(term);
972 gfx_update(term->gc);
973 }
974}
975
976static void term_connection(ipc_call_t *icall, void *arg)
977{
978 terminal_t *term = NULL;
979
980 list_foreach(terms, link, terminal_t, cur) {
981 if (cur->dsid == (service_id_t) ipc_get_arg2(icall)) {
982 term = cur;
983 break;
984 }
985 }
986
987 if (term == NULL) {
988 async_answer_0(icall, ENOENT);
989 return;
990 }
991
992 if (!atomic_flag_test_and_set(&term->refcnt))
993 termui_set_cursor_visibility(term->termui, true);
994
995 con_conn(icall, &term->srvs);
996}
997
998static errno_t term_init_window(terminal_t *term, const char *display_spec,
999 gfx_coord_t width, gfx_coord_t height,
1000 gfx_coord_t min_width, gfx_coord_t min_height,
1001 terminal_flags_t flags)
1002{
1003 gfx_rect_t min_rect = { { 0, 0 }, { min_width, min_height } };
1004 gfx_rect_t wmin_rect;
1005 gfx_rect_t wrect;
1006
1007 errno_t rc = ui_create(display_spec, &term->ui);
1008 if (rc != EOK) {
1009 printf("Error creating UI on %s.\n", display_spec);
1010 return rc;
1011 }
1012
1013 ui_wnd_params_t wparams;
1014 ui_wnd_params_init(&wparams);
1015 wparams.caption = "Terminal";
1016 wparams.style |= ui_wds_maximize_btn | ui_wds_resizable;
1017
1018 if ((flags & tf_topleft) != 0)
1019 wparams.placement = ui_wnd_place_top_left;
1020
1021 if (ui_is_fullscreen(term->ui)) {
1022 wparams.placement = ui_wnd_place_full_screen;
1023 wparams.style &= ~ui_wds_decorated;
1024 }
1025
1026 /* Compute wrect such that application area corresponds to rect. */
1027 ui_wdecor_rect_from_app(term->ui, wparams.style, &min_rect, &wrect);
1028 gfx_rect_rtranslate(&wrect.p0, &wrect, &wmin_rect);
1029 wparams.min_size = wmin_rect.p1;
1030
1031 gfx_rect_t rect = { { 0, 0 }, { width, height } };
1032 ui_wdecor_rect_from_app(term->ui, wparams.style, &rect, &rect);
1033 term->off.x = -rect.p0.x;
1034 term->off.y = -rect.p0.y;
1035 printf("off=%d,%d\n", term->off.x, term->off.y);
1036 gfx_rect_translate(&term->off, &rect, &wparams.rect);
1037 printf("wparams.rect=%d,%d,%d,%d\n",
1038 wparams.rect.p0.x,
1039 wparams.rect.p1.x,
1040 wparams.rect.p0.y,
1041 wparams.rect.p1.y);
1042
1043 rc = ui_window_create(term->ui, &wparams, &term->window);
1044 if (rc != EOK)
1045 return rc;
1046
1047 ui_window_set_cb(term->window, &terminal_window_cb, (void *) term);
1048 return terminal_window_resize(term);
1049}
1050
1051errno_t terminal_create(const char *display_spec, sysarg_t width,
1052 sysarg_t height, terminal_flags_t flags, const char *command,
1053 terminal_t **rterm)
1054{
1055 errno_t rc;
1056
1057 terminal_t *term = calloc(1, sizeof(terminal_t));
1058 if (term == NULL) {
1059 printf("Out of memory.\n");
1060 return ENOMEM;
1061 }
1062
1063 link_initialize(&term->link);
1064 fibril_mutex_initialize(&term->mtx);
1065 atomic_flag_clear(&term->refcnt);
1066
1067 prodcons_initialize(&term->input_pc);
1068 term->char_remains_len = 0;
1069
1070 term->default_bgcolor = termui_color_from_pixel(_basic_colors[COLOR_WHITE | COLOR_BRIGHT]);
1071 term->default_fgcolor = termui_color_from_pixel(_basic_colors[COLOR_BLACK]);
1072
1073 term->emphasis_bgcolor = termui_color_from_pixel(_basic_colors[COLOR_WHITE | COLOR_BRIGHT]);
1074 term->emphasis_fgcolor = termui_color_from_pixel(_basic_colors[COLOR_RED | COLOR_BRIGHT]);
1075
1076 term->selection_bgcolor = termui_color_from_pixel(_basic_colors[COLOR_RED | COLOR_BRIGHT]);
1077 term->selection_fgcolor = termui_color_from_pixel(_basic_colors[COLOR_WHITE | COLOR_BRIGHT]);
1078
1079 rc = term_init_window(term, display_spec, width, height,
1080 MIN_WINDOW_COLS * FONT_WIDTH, MIN_WINDOW_ROWS * FONT_SCANLINES, flags);
1081 if (rc != EOK) {
1082 printf("Error creating window (%s).\n", str_error(rc));
1083 goto error;
1084 }
1085
1086 term->termui = termui_create(term->w / FONT_WIDTH,
1087 term->h / FONT_SCANLINES, SCROLLBACK_MAX_LINES);
1088 if (!term->termui) {
1089 printf("Error creating terminal UI.\n");
1090 rc = ENOMEM;
1091 goto error;
1092 }
1093
1094 termui_set_refresh_cb(term->termui, termui_refresh_cb, term);
1095 termui_set_scroll_cb(term->termui, termui_scroll_cb, term);
1096 termui_set_update_cb(term->termui, termui_update_cb, term);
1097
1098 async_set_fallback_port_handler(term_connection, NULL);
1099 con_srvs_init(&term->srvs);
1100 term->srvs.ops = &con_ops;
1101 term->srvs.sarg = term;
1102
1103 rc = loc_server_register(NAME, &term->srv);
1104 if (rc != EOK) {
1105 printf("Error registering server.\n");
1106 rc = EIO;
1107 goto error;
1108 }
1109
1110 char vc[LOC_NAME_MAXLEN + 1];
1111 snprintf(vc, LOC_NAME_MAXLEN, "%s/%" PRIu64, NAMESPACE,
1112 task_get_id());
1113
1114 rc = loc_service_register(term->srv, vc, &term->dsid);
1115 if (rc != EOK) {
1116 printf("Error registering service.\n");
1117 rc = EIO;
1118 goto error;
1119 }
1120
1121 list_append(&term->link, &terms);
1122 rc = getterm(&term->wait, vc, command);
1123 if (rc != EOK)
1124 goto error;
1125
1126 term->wfid = fibril_create(terminal_wait_fibril, term);
1127 if (term->wfid == 0)
1128 goto error;
1129
1130 fibril_add_ready(term->wfid);
1131
1132 term->is_focused = true;
1133
1134 termui_refresh_cb(term);
1135
1136 *rterm = term;
1137 return EOK;
1138error:
1139 if (term->dsid != 0)
1140 loc_service_unregister(term->srv, term->dsid);
1141 if (term->srv != NULL)
1142 loc_server_unregister(term->srv);
1143 if (term->window != NULL)
1144 ui_window_destroy(term->window);
1145 if (term->ui != NULL)
1146 ui_destroy(term->ui);
1147 if (term->termui != NULL)
1148 termui_destroy(term->termui);
1149 free(term);
1150 return rc;
1151}
1152
1153static errno_t terminal_wait_fibril(void *arg)
1154{
1155 terminal_t *term = (terminal_t *)arg;
1156 task_exit_t texit;
1157 int retval;
1158
1159 /*
1160 * XXX There is no way to break the sleep if the task does not
1161 * exit.
1162 */
1163 (void) task_wait(&term->wait, &texit, &retval);
1164 ui_quit(term->ui);
1165 return EOK;
1166}
1167
1168/** @}
1169 */
Note: See TracBrowser for help on using the repository browser.