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