]> git.proxmox.com Git - mirror_qemu.git/blame - ui/sdl.c
pc-bios/spapr-rtas.bin: remove executable flag
[mirror_qemu.git] / ui / sdl.c
CommitLineData
0f0b7264
FB
1/*
2 * QEMU SDL display driver
5fafdf24 3 *
0f0b7264 4 * Copyright (c) 2003 Fabrice Bellard
5fafdf24 5 *
0f0b7264
FB
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 */
cdfb017e
SW
24
25/* Avoid compiler warning because macro is redefined in SDL_syswm.h. */
26#undef WIN32_LEAN_AND_MEAN
27
0f0b7264 28#include <SDL.h>
c9985aa8 29#include <SDL_syswm.h>
0f0b7264 30
67b915a5
FB
31#ifndef _WIN32
32#include <signal.h>
33#endif
0f0b7264 34
511d2b14
BS
35#include "qemu-common.h"
36#include "console.h"
37#include "sysemu.h"
38#include "x_keymap.h"
c18a2c36 39#include "sdl_zoom.h"
511d2b14 40
7d957bd8
AL
41static DisplayChangeListener *dcl;
42static SDL_Surface *real_screen;
43static SDL_Surface *guest_screen = NULL;
0f0b7264 44static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
8a7ddc38 45static int last_vm_running;
8e9c4afe
FB
46static int gui_saved_grab;
47static int gui_fullscreen;
43523e93 48static int gui_noframe;
8e9c4afe
FB
49static int gui_key_modifier_pressed;
50static int gui_keysym;
d63d307f 51static int gui_fullscreen_initial_grab;
32ff25bf
FB
52static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
53static uint8_t modifiers_state[256];
09b26c5e
FB
54static int width, height;
55static SDL_Cursor *sdl_cursor_normal;
56static SDL_Cursor *sdl_cursor_hidden;
57static int absolute_enabled = 0;
d34cab9f
TS
58static int guest_cursor = 0;
59static int guest_x, guest_y;
660f11be 60static SDL_Cursor *guest_sprite = NULL;
7b5d76da 61static uint8_t allocator;
c18a2c36
SS
62static SDL_PixelFormat host_format;
63static int scaling_active = 0;
3af12c86 64static Notifier mouse_mode_notifier;
0f0b7264
FB
65
66static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
67{
898712a8 68 // printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
c18a2c36
SS
69 SDL_Rect rec;
70 rec.x = x;
71 rec.y = y;
72 rec.w = w;
73 rec.h = h;
74
7b5d76da 75 if (guest_screen) {
c18a2c36
SS
76 if (!scaling_active) {
77 SDL_BlitSurface(guest_screen, &rec, real_screen, &rec);
78 } else {
79 if (sdl_zoom_blit(guest_screen, real_screen, SMOOTHING_ON, &rec) < 0) {
80 fprintf(stderr, "Zoom blit failed\n");
81 exit(1);
82 }
83 }
84 }
85 SDL_UpdateRect(real_screen, rec.x, rec.y, rec.w, rec.h);
7d957bd8
AL
86}
87
88static void sdl_setdata(DisplayState *ds)
89{
7d957bd8
AL
90 if (guest_screen != NULL) SDL_FreeSurface(guest_screen);
91
92 guest_screen = SDL_CreateRGBSurfaceFrom(ds_get_data(ds), ds_get_width(ds), ds_get_height(ds),
93 ds_get_bits_per_pixel(ds), ds_get_linesize(ds),
94 ds->surface->pf.rmask, ds->surface->pf.gmask,
95 ds->surface->pf.bmask, ds->surface->pf.amask);
0f0b7264
FB
96}
97
649c9078 98static void do_sdl_resize(int new_width, int new_height, int bpp)
0f0b7264
FB
99{
100 int flags;
101
102 // printf("resizing to %d %d\n", w, h);
103
c18a2c36 104 flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL|SDL_RESIZABLE;
8e9c4afe
FB
105 if (gui_fullscreen)
106 flags |= SDL_FULLSCREEN;
43523e93
TS
107 if (gui_noframe)
108 flags |= SDL_NOFRAME;
9903da21 109
649c9078
AZ
110 width = new_width;
111 height = new_height;
7b5d76da 112 real_screen = SDL_SetVideoMode(width, height, bpp, flags);
7d957bd8 113 if (!real_screen) {
b6034a39
BM
114 fprintf(stderr, "Could not open SDL display (%dx%dx%d): %s\n", width,
115 height, bpp, SDL_GetError());
0f0b7264
FB
116 exit(1);
117 }
7b5d76da
AL
118}
119
120static void sdl_resize(DisplayState *ds)
121{
122 if (!allocator) {
c18a2c36
SS
123 if (!scaling_active)
124 do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
125 else if (real_screen->format->BitsPerPixel != ds_get_bits_per_pixel(ds))
126 do_sdl_resize(real_screen->w, real_screen->h, ds_get_bits_per_pixel(ds));
7b5d76da
AL
127 sdl_setdata(ds);
128 } else {
129 if (guest_screen != NULL) {
130 SDL_FreeSurface(guest_screen);
131 guest_screen = NULL;
132 }
133 }
134}
135
136static PixelFormat sdl_to_qemu_pixelformat(SDL_PixelFormat *sdl_pf)
137{
138 PixelFormat qemu_pf;
139
140 memset(&qemu_pf, 0x00, sizeof(PixelFormat));
141
142 qemu_pf.bits_per_pixel = sdl_pf->BitsPerPixel;
143 qemu_pf.bytes_per_pixel = sdl_pf->BytesPerPixel;
144 qemu_pf.depth = (qemu_pf.bits_per_pixel) == 32 ? 24 : (qemu_pf.bits_per_pixel);
145
146 qemu_pf.rmask = sdl_pf->Rmask;
147 qemu_pf.gmask = sdl_pf->Gmask;
148 qemu_pf.bmask = sdl_pf->Bmask;
149 qemu_pf.amask = sdl_pf->Amask;
150
151 qemu_pf.rshift = sdl_pf->Rshift;
152 qemu_pf.gshift = sdl_pf->Gshift;
153 qemu_pf.bshift = sdl_pf->Bshift;
154 qemu_pf.ashift = sdl_pf->Ashift;
155
156 qemu_pf.rbits = 8 - sdl_pf->Rloss;
157 qemu_pf.gbits = 8 - sdl_pf->Gloss;
158 qemu_pf.bbits = 8 - sdl_pf->Bloss;
159 qemu_pf.abits = 8 - sdl_pf->Aloss;
160
161 qemu_pf.rmax = ((1 << qemu_pf.rbits) - 1);
162 qemu_pf.gmax = ((1 << qemu_pf.gbits) - 1);
163 qemu_pf.bmax = ((1 << qemu_pf.bbits) - 1);
164 qemu_pf.amax = ((1 << qemu_pf.abits) - 1);
165
166 return qemu_pf;
167}
168
169static DisplaySurface* sdl_create_displaysurface(int width, int height)
170{
171 DisplaySurface *surface = (DisplaySurface*) qemu_mallocz(sizeof(DisplaySurface));
172 if (surface == NULL) {
173 fprintf(stderr, "sdl_create_displaysurface: malloc failed\n");
174 exit(1);
175 }
176
177 surface->width = width;
178 surface->height = height;
ffe8b821 179
c18a2c36 180 if (scaling_active) {
ffe8b821
JS
181 int linesize;
182 PixelFormat pf;
c18a2c36 183 if (host_format.BytesPerPixel != 2 && host_format.BytesPerPixel != 4) {
ffe8b821
JS
184 linesize = width * 4;
185 pf = qemu_default_pixelformat(32);
c18a2c36 186 } else {
ffe8b821
JS
187 linesize = width * host_format.BytesPerPixel;
188 pf = sdl_to_qemu_pixelformat(&host_format);
c18a2c36 189 }
ffe8b821 190 qemu_alloc_display(surface, width, height, linesize, pf, 0);
c18a2c36
SS
191 return surface;
192 }
7d957bd8 193
c18a2c36 194 if (host_format.BitsPerPixel == 16)
7b5d76da
AL
195 do_sdl_resize(width, height, 16);
196 else
197 do_sdl_resize(width, height, 32);
198
199 surface->pf = sdl_to_qemu_pixelformat(real_screen->format);
200 surface->linesize = real_screen->pitch;
201 surface->data = real_screen->pixels;
202
e2542fe2 203#ifdef HOST_WORDS_BIGENDIAN
c18a2c36 204 surface->flags = QEMU_REALPIXELS_FLAG | QEMU_BIG_ENDIAN_FLAG;
7b5d76da 205#else
c18a2c36 206 surface->flags = QEMU_REALPIXELS_FLAG;
7b5d76da
AL
207#endif
208 allocator = 1;
209
210 return surface;
211}
212
213static void sdl_free_displaysurface(DisplaySurface *surface)
214{
215 allocator = 0;
216 if (surface == NULL)
217 return;
c18a2c36
SS
218
219 if (surface->flags & QEMU_ALLOCATED_FLAG)
220 qemu_free(surface->data);
7b5d76da
AL
221 qemu_free(surface);
222}
223
224static DisplaySurface* sdl_resize_displaysurface(DisplaySurface *surface, int width, int height)
225{
226 sdl_free_displaysurface(surface);
227 return sdl_create_displaysurface(width, height);
0f0b7264
FB
228}
229
3d11d0eb 230/* generic keyboard conversion */
e58d12ed 231
3d11d0eb 232#include "sdl_keysym.h"
3d11d0eb 233
c227f099 234static kbd_layout_t *kbd_layout = NULL;
3d11d0eb
FB
235
236static uint8_t sdl_keyevent_to_keycode_generic(const SDL_KeyboardEvent *ev)
e58d12ed 237{
3d11d0eb
FB
238 int keysym;
239 /* workaround for X11+SDL bug with AltGR */
240 keysym = ev->keysym.sym;
241 if (keysym == 0 && ev->keysym.scancode == 113)
242 keysym = SDLK_MODE;
60659e3b
FB
243 /* For Japanese key '\' and '|' */
244 if (keysym == 92 && ev->keysym.scancode == 133) {
245 keysym = 0xa5;
246 }
44bb61c8 247 return keysym2scancode(kbd_layout, keysym) & SCANCODE_KEYMASK;
e58d12ed
FB
248}
249
3d11d0eb
FB
250/* specific keyboard conversions from scan codes */
251
252#if defined(_WIN32)
e58d12ed
FB
253
254static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
255{
256 return ev->keysym.scancode;
257}
258
259#else
260
5368a422
AL
261#if defined(SDL_VIDEO_DRIVER_X11)
262#include <X11/XKBlib.h>
263
264static int check_for_evdev(void)
265{
266 SDL_SysWMinfo info;
229609dd 267 XkbDescPtr desc = NULL;
5368a422 268 int has_evdev = 0;
229609dd 269 char *keycodes = NULL;
5368a422
AL
270
271 SDL_VERSION(&info.version);
229609dd 272 if (!SDL_GetWMInfo(&info)) {
5368a422 273 return 0;
229609dd 274 }
5368a422
AL
275 desc = XkbGetKeyboard(info.info.x11.display,
276 XkbGBN_AllComponentsMask,
277 XkbUseCoreKbd);
229609dd
JK
278 if (desc && desc->names) {
279 keycodes = XGetAtomName(info.info.x11.display, desc->names->keycodes);
280 if (keycodes == NULL) {
281 fprintf(stderr, "could not lookup keycode name\n");
282 } else if (strstart(keycodes, "evdev", NULL)) {
283 has_evdev = 1;
284 } else if (!strstart(keycodes, "xfree86", NULL)) {
285 fprintf(stderr, "unknown keycodes `%s', please report to "
286 "qemu-devel@nongnu.org\n", keycodes);
287 }
288 }
5368a422 289
229609dd
JK
290 if (desc) {
291 XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True);
292 }
293 if (keycodes) {
294 XFree(keycodes);
295 }
5368a422
AL
296 return has_evdev;
297}
298#else
299static int check_for_evdev(void)
300{
301 return 0;
302}
303#endif
304
e58d12ed
FB
305static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
306{
307 int keycode;
5368a422
AL
308 static int has_evdev = -1;
309
310 if (has_evdev == -1)
311 has_evdev = check_for_evdev();
e58d12ed
FB
312
313 keycode = ev->keysym.scancode;
314
315 if (keycode < 9) {
316 keycode = 0;
317 } else if (keycode < 97) {
318 keycode -= 8; /* just an offset */
5368a422 319 } else if (keycode < 158) {
e58d12ed 320 /* use conversion table */
5368a422
AL
321 if (has_evdev)
322 keycode = translate_evdev_keycode(keycode - 97);
323 else
324 keycode = translate_xfree86_keycode(keycode - 97);
325 } else if (keycode == 208) { /* Hiragana_Katakana */
326 keycode = 0x70;
327 } else if (keycode == 211) { /* backslash */
328 keycode = 0x73;
e58d12ed
FB
329 } else {
330 keycode = 0;
331 }
332 return keycode;
333}
334
335#endif
336
32ff25bf
FB
337static void reset_keys(void)
338{
339 int i;
340 for(i = 0; i < 256; i++) {
341 if (modifiers_state[i]) {
44bb61c8
ST
342 if (i & SCANCODE_GREY)
343 kbd_put_keycode(SCANCODE_EMUL0);
344 kbd_put_keycode(i | SCANCODE_UP);
32ff25bf
FB
345 modifiers_state[i] = 0;
346 }
347 }
348}
349
0f0b7264
FB
350static void sdl_process_key(SDL_KeyboardEvent *ev)
351{
32ff25bf 352 int keycode, v;
de2200d3
FB
353
354 if (ev->keysym.sym == SDLK_PAUSE) {
355 /* specific case */
356 v = 0;
357 if (ev->type == SDL_KEYUP)
44bb61c8 358 v |= SCANCODE_UP;
de2200d3
FB
359 kbd_put_keycode(0xe1);
360 kbd_put_keycode(0x1d | v);
361 kbd_put_keycode(0x45 | v);
362 return;
363 }
364
3d11d0eb
FB
365 if (kbd_layout) {
366 keycode = sdl_keyevent_to_keycode_generic(ev);
367 } else {
368 keycode = sdl_keyevent_to_keycode(ev);
369 }
de2200d3
FB
370
371 switch(keycode) {
372 case 0x00:
373 /* sent when leaving window: reset the modifiers state */
32ff25bf 374 reset_keys();
de2200d3
FB
375 return;
376 case 0x2a: /* Left Shift */
377 case 0x36: /* Right Shift */
378 case 0x1d: /* Left CTRL */
379 case 0x9d: /* Right CTRL */
380 case 0x38: /* Left ALT */
381 case 0xb8: /* Right ALT */
0f0b7264 382 if (ev->type == SDL_KEYUP)
de2200d3
FB
383 modifiers_state[keycode] = 0;
384 else
385 modifiers_state[keycode] = 1;
386 break;
4e79bcbb
SW
387#define QEMU_SDL_VERSION ((SDL_MAJOR_VERSION << 8) + SDL_MINOR_VERSION)
388#if QEMU_SDL_VERSION < 0x102 || QEMU_SDL_VERSION == 0x102 && SDL_PATCHLEVEL < 14
389 /* SDL versions before 1.2.14 don't support key up for caps/num lock. */
de2200d3
FB
390 case 0x45: /* num lock */
391 case 0x3a: /* caps lock */
392 /* SDL does not send the key up event, so we generate it */
393 kbd_put_keycode(keycode);
44bb61c8 394 kbd_put_keycode(keycode | SCANCODE_UP);
de2200d3 395 return;
4e79bcbb 396#endif
0f0b7264 397 }
de2200d3
FB
398
399 /* now send the key code */
44bb61c8
ST
400 if (keycode & SCANCODE_GREY)
401 kbd_put_keycode(SCANCODE_EMUL0);
de2200d3 402 if (ev->type == SDL_KEYUP)
44bb61c8 403 kbd_put_keycode(keycode | SCANCODE_UP);
de2200d3 404 else
44bb61c8 405 kbd_put_keycode(keycode & SCANCODE_KEYCODEMASK);
0f0b7264
FB
406}
407
8a7ddc38
FB
408static void sdl_update_caption(void)
409{
b4ed5d18
DE
410 char win_title[1024];
411 char icon_title[1024];
c35734b2
TS
412 const char *status = "";
413
414 if (!vm_running)
415 status = " [Stopped]";
3780e197 416 else if (gui_grab) {
0ca9f8a4 417 if (alt_grab)
4e75b342 418 status = " - Press Ctrl-Alt-Shift to exit mouse grab";
0ca9f8a4 419 else if (ctrl_grab)
4e75b342 420 status = " - Press Right-Ctrl to exit mouse grab";
0ca9f8a4 421 else
4e75b342 422 status = " - Press Ctrl-Alt to exit mouse grab";
3780e197 423 }
c35734b2 424
b4ed5d18
DE
425 if (qemu_name) {
426 snprintf(win_title, sizeof(win_title), "QEMU (%s)%s", qemu_name, status);
427 snprintf(icon_title, sizeof(icon_title), "QEMU (%s)", qemu_name);
428 } else {
429 snprintf(win_title, sizeof(win_title), "QEMU%s", status);
430 snprintf(icon_title, sizeof(icon_title), "QEMU");
431 }
c35734b2 432
b4ed5d18 433 SDL_WM_SetCaption(win_title, icon_title);
8a7ddc38
FB
434}
435
09b26c5e
FB
436static void sdl_hide_cursor(void)
437{
9467cd46
AZ
438 if (!cursor_hide)
439 return;
440
8785a8dd
FB
441 if (kbd_mouse_is_absolute()) {
442 SDL_ShowCursor(1);
443 SDL_SetCursor(sdl_cursor_hidden);
444 } else {
445 SDL_ShowCursor(0);
446 }
09b26c5e
FB
447}
448
449static void sdl_show_cursor(void)
450{
9467cd46
AZ
451 if (!cursor_hide)
452 return;
453
09b26c5e 454 if (!kbd_mouse_is_absolute()) {
8785a8dd 455 SDL_ShowCursor(1);
d34cab9f
TS
456 if (guest_cursor &&
457 (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
458 SDL_SetCursor(guest_sprite);
459 else
460 SDL_SetCursor(sdl_cursor_normal);
09b26c5e
FB
461 }
462}
463
0f0b7264
FB
464static void sdl_grab_start(void)
465{
d34cab9f
TS
466 if (guest_cursor) {
467 SDL_SetCursor(guest_sprite);
08a2d4c4
AZ
468 if (!kbd_mouse_is_absolute() && !absolute_enabled)
469 SDL_WarpMouse(guest_x, guest_y);
d34cab9f
TS
470 } else
471 sdl_hide_cursor();
6bb81603
AL
472
473 if (SDL_WM_GrabInput(SDL_GRAB_ON) == SDL_GRAB_ON) {
474 gui_grab = 1;
475 sdl_update_caption();
476 } else
477 sdl_show_cursor();
0f0b7264
FB
478}
479
480static void sdl_grab_end(void)
481{
0f0b7264 482 SDL_WM_GrabInput(SDL_GRAB_OFF);
0f0b7264 483 gui_grab = 0;
d34cab9f 484 sdl_show_cursor();
8a7ddc38 485 sdl_update_caption();
0f0b7264
FB
486}
487
3af12c86
AL
488static void sdl_mouse_mode_change(Notifier *notify)
489{
490 if (kbd_mouse_is_absolute()) {
491 if (!absolute_enabled) {
492 sdl_hide_cursor();
493 if (gui_grab) {
494 sdl_grab_end();
495 }
496 absolute_enabled = 1;
497 }
498 } else if (absolute_enabled) {
499 sdl_show_cursor();
500 absolute_enabled = 0;
501 }
502}
503
4c44bdcb 504static void sdl_send_mouse_event(int dx, int dy, int dz, int x, int y, int state)
0f0b7264 505{
4c44bdcb 506 int buttons;
0f0b7264
FB
507 buttons = 0;
508 if (state & SDL_BUTTON(SDL_BUTTON_LEFT))
509 buttons |= MOUSE_EVENT_LBUTTON;
510 if (state & SDL_BUTTON(SDL_BUTTON_RIGHT))
511 buttons |= MOUSE_EVENT_RBUTTON;
512 if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE))
513 buttons |= MOUSE_EVENT_MBUTTON;
09b26c5e
FB
514
515 if (kbd_mouse_is_absolute()) {
4c44bdcb
AJ
516 dx = x * 0x7FFF / (width - 1);
517 dy = y * 0x7FFF / (height - 1);
d34cab9f 518 } else if (guest_cursor) {
4c44bdcb
AJ
519 x -= guest_x;
520 y -= guest_y;
521 guest_x += x;
522 guest_y += y;
523 dx = x;
524 dy = y;
09b26c5e
FB
525 }
526
0f0b7264
FB
527 kbd_mouse_event(dx, dy, dz, buttons);
528}
529
8e9c4afe
FB
530static void toggle_full_screen(DisplayState *ds)
531{
532 gui_fullscreen = !gui_fullscreen;
a35aed57 533 do_sdl_resize(real_screen->w, real_screen->h, real_screen->format->BitsPerPixel);
8e9c4afe 534 if (gui_fullscreen) {
c18a2c36 535 scaling_active = 0;
8e9c4afe
FB
536 gui_saved_grab = gui_grab;
537 sdl_grab_start();
538 } else {
539 if (!gui_saved_grab)
540 sdl_grab_end();
541 }
95219897
PB
542 vga_hw_invalidate();
543 vga_hw_update();
8e9c4afe
FB
544}
545
0f0b7264
FB
546static void sdl_refresh(DisplayState *ds)
547{
548 SDL_Event ev1, *ev = &ev1;
8e9c4afe 549 int mod_state;
4c44bdcb 550 int buttonstate = SDL_GetMouseState(NULL, NULL);
3b46e624 551
8a7ddc38
FB
552 if (last_vm_running != vm_running) {
553 last_vm_running = vm_running;
554 sdl_update_caption();
555 }
556
95219897 557 vga_hw_update();
3bee8bd0 558 SDL_EnableUNICODE(!is_graphic_console());
457831f4 559
0f0b7264
FB
560 while (SDL_PollEvent(ev)) {
561 switch (ev->type) {
562 case SDL_VIDEOEXPOSE:
7d957bd8 563 sdl_update(ds, 0, 0, real_screen->w, real_screen->h);
0f0b7264
FB
564 break;
565 case SDL_KEYDOWN:
566 case SDL_KEYUP:
567 if (ev->type == SDL_KEYDOWN) {
0ca9f8a4 568 if (alt_grab) {
3780e197
TS
569 mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
570 (gui_grab_code | KMOD_LSHIFT);
0ca9f8a4
DK
571 } else if (ctrl_grab) {
572 mod_state = (SDL_GetModState() & KMOD_RCTRL) == KMOD_RCTRL;
573 } else {
574 mod_state = (SDL_GetModState() & gui_grab_code) ==
575 gui_grab_code;
3780e197 576 }
8e9c4afe 577 gui_key_modifier_pressed = mod_state;
457831f4 578 if (gui_key_modifier_pressed) {
32ff25bf
FB
579 int keycode;
580 keycode = sdl_keyevent_to_keycode(&ev->key);
581 switch(keycode) {
582 case 0x21: /* 'f' key on US keyboard */
457831f4
FB
583 toggle_full_screen(ds);
584 gui_keysym = 1;
585 break;
c4a735f9 586 case 0x16: /* 'u' key on US keyboard */
587 scaling_active = 0;
588 sdl_resize(ds);
589 vga_hw_invalidate();
590 vga_hw_update();
591 break;
5fafdf24 592 case 0x02 ... 0x0a: /* '1' to '9' keys */
dfd92d3a
FB
593 /* Reset the modifiers sent to the current console */
594 reset_keys();
32ff25bf 595 console_select(keycode - 0x02);
95219897 596 if (!is_graphic_console()) {
457831f4
FB
597 /* display grab if going to a text console */
598 if (gui_grab)
599 sdl_grab_end();
600 }
601 gui_keysym = 1;
602 break;
603 default:
604 break;
605 }
95219897 606 } else if (!is_graphic_console()) {
457831f4
FB
607 int keysym;
608 keysym = 0;
609 if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
610 switch(ev->key.keysym.sym) {
611 case SDLK_UP: keysym = QEMU_KEY_CTRL_UP; break;
612 case SDLK_DOWN: keysym = QEMU_KEY_CTRL_DOWN; break;
613 case SDLK_LEFT: keysym = QEMU_KEY_CTRL_LEFT; break;
614 case SDLK_RIGHT: keysym = QEMU_KEY_CTRL_RIGHT; break;
615 case SDLK_HOME: keysym = QEMU_KEY_CTRL_HOME; break;
616 case SDLK_END: keysym = QEMU_KEY_CTRL_END; break;
617 case SDLK_PAGEUP: keysym = QEMU_KEY_CTRL_PAGEUP; break;
618 case SDLK_PAGEDOWN: keysym = QEMU_KEY_CTRL_PAGEDOWN; break;
619 default: break;
620 }
621 } else {
622 switch(ev->key.keysym.sym) {
623 case SDLK_UP: keysym = QEMU_KEY_UP; break;
624 case SDLK_DOWN: keysym = QEMU_KEY_DOWN; break;
625 case SDLK_LEFT: keysym = QEMU_KEY_LEFT; break;
626 case SDLK_RIGHT: keysym = QEMU_KEY_RIGHT; break;
627 case SDLK_HOME: keysym = QEMU_KEY_HOME; break;
628 case SDLK_END: keysym = QEMU_KEY_END; break;
629 case SDLK_PAGEUP: keysym = QEMU_KEY_PAGEUP; break;
630 case SDLK_PAGEDOWN: keysym = QEMU_KEY_PAGEDOWN; break;
e91c8a77
TS
631 case SDLK_BACKSPACE: keysym = QEMU_KEY_BACKSPACE; break;
632 case SDLK_DELETE: keysym = QEMU_KEY_DELETE; break;
457831f4
FB
633 default: break;
634 }
635 }
636 if (keysym) {
637 kbd_put_keysym(keysym);
638 } else if (ev->key.keysym.unicode != 0) {
639 kbd_put_keysym(ev->key.keysym.unicode);
640 }
8e9c4afe
FB
641 }
642 } else if (ev->type == SDL_KEYUP) {
3780e197
TS
643 if (!alt_grab) {
644 mod_state = (ev->key.keysym.mod & gui_grab_code);
645 } else {
646 mod_state = (ev->key.keysym.mod &
647 (gui_grab_code | KMOD_LSHIFT));
648 }
8e9c4afe
FB
649 if (!mod_state) {
650 if (gui_key_modifier_pressed) {
5b311878 651 gui_key_modifier_pressed = 0;
457831f4 652 if (gui_keysym == 0) {
32ff25bf 653 /* exit/enter grab if pressing Ctrl-Alt */
c66b0d4c
FB
654 if (!gui_grab) {
655 /* if the application is not active,
656 do not try to enter grab state. It
657 prevents
658 'SDL_WM_GrabInput(SDL_GRAB_ON)'
659 from blocking all the application
660 (SDL bug). */
661 if (SDL_GetAppState() & SDL_APPACTIVE)
662 sdl_grab_start();
663 } else {
8e9c4afe 664 sdl_grab_end();
c66b0d4c 665 }
32ff25bf
FB
666 /* SDL does not send back all the
667 modifiers key, so we must correct it */
668 reset_keys();
8e9c4afe
FB
669 break;
670 }
8e9c4afe
FB
671 gui_keysym = 0;
672 }
0f0b7264
FB
673 }
674 }
5fafdf24 675 if (is_graphic_console() && !gui_keysym)
457831f4 676 sdl_process_key(&ev->key);
0f0b7264
FB
677 break;
678 case SDL_QUIT:
5b08fc10 679 if (!no_quit)
731345e1 680 qemu_system_shutdown_request();
0f0b7264
FB
681 break;
682 case SDL_MOUSEMOTION:
455204eb
TS
683 if (gui_grab || kbd_mouse_is_absolute() ||
684 absolute_enabled) {
4c44bdcb
AJ
685 sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,
686 ev->motion.x, ev->motion.y, ev->motion.state);
0f0b7264
FB
687 }
688 break;
689 case SDL_MOUSEBUTTONDOWN:
690 case SDL_MOUSEBUTTONUP:
691 {
692 SDL_MouseButtonEvent *bev = &ev->button;
09b26c5e 693 if (!gui_grab && !kbd_mouse_is_absolute()) {
0f0b7264 694 if (ev->type == SDL_MOUSEBUTTONDOWN &&
4c44bdcb 695 (bev->button == SDL_BUTTON_LEFT)) {
0f0b7264
FB
696 /* start grabbing all events */
697 sdl_grab_start();
698 }
699 } else {
18a6d284
FB
700 int dz;
701 dz = 0;
4c44bdcb
AJ
702 if (ev->type == SDL_MOUSEBUTTONDOWN) {
703 buttonstate |= SDL_BUTTON(bev->button);
704 } else {
705 buttonstate &= ~SDL_BUTTON(bev->button);
706 }
18a6d284 707#ifdef SDL_BUTTON_WHEELUP
09b26c5e 708 if (bev->button == SDL_BUTTON_WHEELUP && ev->type == SDL_MOUSEBUTTONDOWN) {
18a6d284 709 dz = -1;
09b26c5e 710 } else if (bev->button == SDL_BUTTON_WHEELDOWN && ev->type == SDL_MOUSEBUTTONDOWN) {
18a6d284
FB
711 dz = 1;
712 }
3b46e624 713#endif
4c44bdcb 714 sdl_send_mouse_event(0, 0, dz, bev->x, bev->y, buttonstate);
0f0b7264
FB
715 }
716 }
717 break;
0294ffb9 718 case SDL_ACTIVEEVENT:
5b311878
PB
719 if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
720 !ev->active.gain && !gui_fullscreen_initial_grab) {
0294ffb9
FB
721 sdl_grab_end();
722 }
f442e08b
AJ
723 if (ev->active.state & SDL_APPACTIVE) {
724 if (ev->active.gain) {
725 /* Back to default interval */
7d957bd8
AL
726 dcl->gui_timer_interval = 0;
727 dcl->idle = 0;
f442e08b
AJ
728 } else {
729 /* Sleeping interval */
7d957bd8
AL
730 dcl->gui_timer_interval = 500;
731 dcl->idle = 1;
f442e08b
AJ
732 }
733 }
0294ffb9 734 break;
c18a2c36
SS
735 case SDL_VIDEORESIZE:
736 {
737 SDL_ResizeEvent *rev = &ev->resize;
738 int bpp = real_screen->format->BitsPerPixel;
739 if (bpp != 16 && bpp != 32)
740 bpp = 32;
741 do_sdl_resize(rev->w, rev->h, bpp);
742 scaling_active = 1;
ae288347
SS
743 if (!is_buffer_shared(ds->surface)) {
744 ds->surface = qemu_resize_displaysurface(ds, ds_get_width(ds), ds_get_height(ds));
745 dpy_resize(ds);
746 }
c18a2c36
SS
747 vga_hw_invalidate();
748 vga_hw_update();
749 break;
750 }
0f0b7264
FB
751 default:
752 break;
753 }
754 }
755}
756
d34cab9f
TS
757static void sdl_fill(DisplayState *ds, int x, int y, int w, int h, uint32_t c)
758{
759 SDL_Rect dst = { x, y, w, h };
7d957bd8 760 SDL_FillRect(real_screen, &dst, c);
d34cab9f
TS
761}
762
763static void sdl_mouse_warp(int x, int y, int on)
764{
765 if (on) {
766 if (!guest_cursor)
767 sdl_show_cursor();
768 if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
769 SDL_SetCursor(guest_sprite);
08a2d4c4
AZ
770 if (!kbd_mouse_is_absolute() && !absolute_enabled)
771 SDL_WarpMouse(x, y);
d34cab9f
TS
772 }
773 } else if (gui_grab)
774 sdl_hide_cursor();
775 guest_cursor = on;
776 guest_x = x, guest_y = y;
777}
778
fbe6d7a4 779static void sdl_mouse_define(QEMUCursor *c)
d34cab9f 780{
fbe6d7a4
GH
781 uint8_t *image, *mask;
782 int bpl;
783
d34cab9f
TS
784 if (guest_sprite)
785 SDL_FreeCursor(guest_sprite);
786
fbe6d7a4
GH
787 bpl = cursor_get_mono_bpl(c);
788 image = qemu_mallocz(bpl * c->height);
789 mask = qemu_mallocz(bpl * c->height);
790 cursor_get_mono_image(c, 0x000000, image);
791 cursor_get_mono_mask(c, 0, mask);
792 guest_sprite = SDL_CreateCursor(image, mask, c->width, c->height,
793 c->hot_x, c->hot_y);
794 qemu_free(image);
795 qemu_free(mask);
d34cab9f
TS
796
797 if (guest_cursor &&
798 (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
799 SDL_SetCursor(guest_sprite);
800}
801
28695489 802static void sdl_cleanup(void)
898712a8 803{
d34cab9f
TS
804 if (guest_sprite)
805 SDL_FreeCursor(guest_sprite);
d8ee7665 806 SDL_QuitSubSystem(SDL_INIT_VIDEO);
898712a8
FB
807}
808
43523e93 809void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
0f0b7264
FB
810{
811 int flags;
09b26c5e 812 uint8_t data = 0;
7b5d76da
AL
813 DisplayAllocator *da;
814 const SDL_VideoInfo *vi;
0f0b7264 815
3d11d0eb
FB
816#if defined(__APPLE__)
817 /* always use generic keymaps */
818 if (!keyboard_layout)
819 keyboard_layout = "en-us";
820#endif
821 if(keyboard_layout) {
0483755a 822 kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
3d11d0eb
FB
823 if (!kbd_layout)
824 exit(1);
825 }
826
43523e93
TS
827 if (no_frame)
828 gui_noframe = 1;
829
111f8ec9
JK
830 if (!full_screen) {
831 setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", 0);
832 }
833
4e79bcbb
SW
834 /* Enable normal up/down events for Caps-Lock and Num-Lock keys.
835 * This requires SDL >= 1.2.14. */
836 setenv("SDL_DISABLE_LOCK_KEYS", "1", 1);
837
0f0b7264
FB
838 flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
839 if (SDL_Init (flags)) {
3caf2562 840 fprintf(stderr, "Could not initialize SDL(%s) - exiting\n",
841 SDL_GetError());
0f0b7264
FB
842 exit(1);
843 }
7b5d76da 844 vi = SDL_GetVideoInfo();
c18a2c36 845 host_format = *(vi->vfmt);
0ae04d73 846
7d957bd8 847 dcl = qemu_mallocz(sizeof(DisplayChangeListener));
7d957bd8
AL
848 dcl->dpy_update = sdl_update;
849 dcl->dpy_resize = sdl_resize;
850 dcl->dpy_refresh = sdl_refresh;
851 dcl->dpy_setdata = sdl_setdata;
852 dcl->dpy_fill = sdl_fill;
d34cab9f
TS
853 ds->mouse_set = sdl_mouse_warp;
854 ds->cursor_define = sdl_mouse_define;
7d957bd8 855 register_displaychangelistener(ds, dcl);
0f0b7264 856
7b5d76da
AL
857 da = qemu_mallocz(sizeof(DisplayAllocator));
858 da->create_displaysurface = sdl_create_displaysurface;
859 da->resize_displaysurface = sdl_resize_displaysurface;
860 da->free_displaysurface = sdl_free_displaysurface;
861 if (register_displayallocator(ds, da) == da) {
7b5d76da
AL
862 dpy_resize(ds);
863 }
864
3af12c86
AL
865 mouse_mode_notifier.notify = sdl_mouse_mode_change;
866 qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier);
867
8a7ddc38 868 sdl_update_caption();
0f0b7264
FB
869 SDL_EnableKeyRepeat(250, 50);
870 gui_grab = 0;
898712a8 871
09b26c5e
FB
872 sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
873 sdl_cursor_normal = SDL_GetCursor();
874
28695489 875 atexit(sdl_cleanup);
d63d307f
FB
876 if (full_screen) {
877 gui_fullscreen = 1;
878 gui_fullscreen_initial_grab = 1;
879 sdl_grab_start();
880 }
0f0b7264 881}