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
29 #include <SDL_syswm.h>
31 #include "qemu-common.h"
37 static DisplayChangeListener
*dcl
;
38 static SDL_Surface
*real_screen
;
39 static SDL_Surface
*guest_screen
= NULL
;
40 static int gui_grab
; /* if true, all keyboard/mouse events are grabbed */
41 static int last_vm_running
;
42 static int gui_saved_grab
;
43 static int gui_fullscreen
;
44 static int gui_noframe
;
45 static int gui_key_modifier_pressed
;
46 static int gui_keysym
;
47 static int gui_fullscreen_initial_grab
;
48 static int gui_grab_code
= KMOD_LALT
| KMOD_LCTRL
;
49 static uint8_t modifiers_state
[256];
50 static int width
, height
;
51 static SDL_Cursor
*sdl_cursor_normal
;
52 static SDL_Cursor
*sdl_cursor_hidden
;
53 static int absolute_enabled
= 0;
54 static int guest_cursor
= 0;
55 static int guest_x
, guest_y
;
56 static SDL_Cursor
*guest_sprite
= NULL
;
57 static uint8_t allocator
;
58 static SDL_PixelFormat host_format
;
59 static int scaling_active
= 0;
60 static Notifier mouse_mode_notifier
;
62 static void sdl_update(DisplayState
*ds
, int x
, int y
, int w
, int h
)
64 // printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
72 if (!scaling_active
) {
73 SDL_BlitSurface(guest_screen
, &rec
, real_screen
, &rec
);
75 if (sdl_zoom_blit(guest_screen
, real_screen
, SMOOTHING_ON
, &rec
) < 0) {
76 fprintf(stderr
, "Zoom blit failed\n");
81 SDL_UpdateRect(real_screen
, rec
.x
, rec
.y
, rec
.w
, rec
.h
);
84 static void sdl_setdata(DisplayState
*ds
)
86 if (guest_screen
!= NULL
) SDL_FreeSurface(guest_screen
);
88 guest_screen
= SDL_CreateRGBSurfaceFrom(ds_get_data(ds
), ds_get_width(ds
), ds_get_height(ds
),
89 ds_get_bits_per_pixel(ds
), ds_get_linesize(ds
),
90 ds
->surface
->pf
.rmask
, ds
->surface
->pf
.gmask
,
91 ds
->surface
->pf
.bmask
, ds
->surface
->pf
.amask
);
94 static void do_sdl_resize(int new_width
, int new_height
, int bpp
)
98 // printf("resizing to %d %d\n", w, h);
100 flags
= SDL_HWSURFACE
| SDL_ASYNCBLIT
| SDL_HWACCEL
;
101 if (gui_fullscreen
) {
102 flags
|= SDL_FULLSCREEN
;
104 flags
|= SDL_RESIZABLE
;
107 flags
|= SDL_NOFRAME
;
111 real_screen
= SDL_SetVideoMode(width
, height
, bpp
, flags
);
113 fprintf(stderr
, "Could not open SDL display (%dx%dx%d): %s\n", width
,
114 height
, bpp
, SDL_GetError());
119 static void sdl_resize(DisplayState
*ds
)
123 do_sdl_resize(ds_get_width(ds
), ds_get_height(ds
), 0);
124 else if (real_screen
->format
->BitsPerPixel
!= ds_get_bits_per_pixel(ds
))
125 do_sdl_resize(real_screen
->w
, real_screen
->h
, ds_get_bits_per_pixel(ds
));
128 if (guest_screen
!= NULL
) {
129 SDL_FreeSurface(guest_screen
);
135 static PixelFormat
sdl_to_qemu_pixelformat(SDL_PixelFormat
*sdl_pf
)
139 memset(&qemu_pf
, 0x00, sizeof(PixelFormat
));
141 qemu_pf
.bits_per_pixel
= sdl_pf
->BitsPerPixel
;
142 qemu_pf
.bytes_per_pixel
= sdl_pf
->BytesPerPixel
;
143 qemu_pf
.depth
= (qemu_pf
.bits_per_pixel
) == 32 ? 24 : (qemu_pf
.bits_per_pixel
);
145 qemu_pf
.rmask
= sdl_pf
->Rmask
;
146 qemu_pf
.gmask
= sdl_pf
->Gmask
;
147 qemu_pf
.bmask
= sdl_pf
->Bmask
;
148 qemu_pf
.amask
= sdl_pf
->Amask
;
150 qemu_pf
.rshift
= sdl_pf
->Rshift
;
151 qemu_pf
.gshift
= sdl_pf
->Gshift
;
152 qemu_pf
.bshift
= sdl_pf
->Bshift
;
153 qemu_pf
.ashift
= sdl_pf
->Ashift
;
155 qemu_pf
.rbits
= 8 - sdl_pf
->Rloss
;
156 qemu_pf
.gbits
= 8 - sdl_pf
->Gloss
;
157 qemu_pf
.bbits
= 8 - sdl_pf
->Bloss
;
158 qemu_pf
.abits
= 8 - sdl_pf
->Aloss
;
160 qemu_pf
.rmax
= ((1 << qemu_pf
.rbits
) - 1);
161 qemu_pf
.gmax
= ((1 << qemu_pf
.gbits
) - 1);
162 qemu_pf
.bmax
= ((1 << qemu_pf
.bbits
) - 1);
163 qemu_pf
.amax
= ((1 << qemu_pf
.abits
) - 1);
168 static DisplaySurface
* sdl_create_displaysurface(int width
, int height
)
170 DisplaySurface
*surface
= (DisplaySurface
*) qemu_mallocz(sizeof(DisplaySurface
));
171 if (surface
== NULL
) {
172 fprintf(stderr
, "sdl_create_displaysurface: malloc failed\n");
176 surface
->width
= width
;
177 surface
->height
= height
;
179 if (scaling_active
) {
182 if (host_format
.BytesPerPixel
!= 2 && host_format
.BytesPerPixel
!= 4) {
183 linesize
= width
* 4;
184 pf
= qemu_default_pixelformat(32);
186 linesize
= width
* host_format
.BytesPerPixel
;
187 pf
= sdl_to_qemu_pixelformat(&host_format
);
189 qemu_alloc_display(surface
, width
, height
, linesize
, pf
, 0);
193 if (host_format
.BitsPerPixel
== 16)
194 do_sdl_resize(width
, height
, 16);
196 do_sdl_resize(width
, height
, 32);
198 surface
->pf
= sdl_to_qemu_pixelformat(real_screen
->format
);
199 surface
->linesize
= real_screen
->pitch
;
200 surface
->data
= real_screen
->pixels
;
202 #ifdef HOST_WORDS_BIGENDIAN
203 surface
->flags
= QEMU_REALPIXELS_FLAG
| QEMU_BIG_ENDIAN_FLAG
;
205 surface
->flags
= QEMU_REALPIXELS_FLAG
;
212 static void sdl_free_displaysurface(DisplaySurface
*surface
)
218 if (surface
->flags
& QEMU_ALLOCATED_FLAG
)
219 qemu_free(surface
->data
);
223 static DisplaySurface
* sdl_resize_displaysurface(DisplaySurface
*surface
, int width
, int height
)
225 sdl_free_displaysurface(surface
);
226 return sdl_create_displaysurface(width
, height
);
229 /* generic keyboard conversion */
231 #include "sdl_keysym.h"
233 static kbd_layout_t
*kbd_layout
= NULL
;
235 static uint8_t sdl_keyevent_to_keycode_generic(const SDL_KeyboardEvent
*ev
)
238 /* workaround for X11+SDL bug with AltGR */
239 keysym
= ev
->keysym
.sym
;
240 if (keysym
== 0 && ev
->keysym
.scancode
== 113)
242 /* For Japanese key '\' and '|' */
243 if (keysym
== 92 && ev
->keysym
.scancode
== 133) {
246 return keysym2scancode(kbd_layout
, keysym
) & SCANCODE_KEYMASK
;
249 /* specific keyboard conversions from scan codes */
253 static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent
*ev
)
255 return ev
->keysym
.scancode
;
260 #if defined(SDL_VIDEO_DRIVER_X11)
261 #include <X11/XKBlib.h>
263 static int check_for_evdev(void)
266 XkbDescPtr desc
= NULL
;
268 char *keycodes
= NULL
;
270 SDL_VERSION(&info
.version
);
271 if (!SDL_GetWMInfo(&info
)) {
274 desc
= XkbGetKeyboard(info
.info
.x11
.display
,
275 XkbGBN_AllComponentsMask
,
277 if (desc
&& desc
->names
) {
278 keycodes
= XGetAtomName(info
.info
.x11
.display
, desc
->names
->keycodes
);
279 if (keycodes
== NULL
) {
280 fprintf(stderr
, "could not lookup keycode name\n");
281 } else if (strstart(keycodes
, "evdev", NULL
)) {
283 } else if (!strstart(keycodes
, "xfree86", NULL
)) {
284 fprintf(stderr
, "unknown keycodes `%s', please report to "
285 "qemu-devel@nongnu.org\n", keycodes
);
290 XkbFreeKeyboard(desc
, XkbGBN_AllComponentsMask
, True
);
298 static int check_for_evdev(void)
304 static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent
*ev
)
307 static int has_evdev
= -1;
310 has_evdev
= check_for_evdev();
312 keycode
= ev
->keysym
.scancode
;
316 } else if (keycode
< 97) {
317 keycode
-= 8; /* just an offset */
318 } else if (keycode
< 158) {
319 /* use conversion table */
321 keycode
= translate_evdev_keycode(keycode
- 97);
323 keycode
= translate_xfree86_keycode(keycode
- 97);
324 } else if (keycode
== 208) { /* Hiragana_Katakana */
326 } else if (keycode
== 211) { /* backslash */
336 static void reset_keys(void)
339 for(i
= 0; i
< 256; i
++) {
340 if (modifiers_state
[i
]) {
341 if (i
& SCANCODE_GREY
)
342 kbd_put_keycode(SCANCODE_EMUL0
);
343 kbd_put_keycode(i
| SCANCODE_UP
);
344 modifiers_state
[i
] = 0;
349 static void sdl_process_key(SDL_KeyboardEvent
*ev
)
353 if (ev
->keysym
.sym
== SDLK_PAUSE
) {
356 if (ev
->type
== SDL_KEYUP
)
358 kbd_put_keycode(0xe1);
359 kbd_put_keycode(0x1d | v
);
360 kbd_put_keycode(0x45 | v
);
365 keycode
= sdl_keyevent_to_keycode_generic(ev
);
367 keycode
= sdl_keyevent_to_keycode(ev
);
372 /* sent when leaving window: reset the modifiers state */
375 case 0x2a: /* Left Shift */
376 case 0x36: /* Right Shift */
377 case 0x1d: /* Left CTRL */
378 case 0x9d: /* Right CTRL */
379 case 0x38: /* Left ALT */
380 case 0xb8: /* Right ALT */
381 if (ev
->type
== SDL_KEYUP
)
382 modifiers_state
[keycode
] = 0;
384 modifiers_state
[keycode
] = 1;
386 #define QEMU_SDL_VERSION ((SDL_MAJOR_VERSION << 8) + SDL_MINOR_VERSION)
387 #if QEMU_SDL_VERSION < 0x102 || QEMU_SDL_VERSION == 0x102 && SDL_PATCHLEVEL < 14
388 /* SDL versions before 1.2.14 don't support key up for caps/num lock. */
389 case 0x45: /* num lock */
390 case 0x3a: /* caps lock */
391 /* SDL does not send the key up event, so we generate it */
392 kbd_put_keycode(keycode
);
393 kbd_put_keycode(keycode
| SCANCODE_UP
);
398 /* now send the key code */
399 if (keycode
& SCANCODE_GREY
)
400 kbd_put_keycode(SCANCODE_EMUL0
);
401 if (ev
->type
== SDL_KEYUP
)
402 kbd_put_keycode(keycode
| SCANCODE_UP
);
404 kbd_put_keycode(keycode
& SCANCODE_KEYCODEMASK
);
407 static void sdl_update_caption(void)
409 char win_title
[1024];
410 char icon_title
[1024];
411 const char *status
= "";
414 status
= " [Stopped]";
417 status
= " - Press Ctrl-Alt-Shift to exit mouse grab";
419 status
= " - Press Right-Ctrl to exit mouse grab";
421 status
= " - Press Ctrl-Alt to exit mouse grab";
425 snprintf(win_title
, sizeof(win_title
), "QEMU (%s)%s", qemu_name
, status
);
426 snprintf(icon_title
, sizeof(icon_title
), "QEMU (%s)", qemu_name
);
428 snprintf(win_title
, sizeof(win_title
), "QEMU%s", status
);
429 snprintf(icon_title
, sizeof(icon_title
), "QEMU");
432 SDL_WM_SetCaption(win_title
, icon_title
);
435 static void sdl_hide_cursor(void)
440 if (kbd_mouse_is_absolute()) {
442 SDL_SetCursor(sdl_cursor_hidden
);
448 static void sdl_show_cursor(void)
453 if (!kbd_mouse_is_absolute()) {
456 (gui_grab
|| kbd_mouse_is_absolute() || absolute_enabled
))
457 SDL_SetCursor(guest_sprite
);
459 SDL_SetCursor(sdl_cursor_normal
);
463 static void sdl_grab_start(void)
466 SDL_SetCursor(guest_sprite
);
467 if (!kbd_mouse_is_absolute() && !absolute_enabled
)
468 SDL_WarpMouse(guest_x
, guest_y
);
472 if (SDL_WM_GrabInput(SDL_GRAB_ON
) == SDL_GRAB_ON
) {
474 sdl_update_caption();
479 static void sdl_grab_end(void)
481 SDL_WM_GrabInput(SDL_GRAB_OFF
);
484 sdl_update_caption();
487 static void sdl_mouse_mode_change(Notifier
*notify
, void *data
)
489 if (kbd_mouse_is_absolute()) {
490 if (!absolute_enabled
) {
495 absolute_enabled
= 1;
497 } else if (absolute_enabled
) {
499 absolute_enabled
= 0;
503 static void sdl_send_mouse_event(int dx
, int dy
, int dz
, int x
, int y
, int state
)
507 if (state
& SDL_BUTTON(SDL_BUTTON_LEFT
))
508 buttons
|= MOUSE_EVENT_LBUTTON
;
509 if (state
& SDL_BUTTON(SDL_BUTTON_RIGHT
))
510 buttons
|= MOUSE_EVENT_RBUTTON
;
511 if (state
& SDL_BUTTON(SDL_BUTTON_MIDDLE
))
512 buttons
|= MOUSE_EVENT_MBUTTON
;
514 if (kbd_mouse_is_absolute()) {
515 dx
= x
* 0x7FFF / (width
- 1);
516 dy
= y
* 0x7FFF / (height
- 1);
517 } else if (guest_cursor
) {
526 kbd_mouse_event(dx
, dy
, dz
, buttons
);
529 static void toggle_full_screen(DisplayState
*ds
)
531 gui_fullscreen
= !gui_fullscreen
;
532 do_sdl_resize(real_screen
->w
, real_screen
->h
, real_screen
->format
->BitsPerPixel
);
533 if (gui_fullscreen
) {
535 gui_saved_grab
= gui_grab
;
545 static void sdl_refresh(DisplayState
*ds
)
547 SDL_Event ev1
, *ev
= &ev1
;
549 int buttonstate
= SDL_GetMouseState(NULL
, NULL
);
551 if (last_vm_running
!= vm_running
) {
552 last_vm_running
= vm_running
;
553 sdl_update_caption();
557 SDL_EnableUNICODE(!is_graphic_console());
559 while (SDL_PollEvent(ev
)) {
561 case SDL_VIDEOEXPOSE
:
562 sdl_update(ds
, 0, 0, real_screen
->w
, real_screen
->h
);
566 if (ev
->type
== SDL_KEYDOWN
) {
568 mod_state
= (SDL_GetModState() & (gui_grab_code
| KMOD_LSHIFT
)) ==
569 (gui_grab_code
| KMOD_LSHIFT
);
570 } else if (ctrl_grab
) {
571 mod_state
= (SDL_GetModState() & KMOD_RCTRL
) == KMOD_RCTRL
;
573 mod_state
= (SDL_GetModState() & gui_grab_code
) ==
576 gui_key_modifier_pressed
= mod_state
;
577 if (gui_key_modifier_pressed
) {
579 keycode
= sdl_keyevent_to_keycode(&ev
->key
);
581 case 0x21: /* 'f' key on US keyboard */
582 toggle_full_screen(ds
);
585 case 0x16: /* 'u' key on US keyboard */
591 case 0x02 ... 0x0a: /* '1' to '9' keys */
592 /* Reset the modifiers sent to the current console */
594 console_select(keycode
- 0x02);
595 if (!is_graphic_console()) {
596 /* display grab if going to a text console */
605 } else if (!is_graphic_console()) {
608 if (ev
->key
.keysym
.mod
& (KMOD_LCTRL
| KMOD_RCTRL
)) {
609 switch(ev
->key
.keysym
.sym
) {
610 case SDLK_UP
: keysym
= QEMU_KEY_CTRL_UP
; break;
611 case SDLK_DOWN
: keysym
= QEMU_KEY_CTRL_DOWN
; break;
612 case SDLK_LEFT
: keysym
= QEMU_KEY_CTRL_LEFT
; break;
613 case SDLK_RIGHT
: keysym
= QEMU_KEY_CTRL_RIGHT
; break;
614 case SDLK_HOME
: keysym
= QEMU_KEY_CTRL_HOME
; break;
615 case SDLK_END
: keysym
= QEMU_KEY_CTRL_END
; break;
616 case SDLK_PAGEUP
: keysym
= QEMU_KEY_CTRL_PAGEUP
; break;
617 case SDLK_PAGEDOWN
: keysym
= QEMU_KEY_CTRL_PAGEDOWN
; break;
621 switch(ev
->key
.keysym
.sym
) {
622 case SDLK_UP
: keysym
= QEMU_KEY_UP
; break;
623 case SDLK_DOWN
: keysym
= QEMU_KEY_DOWN
; break;
624 case SDLK_LEFT
: keysym
= QEMU_KEY_LEFT
; break;
625 case SDLK_RIGHT
: keysym
= QEMU_KEY_RIGHT
; break;
626 case SDLK_HOME
: keysym
= QEMU_KEY_HOME
; break;
627 case SDLK_END
: keysym
= QEMU_KEY_END
; break;
628 case SDLK_PAGEUP
: keysym
= QEMU_KEY_PAGEUP
; break;
629 case SDLK_PAGEDOWN
: keysym
= QEMU_KEY_PAGEDOWN
; break;
630 case SDLK_BACKSPACE
: keysym
= QEMU_KEY_BACKSPACE
; break;
631 case SDLK_DELETE
: keysym
= QEMU_KEY_DELETE
; break;
636 kbd_put_keysym(keysym
);
637 } else if (ev
->key
.keysym
.unicode
!= 0) {
638 kbd_put_keysym(ev
->key
.keysym
.unicode
);
641 } else if (ev
->type
== SDL_KEYUP
) {
643 mod_state
= (ev
->key
.keysym
.mod
& gui_grab_code
);
645 mod_state
= (ev
->key
.keysym
.mod
&
646 (gui_grab_code
| KMOD_LSHIFT
));
649 if (gui_key_modifier_pressed
) {
650 gui_key_modifier_pressed
= 0;
651 if (gui_keysym
== 0) {
652 /* exit/enter grab if pressing Ctrl-Alt */
654 /* if the application is not active,
655 do not try to enter grab state. It
657 'SDL_WM_GrabInput(SDL_GRAB_ON)'
658 from blocking all the application
660 if (SDL_GetAppState() & SDL_APPACTIVE
)
665 /* SDL does not send back all the
666 modifiers key, so we must correct it */
674 if (is_graphic_console() && !gui_keysym
)
675 sdl_process_key(&ev
->key
);
680 qemu_system_shutdown_request();
683 case SDL_MOUSEMOTION
:
684 if (gui_grab
|| kbd_mouse_is_absolute() ||
686 sdl_send_mouse_event(ev
->motion
.xrel
, ev
->motion
.yrel
, 0,
687 ev
->motion
.x
, ev
->motion
.y
, ev
->motion
.state
);
690 case SDL_MOUSEBUTTONDOWN
:
691 case SDL_MOUSEBUTTONUP
:
693 SDL_MouseButtonEvent
*bev
= &ev
->button
;
694 if (!gui_grab
&& !kbd_mouse_is_absolute()) {
695 if (ev
->type
== SDL_MOUSEBUTTONDOWN
&&
696 (bev
->button
== SDL_BUTTON_LEFT
)) {
697 /* start grabbing all events */
703 if (ev
->type
== SDL_MOUSEBUTTONDOWN
) {
704 buttonstate
|= SDL_BUTTON(bev
->button
);
706 buttonstate
&= ~SDL_BUTTON(bev
->button
);
708 #ifdef SDL_BUTTON_WHEELUP
709 if (bev
->button
== SDL_BUTTON_WHEELUP
&& ev
->type
== SDL_MOUSEBUTTONDOWN
) {
711 } else if (bev
->button
== SDL_BUTTON_WHEELDOWN
&& ev
->type
== SDL_MOUSEBUTTONDOWN
) {
715 sdl_send_mouse_event(0, 0, dz
, bev
->x
, bev
->y
, buttonstate
);
719 case SDL_ACTIVEEVENT
:
720 if (gui_grab
&& ev
->active
.state
== SDL_APPINPUTFOCUS
&&
721 !ev
->active
.gain
&& !gui_fullscreen_initial_grab
) {
724 if (ev
->active
.state
& SDL_APPACTIVE
) {
725 if (ev
->active
.gain
) {
726 /* Back to default interval */
727 dcl
->gui_timer_interval
= 0;
730 /* Sleeping interval */
731 dcl
->gui_timer_interval
= 500;
736 case SDL_VIDEORESIZE
:
738 SDL_ResizeEvent
*rev
= &ev
->resize
;
739 int bpp
= real_screen
->format
->BitsPerPixel
;
740 if (bpp
!= 16 && bpp
!= 32)
742 do_sdl_resize(rev
->w
, rev
->h
, bpp
);
744 if (!is_buffer_shared(ds
->surface
)) {
745 ds
->surface
= qemu_resize_displaysurface(ds
, ds_get_width(ds
), ds_get_height(ds
));
758 static void sdl_fill(DisplayState
*ds
, int x
, int y
, int w
, int h
, uint32_t c
)
760 SDL_Rect dst
= { x
, y
, w
, h
};
761 SDL_FillRect(real_screen
, &dst
, c
);
764 static void sdl_mouse_warp(int x
, int y
, int on
)
769 if (gui_grab
|| kbd_mouse_is_absolute() || absolute_enabled
) {
770 SDL_SetCursor(guest_sprite
);
771 if (!kbd_mouse_is_absolute() && !absolute_enabled
)
777 guest_x
= x
, guest_y
= y
;
780 static void sdl_mouse_define(QEMUCursor
*c
)
782 uint8_t *image
, *mask
;
786 SDL_FreeCursor(guest_sprite
);
788 bpl
= cursor_get_mono_bpl(c
);
789 image
= qemu_mallocz(bpl
* c
->height
);
790 mask
= qemu_mallocz(bpl
* c
->height
);
791 cursor_get_mono_image(c
, 0x000000, image
);
792 cursor_get_mono_mask(c
, 0, mask
);
793 guest_sprite
= SDL_CreateCursor(image
, mask
, c
->width
, c
->height
,
799 (gui_grab
|| kbd_mouse_is_absolute() || absolute_enabled
))
800 SDL_SetCursor(guest_sprite
);
803 static void sdl_cleanup(void)
806 SDL_FreeCursor(guest_sprite
);
807 SDL_QuitSubSystem(SDL_INIT_VIDEO
);
810 void sdl_display_init(DisplayState
*ds
, int full_screen
, int no_frame
)
814 DisplayAllocator
*da
;
815 const SDL_VideoInfo
*vi
;
818 #if defined(__APPLE__)
819 /* always use generic keymaps */
820 if (!keyboard_layout
)
821 keyboard_layout
= "en-us";
823 if(keyboard_layout
) {
824 kbd_layout
= init_keyboard_layout(name2keysym
, keyboard_layout
);
833 setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", 0);
836 /* on Linux, SDL may use fbcon|directfb|svgalib when run without
837 * accessible $DISPLAY to open X11 window. This is often the case
838 * when qemu is run using sudo. But in this case, and when actually
839 * run in X11 environment, SDL fights with X11 for the video card,
840 * making current display unavailable, often until reboot.
841 * So make x11 the default SDL video driver if this variable is unset.
842 * This is a bit hackish but saves us from bigger problem.
843 * Maybe it's a good idea to fix this in SDL instead.
845 setenv("SDL_VIDEODRIVER", "x11", 0);
848 /* Enable normal up/down events for Caps-Lock and Num-Lock keys.
849 * This requires SDL >= 1.2.14. */
850 setenv("SDL_DISABLE_LOCK_KEYS", "1", 1);
852 flags
= SDL_INIT_VIDEO
| SDL_INIT_NOPARACHUTE
;
853 if (SDL_Init (flags
)) {
854 fprintf(stderr
, "Could not initialize SDL(%s) - exiting\n",
858 vi
= SDL_GetVideoInfo();
859 host_format
= *(vi
->vfmt
);
861 /* Load a 32x32x4 image. White pixels are transparent. */
862 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, "qemu-icon.bmp");
864 SDL_Surface
*image
= SDL_LoadBMP(filename
);
866 uint32_t colorkey
= SDL_MapRGB(image
->format
, 255, 255, 255);
867 SDL_SetColorKey(image
, SDL_SRCCOLORKEY
, colorkey
);
868 SDL_WM_SetIcon(image
, NULL
);
873 dcl
= qemu_mallocz(sizeof(DisplayChangeListener
));
874 dcl
->dpy_update
= sdl_update
;
875 dcl
->dpy_resize
= sdl_resize
;
876 dcl
->dpy_refresh
= sdl_refresh
;
877 dcl
->dpy_setdata
= sdl_setdata
;
878 dcl
->dpy_fill
= sdl_fill
;
879 ds
->mouse_set
= sdl_mouse_warp
;
880 ds
->cursor_define
= sdl_mouse_define
;
881 register_displaychangelistener(ds
, dcl
);
883 da
= qemu_mallocz(sizeof(DisplayAllocator
));
884 da
->create_displaysurface
= sdl_create_displaysurface
;
885 da
->resize_displaysurface
= sdl_resize_displaysurface
;
886 da
->free_displaysurface
= sdl_free_displaysurface
;
887 if (register_displayallocator(ds
, da
) == da
) {
891 mouse_mode_notifier
.notify
= sdl_mouse_mode_change
;
892 qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier
);
894 sdl_update_caption();
895 SDL_EnableKeyRepeat(250, 50);
898 sdl_cursor_hidden
= SDL_CreateCursor(&data
, &data
, 8, 1, 0, 0);
899 sdl_cursor_normal
= SDL_GetCursor();
904 gui_fullscreen_initial_grab
= 1;