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