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(NULL)) {
 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(NULL)) {
 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(NULL);
 278         invalidate = 0;
 279     }
 280
 281     graphic_hw_text_update(NULL, 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                         erase();
 322                         wnoutrefresh(stdscr);
 323                         console_select(keycode - QEMU_KEY_CONSOLE0);
 324
 325                         invalidate = 1;
 326                         continue;
 327                     }
 328                 }
 329             }
 330         }
 331
 332         if (kbd_layout) {
 333             keysym = curses2keysym(chr, maybe_keycode);
 334
 335             if (keysym == -1) {
 336                 if (chr < ' ') {
 337                     keysym = chr + '@';
 338                     if (keysym >= 'A' && keysym <= 'Z')
 339                         keysym += 'a' - 'A';
 340                     keysym |= KEYSYM_CNTRL;
 341                 } else
 342                     keysym = chr;
 343             }
 344
 345             keycode = keysym2scancode(kbd_layout, keysym & KEYSYM_MASK,
 346                                       NULL, false);
 347             if (keycode == 0)
 348                 continue;
 349
 350             keycode |= (keysym & ~KEYSYM_MASK) >> 16;
 351             keycode |= keycode_alt;
 352         }
 353
 354         if (keycode == -1)
 355             continue;
 356
 357         if (qemu_console_is_graphic(NULL)) {
 358             /* since terminals don't know about key press and release
 359              * events, we need to emit both for each key received */
 360             if (keycode & SHIFT) {
 361                 qemu_input_event_send_key_number(NULL, SHIFT_CODE, true);
 362                 qemu_input_event_send_key_delay(0);
 363             }
 364             if (keycode & CNTRL) {
 365                 qemu_input_event_send_key_number(NULL, CNTRL_CODE, true);
 366                 qemu_input_event_send_key_delay(0);
 367             }
 368             if (keycode & ALT) {
 369                 qemu_input_event_send_key_number(NULL, ALT_CODE, true);
 370                 qemu_input_event_send_key_delay(0);
 371             }
 372             if (keycode & ALTGR) {
 373                 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, true);
 374                 qemu_input_event_send_key_delay(0);
 375             }
 376
 377             qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, true);
 378             qemu_input_event_send_key_delay(0);
 379             qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, false);
 380             qemu_input_event_send_key_delay(0);
 381
 382             if (keycode & ALTGR) {
 383                 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, false);
 384                 qemu_input_event_send_key_delay(0);
 385             }
 386             if (keycode & ALT) {
 387                 qemu_input_event_send_key_number(NULL, ALT_CODE, false);
 388                 qemu_input_event_send_key_delay(0);
 389             }
 390             if (keycode & CNTRL) {
 391                 qemu_input_event_send_key_number(NULL, CNTRL_CODE, false);
 392                 qemu_input_event_send_key_delay(0);
 393             }
 394             if (keycode & SHIFT) {
 395                 qemu_input_event_send_key_number(NULL, SHIFT_CODE, false);
 396                 qemu_input_event_send_key_delay(0);
 397             }
 398         } else {
 399             keysym = curses2qemu(chr, maybe_keycode);
 400             if (keysym == -1)
 401                 keysym = chr;
 402
 403             kbd_put_keysym(keysym);
 404         }
 405     }
 406 }
 407
 408 static void curses_atexit(void)
 409 {
 410     endwin();
 411     g_free(vga_to_curses);
 412     g_free(screen);
 413 }
 414
 415 /*
 416  * In the following:
 417  * - fch is the font glyph number
 418  * - uch is the unicode value
 419  * - wch is the wchar_t value (may not be unicode, e.g. on BSD/solaris)
 420  * - mbch is the native local-dependent multibyte representation
 421  */
 422
 423 /* Setup wchar glyph for one UCS-2 char */
 424 static void convert_ucs(unsigned char fch, uint16_t uch, iconv_t conv)
 425 {
 426     char mbch[MB_LEN_MAX];
 427     wchar_t wch[2];
 428     char *puch, *pmbch;
 429     size_t such, smbch;
 430     mbstate_t ps;
 431
 432     puch = (char *) &uch;
 433     pmbch = (char *) mbch;
 434     such = sizeof(uch);
 435     smbch = sizeof(mbch);
 436
 437     if (iconv(conv, &puch, &such, &pmbch, &smbch) == (size_t) -1) {
 438         fprintf(stderr, "Could not convert 0x%04x "
 439                         "from UCS-2 to a multibyte character: %s\n",
 440                         uch, strerror(errno));
 441         return;
 442     }
 443
 444     memset(&ps, 0, sizeof(ps));
 445     if (mbrtowc(&wch[0], mbch, sizeof(mbch) - smbch, &ps) == -1) {
 446         fprintf(stderr, "Could not convert 0x%04x "
 447                         "from a multibyte character to wchar_t: %s\n",
 448                         uch, strerror(errno));
 449         return;
 450     }
 451
 452     wch[1] = 0;
 453     setcchar(&vga_to_curses[fch], wch, 0, 0, NULL);
 454 }
 455
 456 /* Setup wchar glyph for one font character */
 457 static void convert_font(unsigned char fch, iconv_t conv)
 458 {
 459     char mbch[MB_LEN_MAX];
 460     wchar_t wch[2];
 461     char *pfch, *pmbch;
 462     size_t sfch, smbch;
 463     mbstate_t ps;
 464
 465     pfch = (char *) &fch;
 466     pmbch = (char *) &mbch;
 467     sfch = sizeof(fch);
 468     smbch = sizeof(mbch);
 469
 470     if (iconv(conv, &pfch, &sfch, &pmbch, &smbch) == (size_t) -1) {
 471         fprintf(stderr, "Could not convert font glyph 0x%02x "
 472                         "from %s to a multibyte character: %s\n",
 473                         fch, font_charset, strerror(errno));
 474         return;
 475     }
 476
 477     memset(&ps, 0, sizeof(ps));
 478     if (mbrtowc(&wch[0], mbch, sizeof(mbch) - smbch, &ps) == -1) {
 479         fprintf(stderr, "Could not convert font glyph 0x%02x "
 480                         "from a multibyte character to wchar_t: %s\n",
 481                         fch, strerror(errno));
 482         return;
 483     }
 484
 485     wch[1] = 0;
 486     setcchar(&vga_to_curses[fch], wch, 0, 0, NULL);
 487 }
 488
 489 /* Convert one wchar to UCS-2 */
 490 static uint16_t get_ucs(wchar_t wch, iconv_t conv)
 491 {
 492     char mbch[MB_LEN_MAX];
 493     uint16_t uch;
 494     char *pmbch, *puch;
 495     size_t smbch, such;
 496     mbstate_t ps;
 497     int ret;
 498
 499     memset(&ps, 0, sizeof(ps));
 500     ret = wcrtomb(mbch, wch, &ps);
 501     if (ret == -1) {
 502         fprintf(stderr, "Could not convert 0x%04lx "
 503                         "from wchar_t to a multibyte character: %s\n",
 504                         (unsigned long)wch, strerror(errno));
 505         return 0xFFFD;
 506     }
 507
 508     pmbch = (char *) mbch;
 509     puch = (char *) &uch;
 510     smbch = ret;
 511     such = sizeof(uch);
 512
 513     if (iconv(conv, &pmbch, &smbch, &puch, &such) == (size_t) -1) {
 514         fprintf(stderr, "Could not convert 0x%04lx "
 515                         "from a multibyte character to UCS-2 : %s\n",
 516                         (unsigned long)wch, strerror(errno));
 517         return 0xFFFD;
 518     }
 519
 520     return uch;
 521 }
 522
 523 /*
 524  * Setup mapping for vga to curses line graphics.
 525  */
 526 static void font_setup(void)
 527 {
 528     iconv_t ucs2_to_nativecharset;
 529     iconv_t nativecharset_to_ucs2;
 530     iconv_t font_conv;
 531     int i;
 532     g_autofree gchar *local_codeset = g_get_codeset();
 533
 534     /*
 535      * Control characters are normally non-printable, but VGA does have
 536      * well-known glyphs for them.
 537      */
 538     static const uint16_t control_characters[0x20] = {
 539       0x0020,
 540       0x263a,
 541       0x263b,
 542       0x2665,
 543       0x2666,
 544       0x2663,
 545       0x2660,
 546       0x2022,
 547       0x25d8,
 548       0x25cb,
 549       0x25d9,
 550       0x2642,
 551       0x2640,
 552       0x266a,
 553       0x266b,
 554       0x263c,
 555       0x25ba,
 556       0x25c4,
 557       0x2195,
 558       0x203c,
 559       0x00b6,
 560       0x00a7,
 561       0x25ac,
 562       0x21a8,
 563       0x2191,
 564       0x2193,
 565       0x2192,
 566       0x2190,
 567       0x221f,
 568       0x2194,
 569       0x25b2,
 570       0x25bc
 571     };
 572
 573     ucs2_to_nativecharset = iconv_open(local_codeset, "UCS-2");
 574     if (ucs2_to_nativecharset == (iconv_t) -1) {
 575         fprintf(stderr, "Could not convert font glyphs from UCS-2: '%s'\n",
 576                         strerror(errno));
 577         exit(1);
 578     }
 579
 580     nativecharset_to_ucs2 = iconv_open("UCS-2", local_codeset);
 581     if (nativecharset_to_ucs2 == (iconv_t) -1) {
 582         iconv_close(ucs2_to_nativecharset);
 583         fprintf(stderr, "Could not convert font glyphs to UCS-2: '%s'\n",
 584                         strerror(errno));
 585         exit(1);
 586     }
 587
 588     font_conv = iconv_open(local_codeset, font_charset);
 589     if (font_conv == (iconv_t) -1) {
 590         iconv_close(ucs2_to_nativecharset);
 591         iconv_close(nativecharset_to_ucs2);
 592         fprintf(stderr, "Could not convert font glyphs from %s: '%s'\n",
 593                         font_charset, strerror(errno));
 594         exit(1);
 595     }
 596
 597     /* Control characters */
 598     for (i = 0; i <= 0x1F; i++) {
 599         convert_ucs(i, control_characters[i], ucs2_to_nativecharset);
 600     }
 601
 602     for (i = 0x20; i <= 0xFF; i++) {
 603         convert_font(i, font_conv);
 604     }
 605
 606     /* DEL */
 607     convert_ucs(0x7F, 0x2302, ucs2_to_nativecharset);
 608
 609     if (strcmp(local_codeset, "UTF-8")) {
 610         /* Non-Unicode capable, use termcap equivalents for those available */
 611         for (i = 0; i <= 0xFF; i++) {
 612             wchar_t wch[CCHARW_MAX];
 613             attr_t attr;
 614             short color;
 615             int ret;
 616
 617             ret = getcchar(&vga_to_curses[i], wch, &attr, &color, NULL);
 618             if (ret == ERR)
 619                 continue;
 620
 621             switch (get_ucs(wch[0], nativecharset_to_ucs2)) {
 622             case 0x00a3:
 623                 vga_to_curses[i] = *WACS_STERLING;
 624                 break;
 625             case 0x2591:
 626                 vga_to_curses[i] = *WACS_BOARD;
 627                 break;
 628             case 0x2592:
 629                 vga_to_curses[i] = *WACS_CKBOARD;
 630                 break;
 631             case 0x2502:
 632                 vga_to_curses[i] = *WACS_VLINE;
 633                 break;
 634             case 0x2524:
 635                 vga_to_curses[i] = *WACS_RTEE;
 636                 break;
 637             case 0x2510:
 638                 vga_to_curses[i] = *WACS_URCORNER;
 639                 break;
 640             case 0x2514:
 641                 vga_to_curses[i] = *WACS_LLCORNER;
 642                 break;
 643             case 0x2534:
 644                 vga_to_curses[i] = *WACS_BTEE;
 645                 break;
 646             case 0x252c:
 647                 vga_to_curses[i] = *WACS_TTEE;
 648                 break;
 649             case 0x251c:
 650                 vga_to_curses[i] = *WACS_LTEE;
 651                 break;
 652             case 0x2500:
 653                 vga_to_curses[i] = *WACS_HLINE;
 654                 break;
 655             case 0x253c:
 656                 vga_to_curses[i] = *WACS_PLUS;
 657                 break;
 658             case 0x256c:
 659                 vga_to_curses[i] = *WACS_LANTERN;
 660                 break;
 661             case 0x256a:
 662                 vga_to_curses[i] = *WACS_NEQUAL;
 663                 break;
 664             case 0x2518:
 665                 vga_to_curses[i] = *WACS_LRCORNER;
 666                 break;
 667             case 0x250c:
 668                 vga_to_curses[i] = *WACS_ULCORNER;
 669                 break;
 670             case 0x2588:
 671                 vga_to_curses[i] = *WACS_BLOCK;
 672                 break;
 673             case 0x03c0:
 674                 vga_to_curses[i] = *WACS_PI;
 675                 break;
 676             case 0x00b1:
 677                 vga_to_curses[i] = *WACS_PLMINUS;
 678                 break;
 679             case 0x2265:
 680                 vga_to_curses[i] = *WACS_GEQUAL;
 681                 break;
 682             case 0x2264:
 683                 vga_to_curses[i] = *WACS_LEQUAL;
 684                 break;
 685             case 0x00b0:
 686                 vga_to_curses[i] = *WACS_DEGREE;
 687                 break;
 688             case 0x25a0:
 689                 vga_to_curses[i] = *WACS_BULLET;
 690                 break;
 691             case 0x2666:
 692                 vga_to_curses[i] = *WACS_DIAMOND;
 693                 break;
 694             case 0x2192:
 695                 vga_to_curses[i] = *WACS_RARROW;
 696                 break;
 697             case 0x2190:
 698                 vga_to_curses[i] = *WACS_LARROW;
 699                 break;
 700             case 0x2191:
 701                 vga_to_curses[i] = *WACS_UARROW;
 702                 break;
 703             case 0x2193:
 704                 vga_to_curses[i] = *WACS_DARROW;
 705                 break;
 706             case 0x23ba:
 707                 vga_to_curses[i] = *WACS_S1;
 708                 break;
 709             case 0x23bb:
 710                 vga_to_curses[i] = *WACS_S3;
 711                 break;
 712             case 0x23bc:
 713                 vga_to_curses[i] = *WACS_S7;
 714                 break;
 715             case 0x23bd:
 716                 vga_to_curses[i] = *WACS_S9;
 717                 break;
 718             }
 719         }
 720     }
 721     iconv_close(ucs2_to_nativecharset);
 722     iconv_close(nativecharset_to_ucs2);
 723     iconv_close(font_conv);
 724 }
 725
 726 static void curses_setup(void)
 727 {
 728     int i, colour_default[8] = {
 729         [QEMU_COLOR_BLACK]   = COLOR_BLACK,
 730         [QEMU_COLOR_BLUE]    = COLOR_BLUE,
 731         [QEMU_COLOR_GREEN]   = COLOR_GREEN,
 732         [QEMU_COLOR_CYAN]    = COLOR_CYAN,
 733         [QEMU_COLOR_RED]     = COLOR_RED,
 734         [QEMU_COLOR_MAGENTA] = COLOR_MAGENTA,
 735         [QEMU_COLOR_YELLOW]  = COLOR_YELLOW,
 736         [QEMU_COLOR_WHITE]   = COLOR_WHITE,
 737     };
 738
 739     /* input as raw as possible, let everything be interpreted
 740      * by the guest system */
 741     initscr(); noecho(); intrflush(stdscr, FALSE);
 742     nodelay(stdscr, TRUE); nonl(); keypad(stdscr, TRUE);
 743     start_color(); raw(); scrollok(stdscr, FALSE);
 744     set_escdelay(25);
 745
 746     /* Make color pair to match color format (3bits bg:3bits fg) */
 747     for (i = 0; i < 64; i++) {
 748         init_pair(i, colour_default[i & 7], colour_default[i >> 3]);
 749     }
 750     /* Set default color for more than 64 for safety. */
 751     for (i = 64; i < COLOR_PAIRS; i++) {
 752         init_pair(i, COLOR_WHITE, COLOR_BLACK);
 753     }
 754
 755     font_setup();
 756 }
 757
 758 static void curses_keyboard_setup(void)
 759 {
 760 #if defined(__APPLE__)
 761     /* always use generic keymaps */
 762     if (!keyboard_layout)
 763         keyboard_layout = "en-us";
 764 #endif
 765     if(keyboard_layout) {
 766         kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout,
 767                                           &error_fatal);
 768     }
 769 }
 770
 771 static const DisplayChangeListenerOps dcl_ops = {
 772     .dpy_name        = "curses",
 773     .dpy_text_update = curses_update,
 774     .dpy_text_resize = curses_resize,
 775     .dpy_refresh     = curses_refresh,
 776     .dpy_text_cursor = curses_cursor_position,
 777 };
 778
 779 static void curses_display_init(DisplayState *ds, DisplayOptions *opts)
 780 {
 781 #ifndef _WIN32
 782     if (!isatty(1)) {
 783         fprintf(stderr, "We need a terminal output\n");
 784         exit(1);
 785     }
 786 #endif
 787
 788     setlocale(LC_CTYPE, "");
 789     if (opts->u.curses.charset) {
 790         font_charset = opts->u.curses.charset;
 791     }
 792     screen = g_new0(console_ch_t, 160 * 100);
 793     vga_to_curses = g_new0(cchar_t, 256);
 794     curses_setup();
 795     curses_keyboard_setup();
 796     atexit(curses_atexit);
 797
 798     curses_winch_init();
 799
 800     dcl = g_new0(DisplayChangeListener, 1);
 801     dcl->ops = &dcl_ops;
 802     register_displaychangelistener(dcl);
 803
 804     invalidate = 1;
 805 }
 806
 807 static QemuDisplay qemu_display_curses = {
 808     .type       = DISPLAY_TYPE_CURSES,
 809     .init       = curses_display_init,
 810 };
 811
 812 static void register_curses(void)
 813 {
 814     qemu_display_register(&qemu_display_curses);
 815 }
 816
 817 type_init(register_curses);