]>
Commit | Line | Data |
---|---|---|
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 |
41 | static DisplayChangeListener *dcl; |
42 | static SDL_Surface *real_screen; | |
43 | static SDL_Surface *guest_screen = NULL; | |
0f0b7264 | 44 | static int gui_grab; /* if true, all keyboard/mouse events are grabbed */ |
8a7ddc38 | 45 | static int last_vm_running; |
8e9c4afe FB |
46 | static int gui_saved_grab; |
47 | static int gui_fullscreen; | |
43523e93 | 48 | static int gui_noframe; |
8e9c4afe FB |
49 | static int gui_key_modifier_pressed; |
50 | static int gui_keysym; | |
d63d307f | 51 | static int gui_fullscreen_initial_grab; |
32ff25bf FB |
52 | static int gui_grab_code = KMOD_LALT | KMOD_LCTRL; |
53 | static uint8_t modifiers_state[256]; | |
09b26c5e FB |
54 | static int width, height; |
55 | static SDL_Cursor *sdl_cursor_normal; | |
56 | static SDL_Cursor *sdl_cursor_hidden; | |
57 | static int absolute_enabled = 0; | |
d34cab9f TS |
58 | static int guest_cursor = 0; |
59 | static int guest_x, guest_y; | |
660f11be | 60 | static SDL_Cursor *guest_sprite = NULL; |
7b5d76da | 61 | static uint8_t allocator; |
c18a2c36 SS |
62 | static SDL_PixelFormat host_format; |
63 | static int scaling_active = 0; | |
3af12c86 | 64 | static Notifier mouse_mode_notifier; |
0f0b7264 FB |
65 | |
66 | static 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 | ||
88 | static 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 | 98 | static 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 | ||
120 | static 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 | ||
136 | static 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 | ||
169 | static 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 | ||
213 | static 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 | ||
224 | static 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 | 234 | static kbd_layout_t *kbd_layout = NULL; |
3d11d0eb FB |
235 | |
236 | static 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 | |
254 | static 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 | ||
264 | static 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 | "[email protected]\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 | |
299 | static int check_for_evdev(void) | |
300 | { | |
301 | return 0; | |
302 | } | |
303 | #endif | |
304 | ||
e58d12ed FB |
305 | static 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 |
337 | static 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 |
350 | static 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 |
408 | static 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 |
436 | static 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 | ||
449 | static 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 |
464 | static 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 | ||
480 | static 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 |
488 | static 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 | 504 | static 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 |
530 | static 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 |
546 | static 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 |
757 | static 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 | ||
763 | static 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 | 779 | static 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 | 802 | static 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 | 809 | void 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; | |
09cec717 | 815 | char *filename; |
0f0b7264 | 816 | |
3d11d0eb FB |
817 | #if defined(__APPLE__) |
818 | /* always use generic keymaps */ | |
819 | if (!keyboard_layout) | |
820 | keyboard_layout = "en-us"; | |
821 | #endif | |
822 | if(keyboard_layout) { | |
0483755a | 823 | kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout); |
3d11d0eb FB |
824 | if (!kbd_layout) |
825 | exit(1); | |
826 | } | |
827 | ||
43523e93 TS |
828 | if (no_frame) |
829 | gui_noframe = 1; | |
830 | ||
111f8ec9 JK |
831 | if (!full_screen) { |
832 | setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", 0); | |
833 | } | |
1de9756b MT |
834 | #ifdef __linux__ |
835 | /* on Linux, SDL may use fbcon|directfb|svgalib when run without | |
836 | * accessible $DISPLAY to open X11 window. This is often the case | |
837 | * when qemu is run using sudo. But in this case, and when actually | |
838 | * run in X11 environment, SDL fights with X11 for the video card, | |
839 | * making current display unavailable, often until reboot. | |
840 | * So make x11 the default SDL video driver if this variable is unset. | |
841 | * This is a bit hackish but saves us from bigger problem. | |
842 | * Maybe it's a good idea to fix this in SDL instead. | |
843 | */ | |
844 | setenv("SDL_VIDEODRIVER", "x11", 0); | |
845 | #endif | |
111f8ec9 | 846 | |
4e79bcbb SW |
847 | /* Enable normal up/down events for Caps-Lock and Num-Lock keys. |
848 | * This requires SDL >= 1.2.14. */ | |
849 | setenv("SDL_DISABLE_LOCK_KEYS", "1", 1); | |
850 | ||
0f0b7264 FB |
851 | flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE; |
852 | if (SDL_Init (flags)) { | |
3caf2562 | 853 | fprintf(stderr, "Could not initialize SDL(%s) - exiting\n", |
854 | SDL_GetError()); | |
0f0b7264 FB |
855 | exit(1); |
856 | } | |
7b5d76da | 857 | vi = SDL_GetVideoInfo(); |
c18a2c36 | 858 | host_format = *(vi->vfmt); |
0ae04d73 | 859 | |
09cec717 SW |
860 | /* Load a 32x32x4 image. White pixels are transparent. */ |
861 | filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu-icon.bmp"); | |
862 | if (filename) { | |
863 | SDL_Surface *image = SDL_LoadBMP(filename); | |
864 | if (image) { | |
865 | uint32_t colorkey = SDL_MapRGB(image->format, 255, 255, 255); | |
866 | SDL_SetColorKey(image, SDL_SRCCOLORKEY, colorkey); | |
867 | SDL_WM_SetIcon(image, NULL); | |
868 | } | |
869 | qemu_free(filename); | |
870 | } | |
871 | ||
7d957bd8 | 872 | dcl = qemu_mallocz(sizeof(DisplayChangeListener)); |
7d957bd8 AL |
873 | dcl->dpy_update = sdl_update; |
874 | dcl->dpy_resize = sdl_resize; | |
875 | dcl->dpy_refresh = sdl_refresh; | |
876 | dcl->dpy_setdata = sdl_setdata; | |
877 | dcl->dpy_fill = sdl_fill; | |
d34cab9f TS |
878 | ds->mouse_set = sdl_mouse_warp; |
879 | ds->cursor_define = sdl_mouse_define; | |
7d957bd8 | 880 | register_displaychangelistener(ds, dcl); |
0f0b7264 | 881 | |
7b5d76da AL |
882 | da = qemu_mallocz(sizeof(DisplayAllocator)); |
883 | da->create_displaysurface = sdl_create_displaysurface; | |
884 | da->resize_displaysurface = sdl_resize_displaysurface; | |
885 | da->free_displaysurface = sdl_free_displaysurface; | |
886 | if (register_displayallocator(ds, da) == da) { | |
7b5d76da AL |
887 | dpy_resize(ds); |
888 | } | |
889 | ||
3af12c86 AL |
890 | mouse_mode_notifier.notify = sdl_mouse_mode_change; |
891 | qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier); | |
892 | ||
8a7ddc38 | 893 | sdl_update_caption(); |
0f0b7264 FB |
894 | SDL_EnableKeyRepeat(250, 50); |
895 | gui_grab = 0; | |
898712a8 | 896 | |
09b26c5e FB |
897 | sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0); |
898 | sdl_cursor_normal = SDL_GetCursor(); | |
899 | ||
28695489 | 900 | atexit(sdl_cleanup); |
d63d307f FB |
901 | if (full_screen) { |
902 | gui_fullscreen = 1; | |
903 | gui_fullscreen_initial_grab = 1; | |
904 | sdl_grab_start(); | |
905 | } | |
0f0b7264 | 906 | } |