vcs.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 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 (screen->format->Bshift > screen->format->Rshift) {
  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];
 222     const char *status = "";
 223
 224     if (!vm_running)
 225         status = " [Stopped]";
 226     else if (gui_grab)
 227         status = " - Press Ctrl-Alt to exit grab";
 228
 229     if (qemu_name)
 230         snprintf(buf, sizeof(buf), "QEMU (%s)%s", qemu_name, status);
 231     else
 232         snprintf(buf, sizeof(buf), "QEMU%s", status);
 233
 234     SDL_WM_SetCaption(buf, "QEMU");
 235 }
 236
 237 static void sdl_hide_cursor(void)
 238 {
 239     if (!cursor_hide)
 240         return;
 241
 242     if (kbd_mouse_is_absolute()) {
 243         SDL_ShowCursor(1);
 244         SDL_SetCursor(sdl_cursor_hidden);
 245     } else {
 246         SDL_ShowCursor(0);
 247     }
 248 }
 249
 250 static void sdl_show_cursor(void)
 251 {
 252     if (!cursor_hide)
 253         return;
 254
 255     if (!kbd_mouse_is_absolute()) {
 256         SDL_ShowCursor(1);
 257         if (guest_cursor &&
 258                 (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
 259             SDL_SetCursor(guest_sprite);
 260         else
 261             SDL_SetCursor(sdl_cursor_normal);
 262     }
 263 }
 264
 265 static void sdl_grab_start(void)
 266 {
 267     if (guest_cursor) {
 268         SDL_SetCursor(guest_sprite);
 269         SDL_WarpMouse(guest_x, guest_y);
 270     } else
 271         sdl_hide_cursor();
 272     SDL_WM_GrabInput(SDL_GRAB_ON);
 273     /* dummy read to avoid moving the mouse */
 274     SDL_GetRelativeMouseState(NULL, NULL);
 275     gui_grab = 1;
 276     sdl_update_caption();
 277 }
 278
 279 static void sdl_grab_end(void)
 280 {
 281     SDL_WM_GrabInput(SDL_GRAB_OFF);
 282     gui_grab = 0;
 283     sdl_show_cursor();
 284     sdl_update_caption();
 285 }
 286
 287 static void sdl_send_mouse_event(int dz)
 288 {
 289     int dx, dy, state, buttons;
 290     state = SDL_GetRelativeMouseState(&dx, &dy);
 291     buttons = 0;
 292     if (state & SDL_BUTTON(SDL_BUTTON_LEFT))
 293         buttons |= MOUSE_EVENT_LBUTTON;
 294     if (state & SDL_BUTTON(SDL_BUTTON_RIGHT))
 295         buttons |= MOUSE_EVENT_RBUTTON;
 296     if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE))
 297         buttons |= MOUSE_EVENT_MBUTTON;
 298
 299     if (kbd_mouse_is_absolute()) {
 300         if (!absolute_enabled) {
 301             sdl_hide_cursor();
 302             if (gui_grab) {
 303                 sdl_grab_end();
 304             }
 305             absolute_enabled = 1;
 306         }
 307
 308         SDL_GetMouseState(&dx, &dy);
 309         dx = dx * 0x7FFF / width;
 310         dy = dy * 0x7FFF / height;
 311     } else if (absolute_enabled) {
 312         sdl_show_cursor();
 313         absolute_enabled = 0;
 314     } else if (guest_cursor) {
 315         SDL_GetMouseState(&dx, &dy);
 316         dx -= guest_x;
 317         dy -= guest_y;
 318         guest_x += dx;
 319         guest_y += dy;
 320     }
 321
 322     kbd_mouse_event(dx, dy, dz, buttons);
 323 }
 324
 325 static void toggle_full_screen(DisplayState *ds)
 326 {
 327     gui_fullscreen = !gui_fullscreen;
 328     sdl_resize(ds, screen->w, screen->h);
 329     if (gui_fullscreen) {
 330         gui_saved_grab = gui_grab;
 331         sdl_grab_start();
 332     } else {
 333         if (!gui_saved_grab)
 334             sdl_grab_end();
 335     }
 336     vga_hw_invalidate();
 337     vga_hw_update();
 338 }
 339
 340 static void sdl_refresh(DisplayState *ds)
 341 {
 342     SDL_Event ev1, *ev = &ev1;
 343     int mod_state;
 344
 345     if (last_vm_running != vm_running) {
 346         last_vm_running = vm_running;
 347         sdl_update_caption();
 348     }
 349
 350     vga_hw_update();
 351
 352     while (SDL_PollEvent(ev)) {
 353         switch (ev->type) {
 354         case SDL_VIDEOEXPOSE:
 355             sdl_update(ds, 0, 0, screen->w, screen->h);
 356             break;
 357         case SDL_KEYDOWN:
 358         case SDL_KEYUP:
 359             if (ev->type == SDL_KEYDOWN) {
 360                 mod_state = (SDL_GetModState() & gui_grab_code) ==
 361                     gui_grab_code;
 362                 gui_key_modifier_pressed = mod_state;
 363                 if (gui_key_modifier_pressed) {
 364                     int keycode;
 365                     keycode = sdl_keyevent_to_keycode(&ev->key);
 366                     switch(keycode) {
 367                     case 0x21: /* 'f' key on US keyboard */
 368                         toggle_full_screen(ds);
 369                         gui_keysym = 1;
 370                         break;
 371                     case 0x02 ... 0x0a: /* '1' to '9' keys */
 372                         /* Reset the modifiers sent to the current console */
 373                         reset_keys();
 374                         console_select(keycode - 0x02);
 375                         if (!is_graphic_console()) {
 376                             /* display grab if going to a text console */
 377                             if (gui_grab)
 378                                 sdl_grab_end();
 379                         }
 380                         gui_keysym = 1;
 381                         break;
 382                     default:
 383                         break;
 384                     }
 385                 } else if (!is_graphic_console()) {
 386                     int keysym;
 387                     keysym = 0;
 388                     if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
 389                         switch(ev->key.keysym.sym) {
 390                         case SDLK_UP: keysym = QEMU_KEY_CTRL_UP; break;
 391                         case SDLK_DOWN: keysym = QEMU_KEY_CTRL_DOWN; break;
 392                         case SDLK_LEFT: keysym = QEMU_KEY_CTRL_LEFT; break;
 393                         case SDLK_RIGHT: keysym = QEMU_KEY_CTRL_RIGHT; break;
 394                         case SDLK_HOME: keysym = QEMU_KEY_CTRL_HOME; break;
 395                         case SDLK_END: keysym = QEMU_KEY_CTRL_END; break;
 396                         case SDLK_PAGEUP: keysym = QEMU_KEY_CTRL_PAGEUP; break;
 397                         case SDLK_PAGEDOWN: keysym = QEMU_KEY_CTRL_PAGEDOWN; break;
 398                         default: break;
 399                         }
 400                     } else {
 401                         switch(ev->key.keysym.sym) {
 402                         case SDLK_UP: keysym = QEMU_KEY_UP; break;
 403                         case SDLK_DOWN: keysym = QEMU_KEY_DOWN; break;
 404                         case SDLK_LEFT: keysym = QEMU_KEY_LEFT; break;
 405                         case SDLK_RIGHT: keysym = QEMU_KEY_RIGHT; break;
 406                         case SDLK_HOME: keysym = QEMU_KEY_HOME; break;
 407                         case SDLK_END: keysym = QEMU_KEY_END; break;
 408                         case SDLK_PAGEUP: keysym = QEMU_KEY_PAGEUP; break;
 409                         case SDLK_PAGEDOWN: keysym = QEMU_KEY_PAGEDOWN; break;
 410                         case SDLK_BACKSPACE: keysym = QEMU_KEY_BACKSPACE; break;
 411                         case SDLK_DELETE: keysym = QEMU_KEY_DELETE; break;
 412                         default: break;
 413                         }
 414                     }
 415                     if (keysym) {
 416                         kbd_put_keysym(keysym);
 417                     } else if (ev->key.keysym.unicode != 0) {
 418                         kbd_put_keysym(ev->key.keysym.unicode);
 419                     }
 420                 }
 421             } else if (ev->type == SDL_KEYUP) {
 422                 mod_state = (ev->key.keysym.mod & gui_grab_code);
 423                 if (!mod_state) {
 424                     if (gui_key_modifier_pressed) {
 425                         gui_key_modifier_pressed = 0;
 426                         if (gui_keysym == 0) {
 427                             /* exit/enter grab if pressing Ctrl-Alt */
 428                             if (!gui_grab) {
 429                                 /* if the application is not active,
 430                                    do not try to enter grab state. It
 431                                    prevents
 432                                    'SDL_WM_GrabInput(SDL_GRAB_ON)'
 433                                    from blocking all the application
 434                                    (SDL bug). */
 435                                 if (SDL_GetAppState() & SDL_APPACTIVE)
 436                                     sdl_grab_start();
 437                             } else {
 438                                 sdl_grab_end();
 439                             }
 440                             /* SDL does not send back all the
 441                                modifiers key, so we must correct it */
 442                             reset_keys();
 443                             break;
 444                         }
 445                         gui_keysym = 0;
 446                     }
 447                 }
 448             }
 449             if (is_graphic_console() && !gui_keysym)
 450                 sdl_process_key(&ev->key);
 451             break;
 452         case SDL_QUIT:
 453             if (!no_quit) {
 454                 qemu_system_shutdown_request();
 455                 vm_start();     /* In case we're paused */
 456             }
 457             break;
 458         case SDL_MOUSEMOTION:
 459             if (gui_grab || kbd_mouse_is_absolute() ||
 460                 absolute_enabled) {
 461                 sdl_send_mouse_event(0);
 462             }
 463             break;
 464         case SDL_MOUSEBUTTONDOWN:
 465         case SDL_MOUSEBUTTONUP:
 466             {
 467                 SDL_MouseButtonEvent *bev = &ev->button;
 468                 if (!gui_grab && !kbd_mouse_is_absolute()) {
 469                     if (ev->type == SDL_MOUSEBUTTONDOWN &&
 470                         (bev->state & SDL_BUTTON_LMASK)) {
 471                         /* start grabbing all events */
 472                         sdl_grab_start();
 473                     }
 474                 } else {
 475                     int dz;
 476                     dz = 0;
 477 #ifdef SDL_BUTTON_WHEELUP
 478                     if (bev->button == SDL_BUTTON_WHEELUP && ev->type == SDL_MOUSEBUTTONDOWN) {
 479                         dz = -1;
 480                     } else if (bev->button == SDL_BUTTON_WHEELDOWN && ev->type == SDL_MOUSEBUTTONDOWN) {
 481                         dz = 1;
 482                     }
 483 #endif
 484                     sdl_send_mouse_event(dz);
 485                 }
 486             }
 487             break;
 488         case SDL_ACTIVEEVENT:
 489             if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
 490                 !ev->active.gain && !gui_fullscreen_initial_grab) {
 491                 sdl_grab_end();
 492             }
 493             break;
 494         default:
 495             break;
 496         }
 497     }
 498 }
 499
 500 static void sdl_fill(DisplayState *ds, int x, int y, int w, int h, uint32_t c)
 501 {
 502     SDL_Rect dst = { x, y, w, h };
 503     SDL_FillRect(screen, &dst, c);
 504 }
 505
 506 static void sdl_mouse_warp(int x, int y, int on)
 507 {
 508     if (on) {
 509         if (!guest_cursor)
 510             sdl_show_cursor();
 511         if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
 512             SDL_SetCursor(guest_sprite);
 513             SDL_WarpMouse(x, y);
 514         }
 515     } else if (gui_grab)
 516         sdl_hide_cursor();
 517     guest_cursor = on;
 518     guest_x = x, guest_y = y;
 519 }
 520
 521 static void sdl_mouse_define(int width, int height, int bpp,
 522                              int hot_x, int hot_y,
 523                              uint8_t *image, uint8_t *mask)
 524 {
 525     uint8_t sprite[256], *line;
 526     int x, y, dst, bypl, src = 0;
 527     if (guest_sprite)
 528         SDL_FreeCursor(guest_sprite);
 529
 530     memset(sprite, 0, 256);
 531     bypl = ((width * bpp + 31) >> 5) << 2;
 532     for (y = 0, dst = 0; y < height; y ++, image += bypl) {
 533         line = image;
 534         for (x = 0; x < width; x ++, dst ++) {
 535             switch (bpp) {
 536             case 24:
 537                 src = *(line ++); src |= *(line ++); src |= *(line ++);
 538                 break;
 539             case 16:
 540             case 15:
 541                 src = *(line ++); src |= *(line ++);
 542                 break;
 543             case 8:
 544                 src = *(line ++);
 545                 break;
 546             case 4:
 547                 src = 0xf & (line[x >> 1] >> ((x & 1)) << 2);
 548                 break;
 549             case 2:
 550                 src = 3 & (line[x >> 2] >> ((x & 3)) << 1);
 551                 break;
 552             case 1:
 553                 src = 1 & (line[x >> 3] >> (x & 7));
 554                 break;
 555             }
 556             if (!src)
 557                 sprite[dst >> 3] |= (1 << (~dst & 7)) & mask[dst >> 3];
 558         }
 559     }
 560     guest_sprite = SDL_CreateCursor(sprite, mask, width, height, hot_x, hot_y);
 561
 562     if (guest_cursor &&
 563             (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
 564         SDL_SetCursor(guest_sprite);
 565 }
 566
 567 static void sdl_cleanup(void)
 568 {
 569     if (guest_sprite)
 570         SDL_FreeCursor(guest_sprite);
 571     SDL_Quit();
 572 }
 573
 574 void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
 575 {
 576     int flags;
 577     uint8_t data = 0;
 578
 579 #if defined(__APPLE__)
 580     /* always use generic keymaps */
 581     if (!keyboard_layout)
 582         keyboard_layout = "en-us";
 583 #endif
 584     if(keyboard_layout) {
 585         kbd_layout = init_keyboard_layout(keyboard_layout);
 586         if (!kbd_layout)
 587             exit(1);
 588     }
 589
 590     if (no_frame)
 591         gui_noframe = 1;
 592
 593     flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
 594     if (SDL_Init (flags)) {
 595         fprintf(stderr, "Could not initialize SDL - exiting\n");
 596         exit(1);
 597     }
 598 #ifndef _WIN32
 599     /* NOTE: we still want Ctrl-C to work, so we undo the SDL redirections */
 600     signal(SIGINT, SIG_DFL);
 601     signal(SIGQUIT, SIG_DFL);
 602 #endif
 603
 604     ds->dpy_update = sdl_update;
 605     ds->dpy_resize = sdl_resize;
 606     ds->dpy_refresh = sdl_refresh;
 607     ds->dpy_fill = sdl_fill;
 608     ds->mouse_set = sdl_mouse_warp;
 609     ds->cursor_define = sdl_mouse_define;
 610
 611     sdl_resize(ds, 640, 400);
 612     sdl_update_caption();
 613     SDL_EnableKeyRepeat(250, 50);
 614     SDL_EnableUNICODE(1);
 615     gui_grab = 0;
 616
 617     sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
 618     sdl_cursor_normal = SDL_GetCursor();
 619
 620     atexit(sdl_cleanup);
 621     if (full_screen) {
 622         gui_fullscreen = 1;
 623         gui_fullscreen_initial_grab = 1;
 624         sdl_grab_start();
 625     }
 626 }