ui/curses.c

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