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