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