1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "qemu/osdep.h"
27#include "qemu/module.h"
28#include "ui/console.h"
29#include "ui/input.h"
30#include "ui/sdl2.h"
31#include "sysemu/sysemu.h"
32
33static int sdl2_num_outputs;
34static struct sdl2_console *sdl2_console;
35
36static SDL_Surface *guest_sprite_surface;
37static int gui_grab;
38
39static int gui_saved_grab;
40static int gui_fullscreen;
41static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
42static SDL_Cursor *sdl_cursor_normal;
43static SDL_Cursor *sdl_cursor_hidden;
44static int absolute_enabled;
45static int guest_cursor;
46static int guest_x, guest_y;
47static SDL_Cursor *guest_sprite;
48static Notifier mouse_mode_notifier;
49
50#define SDL2_REFRESH_INTERVAL_BUSY 10
51#define SDL2_MAX_IDLE_COUNT (2 * GUI_REFRESH_INTERVAL_DEFAULT \
52 / SDL2_REFRESH_INTERVAL_BUSY + 1)
53
54static void sdl_update_caption(struct sdl2_console *scon);
55
56static struct sdl2_console *get_scon_from_window(uint32_t window_id)
57{
58 int i;
59 for (i = 0; i < sdl2_num_outputs; i++) {
60 if (sdl2_console[i].real_window == SDL_GetWindowFromID(window_id)) {
61 return &sdl2_console[i];
62 }
63 }
64 return NULL;
65}
66
67void sdl2_window_create(struct sdl2_console *scon)
68{
69 int flags = 0;
70
71 if (!scon->surface) {
72 return;
73 }
74 assert(!scon->real_window);
75
76 if (gui_fullscreen) {
77 flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
78 } else {
79 flags |= SDL_WINDOW_RESIZABLE;
80 }
81 if (scon->hidden) {
82 flags |= SDL_WINDOW_HIDDEN;
83 }
84
85 scon->real_window = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED,
86 SDL_WINDOWPOS_UNDEFINED,
87 surface_width(scon->surface),
88 surface_height(scon->surface),
89 flags);
90 scon->real_renderer = SDL_CreateRenderer(scon->real_window, -1, 0);
91 if (scon->opengl) {
92 scon->winctx = SDL_GL_GetCurrentContext();
93 }
94 sdl_update_caption(scon);
95}
96
97void sdl2_window_destroy(struct sdl2_console *scon)
98{
99 if (!scon->real_window) {
100 return;
101 }
102
103 SDL_DestroyRenderer(scon->real_renderer);
104 scon->real_renderer = NULL;
105 SDL_DestroyWindow(scon->real_window);
106 scon->real_window = NULL;
107}
108
109void sdl2_window_resize(struct sdl2_console *scon)
110{
111 if (!scon->real_window) {
112 return;
113 }
114
115 SDL_SetWindowSize(scon->real_window,
116 surface_width(scon->surface),
117 surface_height(scon->surface));
118}
119
120static void sdl2_redraw(struct sdl2_console *scon)
121{
122 if (scon->opengl) {
123#ifdef CONFIG_OPENGL
124 sdl2_gl_redraw(scon);
125#endif
126 } else {
127 sdl2_2d_redraw(scon);
128 }
129}
130
131static void sdl_update_caption(struct sdl2_console *scon)
132{
133 char win_title[1024];
134 char icon_title[1024];
135 const char *status = "";
136
137 if (!runstate_is_running()) {
138 status = " [Stopped]";
139 } else if (gui_grab) {
140 if (alt_grab) {
141 status = " - Press Ctrl-Alt-Shift-G to exit grab";
142 } else if (ctrl_grab) {
143 status = " - Press Right-Ctrl-G to exit grab";
144 } else {
145 status = " - Press Ctrl-Alt-G to exit grab";
146 }
147 }
148
149 if (qemu_name) {
150 snprintf(win_title, sizeof(win_title), "QEMU (%s-%d)%s", qemu_name,
151 scon->idx, status);
152 snprintf(icon_title, sizeof(icon_title), "QEMU (%s)", qemu_name);
153 } else {
154 snprintf(win_title, sizeof(win_title), "QEMU%s", status);
155 snprintf(icon_title, sizeof(icon_title), "QEMU");
156 }
157
158 if (scon->real_window) {
159 SDL_SetWindowTitle(scon->real_window, win_title);
160 }
161}
162
163static void sdl_hide_cursor(void)
164{
165 if (!cursor_hide) {
166 return;
167 }
168
169 SDL_ShowCursor(SDL_DISABLE);
170 SDL_SetCursor(sdl_cursor_hidden);
171
172 if (!qemu_input_is_absolute()) {
173 SDL_SetRelativeMouseMode(SDL_TRUE);
174 }
175}
176
177static void sdl_show_cursor(void)
178{
179 if (!cursor_hide) {
180 return;
181 }
182
183 if (!qemu_input_is_absolute()) {
184 SDL_SetRelativeMouseMode(SDL_FALSE);
185 }
186
187 if (guest_cursor &&
188 (gui_grab || qemu_input_is_absolute() || absolute_enabled)) {
189 SDL_SetCursor(guest_sprite);
190 } else {
191 SDL_SetCursor(sdl_cursor_normal);
192 }
193
194 SDL_ShowCursor(SDL_ENABLE);
195}
196
197static void sdl_grab_start(struct sdl2_console *scon)
198{
199 QemuConsole *con = scon ? scon->dcl.con : NULL;
200
201 if (!con || !qemu_console_is_graphic(con)) {
202 return;
203 }
204
205
206
207
208
209 if (!(SDL_GetWindowFlags(scon->real_window) & SDL_WINDOW_INPUT_FOCUS)) {
210 return;
211 }
212 if (guest_cursor) {
213 SDL_SetCursor(guest_sprite);
214 if (!qemu_input_is_absolute() && !absolute_enabled) {
215 SDL_WarpMouseInWindow(scon->real_window, guest_x, guest_y);
216 }
217 } else {
218 sdl_hide_cursor();
219 }
220 SDL_SetWindowGrab(scon->real_window, SDL_TRUE);
221 gui_grab = 1;
222 sdl_update_caption(scon);
223}
224
225static void sdl_grab_end(struct sdl2_console *scon)
226{
227 SDL_SetWindowGrab(scon->real_window, SDL_FALSE);
228 gui_grab = 0;
229 sdl_show_cursor();
230 sdl_update_caption(scon);
231}
232
233static void absolute_mouse_grab(struct sdl2_console *scon)
234{
235 int mouse_x, mouse_y;
236 int scr_w, scr_h;
237 SDL_GetMouseState(&mouse_x, &mouse_y);
238 SDL_GetWindowSize(scon->real_window, &scr_w, &scr_h);
239 if (mouse_x > 0 && mouse_x < scr_w - 1 &&
240 mouse_y > 0 && mouse_y < scr_h - 1) {
241 sdl_grab_start(scon);
242 }
243}
244
245static void sdl_mouse_mode_change(Notifier *notify, void *data)
246{
247 if (qemu_input_is_absolute()) {
248 if (!absolute_enabled) {
249 absolute_enabled = 1;
250 SDL_SetRelativeMouseMode(SDL_FALSE);
251 absolute_mouse_grab(&sdl2_console[0]);
252 }
253 } else if (absolute_enabled) {
254 if (!gui_fullscreen) {
255 sdl_grab_end(&sdl2_console[0]);
256 }
257 absolute_enabled = 0;
258 }
259}
260
261static void sdl_send_mouse_event(struct sdl2_console *scon, int dx, int dy,
262 int x, int y, int state)
263{
264 static uint32_t bmap[INPUT_BUTTON__MAX] = {
265 [INPUT_BUTTON_LEFT] = SDL_BUTTON(SDL_BUTTON_LEFT),
266 [INPUT_BUTTON_MIDDLE] = SDL_BUTTON(SDL_BUTTON_MIDDLE),
267 [INPUT_BUTTON_RIGHT] = SDL_BUTTON(SDL_BUTTON_RIGHT),
268 };
269 static uint32_t prev_state;
270
271 if (prev_state != state) {
272 qemu_input_update_buttons(scon->dcl.con, bmap, prev_state, state);
273 prev_state = state;
274 }
275
276 if (qemu_input_is_absolute()) {
277 qemu_input_queue_abs(scon->dcl.con, INPUT_AXIS_X,
278 x, 0, surface_width(scon->surface));
279 qemu_input_queue_abs(scon->dcl.con, INPUT_AXIS_Y,
280 y, 0, surface_height(scon->surface));
281 } else {
282 if (guest_cursor) {
283 x -= guest_x;
284 y -= guest_y;
285 guest_x += x;
286 guest_y += y;
287 dx = x;
288 dy = y;
289 }
290 qemu_input_queue_rel(scon->dcl.con, INPUT_AXIS_X, dx);
291 qemu_input_queue_rel(scon->dcl.con, INPUT_AXIS_Y, dy);
292 }
293 qemu_input_event_sync();
294}
295
296static void toggle_full_screen(struct sdl2_console *scon)
297{
298 gui_fullscreen = !gui_fullscreen;
299 if (gui_fullscreen) {
300 SDL_SetWindowFullscreen(scon->real_window,
301 SDL_WINDOW_FULLSCREEN_DESKTOP);
302 gui_saved_grab = gui_grab;
303 sdl_grab_start(scon);
304 } else {
305 if (!gui_saved_grab) {
306 sdl_grab_end(scon);
307 }
308 SDL_SetWindowFullscreen(scon->real_window, 0);
309 }
310 sdl2_redraw(scon);
311}
312
313static int get_mod_state(void)
314{
315 SDL_Keymod mod = SDL_GetModState();
316
317 if (alt_grab) {
318 return (mod & (gui_grab_code | KMOD_LSHIFT)) ==
319 (gui_grab_code | KMOD_LSHIFT);
320 } else if (ctrl_grab) {
321 return (mod & KMOD_RCTRL) == KMOD_RCTRL;
322 } else {
323 return (mod & gui_grab_code) == gui_grab_code;
324 }
325}
326
327static void handle_keydown(SDL_Event *ev)
328{
329 int win;
330 struct sdl2_console *scon = get_scon_from_window(ev->key.windowID);
331 int gui_key_modifier_pressed = get_mod_state();
332 int gui_keysym = 0;
333
334 if (!scon->ignore_hotkeys && gui_key_modifier_pressed && !ev->key.repeat) {
335 switch (ev->key.keysym.scancode) {
336 case SDL_SCANCODE_2:
337 case SDL_SCANCODE_3:
338 case SDL_SCANCODE_4:
339 case SDL_SCANCODE_5:
340 case SDL_SCANCODE_6:
341 case SDL_SCANCODE_7:
342 case SDL_SCANCODE_8:
343 case SDL_SCANCODE_9:
344 if (gui_grab) {
345 sdl_grab_end(scon);
346 }
347
348 win = ev->key.keysym.scancode - SDL_SCANCODE_1;
349 if (win < sdl2_num_outputs) {
350 sdl2_console[win].hidden = !sdl2_console[win].hidden;
351 if (sdl2_console[win].real_window) {
352 if (sdl2_console[win].hidden) {
353 SDL_HideWindow(sdl2_console[win].real_window);
354 } else {
355 SDL_ShowWindow(sdl2_console[win].real_window);
356 }
357 }
358 gui_keysym = 1;
359 }
360 break;
361 case SDL_SCANCODE_F:
362 toggle_full_screen(scon);
363 gui_keysym = 1;
364 break;
365 case SDL_SCANCODE_G:
366 gui_keysym = 1;
367 if (!gui_grab) {
368 sdl_grab_start(scon);
369 } else if (!gui_fullscreen) {
370 sdl_grab_end(scon);
371 }
372 break;
373 case SDL_SCANCODE_U:
374 sdl2_window_resize(scon);
375 if (!scon->opengl) {
376
377 sdl2_2d_switch(&scon->dcl, scon->surface);
378 }
379 gui_keysym = 1;
380 break;
381#if 0
382 case SDL_SCANCODE_KP_PLUS:
383 case SDL_SCANCODE_KP_MINUS:
384 if (!gui_fullscreen) {
385 int scr_w, scr_h;
386 int width, height;
387 SDL_GetWindowSize(scon->real_window, &scr_w, &scr_h);
388
389 width = MAX(scr_w + (ev->key.keysym.scancode ==
390 SDL_SCANCODE_KP_PLUS ? 50 : -50),
391 160);
392 height = (surface_height(scon->surface) * width) /
393 surface_width(scon->surface);
394 fprintf(stderr, "%s: scale to %dx%d\n",
395 __func__, width, height);
396 sdl_scale(scon, width, height);
397 sdl2_redraw(scon);
398 gui_keysym = 1;
399 }
400#endif
401 default:
402 break;
403 }
404 }
405 if (!gui_keysym) {
406 sdl2_process_key(scon, &ev->key);
407 }
408}
409
410static void handle_keyup(SDL_Event *ev)
411{
412 struct sdl2_console *scon = get_scon_from_window(ev->key.windowID);
413
414 scon->ignore_hotkeys = false;
415 sdl2_process_key(scon, &ev->key);
416}
417
418static void handle_textinput(SDL_Event *ev)
419{
420 struct sdl2_console *scon = get_scon_from_window(ev->text.windowID);
421 QemuConsole *con = scon ? scon->dcl.con : NULL;
422
423 if (qemu_console_is_graphic(con)) {
424 return;
425 }
426 kbd_put_string_console(con, ev->text.text, strlen(ev->text.text));
427}
428
429static void handle_mousemotion(SDL_Event *ev)
430{
431 int max_x, max_y;
432 struct sdl2_console *scon = get_scon_from_window(ev->motion.windowID);
433
434 if (!scon || !qemu_console_is_graphic(scon->dcl.con)) {
435 return;
436 }
437
438 if (qemu_input_is_absolute() || absolute_enabled) {
439 int scr_w, scr_h;
440 SDL_GetWindowSize(scon->real_window, &scr_w, &scr_h);
441 max_x = scr_w - 1;
442 max_y = scr_h - 1;
443 if (gui_grab && !gui_fullscreen
444 && (ev->motion.x == 0 || ev->motion.y == 0 ||
445 ev->motion.x == max_x || ev->motion.y == max_y)) {
446 sdl_grab_end(scon);
447 }
448 if (!gui_grab &&
449 (ev->motion.x > 0 && ev->motion.x < max_x &&
450 ev->motion.y > 0 && ev->motion.y < max_y)) {
451 sdl_grab_start(scon);
452 }
453 }
454 if (gui_grab || qemu_input_is_absolute() || absolute_enabled) {
455 sdl_send_mouse_event(scon, ev->motion.xrel, ev->motion.yrel,
456 ev->motion.x, ev->motion.y, ev->motion.state);
457 }
458}
459
460static void handle_mousebutton(SDL_Event *ev)
461{
462 int buttonstate = SDL_GetMouseState(NULL, NULL);
463 SDL_MouseButtonEvent *bev;
464 struct sdl2_console *scon = get_scon_from_window(ev->button.windowID);
465
466 if (!scon || !qemu_console_is_graphic(scon->dcl.con)) {
467 return;
468 }
469
470 bev = &ev->button;
471 if (!gui_grab && !qemu_input_is_absolute()) {
472 if (ev->type == SDL_MOUSEBUTTONUP && bev->button == SDL_BUTTON_LEFT) {
473
474 sdl_grab_start(scon);
475 }
476 } else {
477 if (ev->type == SDL_MOUSEBUTTONDOWN) {
478 buttonstate |= SDL_BUTTON(bev->button);
479 } else {
480 buttonstate &= ~SDL_BUTTON(bev->button);
481 }
482 sdl_send_mouse_event(scon, 0, 0, bev->x, bev->y, buttonstate);
483 }
484}
485
486static void handle_mousewheel(SDL_Event *ev)
487{
488 struct sdl2_console *scon = get_scon_from_window(ev->wheel.windowID);
489 SDL_MouseWheelEvent *wev = &ev->wheel;
490 InputButton btn;
491
492 if (!scon || !qemu_console_is_graphic(scon->dcl.con)) {
493 return;
494 }
495
496 if (wev->y > 0) {
497 btn = INPUT_BUTTON_WHEEL_UP;
498 } else if (wev->y < 0) {
499 btn = INPUT_BUTTON_WHEEL_DOWN;
500 } else {
501 return;
502 }
503
504 qemu_input_queue_btn(scon->dcl.con, btn, true);
505 qemu_input_event_sync();
506 qemu_input_queue_btn(scon->dcl.con, btn, false);
507 qemu_input_event_sync();
508}
509
510static void handle_windowevent(SDL_Event *ev)
511{
512 struct sdl2_console *scon = get_scon_from_window(ev->window.windowID);
513 bool allow_close = true;
514
515 if (!scon) {
516 return;
517 }
518
519 switch (ev->window.event) {
520 case SDL_WINDOWEVENT_RESIZED:
521 {
522 QemuUIInfo info;
523 memset(&info, 0, sizeof(info));
524 info.width = ev->window.data1;
525 info.height = ev->window.data2;
526 dpy_set_ui_info(scon->dcl.con, &info);
527 }
528 sdl2_redraw(scon);
529 break;
530 case SDL_WINDOWEVENT_EXPOSED:
531 sdl2_redraw(scon);
532 break;
533 case SDL_WINDOWEVENT_FOCUS_GAINED:
534 case SDL_WINDOWEVENT_ENTER:
535 if (!gui_grab && (qemu_input_is_absolute() || absolute_enabled)) {
536 absolute_mouse_grab(scon);
537 }
538
539
540
541
542
543
544
545 scon->ignore_hotkeys = get_mod_state();
546 break;
547 case SDL_WINDOWEVENT_FOCUS_LOST:
548 if (gui_grab && !gui_fullscreen) {
549 sdl_grab_end(scon);
550 }
551 break;
552 case SDL_WINDOWEVENT_RESTORED:
553 update_displaychangelistener(&scon->dcl, GUI_REFRESH_INTERVAL_DEFAULT);
554 break;
555 case SDL_WINDOWEVENT_MINIMIZED:
556 update_displaychangelistener(&scon->dcl, 500);
557 break;
558 case SDL_WINDOWEVENT_CLOSE:
559 if (qemu_console_is_graphic(scon->dcl.con)) {
560 if (scon->opts->has_window_close && !scon->opts->window_close) {
561 allow_close = false;
562 }
563 if (allow_close) {
564 no_shutdown = 0;
565 qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_UI);
566 }
567 } else {
568 SDL_HideWindow(scon->real_window);
569 scon->hidden = true;
570 }
571 break;
572 case SDL_WINDOWEVENT_SHOWN:
573 scon->hidden = false;
574 break;
575 case SDL_WINDOWEVENT_HIDDEN:
576 scon->hidden = true;
577 break;
578 }
579}
580
581void sdl2_poll_events(struct sdl2_console *scon)
582{
583 SDL_Event ev1, *ev = &ev1;
584 bool allow_close = true;
585 int idle = 1;
586
587 if (scon->last_vm_running != runstate_is_running()) {
588 scon->last_vm_running = runstate_is_running();
589 sdl_update_caption(scon);
590 }
591
592 while (SDL_PollEvent(ev)) {
593 switch (ev->type) {
594 case SDL_KEYDOWN:
595 idle = 0;
596 handle_keydown(ev);
597 break;
598 case SDL_KEYUP:
599 idle = 0;
600 handle_keyup(ev);
601 break;
602 case SDL_TEXTINPUT:
603 idle = 0;
604 handle_textinput(ev);
605 break;
606 case SDL_QUIT:
607 if (scon->opts->has_window_close && !scon->opts->window_close) {
608 allow_close = false;
609 }
610 if (allow_close) {
611 no_shutdown = 0;
612 qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_UI);
613 }
614 break;
615 case SDL_MOUSEMOTION:
616 idle = 0;
617 handle_mousemotion(ev);
618 break;
619 case SDL_MOUSEBUTTONDOWN:
620 case SDL_MOUSEBUTTONUP:
621 idle = 0;
622 handle_mousebutton(ev);
623 break;
624 case SDL_MOUSEWHEEL:
625 idle = 0;
626 handle_mousewheel(ev);
627 break;
628 case SDL_WINDOWEVENT:
629 handle_windowevent(ev);
630 break;
631 default:
632 break;
633 }
634 }
635
636 if (idle) {
637 if (scon->idle_counter < SDL2_MAX_IDLE_COUNT) {
638 scon->idle_counter++;
639 if (scon->idle_counter >= SDL2_MAX_IDLE_COUNT) {
640 scon->dcl.update_interval = GUI_REFRESH_INTERVAL_DEFAULT;
641 }
642 }
643 } else {
644 scon->idle_counter = 0;
645 scon->dcl.update_interval = SDL2_REFRESH_INTERVAL_BUSY;
646 }
647}
648
649static void sdl_mouse_warp(DisplayChangeListener *dcl,
650 int x, int y, int on)
651{
652 struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl);
653
654 if (!qemu_console_is_graphic(scon->dcl.con)) {
655 return;
656 }
657
658 if (on) {
659 if (!guest_cursor) {
660 sdl_show_cursor();
661 }
662 if (gui_grab || qemu_input_is_absolute() || absolute_enabled) {
663 SDL_SetCursor(guest_sprite);
664 if (!qemu_input_is_absolute() && !absolute_enabled) {
665 SDL_WarpMouseInWindow(scon->real_window, x, y);
666 }
667 }
668 } else if (gui_grab) {
669 sdl_hide_cursor();
670 }
671 guest_cursor = on;
672 guest_x = x, guest_y = y;
673}
674
675static void sdl_mouse_define(DisplayChangeListener *dcl,
676 QEMUCursor *c)
677{
678
679 if (guest_sprite) {
680 SDL_FreeCursor(guest_sprite);
681 }
682
683 if (guest_sprite_surface) {
684 SDL_FreeSurface(guest_sprite_surface);
685 }
686
687 guest_sprite_surface =
688 SDL_CreateRGBSurfaceFrom(c->data, c->width, c->height, 32, c->width * 4,
689 0xff0000, 0x00ff00, 0xff, 0xff000000);
690
691 if (!guest_sprite_surface) {
692 fprintf(stderr, "Failed to make rgb surface from %p\n", c);
693 return;
694 }
695 guest_sprite = SDL_CreateColorCursor(guest_sprite_surface,
696 c->hot_x, c->hot_y);
697 if (!guest_sprite) {
698 fprintf(stderr, "Failed to make color cursor from %p\n", c);
699 return;
700 }
701 if (guest_cursor &&
702 (gui_grab || qemu_input_is_absolute() || absolute_enabled)) {
703 SDL_SetCursor(guest_sprite);
704 }
705}
706
707static void sdl_cleanup(void)
708{
709 if (guest_sprite) {
710 SDL_FreeCursor(guest_sprite);
711 }
712 SDL_QuitSubSystem(SDL_INIT_VIDEO);
713}
714
715static const DisplayChangeListenerOps dcl_2d_ops = {
716 .dpy_name = "sdl2-2d",
717 .dpy_gfx_update = sdl2_2d_update,
718 .dpy_gfx_switch = sdl2_2d_switch,
719 .dpy_gfx_check_format = sdl2_2d_check_format,
720 .dpy_refresh = sdl2_2d_refresh,
721 .dpy_mouse_set = sdl_mouse_warp,
722 .dpy_cursor_define = sdl_mouse_define,
723};
724
725#ifdef CONFIG_OPENGL
726static const DisplayChangeListenerOps dcl_gl_ops = {
727 .dpy_name = "sdl2-gl",
728 .dpy_gfx_update = sdl2_gl_update,
729 .dpy_gfx_switch = sdl2_gl_switch,
730 .dpy_gfx_check_format = console_gl_check_format,
731 .dpy_refresh = sdl2_gl_refresh,
732 .dpy_mouse_set = sdl_mouse_warp,
733 .dpy_cursor_define = sdl_mouse_define,
734
735 .dpy_gl_ctx_create = sdl2_gl_create_context,
736 .dpy_gl_ctx_destroy = sdl2_gl_destroy_context,
737 .dpy_gl_ctx_make_current = sdl2_gl_make_context_current,
738 .dpy_gl_ctx_get_current = sdl2_gl_get_current_context,
739 .dpy_gl_scanout_disable = sdl2_gl_scanout_disable,
740 .dpy_gl_scanout_texture = sdl2_gl_scanout_texture,
741 .dpy_gl_update = sdl2_gl_scanout_flush,
742};
743#endif
744
745static void sdl2_display_early_init(DisplayOptions *o)
746{
747 assert(o->type == DISPLAY_TYPE_SDL);
748 if (o->has_gl && o->gl) {
749#ifdef CONFIG_OPENGL
750 display_opengl = 1;
751#endif
752 }
753}
754
755static void sdl2_display_init(DisplayState *ds, DisplayOptions *o)
756{
757 uint8_t data = 0;
758 int i;
759 SDL_SysWMinfo info;
760 SDL_Surface *icon = NULL;
761
762 assert(o->type == DISPLAY_TYPE_SDL);
763
764#ifdef __linux__
765
766
767
768
769
770
771
772
773
774 setenv("SDL_VIDEODRIVER", "x11", 0);
775#endif
776
777 if (SDL_Init(SDL_INIT_VIDEO)) {
778 fprintf(stderr, "Could not initialize SDL(%s) - exiting\n",
779 SDL_GetError());
780 exit(1);
781 }
782#ifdef SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
783 SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0");
784#endif
785 SDL_SetHint(SDL_HINT_GRAB_KEYBOARD, "1");
786 memset(&info, 0, sizeof(info));
787 SDL_VERSION(&info.version);
788
789 gui_fullscreen = o->has_full_screen && o->full_screen;
790
791 for (i = 0;; i++) {
792 QemuConsole *con = qemu_console_lookup_by_index(i);
793 if (!con) {
794 break;
795 }
796 }
797 sdl2_num_outputs = i;
798 if (sdl2_num_outputs == 0) {
799 return;
800 }
801 sdl2_console = g_new0(struct sdl2_console, sdl2_num_outputs);
802 for (i = 0; i < sdl2_num_outputs; i++) {
803 QemuConsole *con = qemu_console_lookup_by_index(i);
804 assert(con != NULL);
805 if (!qemu_console_is_graphic(con) &&
806 qemu_console_get_index(con) != 0) {
807 sdl2_console[i].hidden = true;
808 }
809 sdl2_console[i].idx = i;
810 sdl2_console[i].opts = o;
811#ifdef CONFIG_OPENGL
812 sdl2_console[i].opengl = display_opengl;
813 sdl2_console[i].dcl.ops = display_opengl ? &dcl_gl_ops : &dcl_2d_ops;
814#else
815 sdl2_console[i].opengl = 0;
816 sdl2_console[i].dcl.ops = &dcl_2d_ops;
817#endif
818 sdl2_console[i].dcl.con = con;
819 sdl2_console[i].kbd = qkbd_state_init(con);
820 register_displaychangelistener(&sdl2_console[i].dcl);
821
822#if defined(SDL_VIDEO_DRIVER_WINDOWS) || defined(SDL_VIDEO_DRIVER_X11)
823 if (SDL_GetWindowWMInfo(sdl2_console[i].real_window, &info)) {
824#if defined(SDL_VIDEO_DRIVER_WINDOWS)
825 qemu_console_set_window_id(con, (uintptr_t)info.info.win.window);
826#elif defined(SDL_VIDEO_DRIVER_X11)
827 qemu_console_set_window_id(con, info.info.x11.window);
828#endif
829 }
830#endif
831 }
832
833#ifdef CONFIG_SDL_IMAGE
834 icon = IMG_Load(CONFIG_QEMU_ICONDIR "/hicolor/128x128/apps/qemu.png");
835#else
836
837 icon = SDL_LoadBMP(CONFIG_QEMU_ICONDIR "/hicolor/32x32/apps/qemu.bmp");
838 if (icon) {
839 uint32_t colorkey = SDL_MapRGB(icon->format, 255, 255, 255);
840 SDL_SetColorKey(icon, SDL_TRUE, colorkey);
841 }
842#endif
843 if (icon) {
844 SDL_SetWindowIcon(sdl2_console[0].real_window, icon);
845 }
846
847 gui_grab = 0;
848 if (gui_fullscreen) {
849 sdl_grab_start(0);
850 }
851
852 mouse_mode_notifier.notify = sdl_mouse_mode_change;
853 qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier);
854
855 sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
856 sdl_cursor_normal = SDL_GetCursor();
857
858 atexit(sdl_cleanup);
859}
860
861static QemuDisplay qemu_display_sdl2 = {
862 .type = DISPLAY_TYPE_SDL,
863 .early_init = sdl2_display_early_init,
864 .init = sdl2_display_init,
865};
866
867static void register_sdl1(void)
868{
869 qemu_display_register(&qemu_display_sdl2);
870}
871
872type_init(register_sdl1);
873
