xref: /qemu/ui/curses.c (revision 138ca49a) 
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 <iconv.h>
34 
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"
40 
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
45 
46 #define FONT_HEIGHT 16
47 #define FONT_WIDTH 8
48 
49 enum maybe_keycode {
50     CURSES_KEYCODE,
51     CURSES_CHAR,
52     CURSES_CHAR_OR_KEYCODE,
53 };
54 
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;
60 
61 static const char *font_charset = "CP437";
62 static cchar_t *vga_to_curses;
63 
64 static void curses_update(DisplayChangeListener *dcl,
65                           int x, int y, int w, int h)
66 {
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;
73 
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]);
80 
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;
85             }
86             setcchar(&curses_line[x], wch, at, color_pair, NULL);
87         }
88         mvwadd_wchnstr(screenpad, y, 0, curses_line, width);
89     }
90 
91     pnoutrefresh(screenpad, py, px, sminy, sminx, smaxy - 1, smaxx - 1);
92     refresh();
93 }
94 
95 static void curses_calc_pad(void)
96 {
97     if (qemu_console_is_fixedsize(NULL)) {
98         width = gwidth;
99         height = gheight;
100     } else {
101         width = COLS;
102         height = LINES;
103     }
104 
105     if (screenpad)
106         delwin(screenpad);
107 
108     clear();
109     refresh();
110 
111     screenpad = newpad(height, width);
112 
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;
121     }
122 
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;
131     }
132 }
133 
134 static void curses_resize(DisplayChangeListener *dcl,
135                           int width, int height)
136 {
137     if (width == gwidth && height == gheight) {
138         return;
139     }
140 
141     gwidth = width;
142     gheight = height;
143 
144     curses_calc_pad();
145 }
146 
147 #if !defined(_WIN32) && defined(SIGWINCH) && defined(KEY_RESIZE)
148 static volatile sig_atomic_t got_sigwinch;
149 static void curses_winch_check(void)
150 {
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;
157 
158     if (!got_sigwinch) {
159         return;
160     }
161     got_sigwinch = false;
162 
163     if (ioctl(1, TIOCGWINSZ, &ws) == -1) {
164         return;
165     }
166 
167     resize_term(ws.ws_row, ws.ws_col);
168     invalidate = 1;
169 }
170 
171 static void curses_winch_handler(int signum)
172 {
173     got_sigwinch = true;
174 }
175 
176 static void curses_winch_init(void)
177 {
178     struct sigaction old, winch = {
179         .sa_handler  = curses_winch_handler,
180     };
181     sigaction(SIGWINCH, &winch, &old);
182 }
183 #else
184 static void curses_winch_check(void) {}
185 static void curses_winch_init(void) {}
186 #endif
187 
188 static void curses_cursor_position(DisplayChangeListener *dcl,
189                                    int x, int y)
190 {
191     if (x >= 0) {
192         x = sminx + x - px;
193         y = sminy + y - py;
194 
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);
202             }
203             return;
204         }
205     }
206 
207     curs_set(0);
208 }
209 
210 /* generic keyboard conversion */
211 
212 #include "curses_keys.h"
213 
214 static kbd_layout_t *kbd_layout = NULL;
215 
216 static wint_t console_getch(enum maybe_keycode *maybe_keycode)
217 {
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();
231     }
232     return ret;
233 }
234 
235 static int curses2foo(const int _curses2foo[], const int _curseskey2foo[],
236                       int chr, enum maybe_keycode maybe_keycode)
237 {
238     int ret = -1;
239     if (maybe_keycode == CURSES_CHAR) {
240         if (chr < CURSES_CHARS) {
241             ret = _curses2foo[chr];
242         }
243     } else {
244         if (chr < CURSES_KEYS) {
245             ret = _curseskey2foo[chr];
246         }
247         if (ret == -1 && maybe_keycode == CURSES_CHAR_OR_KEYCODE &&
248             chr < CURSES_CHARS) {
249             ret = _curses2foo[chr];
250         }
251     }
252     return ret;
253 }
254 
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)
261 
262 static void curses_refresh(DisplayChangeListener *dcl)
263 {
264     int chr, keysym, keycode, keycode_alt;
265     enum maybe_keycode maybe_keycode = CURSES_KEYCODE;
266 
267     curses_winch_check();
268 
269     if (invalidate) {
270         clear();
271         refresh();
272         curses_calc_pad();
273         graphic_hw_invalidate(NULL);
274         invalidate = 0;
275     }
276 
277     graphic_hw_text_update(NULL, screen);
278 
279     while (1) {
280         /* while there are any pending key strokes to process */
281         chr = console_getch(&maybe_keycode);
282 
283         if (chr == -1)
284             break;
285 
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;
294         }
295 #endif
296 
297         keycode = curses2keycode(chr, maybe_keycode);
298         keycode_alt = 0;
299 
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);
304 
305             if (nextchr != -1) {
306                 chr = nextchr;
307                 maybe_keycode = next_maybe_keycode;
308                 keycode_alt = ALT;
309                 keycode = curses2keycode(chr, maybe_keycode);
310 
311                 if (keycode != -1) {
312                     keycode |= ALT;
313 
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);
320 
321                         invalidate = 1;
322                         continue;
323                     }
324                 }
325             }
326         }
327 
328         if (kbd_layout) {
329             keysym = curses2keysym(chr, maybe_keycode);
330 
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;
339             }
340 
341             keycode = keysym2scancode(kbd_layout, keysym & KEYSYM_MASK,
342                                       NULL, false);
343             if (keycode == 0)
344                 continue;
345 
346             keycode |= (keysym & ~KEYSYM_MASK) >> 16;
347             keycode |= keycode_alt;
348         }
349 
350         if (keycode == -1)
351             continue;
352 
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);
359             }
360             if (keycode & CNTRL) {
361                 qemu_input_event_send_key_number(NULL, CNTRL_CODE, true);
362                 qemu_input_event_send_key_delay(0);
363             }
364             if (keycode & ALT) {
365                 qemu_input_event_send_key_number(NULL, ALT_CODE, true);
366                 qemu_input_event_send_key_delay(0);
367             }
368             if (keycode & ALTGR) {
369                 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, true);
370                 qemu_input_event_send_key_delay(0);
371             }
372 
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);
377 
378             if (keycode & ALTGR) {
379                 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, false);
380                 qemu_input_event_send_key_delay(0);
381             }
382             if (keycode & ALT) {
383                 qemu_input_event_send_key_number(NULL, ALT_CODE, false);
384                 qemu_input_event_send_key_delay(0);
385             }
386             if (keycode & CNTRL) {
387                 qemu_input_event_send_key_number(NULL, CNTRL_CODE, false);
388                 qemu_input_event_send_key_delay(0);
389             }
390             if (keycode & SHIFT) {
391                 qemu_input_event_send_key_number(NULL, SHIFT_CODE, false);
392                 qemu_input_event_send_key_delay(0);
393             }
394         } else {
395             keysym = curses2qemu(chr, maybe_keycode);
396             if (keysym == -1)
397                 keysym = chr;
398 
399             kbd_put_keysym(keysym);
400         }
401     }
402 }
403 
404 static void curses_atexit(void)
405 {
406     endwin();
407     g_free(vga_to_curses);
408     g_free(screen);
409 }
410 
411 /*
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
417  */
418 
419 /* Setup wchar glyph for one UCS-2 char */
420 static void convert_ucs(unsigned char fch, uint16_t uch, iconv_t conv)
421 {
422     char mbch[MB_LEN_MAX];
423     wchar_t wch[2];
424     char *puch, *pmbch;
425     size_t such, smbch;
426     mbstate_t ps;
427 
428     puch = (char *) &uch;
429     pmbch = (char *) mbch;
430     such = sizeof(uch);
431     smbch = sizeof(mbch);
432 
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;
438     }
439 
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;
446     }
447 
448     wch[1] = 0;
449     setcchar(&vga_to_curses[fch], wch, 0, 0, NULL);
450 }
451 
452 /* Setup wchar glyph for one font character */
453 static void convert_font(unsigned char fch, iconv_t conv)
454 {
455     char mbch[MB_LEN_MAX];
456     wchar_t wch[2];
457     char *pfch, *pmbch;
458     size_t sfch, smbch;
459     mbstate_t ps;
460 
461     pfch = (char *) &fch;
462     pmbch = (char *) &mbch;
463     sfch = sizeof(fch);
464     smbch = sizeof(mbch);
465 
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;
471     }
472 
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;
479     }
480 
481     wch[1] = 0;
482     setcchar(&vga_to_curses[fch], wch, 0, 0, NULL);
483 }
484 
485 /* Convert one wchar to UCS-2 */
486 static uint16_t get_ucs(wchar_t wch, iconv_t conv)
487 {
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;
494 
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;
502     }
503 
504     pmbch = (char *) mbch;
505     puch = (char *) &uch;
506     smbch = ret;
507     such = sizeof(uch);
508 
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;
514     }
515 
516     return uch;
517 }
518 
519 /*
520  * Setup mapping for vga to curses line graphics.
521  */
522 static void font_setup(void)
523 {
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();
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(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);
574     }
575 
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);
582     }
583 
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);
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(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;
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);
814