blob: f6f711c1bba57d57dc360fa01877c02b04b45a6e [file] [log] [blame]
bellard0f0b7262003-08-09 18:26:36 +00001/*
2 * QEMU SDL display driver
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard0f0b7262003-08-09 18:26:36 +00004 * Copyright (c) 2003 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellard0f0b7262003-08-09 18:26:36 +00006 * 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 */
Stefan Weilcdfb0172010-04-01 04:20:07 +000024
25/* Avoid compiler warning because macro is redefined in SDL_syswm.h. */
26#undef WIN32_LEAN_AND_MEAN
27
bellard0f0b7262003-08-09 18:26:36 +000028#include <SDL.h>
aliguoric9985aa2009-03-08 15:04:07 +000029#include <SDL_syswm.h>
bellard0f0b7262003-08-09 18:26:36 +000030
blueswir1511d2b12009-03-07 15:32:56 +000031#include "qemu-common.h"
32#include "console.h"
33#include "sysemu.h"
34#include "x_keymap.h"
Stefano Stabellinic18a2c32009-06-24 11:58:25 +010035#include "sdl_zoom.h"
blueswir1511d2b12009-03-07 15:32:56 +000036
aliguori7d957bd2009-01-15 22:14:11 +000037static DisplayChangeListener *dcl;
38static SDL_Surface *real_screen;
39static SDL_Surface *guest_screen = NULL;
bellard0f0b7262003-08-09 18:26:36 +000040static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
bellard8a7ddc32004-03-31 19:00:16 +000041static int last_vm_running;
Jan Kiszkaf9977892011-07-30 11:39:09 +020042static bool gui_saved_scaling;
43static int gui_saved_width;
44static int gui_saved_height;
bellard8e9c4af2004-04-28 19:33:40 +000045static int gui_saved_grab;
46static int gui_fullscreen;
ths43523e92007-02-18 18:19:32 +000047static int gui_noframe;
bellard8e9c4af2004-04-28 19:33:40 +000048static int gui_key_modifier_pressed;
49static int gui_keysym;
bellard32ff25b2004-10-03 14:33:54 +000050static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
51static uint8_t modifiers_state[256];
bellard09b26c52006-04-12 21:09:08 +000052static SDL_Cursor *sdl_cursor_normal;
53static SDL_Cursor *sdl_cursor_hidden;
54static int absolute_enabled = 0;
thsd34cab92007-04-02 01:10:46 +000055static int guest_cursor = 0;
56static int guest_x, guest_y;
Blue Swirl660f11b2009-07-31 21:16:51 +000057static SDL_Cursor *guest_sprite = NULL;
aliguori7b5d76d2009-03-13 15:02:13 +000058static uint8_t allocator;
Stefano Stabellinic18a2c32009-06-24 11:58:25 +010059static SDL_PixelFormat host_format;
60static int scaling_active = 0;
Anthony Liguori3af12c82010-03-10 09:42:58 -060061static Notifier mouse_mode_notifier;
bellard0f0b7262003-08-09 18:26:36 +000062
63static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
64{
bellard898712a2004-02-06 19:56:42 +000065 // printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
Stefano Stabellinic18a2c32009-06-24 11:58:25 +010066 SDL_Rect rec;
67 rec.x = x;
68 rec.y = y;
69 rec.w = w;
70 rec.h = h;
71
aliguori7b5d76d2009-03-13 15:02:13 +000072 if (guest_screen) {
Stefano Stabellinic18a2c32009-06-24 11:58:25 +010073 if (!scaling_active) {
74 SDL_BlitSurface(guest_screen, &rec, real_screen, &rec);
75 } else {
76 if (sdl_zoom_blit(guest_screen, real_screen, SMOOTHING_ON, &rec) < 0) {
77 fprintf(stderr, "Zoom blit failed\n");
78 exit(1);
79 }
80 }
81 }
82 SDL_UpdateRect(real_screen, rec.x, rec.y, rec.w, rec.h);
bellard0f0b7262003-08-09 18:26:36 +000083}
84
aliguori7d957bd2009-01-15 22:14:11 +000085static void sdl_setdata(DisplayState *ds)
86{
aliguori7d957bd2009-01-15 22:14:11 +000087 if (guest_screen != NULL) SDL_FreeSurface(guest_screen);
88
89 guest_screen = SDL_CreateRGBSurfaceFrom(ds_get_data(ds), ds_get_width(ds), ds_get_height(ds),
90 ds_get_bits_per_pixel(ds), ds_get_linesize(ds),
91 ds->surface->pf.rmask, ds->surface->pf.gmask,
92 ds->surface->pf.bmask, ds->surface->pf.amask);
93}
94
Jan Kiszka9510a482011-07-30 11:39:18 +020095static void do_sdl_resize(int width, int height, int bpp)
bellard0f0b7262003-08-09 18:26:36 +000096{
97 int flags;
98
99 // printf("resizing to %d %d\n", w, h);
100
Jan Kiszka91ada982011-07-30 11:39:05 +0200101 flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
102 if (gui_fullscreen) {
bellard8e9c4af2004-04-28 19:33:40 +0000103 flags |= SDL_FULLSCREEN;
Jan Kiszka91ada982011-07-30 11:39:05 +0200104 } else {
105 flags |= SDL_RESIZABLE;
106 }
ths43523e92007-02-18 18:19:32 +0000107 if (gui_noframe)
108 flags |= SDL_NOFRAME;
bellard9903da22005-10-30 23:19:10 +0000109
aliguori7b5d76d2009-03-13 15:02:13 +0000110 real_screen = SDL_SetVideoMode(width, height, bpp, flags);
aliguori7d957bd2009-01-15 22:14:11 +0000111 if (!real_screen) {
Bjørn Morkb6034a32010-03-08 13:07:14 +0100112 fprintf(stderr, "Could not open SDL display (%dx%dx%d): %s\n", width,
113 height, bpp, SDL_GetError());
bellard0f0b7262003-08-09 18:26:36 +0000114 exit(1);
115 }
aliguori7b5d76d2009-03-13 15:02:13 +0000116}
blueswir1749ecd92008-07-24 11:25:30 +0000117
aliguori7b5d76d2009-03-13 15:02:13 +0000118static void sdl_resize(DisplayState *ds)
119{
120 if (!allocator) {
Stefano Stabellinic18a2c32009-06-24 11:58:25 +0100121 if (!scaling_active)
122 do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
123 else if (real_screen->format->BitsPerPixel != ds_get_bits_per_pixel(ds))
124 do_sdl_resize(real_screen->w, real_screen->h, ds_get_bits_per_pixel(ds));
aliguori7b5d76d2009-03-13 15:02:13 +0000125 sdl_setdata(ds);
126 } else {
127 if (guest_screen != NULL) {
128 SDL_FreeSurface(guest_screen);
129 guest_screen = NULL;
130 }
131 }
132}
133
134static PixelFormat sdl_to_qemu_pixelformat(SDL_PixelFormat *sdl_pf)
135{
136 PixelFormat qemu_pf;
137
138 memset(&qemu_pf, 0x00, sizeof(PixelFormat));
139
140 qemu_pf.bits_per_pixel = sdl_pf->BitsPerPixel;
141 qemu_pf.bytes_per_pixel = sdl_pf->BytesPerPixel;
142 qemu_pf.depth = (qemu_pf.bits_per_pixel) == 32 ? 24 : (qemu_pf.bits_per_pixel);
143
144 qemu_pf.rmask = sdl_pf->Rmask;
145 qemu_pf.gmask = sdl_pf->Gmask;
146 qemu_pf.bmask = sdl_pf->Bmask;
147 qemu_pf.amask = sdl_pf->Amask;
148
149 qemu_pf.rshift = sdl_pf->Rshift;
150 qemu_pf.gshift = sdl_pf->Gshift;
151 qemu_pf.bshift = sdl_pf->Bshift;
152 qemu_pf.ashift = sdl_pf->Ashift;
153
154 qemu_pf.rbits = 8 - sdl_pf->Rloss;
155 qemu_pf.gbits = 8 - sdl_pf->Gloss;
156 qemu_pf.bbits = 8 - sdl_pf->Bloss;
157 qemu_pf.abits = 8 - sdl_pf->Aloss;
158
159 qemu_pf.rmax = ((1 << qemu_pf.rbits) - 1);
160 qemu_pf.gmax = ((1 << qemu_pf.gbits) - 1);
161 qemu_pf.bmax = ((1 << qemu_pf.bbits) - 1);
162 qemu_pf.amax = ((1 << qemu_pf.abits) - 1);
163
164 return qemu_pf;
165}
166
167static DisplaySurface* sdl_create_displaysurface(int width, int height)
168{
Anthony Liguori7267c092011-08-20 22:09:37 -0500169 DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface));
aliguori7b5d76d2009-03-13 15:02:13 +0000170
171 surface->width = width;
172 surface->height = height;
173
Jes Sorensenffe8b822011-03-16 13:33:30 +0100174 if (scaling_active) {
175 int linesize;
176 PixelFormat pf;
177 if (host_format.BytesPerPixel != 2 && host_format.BytesPerPixel != 4) {
178 linesize = width * 4;
179 pf = qemu_default_pixelformat(32);
180 } else {
181 linesize = width * host_format.BytesPerPixel;
182 pf = sdl_to_qemu_pixelformat(&host_format);
183 }
184 qemu_alloc_display(surface, width, height, linesize, pf, 0);
Stefano Stabellinic18a2c32009-06-24 11:58:25 +0100185 return surface;
186 }
187
188 if (host_format.BitsPerPixel == 16)
aliguori7b5d76d2009-03-13 15:02:13 +0000189 do_sdl_resize(width, height, 16);
190 else
191 do_sdl_resize(width, height, 32);
192
193 surface->pf = sdl_to_qemu_pixelformat(real_screen->format);
194 surface->linesize = real_screen->pitch;
195 surface->data = real_screen->pixels;
196
Juan Quintelae2542fe2009-07-27 16:13:06 +0200197#ifdef HOST_WORDS_BIGENDIAN
Stefano Stabellinic18a2c32009-06-24 11:58:25 +0100198 surface->flags = QEMU_REALPIXELS_FLAG | QEMU_BIG_ENDIAN_FLAG;
aliguori7b5d76d2009-03-13 15:02:13 +0000199#else
Stefano Stabellinic18a2c32009-06-24 11:58:25 +0100200 surface->flags = QEMU_REALPIXELS_FLAG;
aliguori7b5d76d2009-03-13 15:02:13 +0000201#endif
202 allocator = 1;
203
204 return surface;
205}
206
207static void sdl_free_displaysurface(DisplaySurface *surface)
208{
209 allocator = 0;
210 if (surface == NULL)
211 return;
Stefano Stabellinic18a2c32009-06-24 11:58:25 +0100212
213 if (surface->flags & QEMU_ALLOCATED_FLAG)
Anthony Liguori7267c092011-08-20 22:09:37 -0500214 g_free(surface->data);
215 g_free(surface);
aliguori7b5d76d2009-03-13 15:02:13 +0000216}
217
218static DisplaySurface* sdl_resize_displaysurface(DisplaySurface *surface, int width, int height)
219{
220 sdl_free_displaysurface(surface);
221 return sdl_create_displaysurface(width, height);
bellard0f0b7262003-08-09 18:26:36 +0000222}
223
bellard3d11d0e2004-12-12 16:56:30 +0000224/* generic keyboard conversion */
bellarde58d12e2004-07-05 22:13:07 +0000225
bellard3d11d0e2004-12-12 16:56:30 +0000226#include "sdl_keysym.h"
bellarde58d12e2004-07-05 22:13:07 +0000227
Anthony Liguoric227f092009-10-01 16:12:16 -0500228static kbd_layout_t *kbd_layout = NULL;
bellarde58d12e2004-07-05 22:13:07 +0000229
bellard3d11d0e2004-12-12 16:56:30 +0000230static uint8_t sdl_keyevent_to_keycode_generic(const SDL_KeyboardEvent *ev)
bellarde58d12e2004-07-05 22:13:07 +0000231{
bellard3d11d0e2004-12-12 16:56:30 +0000232 int keysym;
233 /* workaround for X11+SDL bug with AltGR */
234 keysym = ev->keysym.sym;
235 if (keysym == 0 && ev->keysym.scancode == 113)
236 keysym = SDLK_MODE;
bellard60659e32006-08-19 14:27:31 +0000237 /* For Japanese key '\' and '|' */
238 if (keysym == 92 && ev->keysym.scancode == 133) {
239 keysym = 0xa5;
240 }
Samuel Thibault44bb61c2010-02-28 21:03:00 +0100241 return keysym2scancode(kbd_layout, keysym) & SCANCODE_KEYMASK;
bellarde58d12e2004-07-05 22:13:07 +0000242}
243
bellard3d11d0e2004-12-12 16:56:30 +0000244/* specific keyboard conversions from scan codes */
245
246#if defined(_WIN32)
bellarde58d12e2004-07-05 22:13:07 +0000247
248static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
249{
250 return ev->keysym.scancode;
251}
252
253#else
254
aliguori5368a422009-03-03 17:37:21 +0000255#if defined(SDL_VIDEO_DRIVER_X11)
256#include <X11/XKBlib.h>
257
258static int check_for_evdev(void)
259{
260 SDL_SysWMinfo info;
Jan Kiszka229609d2009-06-27 09:59:40 +0200261 XkbDescPtr desc = NULL;
aliguori5368a422009-03-03 17:37:21 +0000262 int has_evdev = 0;
Jan Kiszka229609d2009-06-27 09:59:40 +0200263 char *keycodes = NULL;
aliguori5368a422009-03-03 17:37:21 +0000264
265 SDL_VERSION(&info.version);
Jan Kiszka229609d2009-06-27 09:59:40 +0200266 if (!SDL_GetWMInfo(&info)) {
aliguori5368a422009-03-03 17:37:21 +0000267 return 0;
Jan Kiszka229609d2009-06-27 09:59:40 +0200268 }
aliguori5368a422009-03-03 17:37:21 +0000269 desc = XkbGetKeyboard(info.info.x11.display,
270 XkbGBN_AllComponentsMask,
271 XkbUseCoreKbd);
Jan Kiszka229609d2009-06-27 09:59:40 +0200272 if (desc && desc->names) {
273 keycodes = XGetAtomName(info.info.x11.display, desc->names->keycodes);
274 if (keycodes == NULL) {
275 fprintf(stderr, "could not lookup keycode name\n");
276 } else if (strstart(keycodes, "evdev", NULL)) {
277 has_evdev = 1;
278 } else if (!strstart(keycodes, "xfree86", NULL)) {
279 fprintf(stderr, "unknown keycodes `%s', please report to "
280 "qemu-devel@nongnu.org\n", keycodes);
281 }
282 }
aliguori5368a422009-03-03 17:37:21 +0000283
Jan Kiszka229609d2009-06-27 09:59:40 +0200284 if (desc) {
285 XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True);
286 }
287 if (keycodes) {
288 XFree(keycodes);
289 }
aliguori5368a422009-03-03 17:37:21 +0000290 return has_evdev;
291}
292#else
293static int check_for_evdev(void)
294{
295 return 0;
296}
297#endif
298
bellarde58d12e2004-07-05 22:13:07 +0000299static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
300{
301 int keycode;
aliguori5368a422009-03-03 17:37:21 +0000302 static int has_evdev = -1;
303
304 if (has_evdev == -1)
305 has_evdev = check_for_evdev();
bellarde58d12e2004-07-05 22:13:07 +0000306
307 keycode = ev->keysym.scancode;
308
309 if (keycode < 9) {
310 keycode = 0;
311 } else if (keycode < 97) {
312 keycode -= 8; /* just an offset */
aliguori5368a422009-03-03 17:37:21 +0000313 } else if (keycode < 158) {
bellarde58d12e2004-07-05 22:13:07 +0000314 /* use conversion table */
aliguori5368a422009-03-03 17:37:21 +0000315 if (has_evdev)
316 keycode = translate_evdev_keycode(keycode - 97);
317 else
318 keycode = translate_xfree86_keycode(keycode - 97);
319 } else if (keycode == 208) { /* Hiragana_Katakana */
320 keycode = 0x70;
321 } else if (keycode == 211) { /* backslash */
322 keycode = 0x73;
bellarde58d12e2004-07-05 22:13:07 +0000323 } else {
324 keycode = 0;
325 }
326 return keycode;
327}
328
329#endif
330
bellard32ff25b2004-10-03 14:33:54 +0000331static void reset_keys(void)
332{
333 int i;
334 for(i = 0; i < 256; i++) {
335 if (modifiers_state[i]) {
Samuel Thibault44bb61c2010-02-28 21:03:00 +0100336 if (i & SCANCODE_GREY)
337 kbd_put_keycode(SCANCODE_EMUL0);
338 kbd_put_keycode(i | SCANCODE_UP);
bellard32ff25b2004-10-03 14:33:54 +0000339 modifiers_state[i] = 0;
340 }
341 }
342}
343
bellard0f0b7262003-08-09 18:26:36 +0000344static void sdl_process_key(SDL_KeyboardEvent *ev)
345{
bellard32ff25b2004-10-03 14:33:54 +0000346 int keycode, v;
bellardde2200d2004-06-04 13:15:06 +0000347
348 if (ev->keysym.sym == SDLK_PAUSE) {
349 /* specific case */
350 v = 0;
351 if (ev->type == SDL_KEYUP)
Samuel Thibault44bb61c2010-02-28 21:03:00 +0100352 v |= SCANCODE_UP;
bellardde2200d2004-06-04 13:15:06 +0000353 kbd_put_keycode(0xe1);
354 kbd_put_keycode(0x1d | v);
355 kbd_put_keycode(0x45 | v);
356 return;
357 }
358
bellard3d11d0e2004-12-12 16:56:30 +0000359 if (kbd_layout) {
360 keycode = sdl_keyevent_to_keycode_generic(ev);
361 } else {
362 keycode = sdl_keyevent_to_keycode(ev);
363 }
bellardde2200d2004-06-04 13:15:06 +0000364
365 switch(keycode) {
366 case 0x00:
367 /* sent when leaving window: reset the modifiers state */
bellard32ff25b2004-10-03 14:33:54 +0000368 reset_keys();
bellardde2200d2004-06-04 13:15:06 +0000369 return;
370 case 0x2a: /* Left Shift */
371 case 0x36: /* Right Shift */
372 case 0x1d: /* Left CTRL */
373 case 0x9d: /* Right CTRL */
374 case 0x38: /* Left ALT */
375 case 0xb8: /* Right ALT */
bellard0f0b7262003-08-09 18:26:36 +0000376 if (ev->type == SDL_KEYUP)
bellardde2200d2004-06-04 13:15:06 +0000377 modifiers_state[keycode] = 0;
378 else
379 modifiers_state[keycode] = 1;
380 break;
Stefan Weil4e79bcb2011-02-03 22:35:07 +0100381#define QEMU_SDL_VERSION ((SDL_MAJOR_VERSION << 8) + SDL_MINOR_VERSION)
382#if QEMU_SDL_VERSION < 0x102 || QEMU_SDL_VERSION == 0x102 && SDL_PATCHLEVEL < 14
383 /* SDL versions before 1.2.14 don't support key up for caps/num lock. */
bellardde2200d2004-06-04 13:15:06 +0000384 case 0x45: /* num lock */
385 case 0x3a: /* caps lock */
386 /* SDL does not send the key up event, so we generate it */
387 kbd_put_keycode(keycode);
Samuel Thibault44bb61c2010-02-28 21:03:00 +0100388 kbd_put_keycode(keycode | SCANCODE_UP);
bellardde2200d2004-06-04 13:15:06 +0000389 return;
Stefan Weil4e79bcb2011-02-03 22:35:07 +0100390#endif
bellard0f0b7262003-08-09 18:26:36 +0000391 }
bellardde2200d2004-06-04 13:15:06 +0000392
393 /* now send the key code */
Samuel Thibault44bb61c2010-02-28 21:03:00 +0100394 if (keycode & SCANCODE_GREY)
395 kbd_put_keycode(SCANCODE_EMUL0);
bellardde2200d2004-06-04 13:15:06 +0000396 if (ev->type == SDL_KEYUP)
Samuel Thibault44bb61c2010-02-28 21:03:00 +0100397 kbd_put_keycode(keycode | SCANCODE_UP);
bellardde2200d2004-06-04 13:15:06 +0000398 else
Samuel Thibault44bb61c2010-02-28 21:03:00 +0100399 kbd_put_keycode(keycode & SCANCODE_KEYCODEMASK);
bellard0f0b7262003-08-09 18:26:36 +0000400}
401
bellard8a7ddc32004-03-31 19:00:16 +0000402static void sdl_update_caption(void)
403{
Dominic Evansb4ed5d12009-09-24 12:13:56 +0100404 char win_title[1024];
405 char icon_title[1024];
thsc35734b2007-03-19 15:17:08 +0000406 const char *status = "";
407
Luiz Capitulino13548692011-07-29 15:36:43 -0300408 if (!runstate_is_running())
thsc35734b2007-03-19 15:17:08 +0000409 status = " [Stopped]";
ths3780e192007-06-21 21:08:02 +0000410 else if (gui_grab) {
Dustin Kirkland0ca9f8a2009-09-17 15:48:04 -0500411 if (alt_grab)
Anthony Liguori4e75b342010-03-01 08:47:28 -0600412 status = " - Press Ctrl-Alt-Shift to exit mouse grab";
Dustin Kirkland0ca9f8a2009-09-17 15:48:04 -0500413 else if (ctrl_grab)
Anthony Liguori4e75b342010-03-01 08:47:28 -0600414 status = " - Press Right-Ctrl to exit mouse grab";
Dustin Kirkland0ca9f8a2009-09-17 15:48:04 -0500415 else
Anthony Liguori4e75b342010-03-01 08:47:28 -0600416 status = " - Press Ctrl-Alt to exit mouse grab";
ths3780e192007-06-21 21:08:02 +0000417 }
thsc35734b2007-03-19 15:17:08 +0000418
Dominic Evansb4ed5d12009-09-24 12:13:56 +0100419 if (qemu_name) {
420 snprintf(win_title, sizeof(win_title), "QEMU (%s)%s", qemu_name, status);
421 snprintf(icon_title, sizeof(icon_title), "QEMU (%s)", qemu_name);
422 } else {
423 snprintf(win_title, sizeof(win_title), "QEMU%s", status);
424 snprintf(icon_title, sizeof(icon_title), "QEMU");
425 }
thsc35734b2007-03-19 15:17:08 +0000426
Dominic Evansb4ed5d12009-09-24 12:13:56 +0100427 SDL_WM_SetCaption(win_title, icon_title);
bellard8a7ddc32004-03-31 19:00:16 +0000428}
429
bellard09b26c52006-04-12 21:09:08 +0000430static void sdl_hide_cursor(void)
431{
balrog9467cd42007-05-01 01:34:14 +0000432 if (!cursor_hide)
433 return;
434
bellard8785a8d2006-06-13 10:49:12 +0000435 if (kbd_mouse_is_absolute()) {
436 SDL_ShowCursor(1);
437 SDL_SetCursor(sdl_cursor_hidden);
438 } else {
439 SDL_ShowCursor(0);
440 }
bellard09b26c52006-04-12 21:09:08 +0000441}
442
443static void sdl_show_cursor(void)
444{
balrog9467cd42007-05-01 01:34:14 +0000445 if (!cursor_hide)
446 return;
447
Jan Kiszka74d9dc62011-07-30 11:39:14 +0200448 if (!kbd_mouse_is_absolute() || !is_graphic_console()) {
bellard8785a8d2006-06-13 10:49:12 +0000449 SDL_ShowCursor(1);
thsd34cab92007-04-02 01:10:46 +0000450 if (guest_cursor &&
451 (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
452 SDL_SetCursor(guest_sprite);
453 else
454 SDL_SetCursor(sdl_cursor_normal);
bellard09b26c52006-04-12 21:09:08 +0000455 }
456}
457
bellard0f0b7262003-08-09 18:26:36 +0000458static void sdl_grab_start(void)
459{
Jan Kiszka85f94f82012-01-31 13:45:28 +0100460 /*
461 * If the application is not active, do not try to enter grab state. This
462 * prevents 'SDL_WM_GrabInput(SDL_GRAB_ON)' from blocking all the
463 * application (SDL bug).
464 */
465 if (!(SDL_GetAppState() & SDL_APPINPUTFOCUS)) {
466 return;
467 }
thsd34cab92007-04-02 01:10:46 +0000468 if (guest_cursor) {
469 SDL_SetCursor(guest_sprite);
balrog08a2d4c2009-01-29 23:29:52 +0000470 if (!kbd_mouse_is_absolute() && !absolute_enabled)
471 SDL_WarpMouse(guest_x, guest_y);
thsd34cab92007-04-02 01:10:46 +0000472 } else
473 sdl_hide_cursor();
Jan Kiszkaeaa2e022012-01-31 13:45:29 +0100474 SDL_WM_GrabInput(SDL_GRAB_ON);
475 gui_grab = 1;
476 sdl_update_caption();
bellard0f0b7262003-08-09 18:26:36 +0000477}
478
479static void sdl_grab_end(void)
480{
bellard0f0b7262003-08-09 18:26:36 +0000481 SDL_WM_GrabInput(SDL_GRAB_OFF);
bellard0f0b7262003-08-09 18:26:36 +0000482 gui_grab = 0;
thsd34cab92007-04-02 01:10:46 +0000483 sdl_show_cursor();
bellard8a7ddc32004-03-31 19:00:16 +0000484 sdl_update_caption();
bellard0f0b7262003-08-09 18:26:36 +0000485}
486
Jan Kiszka66596352012-01-31 13:45:27 +0100487static void absolute_mouse_grab(void)
488{
489 int mouse_x, mouse_y;
490
Jan Kiszka85f94f82012-01-31 13:45:28 +0100491 SDL_GetMouseState(&mouse_x, &mouse_y);
492 if (mouse_x > 0 && mouse_x < real_screen->w - 1 &&
493 mouse_y > 0 && mouse_y < real_screen->h - 1) {
494 sdl_grab_start();
Jan Kiszka66596352012-01-31 13:45:27 +0100495 }
496}
497
Jan Kiszka9e8dd452011-06-20 14:06:26 +0200498static void sdl_mouse_mode_change(Notifier *notify, void *data)
Anthony Liguori3af12c82010-03-10 09:42:58 -0600499{
500 if (kbd_mouse_is_absolute()) {
501 if (!absolute_enabled) {
Anthony Liguori3af12c82010-03-10 09:42:58 -0600502 absolute_enabled = 1;
Jan Kiszka66596352012-01-31 13:45:27 +0100503 if (is_graphic_console()) {
504 absolute_mouse_grab();
505 }
Anthony Liguori3af12c82010-03-10 09:42:58 -0600506 }
507 } else if (absolute_enabled) {
Jan Kiszkaf8b8d632011-08-22 18:42:42 +0200508 if (!gui_fullscreen) {
509 sdl_grab_end();
510 }
Jan Kiszka35b0f232011-07-30 11:39:15 +0200511 absolute_enabled = 0;
Anthony Liguori3af12c82010-03-10 09:42:58 -0600512 }
513}
514
aurel324c44bdc2008-03-13 19:20:18 +0000515static void sdl_send_mouse_event(int dx, int dy, int dz, int x, int y, int state)
bellard0f0b7262003-08-09 18:26:36 +0000516{
Jan Kiszka9510a482011-07-30 11:39:18 +0200517 int buttons = 0;
518
519 if (state & SDL_BUTTON(SDL_BUTTON_LEFT)) {
bellard0f0b7262003-08-09 18:26:36 +0000520 buttons |= MOUSE_EVENT_LBUTTON;
Jan Kiszka9510a482011-07-30 11:39:18 +0200521 }
522 if (state & SDL_BUTTON(SDL_BUTTON_RIGHT)) {
bellard0f0b7262003-08-09 18:26:36 +0000523 buttons |= MOUSE_EVENT_RBUTTON;
Jan Kiszka9510a482011-07-30 11:39:18 +0200524 }
525 if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE)) {
bellard0f0b7262003-08-09 18:26:36 +0000526 buttons |= MOUSE_EVENT_MBUTTON;
Jan Kiszka9510a482011-07-30 11:39:18 +0200527 }
bellard09b26c52006-04-12 21:09:08 +0000528
529 if (kbd_mouse_is_absolute()) {
Jan Kiszka9510a482011-07-30 11:39:18 +0200530 dx = x * 0x7FFF / (real_screen->w - 1);
531 dy = y * 0x7FFF / (real_screen->h - 1);
thsd34cab92007-04-02 01:10:46 +0000532 } else if (guest_cursor) {
aurel324c44bdc2008-03-13 19:20:18 +0000533 x -= guest_x;
534 y -= guest_y;
535 guest_x += x;
536 guest_y += y;
537 dx = x;
538 dy = y;
bellard09b26c52006-04-12 21:09:08 +0000539 }
540
bellard0f0b7262003-08-09 18:26:36 +0000541 kbd_mouse_event(dx, dy, dz, buttons);
542}
543
Jan Kiszkaf9977892011-07-30 11:39:09 +0200544static void sdl_scale(DisplayState *ds, int width, int height)
545{
546 int bpp = real_screen->format->BitsPerPixel;
547
548 if (bpp != 16 && bpp != 32) {
549 bpp = 32;
550 }
551 do_sdl_resize(width, height, bpp);
552 scaling_active = 1;
553 if (!is_buffer_shared(ds->surface)) {
554 ds->surface = qemu_resize_displaysurface(ds, ds_get_width(ds),
555 ds_get_height(ds));
556 dpy_resize(ds);
557 }
558}
559
bellard8e9c4af2004-04-28 19:33:40 +0000560static void toggle_full_screen(DisplayState *ds)
561{
562 gui_fullscreen = !gui_fullscreen;
bellard8e9c4af2004-04-28 19:33:40 +0000563 if (gui_fullscreen) {
Jan Kiszkaf9977892011-07-30 11:39:09 +0200564 gui_saved_width = real_screen->w;
565 gui_saved_height = real_screen->h;
566 gui_saved_scaling = scaling_active;
567
568 do_sdl_resize(ds_get_width(ds), ds_get_height(ds),
569 ds_get_bits_per_pixel(ds));
Stefano Stabellinic18a2c32009-06-24 11:58:25 +0100570 scaling_active = 0;
Jan Kiszkaf9977892011-07-30 11:39:09 +0200571
bellard8e9c4af2004-04-28 19:33:40 +0000572 gui_saved_grab = gui_grab;
573 sdl_grab_start();
574 } else {
Jan Kiszkaf9977892011-07-30 11:39:09 +0200575 if (gui_saved_scaling) {
576 sdl_scale(ds, gui_saved_width, gui_saved_height);
577 } else {
578 do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
579 }
Jan Kiszkaf8558102011-07-30 11:39:12 +0200580 if (!gui_saved_grab || !is_graphic_console()) {
bellard8e9c4af2004-04-28 19:33:40 +0000581 sdl_grab_end();
Jan Kiszkaf8558102011-07-30 11:39:12 +0200582 }
bellard8e9c4af2004-04-28 19:33:40 +0000583 }
pbrook95219892006-04-09 01:06:34 +0000584 vga_hw_invalidate();
585 vga_hw_update();
bellard8e9c4af2004-04-28 19:33:40 +0000586}
587
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200588static void handle_keydown(DisplayState *ds, SDL_Event *ev)
589{
590 int mod_state;
591 int keycode;
592
593 if (alt_grab) {
594 mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
595 (gui_grab_code | KMOD_LSHIFT);
596 } else if (ctrl_grab) {
597 mod_state = (SDL_GetModState() & KMOD_RCTRL) == KMOD_RCTRL;
598 } else {
599 mod_state = (SDL_GetModState() & gui_grab_code) == gui_grab_code;
600 }
601 gui_key_modifier_pressed = mod_state;
602
603 if (gui_key_modifier_pressed) {
604 keycode = sdl_keyevent_to_keycode(&ev->key);
605 switch (keycode) {
606 case 0x21: /* 'f' key on US keyboard */
607 toggle_full_screen(ds);
608 gui_keysym = 1;
609 break;
610 case 0x16: /* 'u' key on US keyboard */
611 if (scaling_active) {
612 scaling_active = 0;
613 sdl_resize(ds);
614 vga_hw_invalidate();
615 vga_hw_update();
616 }
617 gui_keysym = 1;
618 break;
619 case 0x02 ... 0x0a: /* '1' to '9' keys */
620 /* Reset the modifiers sent to the current console */
621 reset_keys();
622 console_select(keycode - 0x02);
623 gui_keysym = 1;
624 if (gui_fullscreen) {
625 break;
626 }
627 if (!is_graphic_console()) {
628 /* release grab if going to a text console */
629 if (gui_grab) {
630 sdl_grab_end();
631 } else if (absolute_enabled) {
632 sdl_show_cursor();
633 }
634 } else if (absolute_enabled) {
635 sdl_hide_cursor();
636 absolute_mouse_grab();
637 }
638 break;
639 case 0x1b: /* '+' */
640 case 0x35: /* '-' */
641 if (!gui_fullscreen) {
642 int width = MAX(real_screen->w + (keycode == 0x1b ? 50 : -50),
643 160);
644 int height = (ds_get_height(ds) * width) / ds_get_width(ds);
645
646 sdl_scale(ds, width, height);
647 vga_hw_invalidate();
648 vga_hw_update();
649 gui_keysym = 1;
650 }
651 default:
652 break;
653 }
654 } else if (!is_graphic_console()) {
655 int keysym = 0;
656
657 if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
658 switch (ev->key.keysym.sym) {
659 case SDLK_UP:
660 keysym = QEMU_KEY_CTRL_UP;
661 break;
662 case SDLK_DOWN:
663 keysym = QEMU_KEY_CTRL_DOWN;
664 break;
665 case SDLK_LEFT:
666 keysym = QEMU_KEY_CTRL_LEFT;
667 break;
668 case SDLK_RIGHT:
669 keysym = QEMU_KEY_CTRL_RIGHT;
670 break;
671 case SDLK_HOME:
672 keysym = QEMU_KEY_CTRL_HOME;
673 break;
674 case SDLK_END:
675 keysym = QEMU_KEY_CTRL_END;
676 break;
677 case SDLK_PAGEUP:
678 keysym = QEMU_KEY_CTRL_PAGEUP;
679 break;
680 case SDLK_PAGEDOWN:
681 keysym = QEMU_KEY_CTRL_PAGEDOWN;
682 break;
683 default:
684 break;
685 }
686 } else {
687 switch (ev->key.keysym.sym) {
688 case SDLK_UP:
689 keysym = QEMU_KEY_UP;
690 break;
691 case SDLK_DOWN:
692 keysym = QEMU_KEY_DOWN;
693 break;
694 case SDLK_LEFT:
695 keysym = QEMU_KEY_LEFT;
696 break;
697 case SDLK_RIGHT:
698 keysym = QEMU_KEY_RIGHT;
699 break;
700 case SDLK_HOME:
701 keysym = QEMU_KEY_HOME;
702 break;
703 case SDLK_END:
704 keysym = QEMU_KEY_END;
705 break;
706 case SDLK_PAGEUP:
707 keysym = QEMU_KEY_PAGEUP;
708 break;
709 case SDLK_PAGEDOWN:
710 keysym = QEMU_KEY_PAGEDOWN;
711 break;
712 case SDLK_BACKSPACE:
713 keysym = QEMU_KEY_BACKSPACE;
714 break;
715 case SDLK_DELETE:
716 keysym = QEMU_KEY_DELETE;
717 break;
718 default:
719 break;
720 }
721 }
722 if (keysym) {
723 kbd_put_keysym(keysym);
724 } else if (ev->key.keysym.unicode != 0) {
725 kbd_put_keysym(ev->key.keysym.unicode);
726 }
727 }
728 if (is_graphic_console() && !gui_keysym) {
729 sdl_process_key(&ev->key);
730 }
731}
732
733static void handle_keyup(DisplayState *ds, SDL_Event *ev)
734{
735 int mod_state;
736
737 if (!alt_grab) {
738 mod_state = (ev->key.keysym.mod & gui_grab_code);
739 } else {
740 mod_state = (ev->key.keysym.mod & (gui_grab_code | KMOD_LSHIFT));
741 }
742 if (!mod_state && gui_key_modifier_pressed) {
743 gui_key_modifier_pressed = 0;
744 if (gui_keysym == 0) {
745 /* exit/enter grab if pressing Ctrl-Alt */
746 if (!gui_grab) {
Jan Kiszka85f94f82012-01-31 13:45:28 +0100747 if (is_graphic_console()) {
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200748 sdl_grab_start();
749 }
750 } else if (!gui_fullscreen) {
751 sdl_grab_end();
752 }
753 /* SDL does not send back all the modifiers key, so we must
754 * correct it. */
755 reset_keys();
756 return;
757 }
758 gui_keysym = 0;
759 }
760 if (is_graphic_console() && !gui_keysym) {
761 sdl_process_key(&ev->key);
762 }
763}
764
765static void handle_mousemotion(DisplayState *ds, SDL_Event *ev)
766{
767 int max_x, max_y;
768
769 if (is_graphic_console() &&
770 (kbd_mouse_is_absolute() || absolute_enabled)) {
771 max_x = real_screen->w - 1;
772 max_y = real_screen->h - 1;
773 if (gui_grab && (ev->motion.x == 0 || ev->motion.y == 0 ||
774 ev->motion.x == max_x || ev->motion.y == max_y)) {
775 sdl_grab_end();
776 }
Jan Kiszka85f94f82012-01-31 13:45:28 +0100777 if (!gui_grab &&
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200778 (ev->motion.x > 0 && ev->motion.x < max_x &&
779 ev->motion.y > 0 && ev->motion.y < max_y)) {
780 sdl_grab_start();
781 }
782 }
783 if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
784 sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,
785 ev->motion.x, ev->motion.y, ev->motion.state);
786 }
787}
788
789static void handle_mousebutton(DisplayState *ds, SDL_Event *ev)
790{
791 int buttonstate = SDL_GetMouseState(NULL, NULL);
792 SDL_MouseButtonEvent *bev;
793 int dz;
794
795 if (!is_graphic_console()) {
796 return;
797 }
798
799 bev = &ev->button;
800 if (!gui_grab && !kbd_mouse_is_absolute()) {
Jan Kiszka822f98d2012-01-31 13:45:30 +0100801 if (ev->type == SDL_MOUSEBUTTONUP && bev->button == SDL_BUTTON_LEFT) {
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200802 /* start grabbing all events */
803 sdl_grab_start();
804 }
805 } else {
806 dz = 0;
807 if (ev->type == SDL_MOUSEBUTTONDOWN) {
808 buttonstate |= SDL_BUTTON(bev->button);
809 } else {
810 buttonstate &= ~SDL_BUTTON(bev->button);
811 }
812#ifdef SDL_BUTTON_WHEELUP
813 if (bev->button == SDL_BUTTON_WHEELUP &&
814 ev->type == SDL_MOUSEBUTTONDOWN) {
815 dz = -1;
816 } else if (bev->button == SDL_BUTTON_WHEELDOWN &&
817 ev->type == SDL_MOUSEBUTTONDOWN) {
818 dz = 1;
819 }
820#endif
821 sdl_send_mouse_event(0, 0, dz, bev->x, bev->y, buttonstate);
822 }
823}
824
825static void handle_activation(DisplayState *ds, SDL_Event *ev)
826{
Jan Kiszka02df4d62012-01-31 13:45:31 +0100827#ifdef _WIN32
828 /* Disable grab if the window no longer has the focus
829 * (Windows-only workaround) */
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200830 if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
831 !ev->active.gain && !gui_fullscreen) {
832 sdl_grab_end();
833 }
Jan Kiszka02df4d62012-01-31 13:45:31 +0100834#endif
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200835 if (!gui_grab && ev->active.gain && is_graphic_console() &&
836 (kbd_mouse_is_absolute() || absolute_enabled)) {
837 absolute_mouse_grab();
838 }
839 if (ev->active.state & SDL_APPACTIVE) {
840 if (ev->active.gain) {
841 /* Back to default interval */
842 dcl->gui_timer_interval = 0;
843 dcl->idle = 0;
844 } else {
845 /* Sleeping interval */
846 dcl->gui_timer_interval = 500;
847 dcl->idle = 1;
848 }
849 }
850}
851
bellard0f0b7262003-08-09 18:26:36 +0000852static void sdl_refresh(DisplayState *ds)
853{
854 SDL_Event ev1, *ev = &ev1;
ths3b46e622007-09-17 08:09:54 +0000855
Luiz Capitulino13548692011-07-29 15:36:43 -0300856 if (last_vm_running != runstate_is_running()) {
857 last_vm_running = runstate_is_running();
bellard8a7ddc32004-03-31 19:00:16 +0000858 sdl_update_caption();
859 }
860
pbrook95219892006-04-09 01:06:34 +0000861 vga_hw_update();
aurel323bee8bd2008-04-13 16:08:37 +0000862 SDL_EnableUNICODE(!is_graphic_console());
bellard457831f2004-07-14 17:22:33 +0000863
bellard0f0b7262003-08-09 18:26:36 +0000864 while (SDL_PollEvent(ev)) {
865 switch (ev->type) {
866 case SDL_VIDEOEXPOSE:
aliguori7d957bd2009-01-15 22:14:11 +0000867 sdl_update(ds, 0, 0, real_screen->w, real_screen->h);
bellard0f0b7262003-08-09 18:26:36 +0000868 break;
869 case SDL_KEYDOWN:
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200870 handle_keydown(ds, ev);
871 break;
bellard0f0b7262003-08-09 18:26:36 +0000872 case SDL_KEYUP:
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200873 handle_keyup(ds, ev);
bellard0f0b7262003-08-09 18:26:36 +0000874 break;
875 case SDL_QUIT:
Jan Kiszka941f5112011-07-30 11:39:04 +0200876 if (!no_quit) {
877 no_shutdown = 0;
balrog731345e2007-06-21 17:56:50 +0000878 qemu_system_shutdown_request();
Jan Kiszka941f5112011-07-30 11:39:04 +0200879 }
bellard0f0b7262003-08-09 18:26:36 +0000880 break;
881 case SDL_MOUSEMOTION:
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200882 handle_mousemotion(ds, ev);
bellard0f0b7262003-08-09 18:26:36 +0000883 break;
884 case SDL_MOUSEBUTTONDOWN:
885 case SDL_MOUSEBUTTONUP:
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200886 handle_mousebutton(ds, ev);
bellard0f0b7262003-08-09 18:26:36 +0000887 break;
bellard0294ffb2004-04-29 22:15:15 +0000888 case SDL_ACTIVEEVENT:
Jan Kiszka1ae1caf2011-07-30 11:39:17 +0200889 handle_activation(ds, ev);
bellard0294ffb2004-04-29 22:15:15 +0000890 break;
Jan Kiszkaf9977892011-07-30 11:39:09 +0200891 case SDL_VIDEORESIZE:
892 sdl_scale(ds, ev->resize.w, ev->resize.h);
Stefano Stabellinic18a2c32009-06-24 11:58:25 +0100893 vga_hw_invalidate();
894 vga_hw_update();
895 break;
bellard0f0b7262003-08-09 18:26:36 +0000896 default:
897 break;
898 }
899 }
900}
901
thsd34cab92007-04-02 01:10:46 +0000902static void sdl_fill(DisplayState *ds, int x, int y, int w, int h, uint32_t c)
903{
904 SDL_Rect dst = { x, y, w, h };
aliguori7d957bd2009-01-15 22:14:11 +0000905 SDL_FillRect(real_screen, &dst, c);
thsd34cab92007-04-02 01:10:46 +0000906}
907
908static void sdl_mouse_warp(int x, int y, int on)
909{
910 if (on) {
911 if (!guest_cursor)
912 sdl_show_cursor();
913 if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
914 SDL_SetCursor(guest_sprite);
balrog08a2d4c2009-01-29 23:29:52 +0000915 if (!kbd_mouse_is_absolute() && !absolute_enabled)
916 SDL_WarpMouse(x, y);
thsd34cab92007-04-02 01:10:46 +0000917 }
918 } else if (gui_grab)
919 sdl_hide_cursor();
920 guest_cursor = on;
921 guest_x = x, guest_y = y;
922}
923
Gerd Hoffmannfbe6d7a2010-05-21 11:54:33 +0200924static void sdl_mouse_define(QEMUCursor *c)
thsd34cab92007-04-02 01:10:46 +0000925{
Gerd Hoffmannfbe6d7a2010-05-21 11:54:33 +0200926 uint8_t *image, *mask;
927 int bpl;
928
thsd34cab92007-04-02 01:10:46 +0000929 if (guest_sprite)
930 SDL_FreeCursor(guest_sprite);
931
Gerd Hoffmannfbe6d7a2010-05-21 11:54:33 +0200932 bpl = cursor_get_mono_bpl(c);
Anthony Liguori7267c092011-08-20 22:09:37 -0500933 image = g_malloc0(bpl * c->height);
934 mask = g_malloc0(bpl * c->height);
Gerd Hoffmannfbe6d7a2010-05-21 11:54:33 +0200935 cursor_get_mono_image(c, 0x000000, image);
936 cursor_get_mono_mask(c, 0, mask);
937 guest_sprite = SDL_CreateCursor(image, mask, c->width, c->height,
938 c->hot_x, c->hot_y);
Anthony Liguori7267c092011-08-20 22:09:37 -0500939 g_free(image);
940 g_free(mask);
thsd34cab92007-04-02 01:10:46 +0000941
942 if (guest_cursor &&
943 (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
944 SDL_SetCursor(guest_sprite);
945}
946
Anthony Liguori28695482010-03-21 14:13:02 -0500947static void sdl_cleanup(void)
bellard898712a2004-02-06 19:56:42 +0000948{
thsd34cab92007-04-02 01:10:46 +0000949 if (guest_sprite)
950 SDL_FreeCursor(guest_sprite);
malcd8ee7662009-05-17 18:26:05 +0400951 SDL_QuitSubSystem(SDL_INIT_VIDEO);
bellard898712a2004-02-06 19:56:42 +0000952}
953
ths43523e92007-02-18 18:19:32 +0000954void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
bellard0f0b7262003-08-09 18:26:36 +0000955{
956 int flags;
bellard09b26c52006-04-12 21:09:08 +0000957 uint8_t data = 0;
aliguori7b5d76d2009-03-13 15:02:13 +0000958 DisplayAllocator *da;
959 const SDL_VideoInfo *vi;
Stefan Weil09cec712011-02-16 21:15:40 +0100960 char *filename;
bellard0f0b7262003-08-09 18:26:36 +0000961
bellard3d11d0e2004-12-12 16:56:30 +0000962#if defined(__APPLE__)
963 /* always use generic keymaps */
964 if (!keyboard_layout)
965 keyboard_layout = "en-us";
966#endif
967 if(keyboard_layout) {
aliguori04837552009-03-06 20:27:10 +0000968 kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
bellard3d11d0e2004-12-12 16:56:30 +0000969 if (!kbd_layout)
970 exit(1);
971 }
972
ths43523e92007-02-18 18:19:32 +0000973 if (no_frame)
974 gui_noframe = 1;
975
Jan Kiszka111f8ec2010-05-23 10:29:34 +0200976 if (!full_screen) {
977 setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", 0);
978 }
Michael Tokarev1de97562011-05-08 01:18:30 +0400979#ifdef __linux__
980 /* on Linux, SDL may use fbcon|directfb|svgalib when run without
981 * accessible $DISPLAY to open X11 window. This is often the case
982 * when qemu is run using sudo. But in this case, and when actually
983 * run in X11 environment, SDL fights with X11 for the video card,
984 * making current display unavailable, often until reboot.
985 * So make x11 the default SDL video driver if this variable is unset.
986 * This is a bit hackish but saves us from bigger problem.
987 * Maybe it's a good idea to fix this in SDL instead.
988 */
989 setenv("SDL_VIDEODRIVER", "x11", 0);
990#endif
Jan Kiszka111f8ec2010-05-23 10:29:34 +0200991
Stefan Weil4e79bcb2011-02-03 22:35:07 +0100992 /* Enable normal up/down events for Caps-Lock and Num-Lock keys.
993 * This requires SDL >= 1.2.14. */
994 setenv("SDL_DISABLE_LOCK_KEYS", "1", 1);
995
bellard0f0b7262003-08-09 18:26:36 +0000996 flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
997 if (SDL_Init (flags)) {
malc3caf2562009-12-30 04:26:34 +0300998 fprintf(stderr, "Could not initialize SDL(%s) - exiting\n",
999 SDL_GetError());
bellard0f0b7262003-08-09 18:26:36 +00001000 exit(1);
1001 }
aliguori7b5d76d2009-03-13 15:02:13 +00001002 vi = SDL_GetVideoInfo();
Stefano Stabellinic18a2c32009-06-24 11:58:25 +01001003 host_format = *(vi->vfmt);
bellard0ae04d72003-09-30 21:09:16 +00001004
Stefan Weil09cec712011-02-16 21:15:40 +01001005 /* Load a 32x32x4 image. White pixels are transparent. */
1006 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu-icon.bmp");
1007 if (filename) {
1008 SDL_Surface *image = SDL_LoadBMP(filename);
1009 if (image) {
1010 uint32_t colorkey = SDL_MapRGB(image->format, 255, 255, 255);
1011 SDL_SetColorKey(image, SDL_SRCCOLORKEY, colorkey);
1012 SDL_WM_SetIcon(image, NULL);
1013 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001014 g_free(filename);
Stefan Weil09cec712011-02-16 21:15:40 +01001015 }
1016
Jan Kiszka110defd2011-07-30 11:39:11 +02001017 if (full_screen) {
1018 gui_fullscreen = 1;
1019 sdl_grab_start();
1020 }
1021
Anthony Liguori7267c092011-08-20 22:09:37 -05001022 dcl = g_malloc0(sizeof(DisplayChangeListener));
aliguori7d957bd2009-01-15 22:14:11 +00001023 dcl->dpy_update = sdl_update;
1024 dcl->dpy_resize = sdl_resize;
1025 dcl->dpy_refresh = sdl_refresh;
1026 dcl->dpy_setdata = sdl_setdata;
1027 dcl->dpy_fill = sdl_fill;
thsd34cab92007-04-02 01:10:46 +00001028 ds->mouse_set = sdl_mouse_warp;
1029 ds->cursor_define = sdl_mouse_define;
aliguori7d957bd2009-01-15 22:14:11 +00001030 register_displaychangelistener(ds, dcl);
bellard0f0b7262003-08-09 18:26:36 +00001031
Anthony Liguori7267c092011-08-20 22:09:37 -05001032 da = g_malloc0(sizeof(DisplayAllocator));
aliguori7b5d76d2009-03-13 15:02:13 +00001033 da->create_displaysurface = sdl_create_displaysurface;
1034 da->resize_displaysurface = sdl_resize_displaysurface;
1035 da->free_displaysurface = sdl_free_displaysurface;
1036 if (register_displayallocator(ds, da) == da) {
aliguori7b5d76d2009-03-13 15:02:13 +00001037 dpy_resize(ds);
1038 }
1039
Anthony Liguori3af12c82010-03-10 09:42:58 -06001040 mouse_mode_notifier.notify = sdl_mouse_mode_change;
1041 qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier);
1042
bellard8a7ddc32004-03-31 19:00:16 +00001043 sdl_update_caption();
bellard0f0b7262003-08-09 18:26:36 +00001044 SDL_EnableKeyRepeat(250, 50);
1045 gui_grab = 0;
bellard898712a2004-02-06 19:56:42 +00001046
bellard09b26c52006-04-12 21:09:08 +00001047 sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
1048 sdl_cursor_normal = SDL_GetCursor();
1049
Anthony Liguori28695482010-03-21 14:13:02 -05001050 atexit(sdl_cleanup);
bellard0f0b7262003-08-09 18:26:36 +00001051}