2 * QEMU SDL display driver
4 * Copyright (c) 2003 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 /* Avoid compiler warning because macro is redefined in SDL_syswm.h. */
26 #undef WIN32_LEAN_AND_MEAN
28 #include "qemu/osdep.h"
30 #include <SDL_syswm.h>
32 #include "qemu-common.h"
33 #include "qemu/cutils.h"
34 #include "ui/console.h"
36 #include "sysemu/sysemu.h"
40 static DisplayChangeListener *dcl;
41 static DisplaySurface *surface;
42 static SDL_Surface *real_screen;
43 static SDL_Surface *guest_screen = NULL;
44 static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
45 static int last_vm_running;
46 static bool gui_saved_scaling;
47 static int gui_saved_width;
48 static int gui_saved_height;
49 static int gui_saved_grab;
50 static int gui_fullscreen;
51 static int gui_noframe;
52 static int gui_key_modifier_pressed;
53 static int gui_keysym;
54 static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
55 static uint8_t modifiers_state[256];
56 static SDL_Cursor *sdl_cursor_normal;
57 static SDL_Cursor *sdl_cursor_hidden;
58 static int absolute_enabled = 0;
59 static int guest_cursor = 0;
60 static int guest_x, guest_y;
61 static SDL_Cursor *guest_sprite = NULL;
62 static SDL_PixelFormat host_format;
63 static int scaling_active = 0;
64 static Notifier mouse_mode_notifier;
65 static int idle_counter;
67 #define SDL_REFRESH_INTERVAL_BUSY 10
68 #define SDL_MAX_IDLE_COUNT (2 * GUI_REFRESH_INTERVAL_DEFAULT \
69 / SDL_REFRESH_INTERVAL_BUSY + 1)
75 static void sdl_update(DisplayChangeListener *dcl,
76 int x, int y, int w, int h)
85 printf("SDL: Updating x=%d y=%d w=%d h=%d (scaling: %d)\n",
86 x, y, w, h, scaling_active);
90 if (!scaling_active) {
91 SDL_BlitSurface(guest_screen, &rec, real_screen, &rec);
93 if (sdl_zoom_blit(guest_screen, real_screen, SMOOTHING_ON, &rec) < 0) {
94 fprintf(stderr, "Zoom blit failed\n");
99 SDL_UpdateRect(real_screen, rec.x, rec.y, rec.w, rec.h);
102 static void do_sdl_resize(int width, int height, int bpp)
105 SDL_Surface *tmp_screen;
108 printf("SDL: Resizing to %dx%d bpp %d\n", width, height, bpp);
111 flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
112 if (gui_fullscreen) {
113 flags |= SDL_FULLSCREEN;
115 flags |= SDL_RESIZABLE;
118 flags |= SDL_NOFRAME;
120 tmp_screen = SDL_SetVideoMode(width, height, bpp, flags);
123 fprintf(stderr, "Could not open SDL display (%dx%dx%d): %s\n",
124 width, height, bpp, SDL_GetError());
129 * Revert to the previous video mode if the change of resizing or
133 fprintf(stderr, "Failed to set SDL display (%dx%dx%d): %s\n",
134 width, height, bpp, SDL_GetError());
139 real_screen = tmp_screen;
142 static void sdl_switch(DisplayChangeListener *dcl,
143 DisplaySurface *new_surface)
147 /* temporary hack: allows to call sdl_switch to handle scaling changes */
149 surface = new_surface;
151 pf = qemu_pixelformat_from_pixman(surface->format);
153 if (!scaling_active) {
154 do_sdl_resize(surface_width(surface), surface_height(surface), 0);
155 } else if (real_screen->format->BitsPerPixel !=
156 surface_bits_per_pixel(surface)) {
157 do_sdl_resize(real_screen->w, real_screen->h,
158 surface_bits_per_pixel(surface));
161 if (guest_screen != NULL) {
162 SDL_FreeSurface(guest_screen);
166 printf("SDL: Creating surface with masks: %08x %08x %08x %08x\n",
167 pf.rmask, pf.gmask, pf.bmask, pf.amask);
170 guest_screen = SDL_CreateRGBSurfaceFrom
171 (surface_data(surface),
172 surface_width(surface), surface_height(surface),
173 surface_bits_per_pixel(surface), surface_stride(surface),
178 static bool sdl_check_format(DisplayChangeListener *dcl,
179 pixman_format_code_t format)
182 * We let SDL convert for us a few more formats than,
183 * the native ones. Thes are the ones I have tested.
185 return (format == PIXMAN_x8r8g8b8 ||
186 format == PIXMAN_b8g8r8x8 ||
187 format == PIXMAN_x1r5g5b5 ||
188 format == PIXMAN_r5g6b5);
191 /* generic keyboard conversion */
193 #include "sdl_keysym.h"
195 static kbd_layout_t *kbd_layout = NULL;
197 static uint8_t sdl_keyevent_to_keycode_generic(const SDL_KeyboardEvent *ev)
200 /* workaround for X11+SDL bug with AltGR */
201 keysym = ev->keysym.sym;
202 if (keysym == 0 && ev->keysym.scancode == 113)
204 /* For Japanese key '\' and '|' */
205 if (keysym == 92 && ev->keysym.scancode == 133) {
208 return keysym2scancode(kbd_layout, keysym) & SCANCODE_KEYMASK;
211 /* specific keyboard conversions from scan codes */
215 static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
217 return ev->keysym.scancode;
222 #if defined(SDL_VIDEO_DRIVER_X11)
223 #include <X11/XKBlib.h>
225 static int check_for_evdev(void)
228 XkbDescPtr desc = NULL;
230 char *keycodes = NULL;
232 SDL_VERSION(&info.version);
233 if (!SDL_GetWMInfo(&info)) {
236 desc = XkbGetMap(info.info.x11.display,
237 XkbGBN_AllComponentsMask,
240 (XkbGetNames(info.info.x11.display,
241 XkbKeycodesNameMask, desc) == Success)) {
242 keycodes = XGetAtomName(info.info.x11.display, desc->names->keycodes);
243 if (keycodes == NULL) {
244 fprintf(stderr, "could not lookup keycode name\n");
245 } else if (strstart(keycodes, "evdev", NULL)) {
247 } else if (!strstart(keycodes, "xfree86", NULL)) {
248 fprintf(stderr, "unknown keycodes `%s', please report to "
254 XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True);
262 static int check_for_evdev(void)
268 static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
271 static int has_evdev = -1;
274 has_evdev = check_for_evdev();
276 keycode = ev->keysym.scancode;
280 } else if (keycode < 97) {
281 keycode -= 8; /* just an offset */
282 } else if (keycode < 158) {
283 /* use conversion table */
285 keycode = translate_evdev_keycode(keycode - 97);
287 keycode = translate_xfree86_keycode(keycode - 97);
288 } else if (keycode == 208) { /* Hiragana_Katakana */
290 } else if (keycode == 211) { /* backslash */
300 static void reset_keys(void)
303 for(i = 0; i < 256; i++) {
304 if (modifiers_state[i]) {
305 qemu_input_event_send_key_number(dcl->con, i, false);
306 modifiers_state[i] = 0;
311 static void sdl_process_key(SDL_KeyboardEvent *ev)
315 if (ev->keysym.sym == SDLK_PAUSE) {
317 qemu_input_event_send_key_qcode(dcl->con, Q_KEY_CODE_PAUSE,
318 ev->type == SDL_KEYDOWN);
323 keycode = sdl_keyevent_to_keycode_generic(ev);
325 keycode = sdl_keyevent_to_keycode(ev);
330 /* sent when leaving window: reset the modifiers state */
333 case 0x2a: /* Left Shift */
334 case 0x36: /* Right Shift */
335 case 0x1d: /* Left CTRL */
336 case 0x9d: /* Right CTRL */
337 case 0x38: /* Left ALT */
338 case 0xb8: /* Right ALT */
339 if (ev->type == SDL_KEYUP)
340 modifiers_state[keycode] = 0;
342 modifiers_state[keycode] = 1;
344 #define QEMU_SDL_VERSION ((SDL_MAJOR_VERSION << 8) + SDL_MINOR_VERSION)
345 #if QEMU_SDL_VERSION < 0x102 || QEMU_SDL_VERSION == 0x102 && SDL_PATCHLEVEL < 14
346 /* SDL versions before 1.2.14 don't support key up for caps/num lock. */
347 case 0x45: /* num lock */
348 case 0x3a: /* caps lock */
349 /* SDL does not send the key up event, so we generate it */
350 qemu_input_event_send_key_number(dcl->con, keycode, true);
351 qemu_input_event_send_key_number(dcl->con, keycode, false);
356 /* now send the key code */
357 qemu_input_event_send_key_number(dcl->con, keycode,
358 ev->type == SDL_KEYDOWN);
361 static void sdl_update_caption(void)
363 char win_title[1024];
364 char icon_title[1024];
365 const char *status = "";
367 if (!runstate_is_running())
368 status = " [Stopped]";
371 status = " - Press Ctrl-Alt-Shift to exit mouse grab";
373 status = " - Press Right-Ctrl to exit mouse grab";
375 status = " - Press Ctrl-Alt to exit mouse grab";
379 snprintf(win_title, sizeof(win_title), "QEMU (%s)%s", qemu_name, status);
380 snprintf(icon_title, sizeof(icon_title), "QEMU (%s)", qemu_name);
382 snprintf(win_title, sizeof(win_title), "QEMU%s", status);
383 snprintf(icon_title, sizeof(icon_title), "QEMU");
386 SDL_WM_SetCaption(win_title, icon_title);
389 static void sdl_hide_cursor(void)
394 if (qemu_input_is_absolute()) {
396 SDL_SetCursor(sdl_cursor_hidden);
402 static void sdl_show_cursor(void)
407 if (!qemu_input_is_absolute() || !qemu_console_is_graphic(NULL)) {
410 (gui_grab || qemu_input_is_absolute() || absolute_enabled))
411 SDL_SetCursor(guest_sprite);
413 SDL_SetCursor(sdl_cursor_normal);
417 static void sdl_grab_start(void)
420 * If the application is not active, do not try to enter grab state. This
421 * prevents 'SDL_WM_GrabInput(SDL_GRAB_ON)' from blocking all the
422 * application (SDL bug).
424 if (!(SDL_GetAppState() & SDL_APPINPUTFOCUS)) {
428 SDL_SetCursor(guest_sprite);
429 if (!qemu_input_is_absolute() && !absolute_enabled) {
430 SDL_WarpMouse(guest_x, guest_y);
434 SDL_WM_GrabInput(SDL_GRAB_ON);
436 sdl_update_caption();
439 static void sdl_grab_end(void)
441 SDL_WM_GrabInput(SDL_GRAB_OFF);
444 sdl_update_caption();
447 static void absolute_mouse_grab(void)
449 int mouse_x, mouse_y;
451 SDL_GetMouseState(&mouse_x, &mouse_y);
452 if (mouse_x > 0 && mouse_x < real_screen->w - 1 &&
453 mouse_y > 0 && mouse_y < real_screen->h - 1) {
458 static void sdl_mouse_mode_change(Notifier *notify, void *data)
460 if (qemu_input_is_absolute()) {
461 if (!absolute_enabled) {
462 absolute_enabled = 1;
463 if (qemu_console_is_graphic(NULL)) {
464 absolute_mouse_grab();
467 } else if (absolute_enabled) {
468 if (!gui_fullscreen) {
471 absolute_enabled = 0;
475 static void sdl_send_mouse_event(int dx, int dy, int x, int y, int state)
477 static uint32_t bmap[INPUT_BUTTON__MAX] = {
478 [INPUT_BUTTON_LEFT] = SDL_BUTTON(SDL_BUTTON_LEFT),
479 [INPUT_BUTTON_MIDDLE] = SDL_BUTTON(SDL_BUTTON_MIDDLE),
480 [INPUT_BUTTON_RIGHT] = SDL_BUTTON(SDL_BUTTON_RIGHT),
481 [INPUT_BUTTON_WHEEL_UP] = SDL_BUTTON(SDL_BUTTON_WHEELUP),
482 [INPUT_BUTTON_WHEEL_DOWN] = SDL_BUTTON(SDL_BUTTON_WHEELDOWN),
484 static uint32_t prev_state;
486 if (prev_state != state) {
487 qemu_input_update_buttons(dcl->con, bmap, prev_state, state);
491 if (qemu_input_is_absolute()) {
492 qemu_input_queue_abs(dcl->con, INPUT_AXIS_X, x,
494 qemu_input_queue_abs(dcl->con, INPUT_AXIS_Y, y,
505 qemu_input_queue_rel(dcl->con, INPUT_AXIS_X, dx);
506 qemu_input_queue_rel(dcl->con, INPUT_AXIS_Y, dy);
508 qemu_input_event_sync();
511 static void sdl_scale(int width, int height)
513 int bpp = real_screen->format->BitsPerPixel;
516 printf("SDL: Scaling to %dx%d bpp %d\n", width, height, bpp);
519 if (bpp != 16 && bpp != 32) {
522 do_sdl_resize(width, height, bpp);
526 static void toggle_full_screen(void)
528 int width = surface_width(surface);
529 int height = surface_height(surface);
530 int bpp = surface_bits_per_pixel(surface);
532 gui_fullscreen = !gui_fullscreen;
533 if (gui_fullscreen) {
534 gui_saved_width = real_screen->w;
535 gui_saved_height = real_screen->h;
536 gui_saved_scaling = scaling_active;
538 do_sdl_resize(width, height, bpp);
541 gui_saved_grab = gui_grab;
544 if (gui_saved_scaling) {
545 sdl_scale(gui_saved_width, gui_saved_height);
547 do_sdl_resize(width, height, 0);
549 if (!gui_saved_grab || !qemu_console_is_graphic(NULL)) {
553 graphic_hw_invalidate(NULL);
554 graphic_hw_update(NULL);
557 static void handle_keydown(SDL_Event *ev)
563 mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
564 (gui_grab_code | KMOD_LSHIFT);
565 } else if (ctrl_grab) {
566 mod_state = (SDL_GetModState() & KMOD_RCTRL) == KMOD_RCTRL;
568 mod_state = (SDL_GetModState() & gui_grab_code) == gui_grab_code;
570 gui_key_modifier_pressed = mod_state;
572 if (gui_key_modifier_pressed) {
573 keycode = sdl_keyevent_to_keycode(&ev->key);
575 case 0x21: /* 'f' key on US keyboard */
576 toggle_full_screen();
579 case 0x16: /* 'u' key on US keyboard */
580 if (scaling_active) {
582 sdl_switch(dcl, NULL);
583 graphic_hw_invalidate(NULL);
584 graphic_hw_update(NULL);
588 case 0x02 ... 0x0a: /* '1' to '9' keys */
589 /* Reset the modifiers sent to the current console */
591 console_select(keycode - 0x02);
593 if (gui_fullscreen) {
596 if (!qemu_console_is_graphic(NULL)) {
597 /* release grab if going to a text console */
600 } else if (absolute_enabled) {
603 } else if (absolute_enabled) {
605 absolute_mouse_grab();
610 if (!gui_fullscreen) {
611 int width = MAX(real_screen->w + (keycode == 0x1b ? 50 : -50),
613 int height = (surface_height(surface) * width) /
614 surface_width(surface);
616 sdl_scale(width, height);
617 graphic_hw_invalidate(NULL);
618 graphic_hw_update(NULL);
624 } else if (!qemu_console_is_graphic(NULL)) {
627 if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
628 switch (ev->key.keysym.sym) {
630 keysym = QEMU_KEY_CTRL_UP;
633 keysym = QEMU_KEY_CTRL_DOWN;
636 keysym = QEMU_KEY_CTRL_LEFT;
639 keysym = QEMU_KEY_CTRL_RIGHT;
642 keysym = QEMU_KEY_CTRL_HOME;
645 keysym = QEMU_KEY_CTRL_END;
648 keysym = QEMU_KEY_CTRL_PAGEUP;
651 keysym = QEMU_KEY_CTRL_PAGEDOWN;
657 switch (ev->key.keysym.sym) {
659 keysym = QEMU_KEY_UP;
662 keysym = QEMU_KEY_DOWN;
665 keysym = QEMU_KEY_LEFT;
668 keysym = QEMU_KEY_RIGHT;
671 keysym = QEMU_KEY_HOME;
674 keysym = QEMU_KEY_END;
677 keysym = QEMU_KEY_PAGEUP;
680 keysym = QEMU_KEY_PAGEDOWN;
683 keysym = QEMU_KEY_BACKSPACE;
686 keysym = QEMU_KEY_DELETE;
693 kbd_put_keysym(keysym);
694 } else if (ev->key.keysym.unicode != 0) {
695 kbd_put_keysym(ev->key.keysym.unicode);
698 if (qemu_console_is_graphic(NULL) && !gui_keysym) {
699 sdl_process_key(&ev->key);
703 static void handle_keyup(SDL_Event *ev)
708 mod_state = (ev->key.keysym.mod & gui_grab_code);
710 mod_state = (ev->key.keysym.mod & (gui_grab_code | KMOD_LSHIFT));
712 if (!mod_state && gui_key_modifier_pressed) {
713 gui_key_modifier_pressed = 0;
714 if (gui_keysym == 0) {
715 /* exit/enter grab if pressing Ctrl-Alt */
717 if (qemu_console_is_graphic(NULL)) {
720 } else if (!gui_fullscreen) {
723 /* SDL does not send back all the modifiers key, so we must
730 if (qemu_console_is_graphic(NULL) && !gui_keysym) {
731 sdl_process_key(&ev->key);
735 static void handle_mousemotion(SDL_Event *ev)
739 if (qemu_console_is_graphic(NULL) &&
740 (qemu_input_is_absolute() || absolute_enabled)) {
741 max_x = real_screen->w - 1;
742 max_y = real_screen->h - 1;
743 if (gui_grab && (ev->motion.x == 0 || ev->motion.y == 0 ||
744 ev->motion.x == max_x || ev->motion.y == max_y)) {
748 (ev->motion.x > 0 && ev->motion.x < max_x &&
749 ev->motion.y > 0 && ev->motion.y < max_y)) {
753 if (gui_grab || qemu_input_is_absolute() || absolute_enabled) {
754 sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel,
755 ev->motion.x, ev->motion.y, ev->motion.state);
759 static void handle_mousebutton(SDL_Event *ev)
761 int buttonstate = SDL_GetMouseState(NULL, NULL);
762 SDL_MouseButtonEvent *bev;
764 if (!qemu_console_is_graphic(NULL)) {
769 if (!gui_grab && !qemu_input_is_absolute()) {
770 if (ev->type == SDL_MOUSEBUTTONUP && bev->button == SDL_BUTTON_LEFT) {
771 /* start grabbing all events */
775 if (ev->type == SDL_MOUSEBUTTONDOWN) {
776 buttonstate |= SDL_BUTTON(bev->button);
778 buttonstate &= ~SDL_BUTTON(bev->button);
780 sdl_send_mouse_event(0, 0, bev->x, bev->y, buttonstate);
784 static void handle_activation(SDL_Event *ev)
787 /* Disable grab if the window no longer has the focus
788 * (Windows-only workaround) */
789 if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
790 !ev->active.gain && !gui_fullscreen) {
794 if (!gui_grab && ev->active.gain && qemu_console_is_graphic(NULL) &&
795 (qemu_input_is_absolute() || absolute_enabled)) {
796 absolute_mouse_grab();
798 if (ev->active.state & SDL_APPACTIVE) {
799 if (ev->active.gain) {
800 /* Back to default interval */
801 update_displaychangelistener(dcl, GUI_REFRESH_INTERVAL_DEFAULT);
803 /* Sleeping interval. Not using the long default here as
804 * sdl_refresh does not only update the guest screen, but
805 * also checks for gui events. */
806 update_displaychangelistener(dcl, 500);
811 static void sdl_refresh(DisplayChangeListener *dcl)
813 SDL_Event ev1, *ev = &ev1;
816 if (last_vm_running != runstate_is_running()) {
817 last_vm_running = runstate_is_running();
818 sdl_update_caption();
821 graphic_hw_update(NULL);
822 SDL_EnableUNICODE(!qemu_console_is_graphic(NULL));
824 while (SDL_PollEvent(ev)) {
826 case SDL_VIDEOEXPOSE:
827 sdl_update(dcl, 0, 0, real_screen->w, real_screen->h);
840 qemu_system_shutdown_request();
843 case SDL_MOUSEMOTION:
845 handle_mousemotion(ev);
847 case SDL_MOUSEBUTTONDOWN:
848 case SDL_MOUSEBUTTONUP:
850 handle_mousebutton(ev);
852 case SDL_ACTIVEEVENT:
853 handle_activation(ev);
855 case SDL_VIDEORESIZE:
856 sdl_scale(ev->resize.w, ev->resize.h);
857 graphic_hw_invalidate(NULL);
858 graphic_hw_update(NULL);
866 if (idle_counter < SDL_MAX_IDLE_COUNT) {
868 if (idle_counter >= SDL_MAX_IDLE_COUNT) {
869 dcl->update_interval = GUI_REFRESH_INTERVAL_DEFAULT;
874 dcl->update_interval = SDL_REFRESH_INTERVAL_BUSY;
878 static void sdl_mouse_warp(DisplayChangeListener *dcl,
879 int x, int y, int on)
884 if (gui_grab || qemu_input_is_absolute() || absolute_enabled) {
885 SDL_SetCursor(guest_sprite);
886 if (!qemu_input_is_absolute() && !absolute_enabled) {
893 guest_x = x, guest_y = y;
896 static void sdl_mouse_define(DisplayChangeListener *dcl,
899 uint8_t *image, *mask;
903 SDL_FreeCursor(guest_sprite);
905 bpl = cursor_get_mono_bpl(c);
906 image = g_malloc0(bpl * c->height);
907 mask = g_malloc0(bpl * c->height);
908 cursor_get_mono_image(c, 0x000000, image);
909 cursor_get_mono_mask(c, 0, mask);
910 guest_sprite = SDL_CreateCursor(image, mask, c->width, c->height,
916 (gui_grab || qemu_input_is_absolute() || absolute_enabled))
917 SDL_SetCursor(guest_sprite);
920 static void sdl_cleanup(void)
923 SDL_FreeCursor(guest_sprite);
924 SDL_QuitSubSystem(SDL_INIT_VIDEO);
927 static const DisplayChangeListenerOps dcl_ops = {
929 .dpy_gfx_update = sdl_update,
930 .dpy_gfx_switch = sdl_switch,
931 .dpy_gfx_check_format = sdl_check_format,
932 .dpy_refresh = sdl_refresh,
933 .dpy_mouse_set = sdl_mouse_warp,
934 .dpy_cursor_define = sdl_mouse_define,
937 void sdl_display_early_init(int opengl)
939 if (opengl == 1 /* on */) {
941 "SDL1 display code has no opengl support.\n"
942 "Please recompile qemu with SDL2, using\n"
943 "./configure --enable-sdl --with-sdlabi=2.0\n");
947 void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
951 const SDL_VideoInfo *vi;
955 #if defined(__APPLE__)
956 /* always use generic keymaps */
957 if (!keyboard_layout)
958 keyboard_layout = "en-us";
960 if(keyboard_layout) {
961 kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
970 setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", 0);
973 /* on Linux, SDL may use fbcon|directfb|svgalib when run without
974 * accessible $DISPLAY to open X11 window. This is often the case
975 * when qemu is run using sudo. But in this case, and when actually
976 * run in X11 environment, SDL fights with X11 for the video card,
977 * making current display unavailable, often until reboot.
978 * So make x11 the default SDL video driver if this variable is unset.
979 * This is a bit hackish but saves us from bigger problem.
980 * Maybe it's a good idea to fix this in SDL instead.
982 setenv("SDL_VIDEODRIVER", "x11", 0);
985 /* Enable normal up/down events for Caps-Lock and Num-Lock keys.
986 * This requires SDL >= 1.2.14. */
987 setenv("SDL_DISABLE_LOCK_KEYS", "1", 1);
989 flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
990 if (SDL_Init (flags)) {
991 fprintf(stderr, "Could not initialize SDL(%s) - exiting\n",
995 vi = SDL_GetVideoInfo();
996 host_format = *(vi->vfmt);
998 /* Load a 32x32x4 image. White pixels are transparent. */
999 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu-icon.bmp");
1001 SDL_Surface *image = SDL_LoadBMP(filename);
1003 uint32_t colorkey = SDL_MapRGB(image->format, 255, 255, 255);
1004 SDL_SetColorKey(image, SDL_SRCCOLORKEY, colorkey);
1005 SDL_WM_SetIcon(image, NULL);
1015 dcl = g_new0(DisplayChangeListener, 1);
1016 dcl->ops = &dcl_ops;
1017 register_displaychangelistener(dcl);
1019 mouse_mode_notifier.notify = sdl_mouse_mode_change;
1020 qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier);
1022 sdl_update_caption();
1023 SDL_EnableKeyRepeat(250, 50);
1026 sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
1027 sdl_cursor_normal = SDL_GetCursor();
1029 memset(&info, 0, sizeof(info));
1030 SDL_VERSION(&info.version);
1031 if (SDL_GetWMInfo(&info)) {
1033 for (i = 0; ; i++) {
1034 /* All consoles share the same window */
1035 QemuConsole *con = qemu_console_lookup_by_index(i);
1037 #if defined(SDL_VIDEO_DRIVER_X11)
1038 qemu_console_set_window_id(con, info.info.x11.wmwindow);
1039 #elif defined(SDL_VIDEO_DRIVER_NANOX) || \
1040 defined(SDL_VIDEO_DRIVER_WINDIB) || defined(SDL_VIDEO_DRIVER_DDRAW) || \
1041 defined(SDL_VIDEO_DRIVER_GAPI) || \
1042 defined(SDL_VIDEO_DRIVER_RISCOS)
1043 qemu_console_set_window_id(con, (int) (uintptr_t) info.window);
1045 qemu_console_set_window_id(con, info.data);
1053 atexit(sdl_cleanup);