Merge remote-tracking branch 'remotes/kraxel/tags/pull-vga-20170103-1' into staging
[qemu.git] / ui / sdl2.c
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 = sdl2_gl_scanout,
737 .dpy_gl_update = sdl2_gl_scanout_flush,
738 };
739 #endif
740
741 void sdl_display_early_init(int opengl)
742 {
743 switch (opengl) {
744 case -1: /* default */
745 case 0: /* off */
746 break;
747 case 1: /* on */
748 #ifdef CONFIG_OPENGL
749 display_opengl = 1;
750 #endif
751 break;
752 default:
753 g_assert_not_reached();
754 break;
755 }
756 }
757
758 void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
759 {
760 int flags;
761 uint8_t data = 0;
762 char *filename;
763 int i;
764
765 if (no_frame) {
766 gui_noframe = 1;
767 }
768
769 #ifdef __linux__
770 /* on Linux, SDL may use fbcon|directfb|svgalib when run without
771 * accessible $DISPLAY to open X11 window. This is often the case
772 * when qemu is run using sudo. But in this case, and when actually
773 * run in X11 environment, SDL fights with X11 for the video card,
774 * making current display unavailable, often until reboot.
775 * So make x11 the default SDL video driver if this variable is unset.
776 * This is a bit hackish but saves us from bigger problem.
777 * Maybe it's a good idea to fix this in SDL instead.
778 */
779 setenv("SDL_VIDEODRIVER", "x11", 0);
780 #endif
781
782 flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
783 if (SDL_Init(flags)) {
784 fprintf(stderr, "Could not initialize SDL(%s) - exiting\n",
785 SDL_GetError());
786 exit(1);
787 }
788 SDL_SetHint(SDL_HINT_GRAB_KEYBOARD, "1");
789
790 for (i = 0;; i++) {
791 QemuConsole *con = qemu_console_lookup_by_index(i);
792 if (!con) {
793 break;
794 }
795 }
796 sdl2_num_outputs = i;
797 if (sdl2_num_outputs == 0) {
798 return;
799 }
800 sdl2_console = g_new0(struct sdl2_console, sdl2_num_outputs);
801 for (i = 0; i < sdl2_num_outputs; i++) {
802 QemuConsole *con = qemu_console_lookup_by_index(i);
803 if (!qemu_console_is_graphic(con)) {
804 sdl2_console[i].hidden = true;
805 }
806 sdl2_console[i].idx = i;
807 #ifdef CONFIG_OPENGL
808 sdl2_console[i].opengl = display_opengl;
809 sdl2_console[i].dcl.ops = display_opengl ? &dcl_gl_ops : &dcl_2d_ops;
810 #else
811 sdl2_console[i].opengl = 0;
812 sdl2_console[i].dcl.ops = &dcl_2d_ops;
813 #endif
814 sdl2_console[i].dcl.con = con;
815 register_displaychangelistener(&sdl2_console[i].dcl);
816 }
817
818 /* Load a 32x32x4 image. White pixels are transparent. */
819 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu-icon.bmp");
820 if (filename) {
821 SDL_Surface *image = SDL_LoadBMP(filename);
822 if (image) {
823 uint32_t colorkey = SDL_MapRGB(image->format, 255, 255, 255);
824 SDL_SetColorKey(image, SDL_TRUE, colorkey);
825 SDL_SetWindowIcon(sdl2_console[0].real_window, image);
826 }
827 g_free(filename);
828 }
829
830 if (full_screen) {
831 gui_fullscreen = 1;
832 sdl_grab_start(0);
833 }
834
835 mouse_mode_notifier.notify = sdl_mouse_mode_change;
836 qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier);
837
838 gui_grab = 0;
839
840 sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
841 sdl_cursor_normal = SDL_GetCursor();
842
843 atexit(sdl_cleanup);
844 }