sdl.c 17 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
 * QEMU SDL display driver
 * 
 * Copyright (c) 2003 Fabrice Bellard
 * 
 * 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.
 */
bellard's avatar
bellard committed
24
#include "vl.h"
25
26
27

#include <SDL.h>

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

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

static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
{
bellard's avatar
bellard committed
49
    //    printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
50
51
52
53
54
55
56
57
58
59
    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;
60
61
    if (gui_fullscreen)
        flags |= SDL_FULLSCREEN;
62

63
64
65
    width = w;
    height = h;

66
 again:
67
68
69
70
71
    screen = SDL_SetVideoMode(w, h, 0, flags);
    if (!screen) {
        fprintf(stderr, "Could not open SDL display\n");
        exit(1);
    }
72
73
74
75
76
77
78
79
80
    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);
    }
81
82
83
    ds->data = screen->pixels;
    ds->linesize = screen->pitch;
    ds->depth = screen->format->BitsPerPixel;
bellard's avatar
bellard committed
84
85
86
87
88
    if (ds->depth == 32 && screen->format->Rshift == 0) {
        ds->bgr = 1;
    } else {
        ds->bgr = 0;
    }
bellard's avatar
bellard committed
89
90
    ds->width = w;
    ds->height = h;
91
92
}

93
/* generic keyboard conversion */
bellard's avatar
bellard committed
94

95
96
97
98
99
100
#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
101
{
102
103
104
105
106
107
    int keysym;
    /* workaround for X11+SDL bug with AltGR */
    keysym = ev->keysym.sym;
    if (keysym == 0 && ev->keysym.scancode == 113)
        keysym = SDLK_MODE;
    return keysym2scancode(kbd_layout, keysym);
bellard's avatar
bellard committed
108
109
}

110
111
112
/* specific keyboard conversions from scan codes */

#if defined(_WIN32)
bellard's avatar
bellard committed
113
114
115
116
117
118
119
120

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

#else

121
122
123
124
125
static const uint8_t x_keycode_to_pc_keycode[61] = {
   0xc7,      /*  97  Home   */
   0xc8,      /*  98  Up     */
   0xc9,      /*  99  PgUp   */
   0xcb,      /* 100  Left   */
126
   0x4c,        /* 101  KP-5   */
127
128
129
130
131
132
133
134
   0xcd,      /* 102  Right  */
   0xcf,      /* 103  End    */
   0xd0,      /* 104  Down   */
   0xd1,      /* 105  PgDn   */
   0xd2,      /* 106  Ins    */
   0xd3,      /* 107  Del    */
   0x9c,      /* 108  Enter  */
   0x9d,      /* 109  Ctrl-R */
bellard's avatar
bellard committed
135
   0x0,       /* 110  Pause  */
136
137
138
139
   0xb7,      /* 111  Print  */
   0xb5,      /* 112  Divide */
   0xb8,      /* 113  Alt-R  */
   0xc6,      /* 114  Break  */   
140
141
142
143
144
   0x0,         /* 115 */
   0x0,         /* 116 */
   0x0,         /* 117 */
   0x0,         /* 118 */
   0x0,         /* 119 */
bellard's avatar
bellard committed
145
   0x70,         /* 120 Hiragana_Katakana */
146
147
   0x0,         /* 121 */
   0x0,         /* 122 */
bellard's avatar
bellard committed
148
   0x73,         /* 123 backslash */
149
150
151
152
153
   0x0,         /* 124 */
   0x0,         /* 125 */
   0x0,         /* 126 */
   0x0,         /* 127 */
   0x0,         /* 128 */
bellard's avatar
bellard committed
154
   0x79,         /* 129 Henkan */
155
   0x0,         /* 130 */
bellard's avatar
bellard committed
156
   0x7b,         /* 131 Muhenkan */
157
   0x0,         /* 132 */
bellard's avatar
bellard committed
158
   0x7d,         /* 133 Yen */
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
   0x0,         /* 134 */
   0x0,         /* 135 */
   0x47,         /* 136 KP_7 */
   0x48,         /* 137 KP_8 */
   0x49,         /* 138 KP_9 */
   0x4b,         /* 139 KP_4 */
   0x4c,         /* 140 KP_5 */
   0x4d,         /* 141 KP_6 */
   0x4f,         /* 142 KP_1 */
   0x50,         /* 143 KP_2 */
   0x51,         /* 144 KP_3 */
   0x52,         /* 145 KP_0 */
   0x53,         /* 146 KP_. */
   0x47,         /* 147 KP_HOME */
   0x48,         /* 148 KP_UP */
   0x49,         /* 149 KP_PgUp */
   0x4b,         /* 150 KP_Left */
   0x4c,         /* 151 KP_ */
   0x4d,         /* 152 KP_Right */
   0x4f,         /* 153 KP_End */
   0x50,         /* 154 KP_Down */
   0x51,         /* 155 KP_PgDn */
   0x52,         /* 156 KP_Ins */
   0x53,         /* 157 KP_Del */
};

bellard's avatar
bellard committed
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
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 */
    } else if (keycode < 158) {
        /* use conversion table */
        keycode = x_keycode_to_pc_keycode[keycode - 97];
    } else {
        keycode = 0;
    }
    return keycode;
}

#endif

206
207
208
209
210
211
212
213
214
215
216
217
218
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;
        }
    }
}

219
220
static void sdl_process_key(SDL_KeyboardEvent *ev)
{
221
    int keycode, v;
222
223
224
225
226
227
228
229
230
231
232
233

    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;
    }

234
235
236
237
238
    if (kbd_layout) {
        keycode = sdl_keyevent_to_keycode_generic(ev);
    } else {
        keycode = sdl_keyevent_to_keycode(ev);
    }
239
240
241
242

    switch(keycode) {
    case 0x00:
        /* sent when leaving window: reset the modifiers state */
243
        reset_keys();
244
245
246
247
248
249
250
        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 */
251
        if (ev->type == SDL_KEYUP)
252
253
254
255
256
257
258
259
260
261
            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;
262
    }
263
264
265
266
267
268
269
270

    /* 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);
271
272
}

273
274
275
276
277
278
279
280
static void sdl_update_caption(void)
{
    char buf[1024];
    strcpy(buf, "QEMU");
    if (!vm_running) {
        strcat(buf, " [Stopped]");
    }
    if (gui_grab) {
281
        strcat(buf, " - Press Ctrl-Alt to exit grab");
282
283
284
285
    }
    SDL_WM_SetCaption(buf, "QEMU");
}

286
287
static void sdl_hide_cursor(void)
{
288
289
290
291
292
293
    if (kbd_mouse_is_absolute()) {
        SDL_ShowCursor(1);
        SDL_SetCursor(sdl_cursor_hidden);
    } else {
        SDL_ShowCursor(0);
    }
294
295
296
297
298
}

static void sdl_show_cursor(void)
{
    if (!kbd_mouse_is_absolute()) {
299
        SDL_ShowCursor(1);
300
301
302
    }
}

303
304
static void sdl_grab_start(void)
{
305
    sdl_hide_cursor();
306
307
308
309
    SDL_WM_GrabInput(SDL_GRAB_ON);
    /* dummy read to avoid moving the mouse */
    SDL_GetRelativeMouseState(NULL, NULL);
    gui_grab = 1;
310
    sdl_update_caption();
311
312
313
314
315
}

static void sdl_grab_end(void)
{
    SDL_WM_GrabInput(SDL_GRAB_OFF);
316
    sdl_show_cursor();
317
    gui_grab = 0;
318
    sdl_update_caption();
319
320
}

321
static void sdl_send_mouse_event(int dz)
322
{
323
    int dx, dy, state, buttons;
324
325
326
327
328
329
330
331
    state = SDL_GetRelativeMouseState(&dx, &dy);
    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;
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346

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

	SDL_GetMouseState(&dx, &dy);
	dx = dx * 0x7FFF / width;
	dy = dy * 0x7FFF / height;
    }

347
348
349
    kbd_mouse_event(dx, dy, dz, buttons);
}

350
351
352
353
354
355
356
357
358
359
360
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
361
362
    vga_hw_invalidate();
    vga_hw_update();
363
364
}

365
366
367
static void sdl_refresh(DisplayState *ds)
{
    SDL_Event ev1, *ev = &ev1;
368
369
    int mod_state;
                     
370
371
372
373
374
    if (last_vm_running != vm_running) {
        last_vm_running = vm_running;
        sdl_update_caption();
    }

pbrook's avatar
pbrook committed
375
    vga_hw_update();
bellard's avatar
bellard committed
376

377
378
379
380
381
382
383
384
    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) {
385
386
                mod_state = (SDL_GetModState() & gui_grab_code) ==
                    gui_grab_code;
387
                gui_key_modifier_pressed = mod_state;
bellard's avatar
bellard committed
388
                if (gui_key_modifier_pressed) {
389
390
391
392
                    int keycode;
                    keycode = sdl_keyevent_to_keycode(&ev->key);
                    switch(keycode) {
                    case 0x21: /* 'f' key on US keyboard */
bellard's avatar
bellard committed
393
394
395
                        toggle_full_screen(ds);
                        gui_keysym = 1;
                        break;
396
397
                    case 0x02 ... 0x0a: /* '1' to '9' keys */ 
                        console_select(keycode - 0x02);
pbrook's avatar
pbrook committed
398
                        if (!is_graphic_console()) {
bellard's avatar
bellard committed
399
400
401
402
403
404
405
406
407
                            /* 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
408
                } else if (!is_graphic_console()) {
bellard's avatar
bellard committed
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
                    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;
                        case SDLK_BACKSPACE: keysym = QEMU_KEY_BACKSPACE; break;                        case SDLK_DELETE: keysym = QEMU_KEY_DELETE; break;
                        default: break;
                        }
                    }
                    if (keysym) {
                        kbd_put_keysym(keysym);
                    } else if (ev->key.keysym.unicode != 0) {
                        kbd_put_keysym(ev->key.keysym.unicode);
                    }
442
443
                }
            } else if (ev->type == SDL_KEYUP) {
444
                mod_state = (ev->key.keysym.mod & gui_grab_code);
445
446
                if (!mod_state) {
                    if (gui_key_modifier_pressed) {
447
                        gui_key_modifier_pressed = 0;
bellard's avatar
bellard committed
448
                        if (gui_keysym == 0) {
449
                            /* exit/enter grab if pressing Ctrl-Alt */
450
451
452
453
454
455
456
457
458
459
                            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 {
460
                                sdl_grab_end();
461
                            }
462
463
464
                            /* SDL does not send back all the
                               modifiers key, so we must correct it */
                            reset_keys();
465
466
467
468
                            break;
                        }
                        gui_keysym = 0;
                    }
469
470
                }
            }
pbrook's avatar
pbrook committed
471
            if (is_graphic_console()) 
bellard's avatar
bellard committed
472
                sdl_process_key(&ev->key);
473
474
            break;
        case SDL_QUIT:
bellard's avatar
bellard committed
475
            qemu_system_shutdown_request();
476
477
            break;
        case SDL_MOUSEMOTION:
478
            if (gui_grab || kbd_mouse_is_absolute()) {
479
                sdl_send_mouse_event(0);
480
481
482
483
484
485
            }
            break;
        case SDL_MOUSEBUTTONDOWN:
        case SDL_MOUSEBUTTONUP:
            {
                SDL_MouseButtonEvent *bev = &ev->button;
486
                if (!gui_grab && !kbd_mouse_is_absolute()) {
487
488
489
490
491
492
                    if (ev->type == SDL_MOUSEBUTTONDOWN &&
                        (bev->state & SDL_BUTTON_LMASK)) {
                        /* start grabbing all events */
                        sdl_grab_start();
                    }
                } else {
493
494
495
                    int dz;
                    dz = 0;
#ifdef SDL_BUTTON_WHEELUP
496
                    if (bev->button == SDL_BUTTON_WHEELUP && ev->type == SDL_MOUSEBUTTONDOWN) {
497
                        dz = -1;
498
                    } else if (bev->button == SDL_BUTTON_WHEELDOWN && ev->type == SDL_MOUSEBUTTONDOWN) {
499
500
501
502
                        dz = 1;
                    }
#endif               
                    sdl_send_mouse_event(dz);
503
504
505
                }
            }
            break;
506
        case SDL_ACTIVEEVENT:
507
508
            if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
                !ev->active.gain && !gui_fullscreen_initial_grab) {
509
510
511
                sdl_grab_end();
            }
            break;
512
513
514
515
516
517
        default:
            break;
        }
    }
}

bellard's avatar
bellard committed
518
519
520
521
522
static void sdl_cleanup(void) 
{
    SDL_Quit();
}

bellard's avatar
bellard committed
523
void sdl_display_init(DisplayState *ds, int full_screen)
524
525
{
    int flags;
526
    uint8_t data = 0;
527

528
529
530
531
532
533
534
535
536
537
538
#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);
    }

539
540
541
542
543
    flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
    if (SDL_Init (flags)) {
        fprintf(stderr, "Could not initialize SDL - exiting\n");
        exit(1);
    }
bellard's avatar
bellard committed
544
#ifndef _WIN32
545
546
547
    /* NOTE: we still want Ctrl-C to work, so we undo the SDL redirections */
    signal(SIGINT, SIG_DFL);
    signal(SIGQUIT, SIG_DFL);
bellard's avatar
bellard committed
548
#endif
549

550
551
552
553
554
    ds->dpy_update = sdl_update;
    ds->dpy_resize = sdl_resize;
    ds->dpy_refresh = sdl_refresh;

    sdl_resize(ds, 640, 400);
555
    sdl_update_caption();
556
    SDL_EnableKeyRepeat(250, 50);
bellard's avatar
bellard committed
557
    SDL_EnableUNICODE(1);
558
    gui_grab = 0;
bellard's avatar
bellard committed
559

560
561
562
    sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
    sdl_cursor_normal = SDL_GetCursor();

bellard's avatar
bellard committed
563
    atexit(sdl_cleanup);
bellard's avatar
bellard committed
564
565
566
567
568
    if (full_screen) {
        gui_fullscreen = 1;
        gui_fullscreen_initial_grab = 1;
        sdl_grab_start();
    }
569
}