sdl.c 20 KB
Newer Older
1 2
/*
 * QEMU SDL display driver
3
 *
4
 * Copyright (c) 2003 Fabrice Bellard
5
 *
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
pbrook's avatar
pbrook committed
24 25 26
#include "qemu-common.h"
#include "console.h"
#include "sysemu.h"
27 28 29

#include <SDL.h>

bellard's avatar
bellard committed
30 31 32
#ifndef _WIN32
#include <signal.h>
#endif
33 34 35

static SDL_Surface *screen;
static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
36
static int last_vm_running;
37 38
static int gui_saved_grab;
static int gui_fullscreen;
39
static int gui_noframe;
40 41
static int gui_key_modifier_pressed;
static int gui_keysym;
bellard's avatar
bellard committed
42
static int gui_fullscreen_initial_grab;
43 44
static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
static uint8_t modifiers_state[256];
45 46 47 48
static int width, height;
static SDL_Cursor *sdl_cursor_normal;
static SDL_Cursor *sdl_cursor_hidden;
static int absolute_enabled = 0;
49 50 51
static int guest_cursor = 0;
static int guest_x, guest_y;
static SDL_Cursor *guest_sprite = 0;
52 53 54

static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
{
bellard's avatar
bellard committed
55
    //    printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
56 57 58 59 60 61 62 63 64 65
    SDL_UpdateRect(screen, x, y, w, h);
}

static void sdl_resize(DisplayState *ds, int w, int h)
{
    int flags;

    //    printf("resizing to %d %d\n", w, h);

    flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
66 67
    if (gui_fullscreen)
        flags |= SDL_FULLSCREEN;
68 69
    if (gui_noframe)
        flags |= SDL_NOFRAME;
70

71 72 73
    width = w;
    height = h;

74
 again:
75 76 77 78 79
    screen = SDL_SetVideoMode(w, h, 0, flags);
    if (!screen) {
        fprintf(stderr, "Could not open SDL display\n");
        exit(1);
    }
80 81 82 83 84 85 86 87 88
    if (!screen->pixels && (flags & SDL_HWSURFACE) && (flags & SDL_FULLSCREEN)) {
        flags &= ~SDL_HWSURFACE;
        goto again;
    }

    if (!screen->pixels) {
        fprintf(stderr, "Could not open SDL display\n");
        exit(1);
    }
89 90 91
    ds->data = screen->pixels;
    ds->linesize = screen->pitch;
    ds->depth = screen->format->BitsPerPixel;
92 93 94 95 96 97 98 99 100 101 102
    /* SDL BitsPerPixel never indicates any values other than
       multiples of 8, so we need to check for strange depths. */
    if (ds->depth == 16) {
        uint32_t mask;

        mask = screen->format->Rmask;
        mask |= screen->format->Gmask;
        mask |= screen->format->Bmask;
        if ((mask & 0x8000) == 0)
            ds->depth = 15;
    }
103
    if (ds->depth == 32 && screen->format->Rshift == 0) {
bellard's avatar
bellard committed
104 105 106 107
        ds->bgr = 1;
    } else {
        ds->bgr = 0;
    }
bellard's avatar
bellard committed
108 109
    ds->width = w;
    ds->height = h;
110 111
}

112
/* generic keyboard conversion */
bellard's avatar
bellard committed
113

114 115 116 117 118 119
#include "sdl_keysym.h"
#include "keymaps.c"

static kbd_layout_t *kbd_layout = NULL;

static uint8_t sdl_keyevent_to_keycode_generic(const SDL_KeyboardEvent *ev)
bellard's avatar
bellard committed
120
{
121 122 123 124 125
    int keysym;
    /* workaround for X11+SDL bug with AltGR */
    keysym = ev->keysym.sym;
    if (keysym == 0 && ev->keysym.scancode == 113)
        keysym = SDLK_MODE;
bellard's avatar
bellard committed
126 127 128 129
    /* For Japanese key '\' and '|' */
    if (keysym == 92 && ev->keysym.scancode == 133) {
        keysym = 0xa5;
    }
130
    return keysym2scancode(kbd_layout, keysym);
bellard's avatar
bellard committed
131 132
}

133 134 135
/* specific keyboard conversions from scan codes */

#if defined(_WIN32)
bellard's avatar
bellard committed
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153

static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
{
    return ev->keysym.scancode;
}

#else

static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
{
    int keycode;

    keycode = ev->keysym.scancode;

    if (keycode < 9) {
        keycode = 0;
    } else if (keycode < 97) {
        keycode -= 8; /* just an offset */
bellard's avatar
bellard committed
154
    } else if (keycode < 212) {
bellard's avatar
bellard committed
155
        /* use conversion table */
156
        keycode = _translate_keycode(keycode - 97);
bellard's avatar
bellard committed
157 158 159 160 161 162 163 164
    } else {
        keycode = 0;
    }
    return keycode;
}

#endif

165 166 167 168 169 170 171 172 173 174 175 176 177
static void reset_keys(void)
{
    int i;
    for(i = 0; i < 256; i++) {
        if (modifiers_state[i]) {
            if (i & 0x80)
                kbd_put_keycode(0xe0);
            kbd_put_keycode(i | 0x80);
            modifiers_state[i] = 0;
        }
    }
}

178 179
static void sdl_process_key(SDL_KeyboardEvent *ev)
{
180
    int keycode, v;
181 182 183 184 185 186 187 188 189 190 191 192

    if (ev->keysym.sym == SDLK_PAUSE) {
        /* specific case */
        v = 0;
        if (ev->type == SDL_KEYUP)
            v |= 0x80;
        kbd_put_keycode(0xe1);
        kbd_put_keycode(0x1d | v);
        kbd_put_keycode(0x45 | v);
        return;
    }

193 194 195 196 197
    if (kbd_layout) {
        keycode = sdl_keyevent_to_keycode_generic(ev);
    } else {
        keycode = sdl_keyevent_to_keycode(ev);
    }
198 199 200 201

    switch(keycode) {
    case 0x00:
        /* sent when leaving window: reset the modifiers state */
202
        reset_keys();
203 204 205 206 207 208 209
        return;
    case 0x2a:                          /* Left Shift */
    case 0x36:                          /* Right Shift */
    case 0x1d:                          /* Left CTRL */
    case 0x9d:                          /* Right CTRL */
    case 0x38:                          /* Left ALT */
    case 0xb8:                         /* Right ALT */
210
        if (ev->type == SDL_KEYUP)
211 212 213 214 215 216 217 218 219 220
            modifiers_state[keycode] = 0;
        else
            modifiers_state[keycode] = 1;
        break;
    case 0x45: /* num lock */
    case 0x3a: /* caps lock */
        /* SDL does not send the key up event, so we generate it */
        kbd_put_keycode(keycode);
        kbd_put_keycode(keycode | 0x80);
        return;
221
    }
222 223 224 225 226 227 228 229

    /* now send the key code */
    if (keycode & 0x80)
        kbd_put_keycode(0xe0);
    if (ev->type == SDL_KEYUP)
        kbd_put_keycode(keycode | 0x80);
    else
        kbd_put_keycode(keycode & 0x7f);
230 231
}

232 233 234
static void sdl_update_caption(void)
{
    char buf[1024];
ths's avatar
ths committed
235 236 237 238
    const char *status = "";

    if (!vm_running)
        status = " [Stopped]";
239 240 241 242 243 244
    else if (gui_grab) {
        if (!alt_grab)
            status = " - Press Ctrl-Alt to exit grab";
        else
            status = " - Press Ctrl-Alt-Shift to exit grab";
    }
ths's avatar
ths committed
245 246 247 248 249 250

    if (qemu_name)
        snprintf(buf, sizeof(buf), "QEMU (%s)%s", qemu_name, status);
    else
        snprintf(buf, sizeof(buf), "QEMU%s", status);

251 252 253
    SDL_WM_SetCaption(buf, "QEMU");
}

254 255
static void sdl_hide_cursor(void)
{
256 257 258
    if (!cursor_hide)
        return;

259 260 261 262 263 264
    if (kbd_mouse_is_absolute()) {
        SDL_ShowCursor(1);
        SDL_SetCursor(sdl_cursor_hidden);
    } else {
        SDL_ShowCursor(0);
    }
265 266 267 268
}

static void sdl_show_cursor(void)
{
269 270 271
    if (!cursor_hide)
        return;

272
    if (!kbd_mouse_is_absolute()) {
273
        SDL_ShowCursor(1);
274 275 276 277 278
        if (guest_cursor &&
                (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
            SDL_SetCursor(guest_sprite);
        else
            SDL_SetCursor(sdl_cursor_normal);
279 280 281
    }
}

282 283
static void sdl_grab_start(void)
{
284 285 286 287 288
    if (guest_cursor) {
        SDL_SetCursor(guest_sprite);
        SDL_WarpMouse(guest_x, guest_y);
    } else
        sdl_hide_cursor();
289 290
    SDL_WM_GrabInput(SDL_GRAB_ON);
    gui_grab = 1;
291
    sdl_update_caption();
292 293 294 295 296 297
}

static void sdl_grab_end(void)
{
    SDL_WM_GrabInput(SDL_GRAB_OFF);
    gui_grab = 0;
298
    sdl_show_cursor();
299
    sdl_update_caption();
300 301
}

aurel32's avatar
aurel32 committed
302
static void sdl_send_mouse_event(int dx, int dy, int dz, int x, int y, int state)
303
{
aurel32's avatar
aurel32 committed
304
    int buttons;
305 306 307 308 309 310 311
    buttons = 0;
    if (state & SDL_BUTTON(SDL_BUTTON_LEFT))
        buttons |= MOUSE_EVENT_LBUTTON;
    if (state & SDL_BUTTON(SDL_BUTTON_RIGHT))
        buttons |= MOUSE_EVENT_RBUTTON;
    if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE))
        buttons |= MOUSE_EVENT_MBUTTON;
312 313 314 315 316 317 318 319 320 321

    if (kbd_mouse_is_absolute()) {
	if (!absolute_enabled) {
	    sdl_hide_cursor();
	    if (gui_grab) {
		sdl_grab_end();
	    }
	    absolute_enabled = 1;
	}

aurel32's avatar
aurel32 committed
322 323
       dx = x * 0x7FFF / (width - 1);
       dy = y * 0x7FFF / (height - 1);
324 325 326
    } else if (absolute_enabled) {
	sdl_show_cursor();
	absolute_enabled = 0;
327
    } else if (guest_cursor) {
aurel32's avatar
aurel32 committed
328 329 330 331 332 333
        x -= guest_x;
        y -= guest_y;
        guest_x += x;
        guest_y += y;
        dx = x;
        dy = y;
334 335
    }

336 337 338
    kbd_mouse_event(dx, dy, dz, buttons);
}

339 340 341 342 343 344 345 346 347 348 349
static void toggle_full_screen(DisplayState *ds)
{
    gui_fullscreen = !gui_fullscreen;
    sdl_resize(ds, screen->w, screen->h);
    if (gui_fullscreen) {
        gui_saved_grab = gui_grab;
        sdl_grab_start();
    } else {
        if (!gui_saved_grab)
            sdl_grab_end();
    }
pbrook's avatar
pbrook committed
350 351
    vga_hw_invalidate();
    vga_hw_update();
352 353
}

354 355 356
static void sdl_refresh(DisplayState *ds)
{
    SDL_Event ev1, *ev = &ev1;
357
    int mod_state;
aurel32's avatar
aurel32 committed
358
    int buttonstate = SDL_GetMouseState(NULL, NULL);
359

360 361 362 363 364
    if (last_vm_running != vm_running) {
        last_vm_running = vm_running;
        sdl_update_caption();
    }

pbrook's avatar
pbrook committed
365
    vga_hw_update();
aurel32's avatar
aurel32 committed
366
    SDL_EnableUNICODE(!is_graphic_console());
bellard's avatar
bellard committed
367

368 369 370 371 372 373 374 375
    while (SDL_PollEvent(ev)) {
        switch (ev->type) {
        case SDL_VIDEOEXPOSE:
            sdl_update(ds, 0, 0, screen->w, screen->h);
            break;
        case SDL_KEYDOWN:
        case SDL_KEYUP:
            if (ev->type == SDL_KEYDOWN) {
376 377 378 379 380 381 382
                if (!alt_grab) {
                    mod_state = (SDL_GetModState() & gui_grab_code) ==
                                gui_grab_code;
                } else {
                    mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
                                (gui_grab_code | KMOD_LSHIFT);
                }
383
                gui_key_modifier_pressed = mod_state;
bellard's avatar
bellard committed
384
                if (gui_key_modifier_pressed) {
385 386 387 388
                    int keycode;
                    keycode = sdl_keyevent_to_keycode(&ev->key);
                    switch(keycode) {
                    case 0x21: /* 'f' key on US keyboard */
bellard's avatar
bellard committed
389 390 391
                        toggle_full_screen(ds);
                        gui_keysym = 1;
                        break;
392
                    case 0x02 ... 0x0a: /* '1' to '9' keys */
393 394
                        /* Reset the modifiers sent to the current console */
                        reset_keys();
395
                        console_select(keycode - 0x02);
pbrook's avatar
pbrook committed
396
                        if (!is_graphic_console()) {
bellard's avatar
bellard committed
397 398 399 400 401 402 403 404 405
                            /* display grab if going to a text console */
                            if (gui_grab)
                                sdl_grab_end();
                        }
                        gui_keysym = 1;
                        break;
                    default:
                        break;
                    }
pbrook's avatar
pbrook committed
406
                } else if (!is_graphic_console()) {
bellard's avatar
bellard committed
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
                    int keysym;
                    keysym = 0;
                    if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
                        switch(ev->key.keysym.sym) {
                        case SDLK_UP: keysym = QEMU_KEY_CTRL_UP; break;
                        case SDLK_DOWN: keysym = QEMU_KEY_CTRL_DOWN; break;
                        case SDLK_LEFT: keysym = QEMU_KEY_CTRL_LEFT; break;
                        case SDLK_RIGHT: keysym = QEMU_KEY_CTRL_RIGHT; break;
                        case SDLK_HOME: keysym = QEMU_KEY_CTRL_HOME; break;
                        case SDLK_END: keysym = QEMU_KEY_CTRL_END; break;
                        case SDLK_PAGEUP: keysym = QEMU_KEY_CTRL_PAGEUP; break;
                        case SDLK_PAGEDOWN: keysym = QEMU_KEY_CTRL_PAGEDOWN; break;
                        default: break;
                        }
                    } else {
                        switch(ev->key.keysym.sym) {
                        case SDLK_UP: keysym = QEMU_KEY_UP; break;
                        case SDLK_DOWN: keysym = QEMU_KEY_DOWN; break;
                        case SDLK_LEFT: keysym = QEMU_KEY_LEFT; break;
                        case SDLK_RIGHT: keysym = QEMU_KEY_RIGHT; break;
                        case SDLK_HOME: keysym = QEMU_KEY_HOME; break;
                        case SDLK_END: keysym = QEMU_KEY_END; break;
                        case SDLK_PAGEUP: keysym = QEMU_KEY_PAGEUP; break;
                        case SDLK_PAGEDOWN: keysym = QEMU_KEY_PAGEDOWN; break;
ths's avatar
ths committed
431 432
                        case SDLK_BACKSPACE: keysym = QEMU_KEY_BACKSPACE; break;
                        case SDLK_DELETE: keysym = QEMU_KEY_DELETE; break;
bellard's avatar
bellard committed
433 434 435 436 437 438 439 440
                        default: break;
                        }
                    }
                    if (keysym) {
                        kbd_put_keysym(keysym);
                    } else if (ev->key.keysym.unicode != 0) {
                        kbd_put_keysym(ev->key.keysym.unicode);
                    }
441 442
                }
            } else if (ev->type == SDL_KEYUP) {
443 444 445 446 447 448
                if (!alt_grab) {
                    mod_state = (ev->key.keysym.mod & gui_grab_code);
                } else {
                    mod_state = (ev->key.keysym.mod &
                                 (gui_grab_code | KMOD_LSHIFT));
                }
449 450
                if (!mod_state) {
                    if (gui_key_modifier_pressed) {
451
                        gui_key_modifier_pressed = 0;
bellard's avatar
bellard committed
452
                        if (gui_keysym == 0) {
453
                            /* exit/enter grab if pressing Ctrl-Alt */
454 455 456 457 458 459 460 461 462 463
                            if (!gui_grab) {
                                /* if the application is not active,
                                   do not try to enter grab state. It
                                   prevents
                                   'SDL_WM_GrabInput(SDL_GRAB_ON)'
                                   from blocking all the application
                                   (SDL bug). */
                                if (SDL_GetAppState() & SDL_APPACTIVE)
                                    sdl_grab_start();
                            } else {
464
                                sdl_grab_end();
465
                            }
466 467 468
                            /* SDL does not send back all the
                               modifiers key, so we must correct it */
                            reset_keys();
469 470 471 472
                            break;
                        }
                        gui_keysym = 0;
                    }
473 474
                }
            }
475
            if (is_graphic_console() && !gui_keysym)
bellard's avatar
bellard committed
476
                sdl_process_key(&ev->key);
477 478
            break;
        case SDL_QUIT:
479
            if (!no_quit)
480
                qemu_system_shutdown_request();
481 482
            break;
        case SDL_MOUSEMOTION:
483 484
            if (gui_grab || kbd_mouse_is_absolute() ||
                absolute_enabled) {
aurel32's avatar
aurel32 committed
485 486
                sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,
                       ev->motion.x, ev->motion.y, ev->motion.state);
487 488 489 490 491 492
            }
            break;
        case SDL_MOUSEBUTTONDOWN:
        case SDL_MOUSEBUTTONUP:
            {
                SDL_MouseButtonEvent *bev = &ev->button;
493
                if (!gui_grab && !kbd_mouse_is_absolute()) {
494
                    if (ev->type == SDL_MOUSEBUTTONDOWN &&
aurel32's avatar
aurel32 committed
495
                        (bev->button == SDL_BUTTON_LEFT)) {
496 497 498 499
                        /* start grabbing all events */
                        sdl_grab_start();
                    }
                } else {
500 501
                    int dz;
                    dz = 0;
aurel32's avatar
aurel32 committed
502 503 504 505 506
                    if (ev->type == SDL_MOUSEBUTTONDOWN) {
                        buttonstate |= SDL_BUTTON(bev->button);
                    } else {
                        buttonstate &= ~SDL_BUTTON(bev->button);
                    }
507
#ifdef SDL_BUTTON_WHEELUP
508
                    if (bev->button == SDL_BUTTON_WHEELUP && ev->type == SDL_MOUSEBUTTONDOWN) {
509
                        dz = -1;
510
                    } else if (bev->button == SDL_BUTTON_WHEELDOWN && ev->type == SDL_MOUSEBUTTONDOWN) {
511 512
                        dz = 1;
                    }
513
#endif
aurel32's avatar
aurel32 committed
514
                    sdl_send_mouse_event(0, 0, dz, bev->x, bev->y, buttonstate);
515 516 517
                }
            }
            break;
518
        case SDL_ACTIVEEVENT:
519 520
            if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
                !ev->active.gain && !gui_fullscreen_initial_grab) {
521 522
                sdl_grab_end();
            }
aurel32's avatar
aurel32 committed
523 524 525 526
            if (ev->active.state & SDL_APPACTIVE) {
                if (ev->active.gain) {
                    /* Back to default interval */
                    ds->gui_timer_interval = 0;
527
                    ds->idle = 0;
aurel32's avatar
aurel32 committed
528 529 530
                } else {
                    /* Sleeping interval */
                    ds->gui_timer_interval = 500;
531
                    ds->idle = 1;
aurel32's avatar
aurel32 committed
532 533
                }
            }
534
            break;
535 536 537 538 539 540
        default:
            break;
        }
    }
}

541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
static void sdl_fill(DisplayState *ds, int x, int y, int w, int h, uint32_t c)
{
    SDL_Rect dst = { x, y, w, h };
    SDL_FillRect(screen, &dst, c);
}

static void sdl_mouse_warp(int x, int y, int on)
{
    if (on) {
        if (!guest_cursor)
            sdl_show_cursor();
        if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
            SDL_SetCursor(guest_sprite);
            SDL_WarpMouse(x, y);
        }
    } else if (gui_grab)
        sdl_hide_cursor();
    guest_cursor = on;
    guest_x = x, guest_y = y;
}

static void sdl_mouse_define(int width, int height, int bpp,
                             int hot_x, int hot_y,
                             uint8_t *image, uint8_t *mask)
{
    uint8_t sprite[256], *line;
    int x, y, dst, bypl, src = 0;
    if (guest_sprite)
        SDL_FreeCursor(guest_sprite);

    memset(sprite, 0, 256);
    bypl = ((width * bpp + 31) >> 5) << 2;
    for (y = 0, dst = 0; y < height; y ++, image += bypl) {
        line = image;
        for (x = 0; x < width; x ++, dst ++) {
            switch (bpp) {
            case 24:
                src = *(line ++); src |= *(line ++); src |= *(line ++);
                break;
            case 16:
            case 15:
                src = *(line ++); src |= *(line ++);
                break;
            case 8:
                src = *(line ++);
                break;
            case 4:
                src = 0xf & (line[x >> 1] >> ((x & 1)) << 2);
                break;
            case 2:
                src = 3 & (line[x >> 2] >> ((x & 3)) << 1);
                break;
            case 1:
                src = 1 & (line[x >> 3] >> (x & 7));
                break;
            }
            if (!src)
                sprite[dst >> 3] |= (1 << (~dst & 7)) & mask[dst >> 3];
        }
    }
    guest_sprite = SDL_CreateCursor(sprite, mask, width, height, hot_x, hot_y);

    if (guest_cursor &&
            (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
        SDL_SetCursor(guest_sprite);
}

608
static void sdl_cleanup(void)
bellard's avatar
bellard committed
609
{
610 611
    if (guest_sprite)
        SDL_FreeCursor(guest_sprite);
bellard's avatar
bellard committed
612 613 614
    SDL_Quit();
}

615
void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
616 617
{
    int flags;
618
    uint8_t data = 0;
619

620 621 622 623 624 625 626 627 628 629 630
#if defined(__APPLE__)
    /* always use generic keymaps */
    if (!keyboard_layout)
        keyboard_layout = "en-us";
#endif
    if(keyboard_layout) {
        kbd_layout = init_keyboard_layout(keyboard_layout);
        if (!kbd_layout)
            exit(1);
    }

631 632 633
    if (no_frame)
        gui_noframe = 1;

634 635 636 637 638
    flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
    if (SDL_Init (flags)) {
        fprintf(stderr, "Could not initialize SDL - exiting\n");
        exit(1);
    }
639

640 641 642
    ds->dpy_update = sdl_update;
    ds->dpy_resize = sdl_resize;
    ds->dpy_refresh = sdl_refresh;
643 644 645
    ds->dpy_fill = sdl_fill;
    ds->mouse_set = sdl_mouse_warp;
    ds->cursor_define = sdl_mouse_define;
646 647

    sdl_resize(ds, 640, 400);
648
    sdl_update_caption();
649 650
    SDL_EnableKeyRepeat(250, 50);
    gui_grab = 0;
bellard's avatar
bellard committed
651

652 653 654
    sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
    sdl_cursor_normal = SDL_GetCursor();

bellard's avatar
bellard committed
655
    atexit(sdl_cleanup);
bellard's avatar
bellard committed
656 657 658 659 660
    if (full_screen) {
        gui_fullscreen = 1;
        gui_fullscreen_initial_grab = 1;
        sdl_grab_start();
    }
661
}