Update version for v5.1.0-rc3 release
[qemu.git] / ui / curses.c
1 /*
2 * QEMU curses/ncurses display driver
3 *
4 * Copyright (c) 2005 Andrzej Zaborowski <balrog@zabor.org>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "qemu/osdep.h"
26
27 #ifndef _WIN32
28 #include <sys/ioctl.h>
29 #include <termios.h>
30 #endif
31 #include <locale.h>
32 #include <wchar.h>
33 #include <langinfo.h>
34 #include <iconv.h>
35
36 #include "qapi/error.h"
37 #include "qemu/module.h"
38 #include "ui/console.h"
39 #include "ui/input.h"
40 #include "sysemu/sysemu.h"
41
42 /* KEY_EVENT is defined in wincon.h and in curses.h. Avoid redefinition. */
43 #undef KEY_EVENT
44 #include <curses.h>
45 #undef KEY_EVENT
46
47 #define FONT_HEIGHT 16
48 #define FONT_WIDTH 8
49
50 enum maybe_keycode {
51 CURSES_KEYCODE,
52 CURSES_CHAR,
53 CURSES_CHAR_OR_KEYCODE,
54 };
55
56 static DisplayChangeListener *dcl;
57 static console_ch_t *screen;
58 static WINDOW *screenpad = NULL;
59 static int width, height, gwidth, gheight, invalidate;
60 static int px, py, sminx, sminy, smaxx, smaxy;
61
62 static const char *font_charset = "CP437";
63 static cchar_t *vga_to_curses;
64
65 static void curses_update(DisplayChangeListener *dcl,
66 int x, int y, int w, int h)
67 {
68 console_ch_t *line;
69 cchar_t curses_line[width];
70 wchar_t wch[CCHARW_MAX];
71 attr_t attrs;
72 short colors;
73 int ret;
74
75 line = screen + y * width;
76 for (h += y; y < h; y ++, line += width) {
77 for (x = 0; x < width; x++) {
78 chtype ch = line[x] & A_CHARTEXT;
79 chtype at = line[x] & A_ATTRIBUTES;
80 short color_pair = PAIR_NUMBER(line[x]);
81
82 ret = getcchar(&vga_to_curses[ch], wch, &attrs, &colors, NULL);
83 if (ret == ERR || wch[0] == 0) {
84 wch[0] = ch;
85 wch[1] = 0;
86 }
87 setcchar(&curses_line[x], wch, at, color_pair, NULL);
88 }
89 mvwadd_wchnstr(screenpad, y, 0, curses_line, width);
90 }
91
92 pnoutrefresh(screenpad, py, px, sminy, sminx, smaxy - 1, smaxx - 1);
93 refresh();
94 }
95
96 static void curses_calc_pad(void)
97 {
98 if (qemu_console_is_fixedsize(NULL)) {
99 width = gwidth;
100 height = gheight;
101 } else {
102 width = COLS;
103 height = LINES;
104 }
105
106 if (screenpad)
107 delwin(screenpad);
108
109 clear();
110 refresh();
111
112 screenpad = newpad(height, width);
113
114 if (width > COLS) {
115 px = (width - COLS) / 2;
116 sminx = 0;
117 smaxx = COLS;
118 } else {
119 px = 0;
120 sminx = (COLS - width) / 2;
121 smaxx = sminx + width;
122 }
123
124 if (height > LINES) {
125 py = (height - LINES) / 2;
126 sminy = 0;
127 smaxy = LINES;
128 } else {
129 py = 0;
130 sminy = (LINES - height) / 2;
131 smaxy = sminy + height;
132 }
133 }
134
135 static void curses_resize(DisplayChangeListener *dcl,
136 int width, int height)
137 {
138 if (width == gwidth && height == gheight) {
139 return;
140 }
141
142 gwidth = width;
143 gheight = height;
144
145 curses_calc_pad();
146 }
147
148 #if !defined(_WIN32) && defined(SIGWINCH) && defined(KEY_RESIZE)
149 static volatile sig_atomic_t got_sigwinch;
150 static void curses_winch_check(void)
151 {
152 struct winsize {
153 unsigned short ws_row;
154 unsigned short ws_col;
155 unsigned short ws_xpixel; /* unused */
156 unsigned short ws_ypixel; /* unused */
157 } ws;
158
159 if (!got_sigwinch) {
160 return;
161 }
162 got_sigwinch = false;
163
164 if (ioctl(1, TIOCGWINSZ, &ws) == -1) {
165 return;
166 }
167
168 resize_term(ws.ws_row, ws.ws_col);
169 invalidate = 1;
170 }
171
172 static void curses_winch_handler(int signum)
173 {
174 got_sigwinch = true;
175 }
176
177 static void curses_winch_init(void)
178 {
179 struct sigaction old, winch = {
180 .sa_handler = curses_winch_handler,
181 };
182 sigaction(SIGWINCH, &winch, &old);
183 }
184 #else
185 static void curses_winch_check(void) {}
186 static void curses_winch_init(void) {}
187 #endif
188
189 static void curses_cursor_position(DisplayChangeListener *dcl,
190 int x, int y)
191 {
192 if (x >= 0) {
193 x = sminx + x - px;
194 y = sminy + y - py;
195
196 if (x >= 0 && y >= 0 && x < COLS && y < LINES) {
197 move(y, x);
198 curs_set(1);
199 /* it seems that curs_set(1) must always be called before
200 * curs_set(2) for the latter to have effect */
201 if (!qemu_console_is_graphic(NULL)) {
202 curs_set(2);
203 }
204 return;
205 }
206 }
207
208 curs_set(0);
209 }
210
211 /* generic keyboard conversion */
212
213 #include "curses_keys.h"
214
215 static kbd_layout_t *kbd_layout = NULL;
216
217 static wint_t console_getch(enum maybe_keycode *maybe_keycode)
218 {
219 wint_t ret;
220 switch (get_wch(&ret)) {
221 case KEY_CODE_YES:
222 *maybe_keycode = CURSES_KEYCODE;
223 break;
224 case OK:
225 *maybe_keycode = CURSES_CHAR;
226 break;
227 case ERR:
228 ret = -1;
229 break;
230 default:
231 abort();
232 }
233 return ret;
234 }
235
236 static int curses2foo(const int _curses2foo[], const int _curseskey2foo[],
237 int chr, enum maybe_keycode maybe_keycode)
238 {
239 int ret = -1;
240 if (maybe_keycode == CURSES_CHAR) {
241 if (chr < CURSES_CHARS) {
242 ret = _curses2foo[chr];
243 }
244 } else {
245 if (chr < CURSES_KEYS) {
246 ret = _curseskey2foo[chr];
247 }
248 if (ret == -1 && maybe_keycode == CURSES_CHAR_OR_KEYCODE &&
249 chr < CURSES_CHARS) {
250 ret = _curses2foo[chr];
251 }
252 }
253 return ret;
254 }
255
256 #define curses2keycode(chr, maybe_keycode) \
257 curses2foo(_curses2keycode, _curseskey2keycode, chr, maybe_keycode)
258 #define curses2keysym(chr, maybe_keycode) \
259 curses2foo(_curses2keysym, _curseskey2keysym, chr, maybe_keycode)
260 #define curses2qemu(chr, maybe_keycode) \
261 curses2foo(_curses2qemu, _curseskey2qemu, chr, maybe_keycode)
262
263 static void curses_refresh(DisplayChangeListener *dcl)
264 {
265 int chr, keysym, keycode, keycode_alt;
266 enum maybe_keycode maybe_keycode;
267
268 curses_winch_check();
269
270 if (invalidate) {
271 clear();
272 refresh();
273 curses_calc_pad();
274 graphic_hw_invalidate(NULL);
275 invalidate = 0;
276 }
277
278 graphic_hw_text_update(NULL, screen);
279
280 while (1) {
281 /* while there are any pending key strokes to process */
282 chr = console_getch(&maybe_keycode);
283
284 if (chr == -1)
285 break;
286
287 #ifdef KEY_RESIZE
288 /* this shouldn't occur when we use a custom SIGWINCH handler */
289 if (maybe_keycode != CURSES_CHAR && chr == KEY_RESIZE) {
290 clear();
291 refresh();
292 curses_calc_pad();
293 curses_update(dcl, 0, 0, width, height);
294 continue;
295 }
296 #endif
297
298 keycode = curses2keycode(chr, maybe_keycode);
299 keycode_alt = 0;
300
301 /* alt or esc key */
302 if (keycode == 1) {
303 enum maybe_keycode next_maybe_keycode;
304 int nextchr = console_getch(&next_maybe_keycode);
305
306 if (nextchr != -1) {
307 chr = nextchr;
308 maybe_keycode = next_maybe_keycode;
309 keycode_alt = ALT;
310 keycode = curses2keycode(chr, maybe_keycode);
311
312 if (keycode != -1) {
313 keycode |= ALT;
314
315 /* process keys reserved for qemu */
316 if (keycode >= QEMU_KEY_CONSOLE0 &&
317 keycode < QEMU_KEY_CONSOLE0 + 9) {
318 erase();
319 wnoutrefresh(stdscr);
320 console_select(keycode - QEMU_KEY_CONSOLE0);
321
322 invalidate = 1;
323 continue;
324 }
325 }
326 }
327 }
328
329 if (kbd_layout) {
330 keysym = curses2keysym(chr, maybe_keycode);
331
332 if (keysym == -1) {
333 if (chr < ' ') {
334 keysym = chr + '@';
335 if (keysym >= 'A' && keysym <= 'Z')
336 keysym += 'a' - 'A';
337 keysym |= KEYSYM_CNTRL;
338 } else
339 keysym = chr;
340 }
341
342 keycode = keysym2scancode(kbd_layout, keysym & KEYSYM_MASK,
343 NULL, false);
344 if (keycode == 0)
345 continue;
346
347 keycode |= (keysym & ~KEYSYM_MASK) >> 16;
348 keycode |= keycode_alt;
349 }
350
351 if (keycode == -1)
352 continue;
353
354 if (qemu_console_is_graphic(NULL)) {
355 /* since terminals don't know about key press and release
356 * events, we need to emit both for each key received */
357 if (keycode & SHIFT) {
358 qemu_input_event_send_key_number(NULL, SHIFT_CODE, true);
359 qemu_input_event_send_key_delay(0);
360 }
361 if (keycode & CNTRL) {
362 qemu_input_event_send_key_number(NULL, CNTRL_CODE, true);
363 qemu_input_event_send_key_delay(0);
364 }
365 if (keycode & ALT) {
366 qemu_input_event_send_key_number(NULL, ALT_CODE, true);
367 qemu_input_event_send_key_delay(0);
368 }
369 if (keycode & ALTGR) {
370 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, true);
371 qemu_input_event_send_key_delay(0);
372 }
373
374 qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, true);
375 qemu_input_event_send_key_delay(0);
376 qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, false);
377 qemu_input_event_send_key_delay(0);
378
379 if (keycode & ALTGR) {
380 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, false);
381 qemu_input_event_send_key_delay(0);
382 }
383 if (keycode & ALT) {
384 qemu_input_event_send_key_number(NULL, ALT_CODE, false);
385 qemu_input_event_send_key_delay(0);
386 }
387 if (keycode & CNTRL) {
388 qemu_input_event_send_key_number(NULL, CNTRL_CODE, false);
389 qemu_input_event_send_key_delay(0);
390 }
391 if (keycode & SHIFT) {
392 qemu_input_event_send_key_number(NULL, SHIFT_CODE, false);
393 qemu_input_event_send_key_delay(0);
394 }
395 } else {
396 keysym = curses2qemu(chr, maybe_keycode);
397 if (keysym == -1)
398 keysym = chr;
399
400 kbd_put_keysym(keysym);
401 }
402 }
403 }
404
405 static void curses_atexit(void)
406 {
407 endwin();
408 g_free(vga_to_curses);
409 g_free(screen);
410 }
411
412 /*
413 * In the following:
414 * - fch is the font glyph number
415 * - uch is the unicode value
416 * - wch is the wchar_t value (may not be unicode, e.g. on BSD/solaris)
417 * - mbch is the native local-dependent multibyte representation
418 */
419
420 /* Setup wchar glyph for one UCS-2 char */
421 static void convert_ucs(unsigned char fch, uint16_t uch, iconv_t conv)
422 {
423 char mbch[MB_LEN_MAX];
424 wchar_t wch[2];
425 char *puch, *pmbch;
426 size_t such, smbch;
427 mbstate_t ps;
428
429 puch = (char *) &uch;
430 pmbch = (char *) mbch;
431 such = sizeof(uch);
432 smbch = sizeof(mbch);
433
434 if (iconv(conv, &puch, &such, &pmbch, &smbch) == (size_t) -1) {
435 fprintf(stderr, "Could not convert 0x%04x "
436 "from UCS-2 to a multibyte character: %s\n",
437 uch, strerror(errno));
438 return;
439 }
440
441 memset(&ps, 0, sizeof(ps));
442 if (mbrtowc(&wch[0], mbch, sizeof(mbch) - smbch, &ps) == -1) {
443 fprintf(stderr, "Could not convert 0x%04x "
444 "from a multibyte character to wchar_t: %s\n",
445 uch, strerror(errno));
446 return;
447 }
448
449 wch[1] = 0;
450 setcchar(&vga_to_curses[fch], wch, 0, 0, NULL);
451 }
452
453 /* Setup wchar glyph for one font character */
454 static void convert_font(unsigned char fch, iconv_t conv)
455 {
456 char mbch[MB_LEN_MAX];
457 wchar_t wch[2];
458 char *pfch, *pmbch;
459 size_t sfch, smbch;
460 mbstate_t ps;
461
462 pfch = (char *) &fch;
463 pmbch = (char *) &mbch;
464 sfch = sizeof(fch);
465 smbch = sizeof(mbch);
466
467 if (iconv(conv, &pfch, &sfch, &pmbch, &smbch) == (size_t) -1) {
468 fprintf(stderr, "Could not convert font glyph 0x%02x "
469 "from %s to a multibyte character: %s\n",
470 fch, font_charset, strerror(errno));
471 return;
472 }
473
474 memset(&ps, 0, sizeof(ps));
475 if (mbrtowc(&wch[0], mbch, sizeof(mbch) - smbch, &ps) == -1) {
476 fprintf(stderr, "Could not convert font glyph 0x%02x "
477 "from a multibyte character to wchar_t: %s\n",
478 fch, strerror(errno));
479 return;
480 }
481
482 wch[1] = 0;
483 setcchar(&vga_to_curses[fch], wch, 0, 0, NULL);
484 }
485
486 /* Convert one wchar to UCS-2 */
487 static uint16_t get_ucs(wchar_t wch, iconv_t conv)
488 {
489 char mbch[MB_LEN_MAX];
490 uint16_t uch;
491 char *pmbch, *puch;
492 size_t smbch, such;
493 mbstate_t ps;
494 int ret;
495
496 memset(&ps, 0, sizeof(ps));
497 ret = wcrtomb(mbch, wch, &ps);
498 if (ret == -1) {
499 fprintf(stderr, "Could not convert 0x%04lx "
500 "from wchar_t to a multibyte character: %s\n",
501 (unsigned long)wch, strerror(errno));
502 return 0xFFFD;
503 }
504
505 pmbch = (char *) mbch;
506 puch = (char *) &uch;
507 smbch = ret;
508 such = sizeof(uch);
509
510 if (iconv(conv, &pmbch, &smbch, &puch, &such) == (size_t) -1) {
511 fprintf(stderr, "Could not convert 0x%04lx "
512 "from a multibyte character to UCS-2 : %s\n",
513 (unsigned long)wch, strerror(errno));
514 return 0xFFFD;
515 }
516
517 return uch;
518 }
519
520 /*
521 * Setup mapping for vga to curses line graphics.
522 */
523 static void font_setup(void)
524 {
525 iconv_t ucs2_to_nativecharset;
526 iconv_t nativecharset_to_ucs2;
527 iconv_t font_conv;
528 int i;
529
530 /*
531 * Control characters are normally non-printable, but VGA does have
532 * well-known glyphs for them.
533 */
534 static const uint16_t control_characters[0x20] = {
535 0x0020,
536 0x263a,
537 0x263b,
538 0x2665,
539 0x2666,
540 0x2663,
541 0x2660,
542 0x2022,
543 0x25d8,
544 0x25cb,
545 0x25d9,
546 0x2642,
547 0x2640,
548 0x266a,
549 0x266b,
550 0x263c,
551 0x25ba,
552 0x25c4,
553 0x2195,
554 0x203c,
555 0x00b6,
556 0x00a7,
557 0x25ac,
558 0x21a8,
559 0x2191,
560 0x2193,
561 0x2192,
562 0x2190,
563 0x221f,
564 0x2194,
565 0x25b2,
566 0x25bc
567 };
568
569 ucs2_to_nativecharset = iconv_open(nl_langinfo(CODESET), "UCS-2");
570 if (ucs2_to_nativecharset == (iconv_t) -1) {
571 fprintf(stderr, "Could not convert font glyphs from UCS-2: '%s'\n",
572 strerror(errno));
573 exit(1);
574 }
575
576 nativecharset_to_ucs2 = iconv_open("UCS-2", nl_langinfo(CODESET));
577 if (nativecharset_to_ucs2 == (iconv_t) -1) {
578 iconv_close(ucs2_to_nativecharset);
579 fprintf(stderr, "Could not convert font glyphs to UCS-2: '%s'\n",
580 strerror(errno));
581 exit(1);
582 }
583
584 font_conv = iconv_open(nl_langinfo(CODESET), font_charset);
585 if (font_conv == (iconv_t) -1) {
586 iconv_close(ucs2_to_nativecharset);
587 iconv_close(nativecharset_to_ucs2);
588 fprintf(stderr, "Could not convert font glyphs from %s: '%s'\n",
589 font_charset, strerror(errno));
590 exit(1);
591 }
592
593 /* Control characters */
594 for (i = 0; i <= 0x1F; i++) {
595 convert_ucs(i, control_characters[i], ucs2_to_nativecharset);
596 }
597
598 for (i = 0x20; i <= 0xFF; i++) {
599 convert_font(i, font_conv);
600 }
601
602 /* DEL */
603 convert_ucs(0x7F, 0x2302, ucs2_to_nativecharset);
604
605 if (strcmp(nl_langinfo(CODESET), "UTF-8")) {
606 /* Non-Unicode capable, use termcap equivalents for those available */
607 for (i = 0; i <= 0xFF; i++) {
608 wchar_t wch[CCHARW_MAX];
609 attr_t attr;
610 short color;
611 int ret;
612
613 ret = getcchar(&vga_to_curses[i], wch, &attr, &color, NULL);
614 if (ret == ERR)
615 continue;
616
617 switch (get_ucs(wch[0], nativecharset_to_ucs2)) {
618 case 0x00a3:
619 vga_to_curses[i] = *WACS_STERLING;
620 break;
621 case 0x2591:
622 vga_to_curses[i] = *WACS_BOARD;
623 break;
624 case 0x2592:
625 vga_to_curses[i] = *WACS_CKBOARD;
626 break;
627 case 0x2502:
628 vga_to_curses[i] = *WACS_VLINE;
629 break;
630 case 0x2524:
631 vga_to_curses[i] = *WACS_RTEE;
632 break;
633 case 0x2510:
634 vga_to_curses[i] = *WACS_URCORNER;
635 break;
636 case 0x2514:
637 vga_to_curses[i] = *WACS_LLCORNER;
638 break;
639 case 0x2534:
640 vga_to_curses[i] = *WACS_BTEE;
641 break;
642 case 0x252c:
643 vga_to_curses[i] = *WACS_TTEE;
644 break;
645 case 0x251c:
646 vga_to_curses[i] = *WACS_LTEE;
647 break;
648 case 0x2500:
649 vga_to_curses[i] = *WACS_HLINE;
650 break;
651 case 0x253c:
652 vga_to_curses[i] = *WACS_PLUS;
653 break;
654 case 0x256c:
655 vga_to_curses[i] = *WACS_LANTERN;
656 break;
657 case 0x256a:
658 vga_to_curses[i] = *WACS_NEQUAL;
659 break;
660 case 0x2518:
661 vga_to_curses[i] = *WACS_LRCORNER;
662 break;
663 case 0x250c:
664 vga_to_curses[i] = *WACS_ULCORNER;
665 break;
666 case 0x2588:
667 vga_to_curses[i] = *WACS_BLOCK;
668 break;
669 case 0x03c0:
670 vga_to_curses[i] = *WACS_PI;
671 break;
672 case 0x00b1:
673 vga_to_curses[i] = *WACS_PLMINUS;
674 break;
675 case 0x2265:
676 vga_to_curses[i] = *WACS_GEQUAL;
677 break;
678 case 0x2264:
679 vga_to_curses[i] = *WACS_LEQUAL;
680 break;
681 case 0x00b0:
682 vga_to_curses[i] = *WACS_DEGREE;
683 break;
684 case 0x25a0:
685 vga_to_curses[i] = *WACS_BULLET;
686 break;
687 case 0x2666:
688 vga_to_curses[i] = *WACS_DIAMOND;
689 break;
690 case 0x2192:
691 vga_to_curses[i] = *WACS_RARROW;
692 break;
693 case 0x2190:
694 vga_to_curses[i] = *WACS_LARROW;
695 break;
696 case 0x2191:
697 vga_to_curses[i] = *WACS_UARROW;
698 break;
699 case 0x2193:
700 vga_to_curses[i] = *WACS_DARROW;
701 break;
702 case 0x23ba:
703 vga_to_curses[i] = *WACS_S1;
704 break;
705 case 0x23bb:
706 vga_to_curses[i] = *WACS_S3;
707 break;
708 case 0x23bc:
709 vga_to_curses[i] = *WACS_S7;
710 break;
711 case 0x23bd:
712 vga_to_curses[i] = *WACS_S9;
713 break;
714 }
715 }
716 }
717 iconv_close(ucs2_to_nativecharset);
718 iconv_close(nativecharset_to_ucs2);
719 iconv_close(font_conv);
720 }
721
722 static void curses_setup(void)
723 {
724 int i, colour_default[8] = {
725 [QEMU_COLOR_BLACK] = COLOR_BLACK,
726 [QEMU_COLOR_BLUE] = COLOR_BLUE,
727 [QEMU_COLOR_GREEN] = COLOR_GREEN,
728 [QEMU_COLOR_CYAN] = COLOR_CYAN,
729 [QEMU_COLOR_RED] = COLOR_RED,
730 [QEMU_COLOR_MAGENTA] = COLOR_MAGENTA,
731 [QEMU_COLOR_YELLOW] = COLOR_YELLOW,
732 [QEMU_COLOR_WHITE] = COLOR_WHITE,
733 };
734
735 /* input as raw as possible, let everything be interpreted
736 * by the guest system */
737 initscr(); noecho(); intrflush(stdscr, FALSE);
738 nodelay(stdscr, TRUE); nonl(); keypad(stdscr, TRUE);
739 start_color(); raw(); scrollok(stdscr, FALSE);
740 set_escdelay(25);
741
742 /* Make color pair to match color format (3bits bg:3bits fg) */
743 for (i = 0; i < 64; i++) {
744 init_pair(i, colour_default[i & 7], colour_default[i >> 3]);
745 }
746 /* Set default color for more than 64 for safety. */
747 for (i = 64; i < COLOR_PAIRS; i++) {
748 init_pair(i, COLOR_WHITE, COLOR_BLACK);
749 }
750
751 font_setup();
752 }
753
754 static void curses_keyboard_setup(void)
755 {
756 #if defined(__APPLE__)
757 /* always use generic keymaps */
758 if (!keyboard_layout)
759 keyboard_layout = "en-us";
760 #endif
761 if(keyboard_layout) {
762 kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout,
763 &error_fatal);
764 }
765 }
766
767 static const DisplayChangeListenerOps dcl_ops = {
768 .dpy_name = "curses",
769 .dpy_text_update = curses_update,
770 .dpy_text_resize = curses_resize,
771 .dpy_refresh = curses_refresh,
772 .dpy_text_cursor = curses_cursor_position,
773 };
774
775 static void curses_display_init(DisplayState *ds, DisplayOptions *opts)
776 {
777 #ifndef _WIN32
778 if (!isatty(1)) {
779 fprintf(stderr, "We need a terminal output\n");
780 exit(1);
781 }
782 #endif
783
784 setlocale(LC_CTYPE, "");
785 if (opts->u.curses.charset) {
786 font_charset = opts->u.curses.charset;
787 }
788 screen = g_new0(console_ch_t, 160 * 100);
789 vga_to_curses = g_new0(cchar_t, 256);
790 curses_setup();
791 curses_keyboard_setup();
792 atexit(curses_atexit);
793
794 curses_winch_init();
795
796 dcl = g_new0(DisplayChangeListener, 1);
797 dcl->ops = &dcl_ops;
798 register_displaychangelistener(dcl);
799
800 invalidate = 1;
801 }
802
803 static QemuDisplay qemu_display_curses = {
804 .type = DISPLAY_TYPE_CURSES,
805 .init = curses_display_init,
806 };
807
808 static void register_curses(void)
809 {
810 qemu_display_register(&qemu_display_curses);
811 }
812
813 type_init(register_curses);