xref: /openbmc/qemu/ui/sdl2.c (revision 39164c13)
1 /*
2  * QEMU SDL display driver
3  *
4  * Copyright (c) 2003 Fabrice Bellard
5  *
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:
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  */
24 /* Ported SDL 1.2 code to 2.0 by Dave Airlie. */
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 
33 static int sdl2_num_outputs;
34 static struct sdl2_console *sdl2_console;
35 
36 static SDL_Surface *guest_sprite_surface;
37 static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
38 
39 static int gui_saved_grab;
40 static int gui_fullscreen;
41 static int gui_noframe;
42 static int gui_key_modifier_pressed;
43 static int gui_keysym;
44 static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
45 static SDL_Cursor *sdl_cursor_normal;
46 static SDL_Cursor *sdl_cursor_hidden;
47 static int absolute_enabled;
48 static int guest_cursor;
49 static int guest_x, guest_y;
50 static SDL_Cursor *guest_sprite;
51 static Notifier mouse_mode_notifier;
52 
53 #define SDL2_REFRESH_INTERVAL_BUSY 10
54 #define SDL2_MAX_IDLE_COUNT (2 * GUI_REFRESH_INTERVAL_DEFAULT \
55                              / SDL2_REFRESH_INTERVAL_BUSY + 1)
56 
57 static void sdl_update_caption(struct sdl2_console *scon);
58 
59 static struct sdl2_console *get_scon_from_window(uint32_t window_id)
60 {
61     int i;
62     for (i = 0; i < sdl2_num_outputs; i++) {
63         if (sdl2_console[i].real_window == SDL_GetWindowFromID(window_id)) {
64             return &sdl2_console[i];
65         }
66     }
67     return NULL;
68 }
69 
70 void sdl2_window_create(struct sdl2_console *scon)
71 {
72     int flags = 0;
73 
74     if (!scon->surface) {
75         return;
76     }
77     assert(!scon->real_window);
78 
79     if (gui_fullscreen) {
80         flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
81     } else {
82         flags |= SDL_WINDOW_RESIZABLE;
83     }
84     if (scon->hidden) {
85         flags |= SDL_WINDOW_HIDDEN;
86     }
87 
88     scon->real_window = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED,
89                                          SDL_WINDOWPOS_UNDEFINED,
90                                          surface_width(scon->surface),
91                                          surface_height(scon->surface),
92                                          flags);
93     scon->real_renderer = SDL_CreateRenderer(scon->real_window, -1, 0);
94     if (scon->opengl) {
95         scon->winctx = SDL_GL_GetCurrentContext();
96     }
97     sdl_update_caption(scon);
98 }
99 
100 void sdl2_window_destroy(struct sdl2_console *scon)
101 {
102     if (!scon->real_window) {
103         return;
104     }
105 
106     SDL_DestroyRenderer(scon->real_renderer);
107     scon->real_renderer = NULL;
108     SDL_DestroyWindow(scon->real_window);
109     scon->real_window = NULL;
110 }
111 
112 void sdl2_window_resize(struct sdl2_console *scon)
113 {
114     if (!scon->real_window) {
115         return;
116     }
117 
118     SDL_SetWindowSize(scon->real_window,
119                       surface_width(scon->surface),
120                       surface_height(scon->surface));
121 }
122 
123 static void sdl2_redraw(struct sdl2_console *scon)
124 {
125     if (scon->opengl) {
126 #ifdef CONFIG_OPENGL
127         sdl2_gl_redraw(scon);
128 #endif
129     } else {
130         sdl2_2d_redraw(scon);
131     }
132 }
133 
134 static void sdl_update_caption(struct sdl2_console *scon)
135 {
136     char win_title[1024];
137     char icon_title[1024];
138     const char *status = "";
139 
140     if (!runstate_is_running()) {
141         status = " [Stopped]";
142     } else if (gui_grab) {
143         if (alt_grab) {
144             status = " - Press Ctrl-Alt-Shift to exit grab";
145         } else if (ctrl_grab) {
146             status = " - Press Right-Ctrl to exit grab";
147         } else {
148             status = " - Press Ctrl-Alt to exit grab";
149         }
150     }
151 
152     if (qemu_name) {
153         snprintf(win_title, sizeof(win_title), "QEMU (%s-%d)%s", qemu_name,
154                  scon->idx, status);
155         snprintf(icon_title, sizeof(icon_title), "QEMU (%s)", qemu_name);
156     } else {
157         snprintf(win_title, sizeof(win_title), "QEMU%s", status);
158         snprintf(icon_title, sizeof(icon_title), "QEMU");
159     }
160 
161     if (scon->real_window) {
162         SDL_SetWindowTitle(scon->real_window, win_title);
163     }
164 }
165 
166 static void sdl_hide_cursor(void)
167 {
168     if (!cursor_hide) {
169         return;
170     }
171 
172     if (qemu_input_is_absolute()) {
173         SDL_ShowCursor(1);
174         SDL_SetCursor(sdl_cursor_hidden);
175     } else {
176         SDL_SetRelativeMouseMode(SDL_TRUE);
177     }
178 }
179 
180 static void sdl_show_cursor(void)
181 {
182     if (!cursor_hide) {
183         return;
184     }
185 
186     if (!qemu_input_is_absolute()) {
187         SDL_SetRelativeMouseMode(SDL_FALSE);
188         SDL_ShowCursor(1);
189         if (guest_cursor &&
190             (gui_grab || qemu_input_is_absolute() || absolute_enabled)) {
191             SDL_SetCursor(guest_sprite);
192         } else {
193             SDL_SetCursor(sdl_cursor_normal);
194         }
195     }
196 }
197 
198 static 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      * If the application is not active, do not try to enter grab state. This
207      * prevents 'SDL_WM_GrabInput(SDL_GRAB_ON)' from blocking all the
208      * application (SDL bug).
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 
226 static 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 
234 static 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 
246 static 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             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 
261 static 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         int scr_w, scr_h;
278         int max_w = 0, max_h = 0;
279         int off_x = 0, off_y = 0;
280         int cur_off_x = 0, cur_off_y = 0;
281         int i;
282 
283         for (i = 0; i < sdl2_num_outputs; i++) {
284             struct sdl2_console *thiscon = &sdl2_console[i];
285             if (thiscon->real_window && thiscon->surface) {
286                 SDL_GetWindowSize(thiscon->real_window, &scr_w, &scr_h);
287                 cur_off_x = thiscon->x;
288                 cur_off_y = thiscon->y;
289                 if (scr_w + cur_off_x > max_w) {
290                     max_w = scr_w + cur_off_x;
291                 }
292                 if (scr_h + cur_off_y > max_h) {
293                     max_h = scr_h + cur_off_y;
294                 }
295                 if (i == scon->idx) {
296                     off_x = cur_off_x;
297                     off_y = cur_off_y;
298                 }
299             }
300         }
301         qemu_input_queue_abs(scon->dcl.con, INPUT_AXIS_X, off_x + x, max_w);
302         qemu_input_queue_abs(scon->dcl.con, INPUT_AXIS_Y, off_y + y, max_h);
303     } else {
304         if (guest_cursor) {
305             x -= guest_x;
306             y -= guest_y;
307             guest_x += x;
308             guest_y += y;
309             dx = x;
310             dy = y;
311         }
312         qemu_input_queue_rel(scon->dcl.con, INPUT_AXIS_X, dx);
313         qemu_input_queue_rel(scon->dcl.con, INPUT_AXIS_Y, dy);
314     }
315     qemu_input_event_sync();
316 }
317 
318 static void toggle_full_screen(struct sdl2_console *scon)
319 {
320     gui_fullscreen = !gui_fullscreen;
321     if (gui_fullscreen) {
322         SDL_SetWindowFullscreen(scon->real_window,
323                                 SDL_WINDOW_FULLSCREEN_DESKTOP);
324         gui_saved_grab = gui_grab;
325         sdl_grab_start(scon);
326     } else {
327         if (!gui_saved_grab) {
328             sdl_grab_end(scon);
329         }
330         SDL_SetWindowFullscreen(scon->real_window, 0);
331     }
332     sdl2_redraw(scon);
333 }
334 
335 static void handle_keydown(SDL_Event *ev)
336 {
337     int mod_state, win;
338     struct sdl2_console *scon = get_scon_from_window(ev->key.windowID);
339 
340     if (alt_grab) {
341         mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
342             (gui_grab_code | KMOD_LSHIFT);
343     } else if (ctrl_grab) {
344         mod_state = (SDL_GetModState() & KMOD_RCTRL) == KMOD_RCTRL;
345     } else {
346         mod_state = (SDL_GetModState() & gui_grab_code) == gui_grab_code;
347     }
348     gui_key_modifier_pressed = mod_state;
349 
350     if (gui_key_modifier_pressed) {
351         switch (ev->key.keysym.scancode) {
352         case SDL_SCANCODE_2:
353         case SDL_SCANCODE_3:
354         case SDL_SCANCODE_4:
355         case SDL_SCANCODE_5:
356         case SDL_SCANCODE_6:
357         case SDL_SCANCODE_7:
358         case SDL_SCANCODE_8:
359         case SDL_SCANCODE_9:
360             if (gui_grab) {
361                 sdl_grab_end(scon);
362             }
363 
364             win = ev->key.keysym.scancode - SDL_SCANCODE_1;
365             if (win < sdl2_num_outputs) {
366                 sdl2_console[win].hidden = !sdl2_console[win].hidden;
367                 if (sdl2_console[win].real_window) {
368                     if (sdl2_console[win].hidden) {
369                         SDL_HideWindow(sdl2_console[win].real_window);
370                     } else {
371                         SDL_ShowWindow(sdl2_console[win].real_window);
372                     }
373                 }
374                 gui_keysym = 1;
375             }
376             break;
377         case SDL_SCANCODE_F:
378             toggle_full_screen(scon);
379             gui_keysym = 1;
380             break;
381         case SDL_SCANCODE_U:
382             sdl2_window_destroy(scon);
383             sdl2_window_create(scon);
384             if (!scon->opengl) {
385                 /* re-create scon->texture */
386                 sdl2_2d_switch(&scon->dcl, scon->surface);
387             }
388             gui_keysym = 1;
389             break;
390 #if 0
391         case SDL_SCANCODE_KP_PLUS:
392         case SDL_SCANCODE_KP_MINUS:
393             if (!gui_fullscreen) {
394                 int scr_w, scr_h;
395                 int width, height;
396                 SDL_GetWindowSize(scon->real_window, &scr_w, &scr_h);
397 
398                 width = MAX(scr_w + (ev->key.keysym.scancode ==
399                                      SDL_SCANCODE_KP_PLUS ? 50 : -50),
400                             160);
401                 height = (surface_height(scon->surface) * width) /
402                     surface_width(scon->surface);
403                 fprintf(stderr, "%s: scale to %dx%d\n",
404                         __func__, width, height);
405                 sdl_scale(scon, width, height);
406                 sdl2_redraw(scon);
407                 gui_keysym = 1;
408             }
409 #endif
410         default:
411             break;
412         }
413     }
414     if (!gui_keysym) {
415         sdl2_process_key(scon, &ev->key);
416     }
417 }
418 
419 static void handle_keyup(SDL_Event *ev)
420 {
421     int mod_state;
422     struct sdl2_console *scon = get_scon_from_window(ev->key.windowID);
423 
424     if (!alt_grab) {
425         mod_state = (ev->key.keysym.mod & gui_grab_code);
426     } else {
427         mod_state = (ev->key.keysym.mod & (gui_grab_code | KMOD_LSHIFT));
428     }
429     if (!mod_state && gui_key_modifier_pressed) {
430         gui_key_modifier_pressed = 0;
431         if (gui_keysym == 0) {
432             /* exit/enter grab if pressing Ctrl-Alt */
433             if (!gui_grab) {
434                 sdl_grab_start(scon);
435             } else if (!gui_fullscreen) {
436                 sdl_grab_end(scon);
437             }
438             /* SDL does not send back all the modifiers key, so we must
439              * correct it. */
440             sdl2_reset_keys(scon);
441             return;
442         }
443         gui_keysym = 0;
444     }
445     if (!gui_keysym) {
446         sdl2_process_key(scon, &ev->key);
447     }
448 }
449 
450 static void handle_textinput(SDL_Event *ev)
451 {
452     struct sdl2_console *scon = get_scon_from_window(ev->key.windowID);
453     QemuConsole *con = scon ? scon->dcl.con : NULL;
454 
455     if (qemu_console_is_graphic(con)) {
456         return;
457     }
458     kbd_put_string_console(con, ev->text.text, strlen(ev->text.text));
459 }
460 
461 static void handle_mousemotion(SDL_Event *ev)
462 {
463     int max_x, max_y;
464     struct sdl2_console *scon = get_scon_from_window(ev->key.windowID);
465 
466     if (qemu_input_is_absolute() || absolute_enabled) {
467         int scr_w, scr_h;
468         SDL_GetWindowSize(scon->real_window, &scr_w, &scr_h);
469         max_x = scr_w - 1;
470         max_y = scr_h - 1;
471         if (gui_grab && (ev->motion.x == 0 || ev->motion.y == 0 ||
472                          ev->motion.x == max_x || ev->motion.y == max_y)) {
473             sdl_grab_end(scon);
474         }
475         if (!gui_grab &&
476             (ev->motion.x > 0 && ev->motion.x < max_x &&
477              ev->motion.y > 0 && ev->motion.y < max_y)) {
478             sdl_grab_start(scon);
479         }
480     }
481     if (gui_grab || qemu_input_is_absolute() || absolute_enabled) {
482         sdl_send_mouse_event(scon, ev->motion.xrel, ev->motion.yrel,
483                              ev->motion.x, ev->motion.y, ev->motion.state);
484     }
485 }
486 
487 static void handle_mousebutton(SDL_Event *ev)
488 {
489     int buttonstate = SDL_GetMouseState(NULL, NULL);
490     SDL_MouseButtonEvent *bev;
491     struct sdl2_console *scon = get_scon_from_window(ev->key.windowID);
492 
493     bev = &ev->button;
494     if (!gui_grab && !qemu_input_is_absolute()) {
495         if (ev->type == SDL_MOUSEBUTTONUP && bev->button == SDL_BUTTON_LEFT) {
496             /* start grabbing all events */
497             sdl_grab_start(scon);
498         }
499     } else {
500         if (ev->type == SDL_MOUSEBUTTONDOWN) {
501             buttonstate |= SDL_BUTTON(bev->button);
502         } else {
503             buttonstate &= ~SDL_BUTTON(bev->button);
504         }
505         sdl_send_mouse_event(scon, 0, 0, bev->x, bev->y, buttonstate);
506     }
507 }
508 
509 static void handle_mousewheel(SDL_Event *ev)
510 {
511     struct sdl2_console *scon = get_scon_from_window(ev->key.windowID);
512     SDL_MouseWheelEvent *wev = &ev->wheel;
513     InputButton btn;
514 
515     if (wev->y > 0) {
516         btn = INPUT_BUTTON_WHEEL_UP;
517     } else if (wev->y < 0) {
518         btn = INPUT_BUTTON_WHEEL_DOWN;
519     } else {
520         return;
521     }
522 
523     qemu_input_queue_btn(scon->dcl.con, btn, true);
524     qemu_input_event_sync();
525     qemu_input_queue_btn(scon->dcl.con, btn, false);
526     qemu_input_event_sync();
527 }
528 
529 static void handle_windowevent(SDL_Event *ev)
530 {
531     struct sdl2_console *scon = get_scon_from_window(ev->window.windowID);
532 
533     if (!scon) {
534         return;
535     }
536 
537     switch (ev->window.event) {
538     case SDL_WINDOWEVENT_RESIZED:
539         {
540             QemuUIInfo info;
541             memset(&info, 0, sizeof(info));
542             info.width = ev->window.data1;
543             info.height = ev->window.data2;
544             dpy_set_ui_info(scon->dcl.con, &info);
545         }
546         sdl2_redraw(scon);
547         break;
548     case SDL_WINDOWEVENT_EXPOSED:
549         sdl2_redraw(scon);
550         break;
551     case SDL_WINDOWEVENT_FOCUS_GAINED:
552     case SDL_WINDOWEVENT_ENTER:
553         if (!gui_grab && (qemu_input_is_absolute() || absolute_enabled)) {
554             absolute_mouse_grab(scon);
555         }
556         break;
557     case SDL_WINDOWEVENT_FOCUS_LOST:
558         if (gui_grab && !gui_fullscreen) {
559             sdl_grab_end(scon);
560         }
561         break;
562     case SDL_WINDOWEVENT_RESTORED:
563         update_displaychangelistener(&scon->dcl, GUI_REFRESH_INTERVAL_DEFAULT);
564         break;
565     case SDL_WINDOWEVENT_MINIMIZED:
566         update_displaychangelistener(&scon->dcl, 500);
567         break;
568     case SDL_WINDOWEVENT_CLOSE:
569         if (!no_quit) {
570             no_shutdown = 0;
571             qemu_system_shutdown_request();
572         }
573         break;
574     case SDL_WINDOWEVENT_SHOWN:
575         if (scon->hidden) {
576             SDL_HideWindow(scon->real_window);
577         }
578         break;
579     case SDL_WINDOWEVENT_HIDDEN:
580         if (!scon->hidden) {
581             SDL_ShowWindow(scon->real_window);
582         }
583         break;
584     }
585 }
586 
587 void sdl2_poll_events(struct sdl2_console *scon)
588 {
589     SDL_Event ev1, *ev = &ev1;
590     int idle = 1;
591 
592     if (scon->last_vm_running != runstate_is_running()) {
593         scon->last_vm_running = runstate_is_running();
594         sdl_update_caption(scon);
595     }
596 
597     while (SDL_PollEvent(ev)) {
598         switch (ev->type) {
599         case SDL_KEYDOWN:
600             idle = 0;
601             handle_keydown(ev);
602             break;
603         case SDL_KEYUP:
604             idle = 0;
605             handle_keyup(ev);
606             break;
607         case SDL_TEXTINPUT:
608             idle = 0;
609             handle_textinput(ev);
610             break;
611         case SDL_QUIT:
612             if (!no_quit) {
613                 no_shutdown = 0;
614                 qemu_system_shutdown_request();
615             }
616             break;
617         case SDL_MOUSEMOTION:
618             idle = 0;
619             handle_mousemotion(ev);
620             break;
621         case SDL_MOUSEBUTTONDOWN:
622         case SDL_MOUSEBUTTONUP:
623             idle = 0;
624             handle_mousebutton(ev);
625             break;
626         case SDL_MOUSEWHEEL:
627             idle = 0;
628             handle_mousewheel(ev);
629             break;
630         case SDL_WINDOWEVENT:
631             handle_windowevent(ev);
632             break;
633         default:
634             break;
635         }
636     }
637 
638     if (idle) {
639         if (scon->idle_counter < SDL2_MAX_IDLE_COUNT) {
640             scon->idle_counter++;
641             if (scon->idle_counter >= SDL2_MAX_IDLE_COUNT) {
642                 scon->dcl.update_interval = GUI_REFRESH_INTERVAL_DEFAULT;
643             }
644         }
645     } else {
646         scon->idle_counter = 0;
647         scon->dcl.update_interval = SDL2_REFRESH_INTERVAL_BUSY;
648     }
649 }
650 
651 static void sdl_mouse_warp(DisplayChangeListener *dcl,
652                            int x, int y, int on)
653 {
654     struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl);
655     if (on) {
656         if (!guest_cursor) {
657             sdl_show_cursor();
658         }
659         if (gui_grab || qemu_input_is_absolute() || absolute_enabled) {
660             SDL_SetCursor(guest_sprite);
661             if (!qemu_input_is_absolute() && !absolute_enabled) {
662                 SDL_WarpMouseInWindow(scon->real_window, x, y);
663             }
664         }
665     } else if (gui_grab) {
666         sdl_hide_cursor();
667     }
668     guest_cursor = on;
669     guest_x = x, guest_y = y;
670 }
671 
672 static void sdl_mouse_define(DisplayChangeListener *dcl,
673                              QEMUCursor *c)
674 {
675 
676     if (guest_sprite) {
677         SDL_FreeCursor(guest_sprite);
678     }
679 
680     if (guest_sprite_surface) {
681         SDL_FreeSurface(guest_sprite_surface);
682     }
683 
684     guest_sprite_surface =
685         SDL_CreateRGBSurfaceFrom(c->data, c->width, c->height, 32, c->width * 4,
686                                  0xff0000, 0x00ff00, 0xff, 0xff000000);
687 
688     if (!guest_sprite_surface) {
689         fprintf(stderr, "Failed to make rgb surface from %p\n", c);
690         return;
691     }
692     guest_sprite = SDL_CreateColorCursor(guest_sprite_surface,
693                                          c->hot_x, c->hot_y);
694     if (!guest_sprite) {
695         fprintf(stderr, "Failed to make color cursor from %p\n", c);
696         return;
697     }
698     if (guest_cursor &&
699         (gui_grab || qemu_input_is_absolute() || absolute_enabled)) {
700         SDL_SetCursor(guest_sprite);
701     }
702 }
703 
704 static void sdl_cleanup(void)
705 {
706     if (guest_sprite) {
707         SDL_FreeCursor(guest_sprite);
708     }
709     SDL_QuitSubSystem(SDL_INIT_VIDEO);
710 }
711 
712 static const DisplayChangeListenerOps dcl_2d_ops = {
713     .dpy_name             = "sdl2-2d",
714     .dpy_gfx_update       = sdl2_2d_update,
715     .dpy_gfx_switch       = sdl2_2d_switch,
716     .dpy_gfx_check_format = sdl2_2d_check_format,
717     .dpy_refresh          = sdl2_2d_refresh,
718     .dpy_mouse_set        = sdl_mouse_warp,
719     .dpy_cursor_define    = sdl_mouse_define,
720 };
721 
722 #ifdef CONFIG_OPENGL
723 static const DisplayChangeListenerOps dcl_gl_ops = {
724     .dpy_name                = "sdl2-gl",
725     .dpy_gfx_update          = sdl2_gl_update,
726     .dpy_gfx_switch          = sdl2_gl_switch,
727     .dpy_gfx_check_format    = console_gl_check_format,
728     .dpy_refresh             = sdl2_gl_refresh,
729     .dpy_mouse_set           = sdl_mouse_warp,
730     .dpy_cursor_define       = sdl_mouse_define,
731 
732     .dpy_gl_ctx_create       = sdl2_gl_create_context,
733     .dpy_gl_ctx_destroy      = sdl2_gl_destroy_context,
734     .dpy_gl_ctx_make_current = sdl2_gl_make_context_current,
735     .dpy_gl_ctx_get_current  = sdl2_gl_get_current_context,
736     .dpy_gl_scanout_disable  = sdl2_gl_scanout_disable,
737     .dpy_gl_scanout_texture  = sdl2_gl_scanout_texture,
738     .dpy_gl_update           = sdl2_gl_scanout_flush,
739 };
740 #endif
741 
742 void sdl_display_early_init(int opengl)
743 {
744     switch (opengl) {
745     case -1: /* default */
746     case 0:  /* off */
747         break;
748     case 1: /* on */
749 #ifdef CONFIG_OPENGL
750         display_opengl = 1;
751 #endif
752         break;
753     default:
754         g_assert_not_reached();
755         break;
756     }
757 }
758 
759 void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
760 {
761     int flags;
762     uint8_t data = 0;
763     char *filename;
764     int i;
765     SDL_SysWMinfo info;
766 
767     if (no_frame) {
768         gui_noframe = 1;
769     }
770 
771 #ifdef __linux__
772     /* on Linux, SDL may use fbcon|directfb|svgalib when run without
773      * accessible $DISPLAY to open X11 window.  This is often the case
774      * when qemu is run using sudo.  But in this case, and when actually
775      * run in X11 environment, SDL fights with X11 for the video card,
776      * making current display unavailable, often until reboot.
777      * So make x11 the default SDL video driver if this variable is unset.
778      * This is a bit hackish but saves us from bigger problem.
779      * Maybe it's a good idea to fix this in SDL instead.
780      */
781     setenv("SDL_VIDEODRIVER", "x11", 0);
782 #endif
783 
784     flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
785     if (SDL_Init(flags)) {
786         fprintf(stderr, "Could not initialize SDL(%s) - exiting\n",
787                 SDL_GetError());
788         exit(1);
789     }
790     SDL_SetHint(SDL_HINT_GRAB_KEYBOARD, "1");
791     memset(&info, 0, sizeof(info));
792     SDL_VERSION(&info.version);
793 
794     for (i = 0;; i++) {
795         QemuConsole *con = qemu_console_lookup_by_index(i);
796         if (!con) {
797             break;
798         }
799     }
800     sdl2_num_outputs = i;
801     if (sdl2_num_outputs == 0) {
802         return;
803     }
804     sdl2_console = g_new0(struct sdl2_console, sdl2_num_outputs);
805     for (i = 0; i < sdl2_num_outputs; i++) {
806         QemuConsole *con = qemu_console_lookup_by_index(i);
807         if (!qemu_console_is_graphic(con)) {
808             sdl2_console[i].hidden = true;
809         }
810         sdl2_console[i].idx = i;
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         register_displaychangelistener(&sdl2_console[i].dcl);
820 
821 #if defined(SDL_VIDEO_DRIVER_WINDOWS) || defined(SDL_VIDEO_DRIVER_X11)
822         if (SDL_GetWindowWMInfo(sdl2_console[i].real_window, &info)) {
823 #if defined(SDL_VIDEO_DRIVER_WINDOWS)
824             qemu_console_set_window_id(con, (uintptr_t)info.info.win.window);
825 #elif defined(SDL_VIDEO_DRIVER_X11)
826             qemu_console_set_window_id(con, info.info.x11.window);
827 #endif
828         }
829 #endif
830     }
831 
832     /* Load a 32x32x4 image. White pixels are transparent. */
833     filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu-icon.bmp");
834     if (filename) {
835         SDL_Surface *image = SDL_LoadBMP(filename);
836         if (image) {
837             uint32_t colorkey = SDL_MapRGB(image->format, 255, 255, 255);
838             SDL_SetColorKey(image, SDL_TRUE, colorkey);
839             SDL_SetWindowIcon(sdl2_console[0].real_window, image);
840         }
841         g_free(filename);
842     }
843 
844     if (full_screen) {
845         gui_fullscreen = 1;
846         sdl_grab_start(0);
847     }
848 
849     mouse_mode_notifier.notify = sdl_mouse_mode_change;
850     qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier);
851 
852     gui_grab = 0;
853 
854     sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
855     sdl_cursor_normal = SDL_GetCursor();
856 
857     atexit(sdl_cleanup);
858 }
859