Statistics
| Branch: | Revision:

root / sdl.c @ f442e08b

History | View | Annotate | Download (19.8 kB)

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 "qemu-common.h"
25
#include "console.h"
26
#include "sysemu.h"
27

    
28
#include <SDL.h>
29

    
30
#ifndef _WIN32
31
#include <signal.h>
32
#endif
33

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

    
53
static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
54
{
55
    //    printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
56
    SDL_UpdateRect(screen, x, y, w, h);
57
}
58

    
59
static void sdl_resize(DisplayState *ds, int w, int h)
60
{
61
    int flags;
62

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

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

    
71
    width = w;
72
    height = h;
73

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

    
85
    if (!screen->pixels) {
86
        fprintf(stderr, "Could not open SDL display\n");
87
        exit(1);
88
    }
89
    ds->data = screen->pixels;
90
    ds->linesize = screen->pitch;
91
    ds->depth = screen->format->BitsPerPixel;
92
    if (screen->format->Bshift > screen->format->Rshift) {
93
        ds->bgr = 1;
94
    } else {
95
        ds->bgr = 0;
96
    }
97
    ds->width = w;
98
    ds->height = h;
99
}
100

    
101
/* generic keyboard conversion */
102

    
103
#include "sdl_keysym.h"
104
#include "keymaps.c"
105

    
106
static kbd_layout_t *kbd_layout = NULL;
107

    
108
static uint8_t sdl_keyevent_to_keycode_generic(const SDL_KeyboardEvent *ev)
109
{
110
    int keysym;
111
    /* workaround for X11+SDL bug with AltGR */
112
    keysym = ev->keysym.sym;
113
    if (keysym == 0 && ev->keysym.scancode == 113)
114
        keysym = SDLK_MODE;
115
    /* For Japanese key '\' and '|' */
116
    if (keysym == 92 && ev->keysym.scancode == 133) {
117
        keysym = 0xa5;
118
    }
119
    return keysym2scancode(kbd_layout, keysym);
120
}
121

    
122
/* specific keyboard conversions from scan codes */
123

    
124
#if defined(_WIN32)
125

    
126
static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
127
{
128
    return ev->keysym.scancode;
129
}
130

    
131
#else
132

    
133
static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
134
{
135
    int keycode;
136

    
137
    keycode = ev->keysym.scancode;
138

    
139
    if (keycode < 9) {
140
        keycode = 0;
141
    } else if (keycode < 97) {
142
        keycode -= 8; /* just an offset */
143
    } else if (keycode < 212) {
144
        /* use conversion table */
145
        keycode = _translate_keycode(keycode - 97);
146
    } else {
147
        keycode = 0;
148
    }
149
    return keycode;
150
}
151

    
152
#endif
153

    
154
static void reset_keys(void)
155
{
156
    int i;
157
    for(i = 0; i < 256; i++) {
158
        if (modifiers_state[i]) {
159
            if (i & 0x80)
160
                kbd_put_keycode(0xe0);
161
            kbd_put_keycode(i | 0x80);
162
            modifiers_state[i] = 0;
163
        }
164
    }
165
}
166

    
167
static void sdl_process_key(SDL_KeyboardEvent *ev)
168
{
169
    int keycode, v;
170

    
171
    if (ev->keysym.sym == SDLK_PAUSE) {
172
        /* specific case */
173
        v = 0;
174
        if (ev->type == SDL_KEYUP)
175
            v |= 0x80;
176
        kbd_put_keycode(0xe1);
177
        kbd_put_keycode(0x1d | v);
178
        kbd_put_keycode(0x45 | v);
179
        return;
180
    }
181

    
182
    if (kbd_layout) {
183
        keycode = sdl_keyevent_to_keycode_generic(ev);
184
    } else {
185
        keycode = sdl_keyevent_to_keycode(ev);
186
    }
187

    
188
    switch(keycode) {
189
    case 0x00:
190
        /* sent when leaving window: reset the modifiers state */
191
        reset_keys();
192
        return;
193
    case 0x2a:                          /* Left Shift */
194
    case 0x36:                          /* Right Shift */
195
    case 0x1d:                          /* Left CTRL */
196
    case 0x9d:                          /* Right CTRL */
197
    case 0x38:                          /* Left ALT */
198
    case 0xb8:                         /* Right ALT */
199
        if (ev->type == SDL_KEYUP)
200
            modifiers_state[keycode] = 0;
201
        else
202
            modifiers_state[keycode] = 1;
203
        break;
204
    case 0x45: /* num lock */
205
    case 0x3a: /* caps lock */
206
        /* SDL does not send the key up event, so we generate it */
207
        kbd_put_keycode(keycode);
208
        kbd_put_keycode(keycode | 0x80);
209
        return;
210
    }
211

    
212
    /* now send the key code */
213
    if (keycode & 0x80)
214
        kbd_put_keycode(0xe0);
215
    if (ev->type == SDL_KEYUP)
216
        kbd_put_keycode(keycode | 0x80);
217
    else
218
        kbd_put_keycode(keycode & 0x7f);
219
}
220

    
221
static void sdl_update_caption(void)
222
{
223
    char buf[1024];
224
    const char *status = "";
225

    
226
    if (!vm_running)
227
        status = " [Stopped]";
228
    else if (gui_grab) {
229
        if (!alt_grab)
230
            status = " - Press Ctrl-Alt to exit grab";
231
        else
232
            status = " - Press Ctrl-Alt-Shift to exit grab";
233
    }
234

    
235
    if (qemu_name)
236
        snprintf(buf, sizeof(buf), "QEMU (%s)%s", qemu_name, status);
237
    else
238
        snprintf(buf, sizeof(buf), "QEMU%s", status);
239

    
240
    SDL_WM_SetCaption(buf, "QEMU");
241
}
242

    
243
static void sdl_hide_cursor(void)
244
{
245
    if (!cursor_hide)
246
        return;
247

    
248
    if (kbd_mouse_is_absolute()) {
249
        SDL_ShowCursor(1);
250
        SDL_SetCursor(sdl_cursor_hidden);
251
    } else {
252
        SDL_ShowCursor(0);
253
    }
254
}
255

    
256
static void sdl_show_cursor(void)
257
{
258
    if (!cursor_hide)
259
        return;
260

    
261
    if (!kbd_mouse_is_absolute()) {
262
        SDL_ShowCursor(1);
263
        if (guest_cursor &&
264
                (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
265
            SDL_SetCursor(guest_sprite);
266
        else
267
            SDL_SetCursor(sdl_cursor_normal);
268
    }
269
}
270

    
271
static void sdl_grab_start(void)
272
{
273
    if (guest_cursor) {
274
        SDL_SetCursor(guest_sprite);
275
        SDL_WarpMouse(guest_x, guest_y);
276
    } else
277
        sdl_hide_cursor();
278
    SDL_WM_GrabInput(SDL_GRAB_ON);
279
    gui_grab = 1;
280
    sdl_update_caption();
281
}
282

    
283
static void sdl_grab_end(void)
284
{
285
    SDL_WM_GrabInput(SDL_GRAB_OFF);
286
    gui_grab = 0;
287
    sdl_show_cursor();
288
    sdl_update_caption();
289
}
290

    
291
static void sdl_send_mouse_event(int dx, int dy, int dz, int x, int y, int state)
292
{
293
    int buttons;
294
    buttons = 0;
295
    if (state & SDL_BUTTON(SDL_BUTTON_LEFT))
296
        buttons |= MOUSE_EVENT_LBUTTON;
297
    if (state & SDL_BUTTON(SDL_BUTTON_RIGHT))
298
        buttons |= MOUSE_EVENT_RBUTTON;
299
    if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE))
300
        buttons |= MOUSE_EVENT_MBUTTON;
301

    
302
    if (kbd_mouse_is_absolute()) {
303
        if (!absolute_enabled) {
304
            sdl_hide_cursor();
305
            if (gui_grab) {
306
                sdl_grab_end();
307
            }
308
            absolute_enabled = 1;
309
        }
310

    
311
       dx = x * 0x7FFF / (width - 1);
312
       dy = y * 0x7FFF / (height - 1);
313
    } else if (absolute_enabled) {
314
        sdl_show_cursor();
315
        absolute_enabled = 0;
316
    } else if (guest_cursor) {
317
        x -= guest_x;
318
        y -= guest_y;
319
        guest_x += x;
320
        guest_y += y;
321
        dx = x;
322
        dy = y;
323
    }
324

    
325
    kbd_mouse_event(dx, dy, dz, buttons);
326
}
327

    
328
static void toggle_full_screen(DisplayState *ds)
329
{
330
    gui_fullscreen = !gui_fullscreen;
331
    sdl_resize(ds, screen->w, screen->h);
332
    if (gui_fullscreen) {
333
        gui_saved_grab = gui_grab;
334
        sdl_grab_start();
335
    } else {
336
        if (!gui_saved_grab)
337
            sdl_grab_end();
338
    }
339
    vga_hw_invalidate();
340
    vga_hw_update();
341
}
342

    
343
static void sdl_refresh(DisplayState *ds)
344
{
345
    SDL_Event ev1, *ev = &ev1;
346
    int mod_state;
347
    int buttonstate = SDL_GetMouseState(NULL, NULL);
348

    
349
    if (last_vm_running != vm_running) {
350
        last_vm_running = vm_running;
351
        sdl_update_caption();
352
    }
353

    
354
    vga_hw_update();
355

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

    
529
static void sdl_fill(DisplayState *ds, int x, int y, int w, int h, uint32_t c)
530
{
531
    SDL_Rect dst = { x, y, w, h };
532
    SDL_FillRect(screen, &dst, c);
533
}
534

    
535
static void sdl_mouse_warp(int x, int y, int on)
536
{
537
    if (on) {
538
        if (!guest_cursor)
539
            sdl_show_cursor();
540
        if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
541
            SDL_SetCursor(guest_sprite);
542
            SDL_WarpMouse(x, y);
543
        }
544
    } else if (gui_grab)
545
        sdl_hide_cursor();
546
    guest_cursor = on;
547
    guest_x = x, guest_y = y;
548
}
549

    
550
static void sdl_mouse_define(int width, int height, int bpp,
551
                             int hot_x, int hot_y,
552
                             uint8_t *image, uint8_t *mask)
553
{
554
    uint8_t sprite[256], *line;
555
    int x, y, dst, bypl, src = 0;
556
    if (guest_sprite)
557
        SDL_FreeCursor(guest_sprite);
558

    
559
    memset(sprite, 0, 256);
560
    bypl = ((width * bpp + 31) >> 5) << 2;
561
    for (y = 0, dst = 0; y < height; y ++, image += bypl) {
562
        line = image;
563
        for (x = 0; x < width; x ++, dst ++) {
564
            switch (bpp) {
565
            case 24:
566
                src = *(line ++); src |= *(line ++); src |= *(line ++);
567
                break;
568
            case 16:
569
            case 15:
570
                src = *(line ++); src |= *(line ++);
571
                break;
572
            case 8:
573
                src = *(line ++);
574
                break;
575
            case 4:
576
                src = 0xf & (line[x >> 1] >> ((x & 1)) << 2);
577
                break;
578
            case 2:
579
                src = 3 & (line[x >> 2] >> ((x & 3)) << 1);
580
                break;
581
            case 1:
582
                src = 1 & (line[x >> 3] >> (x & 7));
583
                break;
584
            }
585
            if (!src)
586
                sprite[dst >> 3] |= (1 << (~dst & 7)) & mask[dst >> 3];
587
        }
588
    }
589
    guest_sprite = SDL_CreateCursor(sprite, mask, width, height, hot_x, hot_y);
590

    
591
    if (guest_cursor &&
592
            (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
593
        SDL_SetCursor(guest_sprite);
594
}
595

    
596
static void sdl_cleanup(void)
597
{
598
    if (guest_sprite)
599
        SDL_FreeCursor(guest_sprite);
600
    SDL_Quit();
601
}
602

    
603
void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
604
{
605
    int flags;
606
    uint8_t data = 0;
607

    
608
#if defined(__APPLE__)
609
    /* always use generic keymaps */
610
    if (!keyboard_layout)
611
        keyboard_layout = "en-us";
612
#endif
613
    if(keyboard_layout) {
614
        kbd_layout = init_keyboard_layout(keyboard_layout);
615
        if (!kbd_layout)
616
            exit(1);
617
    }
618

    
619
    if (no_frame)
620
        gui_noframe = 1;
621

    
622
    flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
623
    if (SDL_Init (flags)) {
624
        fprintf(stderr, "Could not initialize SDL - exiting\n");
625
        exit(1);
626
    }
627
#ifndef _WIN32
628
    /* NOTE: we still want Ctrl-C to work, so we undo the SDL redirections */
629
    signal(SIGINT, SIG_DFL);
630
    signal(SIGQUIT, SIG_DFL);
631
#endif
632

    
633
    ds->dpy_update = sdl_update;
634
    ds->dpy_resize = sdl_resize;
635
    ds->dpy_refresh = sdl_refresh;
636
    ds->dpy_fill = sdl_fill;
637
    ds->mouse_set = sdl_mouse_warp;
638
    ds->cursor_define = sdl_mouse_define;
639

    
640
    sdl_resize(ds, 640, 400);
641
    sdl_update_caption();
642
    SDL_EnableKeyRepeat(250, 50);
643
    SDL_EnableUNICODE(1);
644
    gui_grab = 0;
645

    
646
    sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
647
    sdl_cursor_normal = SDL_GetCursor();
648

    
649
    atexit(sdl_cleanup);
650
    if (full_screen) {
651
        gui_fullscreen = 1;
652
        gui_fullscreen_initial_grab = 1;
653
        sdl_grab_start();
654
    }
655
}