sdl.c

   1 /*
   2  * QEMU SDL display driver
   3  *
   4  * Copyright (c) 2003 Fabrice Bellard
   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 #include "vl.h"
  25
  26 #include <SDL.h>
  27
  28 #ifndef _WIN32
  29 #include <signal.h>
  30 #endif
  31
  32 static SDL_Surface *screen;
  33 static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
  34 static int last_vm_running;
  35 static int gui_saved_grab;
  36 static int gui_fullscreen;
  37 static int gui_noframe;
  38 static int gui_key_modifier_pressed;
  39 static int gui_keysym;
  40 static int gui_fullscreen_initial_grab;
  41 static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
  42 static uint8_t modifiers_state[256];
  43 static int width, height;
  44 static SDL_Cursor *sdl_cursor_normal;
  45 static SDL_Cursor *sdl_cursor_hidden;
  46 static int absolute_enabled = 0;
  47 static int guest_cursor = 0;
  48 static int guest_x, guest_y;
  49 static SDL_Cursor *guest_sprite = 0;
  50
  51 static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
  52 {
  53     //    printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
  54     SDL_UpdateRect(screen, x, y, w, h);
  55 }
  56
  57 static void sdl_resize(DisplayState *ds, int w, int h)
  58 {
  59     int flags;
  60
  61     //    printf("resizing to %d %d\n", w, h);
  62
  63     flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
  64     if (gui_fullscreen)
  65         flags |= SDL_FULLSCREEN;
  66     if (gui_noframe)
  67         flags |= SDL_NOFRAME;
  68
  69     width = w;
  70     height = h;
  71
  72  again:
  73     screen = SDL_SetVideoMode(w, h, 0, flags);
  74     if (!screen) {
  75         fprintf(stderr, "Could not open SDL display\n");
  76         exit(1);
  77     }
  78     if (!screen->pixels && (flags & SDL_HWSURFACE) && (flags & SDL_FULLSCREEN)) {
  79         flags &= ~SDL_HWSURFACE;
  80         goto again;
  81     }
  82
  83     if (!screen->pixels) {
  84         fprintf(stderr, "Could not open SDL display\n");
  85         exit(1);
  86     }
  87     ds->data = screen->pixels;
  88     ds->linesize = screen->pitch;
  89     ds->depth = screen->format->BitsPerPixel;
  90     if (ds->depth == 32 && screen->format->Rshift == 0) {
  91         ds->bgr = 1;
  92     } else {
  93         ds->bgr = 0;
  94     }
  95     ds->width = w;
  96     ds->height = h;
  97 }
  98
  99 /* generic keyboard conversion */
 100
 101 #include "sdl_keysym.h"
 102 #include "keymaps.c"
 103
 104 static kbd_layout_t *kbd_layout = NULL;
 105
 106 static uint8_t sdl_keyevent_to_keycode_generic(const SDL_KeyboardEvent *ev)
 107 {
 108     int keysym;
 109     /* workaround for X11+SDL bug with AltGR */
 110     keysym = ev->keysym.sym;
 111     if (keysym == 0 && ev->keysym.scancode == 113)
 112         keysym = SDLK_MODE;
 113     /* For Japanese key '\' and '|' */
 114     if (keysym == 92 && ev->keysym.scancode == 133) {
 115         keysym = 0xa5;
 116     }
 117     return keysym2scancode(kbd_layout, keysym);
 118 }
 119
 120 /* specific keyboard conversions from scan codes */
 121
 122 #if defined(_WIN32)
 123
 124 static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
 125 {
 126     return ev->keysym.scancode;
 127 }
 128
 129 #else
 130
 131 static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
 132 {
 133     int keycode;
 134
 135     keycode = ev->keysym.scancode;
 136
 137     if (keycode < 9) {
 138         keycode = 0;
 139     } else if (keycode < 97) {
 140         keycode -= 8; /* just an offset */
 141     } else if (keycode < 212) {
 142         /* use conversion table */
 143         keycode = _translate_keycode(keycode - 97);
 144     } else {
 145         keycode = 0;
 146     }
 147     return keycode;
 148 }
 149
 150 #endif
 151
 152 static void reset_keys(void)
 153 {
 154     int i;
 155     for(i = 0; i < 256; i++) {
 156         if (modifiers_state[i]) {
 157             if (i & 0x80)
 158                 kbd_put_keycode(0xe0);
 159             kbd_put_keycode(i | 0x80);
 160             modifiers_state[i] = 0;
 161         }
 162     }
 163 }
 164
 165 static void sdl_process_key(SDL_KeyboardEvent *ev)
 166 {
 167     int keycode, v;
 168
 169     if (ev->keysym.sym == SDLK_PAUSE) {
 170         /* specific case */
 171         v = 0;
 172         if (ev->type == SDL_KEYUP)
 173             v |= 0x80;
 174         kbd_put_keycode(0xe1);
 175         kbd_put_keycode(0x1d | v);
 176         kbd_put_keycode(0x45 | v);
 177         return;
 178     }
 179
 180     if (kbd_layout) {
 181         keycode = sdl_keyevent_to_keycode_generic(ev);
 182     } else {
 183         keycode = sdl_keyevent_to_keycode(ev);
 184     }
 185
 186     switch(keycode) {
 187     case 0x00:
 188         /* sent when leaving window: reset the modifiers state */
 189         reset_keys();
 190         return;
 191     case 0x2a:                          /* Left Shift */
 192     case 0x36:                          /* Right Shift */
 193     case 0x1d:                          /* Left CTRL */
 194     case 0x9d:                          /* Right CTRL */
 195     case 0x38:                          /* Left ALT */
 196     case 0xb8:                         /* Right ALT */
 197         if (ev->type == SDL_KEYUP)
 198             modifiers_state[keycode] = 0;
 199         else
 200             modifiers_state[keycode] = 1;
 201         break;
 202     case 0x45: /* num lock */
 203     case 0x3a: /* caps lock */
 204         /* SDL does not send the key up event, so we generate it */
 205         kbd_put_keycode(keycode);
 206         kbd_put_keycode(keycode | 0x80);
 207         return;
 208     }
 209
 210     /* now send the key code */
 211     if (keycode & 0x80)
 212         kbd_put_keycode(0xe0);
 213     if (ev->type == SDL_KEYUP)
 214         kbd_put_keycode(keycode | 0x80);
 215     else
 216         kbd_put_keycode(keycode & 0x7f);
 217 }
 218
 219 static void sdl_update_caption(void)
 220 {
 221     char buf[1024], appname[20] = "QEMU";
 222     const char *status = "";
 223
 224     if (!vm_running)
 225         status = " [Stopped]";
 226     else if (gui_grab) {
 227         if (!alt_grab)
 228             status = " - Press Ctrl-Alt to exit grab";
 229         else
 230             status = " - Press Ctrl-Alt-Shift to exit grab";
 231     }
 232
 233 #if USE_KVM
 234     if (kvm_allowed) {
 235         strncat(appname, "/KVM", sizeof(appname));
 236     }
 237 #endif
 238
 239     if (qemu_name)
 240         snprintf(buf, sizeof(buf), "%s (%s)%s", appname, qemu_name, status);
 241     else
 242         snprintf(buf, sizeof(buf), "%s%s", appname, status);
 243
 244     SDL_WM_SetCaption(buf, appname);
 245 }
 246
 247 static void sdl_hide_cursor(void)
 248 {
 249     if (!cursor_hide)
 250         return;
 251
 252     if (kbd_mouse_is_absolute()) {
 253         SDL_ShowCursor(1);
 254         SDL_SetCursor(sdl_cursor_hidden);
 255     } else {
 256         SDL_ShowCursor(0);
 257     }
 258 }
 259
 260 static void sdl_show_cursor(void)
 261 {
 262     if (!cursor_hide)
 263         return;
 264
 265     if (!kbd_mouse_is_absolute()) {
 266         SDL_ShowCursor(1);
 267         if (guest_cursor &&
 268                 (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
 269             SDL_SetCursor(guest_sprite);
 270         else
 271             SDL_SetCursor(sdl_cursor_normal);
 272     }
 273 }
 274
 275 static void sdl_grab_start(void)
 276 {
 277     if (guest_cursor) {
 278         SDL_SetCursor(guest_sprite);
 279         SDL_WarpMouse(guest_x, guest_y);
 280     } else
 281         sdl_hide_cursor();
 282     SDL_WM_GrabInput(SDL_GRAB_ON);
 283     /* dummy read to avoid moving the mouse */
 284     SDL_GetRelativeMouseState(NULL, NULL);
 285     gui_grab = 1;
 286     sdl_update_caption();
 287 }
 288
 289 static void sdl_grab_end(void)
 290 {
 291     SDL_WM_GrabInput(SDL_GRAB_OFF);
 292     gui_grab = 0;
 293     sdl_show_cursor();
 294     sdl_update_caption();
 295 }
 296
 297 static void sdl_send_mouse_event(int dz)
 298 {
 299     int dx, dy, state, buttons;
 300     state = SDL_GetRelativeMouseState(&dx, &dy);
 301     buttons = 0;
 302     if (state & SDL_BUTTON(SDL_BUTTON_LEFT))
 303         buttons |= MOUSE_EVENT_LBUTTON;
 304     if (state & SDL_BUTTON(SDL_BUTTON_RIGHT))
 305         buttons |= MOUSE_EVENT_RBUTTON;
 306     if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE))
 307         buttons |= MOUSE_EVENT_MBUTTON;
 308
 309     if (kbd_mouse_is_absolute()) {
 310         if (!absolute_enabled) {
 311             sdl_hide_cursor();
 312             if (gui_grab) {
 313                 sdl_grab_end();
 314             }
 315             absolute_enabled = 1;
 316         }
 317
 318         SDL_GetMouseState(&dx, &dy);
 319         dx = dx * 0x7FFF / width;
 320         dy = dy * 0x7FFF / height;
 321     } else if (absolute_enabled) {
 322         sdl_show_cursor();
 323         absolute_enabled = 0;
 324     } else if (guest_cursor) {
 325         SDL_GetMouseState(&dx, &dy);
 326         dx -= guest_x;
 327         dy -= guest_y;
 328         guest_x += dx;
 329         guest_y += dy;
 330     }
 331
 332     kbd_mouse_event(dx, dy, dz, buttons);
 333 }
 334
 335 static void toggle_full_screen(DisplayState *ds)
 336 {
 337     gui_fullscreen = !gui_fullscreen;
 338     sdl_resize(ds, screen->w, screen->h);
 339     if (gui_fullscreen) {
 340         gui_saved_grab = gui_grab;
 341         sdl_grab_start();
 342     } else {
 343         if (!gui_saved_grab)
 344             sdl_grab_end();
 345     }
 346     vga_hw_invalidate();
 347     vga_hw_update();
 348 }
 349
 350 static void sdl_refresh(DisplayState *ds)
 351 {
 352     SDL_Event ev1, *ev = &ev1;
 353     int mod_state;
 354
 355     if (last_vm_running != vm_running) {
 356         last_vm_running = vm_running;
 357         sdl_update_caption();
 358     }
 359
 360     vga_hw_update();
 361
 362     while (SDL_PollEvent(ev)) {
 363         switch (ev->type) {
 364         case SDL_VIDEOEXPOSE:
 365             sdl_update(ds, 0, 0, screen->w, screen->h);
 366             break;
 367         case SDL_KEYDOWN:
 368         case SDL_KEYUP:
 369             if (ev->type == SDL_KEYDOWN) {
 370                 if (!alt_grab) {
 371                     mod_state = (SDL_GetModState() & gui_grab_code) ==
 372                                 gui_grab_code;
 373                 } else {
 374                     mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
 375                                 (gui_grab_code | KMOD_LSHIFT);
 376                 }
 377                 gui_key_modifier_pressed = mod_state;
 378                 if (gui_key_modifier_pressed) {
 379                     int keycode;
 380                     keycode = sdl_keyevent_to_keycode(&ev->key);
 381                     switch(keycode) {
 382                     case 0x21: /* 'f' key on US keyboard */
 383                         toggle_full_screen(ds);
 384                         gui_keysym = 1;
 385                         break;
 386                     case 0x02 ... 0x0a: /* '1' to '9' keys */
 387                         /* Reset the modifiers sent to the current console */
 388                         reset_keys();
 389                         console_select(keycode - 0x02);
 390                         if (!is_graphic_console()) {
 391                             /* display grab if going to a text console */
 392                             if (gui_grab)
 393                                 sdl_grab_end();
 394                         }
 395                         gui_keysym = 1;
 396                         break;
 397                     default:
 398                         break;
 399                     }
 400                 } else if (!is_graphic_console()) {
 401                     int keysym;
 402                     keysym = 0;
 403                     if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
 404                         switch(ev->key.keysym.sym) {
 405                         case SDLK_UP: keysym = QEMU_KEY_CTRL_UP; break;
 406                         case SDLK_DOWN: keysym = QEMU_KEY_CTRL_DOWN; break;
 407                         case SDLK_LEFT: keysym = QEMU_KEY_CTRL_LEFT; break;
 408                         case SDLK_RIGHT: keysym = QEMU_KEY_CTRL_RIGHT; break;
 409                         case SDLK_HOME: keysym = QEMU_KEY_CTRL_HOME; break;
 410                         case SDLK_END: keysym = QEMU_KEY_CTRL_END; break;
 411                         case SDLK_PAGEUP: keysym = QEMU_KEY_CTRL_PAGEUP; break;
 412                         case SDLK_PAGEDOWN: keysym = QEMU_KEY_CTRL_PAGEDOWN; break;
 413                         default: break;
 414                         }
 415                     } else {
 416                         switch(ev->key.keysym.sym) {
 417                         case SDLK_UP: keysym = QEMU_KEY_UP; break;
 418                         case SDLK_DOWN: keysym = QEMU_KEY_DOWN; break;
 419                         case SDLK_LEFT: keysym = QEMU_KEY_LEFT; break;
 420                         case SDLK_RIGHT: keysym = QEMU_KEY_RIGHT; break;
 421                         case SDLK_HOME: keysym = QEMU_KEY_HOME; break;
 422                         case SDLK_END: keysym = QEMU_KEY_END; break;
 423                         case SDLK_PAGEUP: keysym = QEMU_KEY_PAGEUP; break;
 424                         case SDLK_PAGEDOWN: keysym = QEMU_KEY_PAGEDOWN; break;
 425                         case SDLK_BACKSPACE: keysym = QEMU_KEY_BACKSPACE; break;
 426                         case SDLK_DELETE: keysym = QEMU_KEY_DELETE; break;
 427                         default: break;
 428                         }
 429                     }
 430                     if (keysym) {
 431                         kbd_put_keysym(keysym);
 432                     } else if (ev->key.keysym.unicode != 0) {
 433                         kbd_put_keysym(ev->key.keysym.unicode);
 434                     }
 435                 }
 436             } else if (ev->type == SDL_KEYUP) {
 437                 if (!alt_grab) {
 438                     mod_state = (ev->key.keysym.mod & gui_grab_code);
 439                 } else {
 440                     mod_state = (ev->key.keysym.mod &
 441                                  (gui_grab_code | KMOD_LSHIFT));
 442                 }
 443                 if (!mod_state) {
 444                     if (gui_key_modifier_pressed) {
 445                         gui_key_modifier_pressed = 0;
 446                         if (gui_keysym == 0) {
 447                             /* exit/enter grab if pressing Ctrl-Alt */
 448                             if (!gui_grab) {
 449                                 /* if the application is not active,
 450                                    do not try to enter grab state. It
 451                                    prevents
 452                                    'SDL_WM_GrabInput(SDL_GRAB_ON)'
 453                                    from blocking all the application
 454                                    (SDL bug). */
 455                                 if (SDL_GetAppState() & SDL_APPACTIVE)
 456                                     sdl_grab_start();
 457                             } else {
 458                                 sdl_grab_end();
 459                             }
 460                             /* SDL does not send back all the
 461                                modifiers key, so we must correct it */
 462                             reset_keys();
 463                             break;
 464                         }
 465                         gui_keysym = 0;
 466                     }
 467                 }
 468             }
 469             if (is_graphic_console() && !gui_keysym)
 470                 sdl_process_key(&ev->key);
 471             break;
 472         case SDL_QUIT:
 473             if (!no_quit) {
 474                 qemu_system_shutdown_request();
 475                 vm_start();     /* In case we're paused */
 476             }
 477             break;
 478         case SDL_MOUSEMOTION:
 479             if (gui_grab || kbd_mouse_is_absolute() ||
 480                 absolute_enabled) {
 481                 sdl_send_mouse_event(0);
 482             }
 483             break;
 484         case SDL_MOUSEBUTTONDOWN:
 485         case SDL_MOUSEBUTTONUP:
 486             {
 487                 SDL_MouseButtonEvent *bev = &ev->button;
 488                 if (!gui_grab && !kbd_mouse_is_absolute()) {
 489                     if (ev->type == SDL_MOUSEBUTTONDOWN &&
 490                         (bev->state & SDL_BUTTON_LMASK)) {
 491                         /* start grabbing all events */
 492                         sdl_grab_start();
 493                     }
 494                 } else {
 495                     int dz;
 496                     dz = 0;
 497 #ifdef SDL_BUTTON_WHEELUP
 498                     if (bev->button == SDL_BUTTON_WHEELUP && ev->type == SDL_MOUSEBUTTONDOWN) {
 499                         dz = -1;
 500                     } else if (bev->button == SDL_BUTTON_WHEELDOWN && ev->type == SDL_MOUSEBUTTONDOWN) {
 501                         dz = 1;
 502                     }
 503 #endif
 504                     sdl_send_mouse_event(dz);
 505                 }
 506             }
 507             break;
 508         case SDL_ACTIVEEVENT:
 509             if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
 510                 !ev->active.gain && !gui_fullscreen_initial_grab) {
 511                 sdl_grab_end();
 512             }
 513             break;
 514         default:
 515             break;
 516         }
 517     }
 518 }
 519
 520 static void sdl_fill(DisplayState *ds, int x, int y, int w, int h, uint32_t c)
 521 {
 522     SDL_Rect dst = { x, y, w, h };
 523     SDL_FillRect(screen, &dst, c);
 524 }
 525
 526 static void sdl_mouse_warp(int x, int y, int on)
 527 {
 528     if (on) {
 529         if (!guest_cursor)
 530             sdl_show_cursor();
 531         if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
 532             SDL_SetCursor(guest_sprite);
 533             SDL_WarpMouse(x, y);
 534         }
 535     } else if (gui_grab)
 536         sdl_hide_cursor();
 537     guest_cursor = on;
 538     guest_x = x, guest_y = y;
 539 }
 540
 541 static void sdl_mouse_define(int width, int height, int bpp,
 542                              int hot_x, int hot_y,
 543                              uint8_t *image, uint8_t *mask)
 544 {
 545     uint8_t sprite[256], *line;
 546     int x, y, dst, bypl, src = 0;
 547     if (guest_sprite)
 548         SDL_FreeCursor(guest_sprite);
 549
 550     memset(sprite, 0, 256);
 551     bypl = ((width * bpp + 31) >> 5) << 2;
 552     for (y = 0, dst = 0; y < height; y ++, image += bypl) {
 553         line = image;
 554         for (x = 0; x < width; x ++, dst ++) {
 555             switch (bpp) {
 556             case 24:
 557                 src = *(line ++); src |= *(line ++); src |= *(line ++);
 558                 break;
 559             case 16:
 560             case 15:
 561                 src = *(line ++); src |= *(line ++);
 562                 break;
 563             case 8:
 564                 src = *(line ++);
 565                 break;
 566             case 4:
 567                 src = 0xf & (line[x >> 1] >> ((x & 1)) << 2);
 568                 break;
 569             case 2:
 570                 src = 3 & (line[x >> 2] >> ((x & 3)) << 1);
 571                 break;
 572             case 1:
 573                 src = 1 & (line[x >> 3] >> (x & 7));
 574                 break;
 575             }
 576             if (!src)
 577                 sprite[dst >> 3] |= (1 << (~dst & 7)) & mask[dst >> 3];
 578         }
 579     }
 580     guest_sprite = SDL_CreateCursor(sprite, mask, width, height, hot_x, hot_y);
 581
 582     if (guest_cursor &&
 583             (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
 584         SDL_SetCursor(guest_sprite);
 585 }
 586
 587 static void sdl_cleanup(void)
 588 {
 589     if (guest_sprite)
 590         SDL_FreeCursor(guest_sprite);
 591     SDL_Quit();
 592 }
 593
 594 void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
 595 {
 596     int flags;
 597     uint8_t data = 0;
 598
 599 #if defined(__APPLE__)
 600     /* always use generic keymaps */
 601     if (!keyboard_layout)
 602         keyboard_layout = "en-us";
 603 #endif
 604     if(keyboard_layout) {
 605         kbd_layout = init_keyboard_layout(keyboard_layout);
 606         if (!kbd_layout)
 607             exit(1);
 608     }
 609
 610     if (no_frame)
 611         gui_noframe = 1;
 612
 613     flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
 614     if (SDL_Init (flags)) {
 615         fprintf(stderr, "Could not initialize SDL - exiting\n");
 616         exit(1);
 617     }
 618 #ifndef _WIN32
 619     /* NOTE: we still want Ctrl-C to work, so we undo the SDL redirections */
 620     signal(SIGINT, SIG_DFL);
 621     signal(SIGQUIT, SIG_DFL);
 622 #endif
 623
 624     ds->dpy_update = sdl_update;
 625     ds->dpy_resize = sdl_resize;
 626     ds->dpy_refresh = sdl_refresh;
 627     ds->dpy_fill = sdl_fill;
 628     ds->mouse_set = sdl_mouse_warp;
 629     ds->cursor_define = sdl_mouse_define;
 630
 631     sdl_resize(ds, 640, 400);
 632     sdl_update_caption();
 633     SDL_EnableKeyRepeat(250, 50);
 634     SDL_EnableUNICODE(1);
 635     gui_grab = 0;
 636
 637     sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
 638     sdl_cursor_normal = SDL_GetCursor();
 639
 640     atexit(sdl_cleanup);
 641     if (full_screen) {
 642         gui_fullscreen = 1;
 643         gui_fullscreen_initial_grab = 1;
 644         sdl_grab_start();
 645     }
 646 }