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 <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);