target/mips: Move MUL opcode check from decode_mxu() to decode_legacy()
[qemu/ar7.git] / ui / curses.c
blobe4f9588c3e8ad001d74f9704ba3bf55299d98925
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
25 #include "qemu/osdep.h"
27 #ifndef _WIN32
28 #include <sys/ioctl.h>
29 #include <termios.h>
30 #endif
31 #include <locale.h>
32 #include <wchar.h>
33 #include <iconv.h>
35 #include "qapi/error.h"
36 #include "qemu/module.h"
37 #include "ui/console.h"
38 #include "ui/input.h"
39 #include "sysemu/sysemu.h"
41 /* KEY_EVENT is defined in wincon.h and in curses.h. Avoid redefinition. */
42 #undef KEY_EVENT
43 #include <curses.h>
44 #undef KEY_EVENT
46 #define FONT_HEIGHT 16
47 #define FONT_WIDTH 8
49 enum maybe_keycode {
50 CURSES_KEYCODE,
51 CURSES_CHAR,
52 CURSES_CHAR_OR_KEYCODE,
55 static DisplayChangeListener *dcl;
56 static console_ch_t *screen;
57 static WINDOW *screenpad = NULL;
58 static int width, height, gwidth, gheight, invalidate;
59 static int px, py, sminx, sminy, smaxx, smaxy;
61 static const char *font_charset = "CP437";
62 static cchar_t *vga_to_curses;
64 static void curses_update(DisplayChangeListener *dcl,
65 int x, int y, int w, int h)
67 console_ch_t *line;
68 cchar_t curses_line[width];
69 wchar_t wch[CCHARW_MAX];
70 attr_t attrs;
71 short colors;
72 int ret;
74 line = screen + y * width;
75 for (h += y; y < h; y ++, line += width) {
76 for (x = 0; x < width; x++) {
77 chtype ch = line[x] & A_CHARTEXT;
78 chtype at = line[x] & A_ATTRIBUTES;
79 short color_pair = PAIR_NUMBER(line[x]);
81 ret = getcchar(&vga_to_curses[ch], wch, &attrs, &colors, NULL);
82 if (ret == ERR || wch[0] == 0) {
83 wch[0] = ch;
84 wch[1] = 0;
86 setcchar(&curses_line[x], wch, at, color_pair, NULL);
88 mvwadd_wchnstr(screenpad, y, 0, curses_line, width);
91 pnoutrefresh(screenpad, py, px, sminy, sminx, smaxy - 1, smaxx - 1);
92 refresh();
95 static void curses_calc_pad(void)
97 if (qemu_console_is_fixedsize(NULL)) {
98 width = gwidth;
99 height = gheight;
100 } else {
101 width = COLS;
102 height = LINES;
105 if (screenpad)
106 delwin(screenpad);
108 clear();
109 refresh();
111 screenpad = newpad(height, width);
113 if (width > COLS) {
114 px = (width - COLS) / 2;
115 sminx = 0;
116 smaxx = COLS;
117 } else {
118 px = 0;
119 sminx = (COLS - width) / 2;
120 smaxx = sminx + width;
123 if (height > LINES) {
124 py = (height - LINES) / 2;
125 sminy = 0;
126 smaxy = LINES;
127 } else {
128 py = 0;
129 sminy = (LINES - height) / 2;
130 smaxy = sminy + height;
134 static void curses_resize(DisplayChangeListener *dcl,
135 int width, int height)
137 if (width == gwidth && height == gheight) {
138 return;
141 gwidth = width;
142 gheight = height;
144 curses_calc_pad();
147 #if !defined(_WIN32) && defined(SIGWINCH) && defined(KEY_RESIZE)
148 static volatile sig_atomic_t got_sigwinch;
149 static void curses_winch_check(void)
151 struct winsize {
152 unsigned short ws_row;
153 unsigned short ws_col;
154 unsigned short ws_xpixel; /* unused */
155 unsigned short ws_ypixel; /* unused */
156 } ws;
158 if (!got_sigwinch) {
159 return;
161 got_sigwinch = false;
163 if (ioctl(1, TIOCGWINSZ, &ws) == -1) {
164 return;
167 resize_term(ws.ws_row, ws.ws_col);
168 invalidate = 1;
171 static void curses_winch_handler(int signum)
173 got_sigwinch = true;
176 static void curses_winch_init(void)
178 struct sigaction old, winch = {
179 .sa_handler = curses_winch_handler,
181 sigaction(SIGWINCH, &winch, &old);
183 #else
184 static void curses_winch_check(void) {}
185 static void curses_winch_init(void) {}
186 #endif
188 static void curses_cursor_position(DisplayChangeListener *dcl,
189 int x, int y)
191 if (x >= 0) {
192 x = sminx + x - px;
193 y = sminy + y - py;
195 if (x >= 0 && y >= 0 && x < COLS && y < LINES) {
196 move(y, x);
197 curs_set(1);
198 /* it seems that curs_set(1) must always be called before
199 * curs_set(2) for the latter to have effect */
200 if (!qemu_console_is_graphic(NULL)) {
201 curs_set(2);
203 return;
207 curs_set(0);
210 /* generic keyboard conversion */
212 #include "curses_keys.h"
214 static kbd_layout_t *kbd_layout = NULL;
216 static wint_t console_getch(enum maybe_keycode *maybe_keycode)
218 wint_t ret;
219 switch (get_wch(&ret)) {
220 case KEY_CODE_YES:
221 *maybe_keycode = CURSES_KEYCODE;
222 break;
223 case OK:
224 *maybe_keycode = CURSES_CHAR;
225 break;
226 case ERR:
227 ret = -1;
228 break;
229 default:
230 abort();
232 return ret;
235 static int curses2foo(const int _curses2foo[], const int _curseskey2foo[],
236 int chr, enum maybe_keycode maybe_keycode)
238 int ret = -1;
239 if (maybe_keycode == CURSES_CHAR) {
240 if (chr < CURSES_CHARS) {
241 ret = _curses2foo[chr];
243 } else {
244 if (chr < CURSES_KEYS) {
245 ret = _curseskey2foo[chr];
247 if (ret == -1 && maybe_keycode == CURSES_CHAR_OR_KEYCODE &&
248 chr < CURSES_CHARS) {
249 ret = _curses2foo[chr];
252 return ret;
255 #define curses2keycode(chr, maybe_keycode) \
256 curses2foo(_curses2keycode, _curseskey2keycode, chr, maybe_keycode)
257 #define curses2keysym(chr, maybe_keycode) \
258 curses2foo(_curses2keysym, _curseskey2keysym, chr, maybe_keycode)
259 #define curses2qemu(chr, maybe_keycode) \
260 curses2foo(_curses2qemu, _curseskey2qemu, chr, maybe_keycode)
262 static void curses_refresh(DisplayChangeListener *dcl)
264 int chr, keysym, keycode, keycode_alt;
265 enum maybe_keycode maybe_keycode = CURSES_KEYCODE;
267 curses_winch_check();
269 if (invalidate) {
270 clear();
271 refresh();
272 curses_calc_pad();
273 graphic_hw_invalidate(NULL);
274 invalidate = 0;
277 graphic_hw_text_update(NULL, screen);
279 while (1) {
280 /* while there are any pending key strokes to process */
281 chr = console_getch(&maybe_keycode);
283 if (chr == -1)
284 break;
286 #ifdef KEY_RESIZE
287 /* this shouldn't occur when we use a custom SIGWINCH handler */
288 if (maybe_keycode != CURSES_CHAR && chr == KEY_RESIZE) {
289 clear();
290 refresh();
291 curses_calc_pad();
292 curses_update(dcl, 0, 0, width, height);
293 continue;
295 #endif
297 keycode = curses2keycode(chr, maybe_keycode);
298 keycode_alt = 0;
300 /* alt or esc key */
301 if (keycode == 1) {
302 enum maybe_keycode next_maybe_keycode = CURSES_KEYCODE;
303 int nextchr = console_getch(&next_maybe_keycode);
305 if (nextchr != -1) {
306 chr = nextchr;
307 maybe_keycode = next_maybe_keycode;
308 keycode_alt = ALT;
309 keycode = curses2keycode(chr, maybe_keycode);
311 if (keycode != -1) {
312 keycode |= ALT;
314 /* process keys reserved for qemu */
315 if (keycode >= QEMU_KEY_CONSOLE0 &&
316 keycode < QEMU_KEY_CONSOLE0 + 9) {
317 erase();
318 wnoutrefresh(stdscr);
319 console_select(keycode - QEMU_KEY_CONSOLE0);
321 invalidate = 1;
322 continue;
328 if (kbd_layout) {
329 keysym = curses2keysym(chr, maybe_keycode);
331 if (keysym == -1) {
332 if (chr < ' ') {
333 keysym = chr + '@';
334 if (keysym >= 'A' && keysym <= 'Z')
335 keysym += 'a' - 'A';
336 keysym |= KEYSYM_CNTRL;
337 } else
338 keysym = chr;
341 keycode = keysym2scancode(kbd_layout, keysym & KEYSYM_MASK,
342 NULL, false);
343 if (keycode == 0)
344 continue;
346 keycode |= (keysym & ~KEYSYM_MASK) >> 16;
347 keycode |= keycode_alt;
350 if (keycode == -1)
351 continue;
353 if (qemu_console_is_graphic(NULL)) {
354 /* since terminals don't know about key press and release
355 * events, we need to emit both for each key received */
356 if (keycode & SHIFT) {
357 qemu_input_event_send_key_number(NULL, SHIFT_CODE, true);
358 qemu_input_event_send_key_delay(0);
360 if (keycode & CNTRL) {
361 qemu_input_event_send_key_number(NULL, CNTRL_CODE, true);
362 qemu_input_event_send_key_delay(0);
364 if (keycode & ALT) {
365 qemu_input_event_send_key_number(NULL, ALT_CODE, true);
366 qemu_input_event_send_key_delay(0);
368 if (keycode & ALTGR) {
369 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, true);
370 qemu_input_event_send_key_delay(0);
373 qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, true);
374 qemu_input_event_send_key_delay(0);
375 qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, false);
376 qemu_input_event_send_key_delay(0);
378 if (keycode & ALTGR) {
379 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, false);
380 qemu_input_event_send_key_delay(0);
382 if (keycode & ALT) {
383 qemu_input_event_send_key_number(NULL, ALT_CODE, false);
384 qemu_input_event_send_key_delay(0);
386 if (keycode & CNTRL) {
387 qemu_input_event_send_key_number(NULL, CNTRL_CODE, false);
388 qemu_input_event_send_key_delay(0);
390 if (keycode & SHIFT) {
391 qemu_input_event_send_key_number(NULL, SHIFT_CODE, false);
392 qemu_input_event_send_key_delay(0);
394 } else {
395 keysym = curses2qemu(chr, maybe_keycode);
396 if (keysym == -1)
397 keysym = chr;
399 kbd_put_keysym(keysym);
404 static void curses_atexit(void)
406 endwin();
407 g_free(vga_to_curses);
408 g_free(screen);
412 * In the following:
413 * - fch is the font glyph number
414 * - uch is the unicode value
415 * - wch is the wchar_t value (may not be unicode, e.g. on BSD/solaris)
416 * - mbch is the native local-dependent multibyte representation
419 /* Setup wchar glyph for one UCS-2 char */
420 static void convert_ucs(unsigned char fch, uint16_t uch, iconv_t conv)
422 char mbch[MB_LEN_MAX];
423 wchar_t wch[2];
424 char *puch, *pmbch;
425 size_t such, smbch;
426 mbstate_t ps;
428 puch = (char *) &uch;
429 pmbch = (char *) mbch;
430 such = sizeof(uch);
431 smbch = sizeof(mbch);
433 if (iconv(conv, &puch, &such, &pmbch, &smbch) == (size_t) -1) {
434 fprintf(stderr, "Could not convert 0x%04x "
435 "from UCS-2 to a multibyte character: %s\n",
436 uch, strerror(errno));
437 return;
440 memset(&ps, 0, sizeof(ps));
441 if (mbrtowc(&wch[0], mbch, sizeof(mbch) - smbch, &ps) == -1) {
442 fprintf(stderr, "Could not convert 0x%04x "
443 "from a multibyte character to wchar_t: %s\n",
444 uch, strerror(errno));
445 return;
448 wch[1] = 0;
449 setcchar(&vga_to_curses[fch], wch, 0, 0, NULL);
452 /* Setup wchar glyph for one font character */
453 static void convert_font(unsigned char fch, iconv_t conv)
455 char mbch[MB_LEN_MAX];
456 wchar_t wch[2];
457 char *pfch, *pmbch;
458 size_t sfch, smbch;
459 mbstate_t ps;
461 pfch = (char *) &fch;
462 pmbch = (char *) &mbch;
463 sfch = sizeof(fch);
464 smbch = sizeof(mbch);
466 if (iconv(conv, &pfch, &sfch, &pmbch, &smbch) == (size_t) -1) {
467 fprintf(stderr, "Could not convert font glyph 0x%02x "
468 "from %s to a multibyte character: %s\n",
469 fch, font_charset, strerror(errno));
470 return;
473 memset(&ps, 0, sizeof(ps));
474 if (mbrtowc(&wch[0], mbch, sizeof(mbch) - smbch, &ps) == -1) {
475 fprintf(stderr, "Could not convert font glyph 0x%02x "
476 "from a multibyte character to wchar_t: %s\n",
477 fch, strerror(errno));
478 return;
481 wch[1] = 0;
482 setcchar(&vga_to_curses[fch], wch, 0, 0, NULL);
485 /* Convert one wchar to UCS-2 */
486 static uint16_t get_ucs(wchar_t wch, iconv_t conv)
488 char mbch[MB_LEN_MAX];
489 uint16_t uch;
490 char *pmbch, *puch;
491 size_t smbch, such;
492 mbstate_t ps;
493 int ret;
495 memset(&ps, 0, sizeof(ps));
496 ret = wcrtomb(mbch, wch, &ps);
497 if (ret == -1) {
498 fprintf(stderr, "Could not convert 0x%04lx "
499 "from wchar_t to a multibyte character: %s\n",
500 (unsigned long)wch, strerror(errno));
501 return 0xFFFD;
504 pmbch = (char *) mbch;
505 puch = (char *) &uch;
506 smbch = ret;
507 such = sizeof(uch);
509 if (iconv(conv, &pmbch, &smbch, &puch, &such) == (size_t) -1) {
510 fprintf(stderr, "Could not convert 0x%04lx "
511 "from a multibyte character to UCS-2 : %s\n",
512 (unsigned long)wch, strerror(errno));
513 return 0xFFFD;
516 return uch;
520 * Setup mapping for vga to curses line graphics.
522 static void font_setup(void)
524 iconv_t ucs2_to_nativecharset;
525 iconv_t nativecharset_to_ucs2;
526 iconv_t font_conv;
527 int i;
528 g_autofree gchar *local_codeset = g_get_codeset();
531 * Control characters are normally non-printable, but VGA does have
532 * well-known glyphs for them.
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
569 ucs2_to_nativecharset = iconv_open(local_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);
576 nativecharset_to_ucs2 = iconv_open("UCS-2", local_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);
584 font_conv = iconv_open(local_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);
593 /* Control characters */
594 for (i = 0; i <= 0x1F; i++) {
595 convert_ucs(i, control_characters[i], ucs2_to_nativecharset);
598 for (i = 0x20; i <= 0xFF; i++) {
599 convert_font(i, font_conv);
602 /* DEL */
603 convert_ucs(0x7F, 0x2302, ucs2_to_nativecharset);
605 if (strcmp(local_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;
613 ret = getcchar(&vga_to_curses[i], wch, &attr, &color, NULL);
614 if (ret == ERR)
615 continue;
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;
717 iconv_close(ucs2_to_nativecharset);
718 iconv_close(nativecharset_to_ucs2);
719 iconv_close(font_conv);
722 static void curses_setup(void)
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,
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);
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]);
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);
751 font_setup();
754 static void curses_keyboard_setup(void)
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);
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,
775 static void curses_display_init(DisplayState *ds, DisplayOptions *opts)
777 #ifndef _WIN32
778 if (!isatty(1)) {
779 fprintf(stderr, "We need a terminal output\n");
780 exit(1);
782 #endif
784 setlocale(LC_CTYPE, "");
785 if (opts->u.curses.charset) {
786 font_charset = opts->u.curses.charset;
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);
794 curses_winch_init();
796 dcl = g_new0(DisplayChangeListener, 1);
797 dcl->ops = &dcl_ops;
798 register_displaychangelistener(dcl);
800 invalidate = 1;
803 static QemuDisplay qemu_display_curses = {
804 .type = DISPLAY_TYPE_CURSES,
805 .init = curses_display_init,
808 static void register_curses(void)
810 qemu_display_register(&qemu_display_curses);
813 type_init(register_curses);