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/module.h" |
28 | #include "ui/console.h" |
29 | #include "ui/input.h" |
30 | #include "ui/sdl2.h" |
31 | #include "sysemu/runstate.h" |
32 | #include "sysemu/sysemu.h" |
33 | |
34 | static int sdl2_num_outputs; |
35 | static struct sdl2_console *sdl2_console; |
36 | |
37 | static SDL_Surface *guest_sprite_surface; |
38 | static int gui_grab; /* if true, all keyboard/mouse events are grabbed */ |
39 | |
40 | static int gui_saved_grab; |
41 | static int gui_fullscreen; |
42 | static int gui_grab_code = KMOD_LALT | KMOD_LCTRL; |
43 | static SDL_Cursor *sdl_cursor_normal; |
44 | static SDL_Cursor *sdl_cursor_hidden; |
45 | static int absolute_enabled; |
46 | static int guest_cursor; |
47 | static int guest_x, guest_y; |
48 | static SDL_Cursor *guest_sprite; |
49 | static 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 | |
55 | static void sdl_update_caption(struct sdl2_console *scon); |
56 | |
57 | static 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 | |
68 | void 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 | |
98 | void 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 | |
110 | void 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 | |
121 | static 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 | |
132 | static 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 | |
164 | static 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 | |
178 | static 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 | |
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 | 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 | |
262 | static 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 | |
297 | static 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 | |
314 | static 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 | |
328 | static 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 | int gui_keysym = 0; |
334 | |
335 | if (!scon->ignore_hotkeys && gui_key_modifier_pressed && !ev->key.repeat) { |
336 | switch (ev->key.keysym.scancode) { |
337 | case SDL_SCANCODE_2: |
338 | case SDL_SCANCODE_3: |
339 | case SDL_SCANCODE_4: |
340 | case SDL_SCANCODE_5: |
341 | case SDL_SCANCODE_6: |
342 | case SDL_SCANCODE_7: |
343 | case SDL_SCANCODE_8: |
344 | case SDL_SCANCODE_9: |
345 | if (gui_grab) { |
346 | sdl_grab_end(scon); |
347 | } |
348 | |
349 | win = ev->key.keysym.scancode - SDL_SCANCODE_1; |
350 | if (win < sdl2_num_outputs) { |
351 | sdl2_console[win].hidden = !sdl2_console[win].hidden; |
352 | if (sdl2_console[win].real_window) { |
353 | if (sdl2_console[win].hidden) { |
354 | SDL_HideWindow(sdl2_console[win].real_window); |
355 | } else { |
356 | SDL_ShowWindow(sdl2_console[win].real_window); |
357 | } |
358 | } |
359 | gui_keysym = 1; |
360 | } |
361 | break; |
362 | case SDL_SCANCODE_F: |
363 | toggle_full_screen(scon); |
364 | gui_keysym = 1; |
365 | break; |
366 | case SDL_SCANCODE_G: |
367 | gui_keysym = 1; |
368 | if (!gui_grab) { |
369 | sdl_grab_start(scon); |
370 | } else if (!gui_fullscreen) { |
371 | sdl_grab_end(scon); |
372 | } |
373 | break; |
374 | case SDL_SCANCODE_U: |
375 | sdl2_window_resize(scon); |
376 | if (!scon->opengl) { |
377 | /* re-create scon->texture */ |
378 | sdl2_2d_switch(&scon->dcl, scon->surface); |
379 | } |
380 | gui_keysym = 1; |
381 | break; |
382 | #if 0 |
383 | case SDL_SCANCODE_KP_PLUS: |
384 | case SDL_SCANCODE_KP_MINUS: |
385 | if (!gui_fullscreen) { |
386 | int scr_w, scr_h; |
387 | int width, height; |
388 | SDL_GetWindowSize(scon->real_window, &scr_w, &scr_h); |
389 | |
390 | width = MAX(scr_w + (ev->key.keysym.scancode == |
391 | SDL_SCANCODE_KP_PLUS ? 50 : -50), |
392 | 160); |
393 | height = (surface_height(scon->surface) * width) / |
394 | surface_width(scon->surface); |
395 | fprintf(stderr, "%s: scale to %dx%d\n" , |
396 | __func__, width, height); |
397 | sdl_scale(scon, width, height); |
398 | sdl2_redraw(scon); |
399 | gui_keysym = 1; |
400 | } |
401 | #endif |
402 | default: |
403 | break; |
404 | } |
405 | } |
406 | if (!gui_keysym) { |
407 | sdl2_process_key(scon, &ev->key); |
408 | } |
409 | } |
410 | |
411 | static void handle_keyup(SDL_Event *ev) |
412 | { |
413 | struct sdl2_console *scon = get_scon_from_window(ev->key.windowID); |
414 | |
415 | scon->ignore_hotkeys = false; |
416 | sdl2_process_key(scon, &ev->key); |
417 | } |
418 | |
419 | static void handle_textinput(SDL_Event *ev) |
420 | { |
421 | struct sdl2_console *scon = get_scon_from_window(ev->text.windowID); |
422 | QemuConsole *con = scon ? scon->dcl.con : NULL; |
423 | |
424 | if (qemu_console_is_graphic(con)) { |
425 | return; |
426 | } |
427 | kbd_put_string_console(con, ev->text.text, strlen(ev->text.text)); |
428 | } |
429 | |
430 | static void handle_mousemotion(SDL_Event *ev) |
431 | { |
432 | int max_x, max_y; |
433 | struct sdl2_console *scon = get_scon_from_window(ev->motion.windowID); |
434 | |
435 | if (!scon || !qemu_console_is_graphic(scon->dcl.con)) { |
436 | return; |
437 | } |
438 | |
439 | if (qemu_input_is_absolute() || absolute_enabled) { |
440 | int scr_w, scr_h; |
441 | SDL_GetWindowSize(scon->real_window, &scr_w, &scr_h); |
442 | max_x = scr_w - 1; |
443 | max_y = scr_h - 1; |
444 | if (gui_grab && !gui_fullscreen |
445 | && (ev->motion.x == 0 || ev->motion.y == 0 || |
446 | ev->motion.x == max_x || ev->motion.y == max_y)) { |
447 | sdl_grab_end(scon); |
448 | } |
449 | if (!gui_grab && |
450 | (ev->motion.x > 0 && ev->motion.x < max_x && |
451 | ev->motion.y > 0 && ev->motion.y < max_y)) { |
452 | sdl_grab_start(scon); |
453 | } |
454 | } |
455 | if (gui_grab || qemu_input_is_absolute() || absolute_enabled) { |
456 | sdl_send_mouse_event(scon, ev->motion.xrel, ev->motion.yrel, |
457 | ev->motion.x, ev->motion.y, ev->motion.state); |
458 | } |
459 | } |
460 | |
461 | static void handle_mousebutton(SDL_Event *ev) |
462 | { |
463 | int buttonstate = SDL_GetMouseState(NULL, NULL); |
464 | SDL_MouseButtonEvent *bev; |
465 | struct sdl2_console *scon = get_scon_from_window(ev->button.windowID); |
466 | |
467 | if (!scon || !qemu_console_is_graphic(scon->dcl.con)) { |
468 | return; |
469 | } |
470 | |
471 | bev = &ev->button; |
472 | if (!gui_grab && !qemu_input_is_absolute()) { |
473 | if (ev->type == SDL_MOUSEBUTTONUP && bev->button == SDL_BUTTON_LEFT) { |
474 | /* start grabbing all events */ |
475 | sdl_grab_start(scon); |
476 | } |
477 | } else { |
478 | if (ev->type == SDL_MOUSEBUTTONDOWN) { |
479 | buttonstate |= SDL_BUTTON(bev->button); |
480 | } else { |
481 | buttonstate &= ~SDL_BUTTON(bev->button); |
482 | } |
483 | sdl_send_mouse_event(scon, 0, 0, bev->x, bev->y, buttonstate); |
484 | } |
485 | } |
486 | |
487 | static void handle_mousewheel(SDL_Event *ev) |
488 | { |
489 | struct sdl2_console *scon = get_scon_from_window(ev->wheel.windowID); |
490 | SDL_MouseWheelEvent *wev = &ev->wheel; |
491 | InputButton btn; |
492 | |
493 | if (!scon || !qemu_console_is_graphic(scon->dcl.con)) { |
494 | return; |
495 | } |
496 | |
497 | if (wev->y > 0) { |
498 | btn = INPUT_BUTTON_WHEEL_UP; |
499 | } else if (wev->y < 0) { |
500 | btn = INPUT_BUTTON_WHEEL_DOWN; |
501 | } else { |
502 | return; |
503 | } |
504 | |
505 | qemu_input_queue_btn(scon->dcl.con, btn, true); |
506 | qemu_input_event_sync(); |
507 | qemu_input_queue_btn(scon->dcl.con, btn, false); |
508 | qemu_input_event_sync(); |
509 | } |
510 | |
511 | static void handle_windowevent(SDL_Event *ev) |
512 | { |
513 | struct sdl2_console *scon = get_scon_from_window(ev->window.windowID); |
514 | bool allow_close = true; |
515 | |
516 | if (!scon) { |
517 | return; |
518 | } |
519 | |
520 | switch (ev->window.event) { |
521 | case SDL_WINDOWEVENT_RESIZED: |
522 | { |
523 | QemuUIInfo info; |
524 | memset(&info, 0, sizeof(info)); |
525 | info.width = ev->window.data1; |
526 | info.height = ev->window.data2; |
527 | dpy_set_ui_info(scon->dcl.con, &info); |
528 | } |
529 | sdl2_redraw(scon); |
530 | break; |
531 | case SDL_WINDOWEVENT_EXPOSED: |
532 | sdl2_redraw(scon); |
533 | break; |
534 | case SDL_WINDOWEVENT_FOCUS_GAINED: |
535 | case SDL_WINDOWEVENT_ENTER: |
536 | if (!gui_grab && (qemu_input_is_absolute() || absolute_enabled)) { |
537 | absolute_mouse_grab(scon); |
538 | } |
539 | /* If a new console window opened using a hotkey receives the |
540 | * focus, SDL sends another KEYDOWN event to the new window, |
541 | * closing the console window immediately after. |
542 | * |
543 | * Work around this by ignoring further hotkey events until a |
544 | * key is released. |
545 | */ |
546 | scon->ignore_hotkeys = get_mod_state(); |
547 | break; |
548 | case SDL_WINDOWEVENT_FOCUS_LOST: |
549 | if (gui_grab && !gui_fullscreen) { |
550 | sdl_grab_end(scon); |
551 | } |
552 | break; |
553 | case SDL_WINDOWEVENT_RESTORED: |
554 | update_displaychangelistener(&scon->dcl, GUI_REFRESH_INTERVAL_DEFAULT); |
555 | break; |
556 | case SDL_WINDOWEVENT_MINIMIZED: |
557 | update_displaychangelistener(&scon->dcl, 500); |
558 | break; |
559 | case SDL_WINDOWEVENT_CLOSE: |
560 | if (qemu_console_is_graphic(scon->dcl.con)) { |
561 | if (scon->opts->has_window_close && !scon->opts->window_close) { |
562 | allow_close = false; |
563 | } |
564 | if (allow_close) { |
565 | no_shutdown = 0; |
566 | qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_UI); |
567 | } |
568 | } else { |
569 | SDL_HideWindow(scon->real_window); |
570 | scon->hidden = true; |
571 | } |
572 | break; |
573 | case SDL_WINDOWEVENT_SHOWN: |
574 | scon->hidden = false; |
575 | break; |
576 | case SDL_WINDOWEVENT_HIDDEN: |
577 | scon->hidden = true; |
578 | break; |
579 | } |
580 | } |
581 | |
582 | void sdl2_poll_events(struct sdl2_console *scon) |
583 | { |
584 | SDL_Event ev1, *ev = &ev1; |
585 | bool allow_close = true; |
586 | int idle = 1; |
587 | |
588 | if (scon->last_vm_running != runstate_is_running()) { |
589 | scon->last_vm_running = runstate_is_running(); |
590 | sdl_update_caption(scon); |
591 | } |
592 | |
593 | while (SDL_PollEvent(ev)) { |
594 | switch (ev->type) { |
595 | case SDL_KEYDOWN: |
596 | idle = 0; |
597 | handle_keydown(ev); |
598 | break; |
599 | case SDL_KEYUP: |
600 | idle = 0; |
601 | handle_keyup(ev); |
602 | break; |
603 | case SDL_TEXTINPUT: |
604 | idle = 0; |
605 | handle_textinput(ev); |
606 | break; |
607 | case SDL_QUIT: |
608 | if (scon->opts->has_window_close && !scon->opts->window_close) { |
609 | allow_close = false; |
610 | } |
611 | if (allow_close) { |
612 | no_shutdown = 0; |
613 | qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_UI); |
614 | } |
615 | break; |
616 | case SDL_MOUSEMOTION: |
617 | idle = 0; |
618 | handle_mousemotion(ev); |
619 | break; |
620 | case SDL_MOUSEBUTTONDOWN: |
621 | case SDL_MOUSEBUTTONUP: |
622 | idle = 0; |
623 | handle_mousebutton(ev); |
624 | break; |
625 | case SDL_MOUSEWHEEL: |
626 | idle = 0; |
627 | handle_mousewheel(ev); |
628 | break; |
629 | case SDL_WINDOWEVENT: |
630 | handle_windowevent(ev); |
631 | break; |
632 | default: |
633 | break; |
634 | } |
635 | } |
636 | |
637 | if (idle) { |
638 | if (scon->idle_counter < SDL2_MAX_IDLE_COUNT) { |
639 | scon->idle_counter++; |
640 | if (scon->idle_counter >= SDL2_MAX_IDLE_COUNT) { |
641 | scon->dcl.update_interval = GUI_REFRESH_INTERVAL_DEFAULT; |
642 | } |
643 | } |
644 | } else { |
645 | scon->idle_counter = 0; |
646 | scon->dcl.update_interval = SDL2_REFRESH_INTERVAL_BUSY; |
647 | } |
648 | } |
649 | |
650 | static void sdl_mouse_warp(DisplayChangeListener *dcl, |
651 | int x, int y, int on) |
652 | { |
653 | struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl); |
654 | |
655 | if (!qemu_console_is_graphic(scon->dcl.con)) { |
656 | return; |
657 | } |
658 | |
659 | if (on) { |
660 | if (!guest_cursor) { |
661 | sdl_show_cursor(); |
662 | } |
663 | if (gui_grab || qemu_input_is_absolute() || absolute_enabled) { |
664 | SDL_SetCursor(guest_sprite); |
665 | if (!qemu_input_is_absolute() && !absolute_enabled) { |
666 | SDL_WarpMouseInWindow(scon->real_window, x, y); |
667 | } |
668 | } |
669 | } else if (gui_grab) { |
670 | sdl_hide_cursor(); |
671 | } |
672 | guest_cursor = on; |
673 | guest_x = x, guest_y = y; |
674 | } |
675 | |
676 | static void sdl_mouse_define(DisplayChangeListener *dcl, |
677 | QEMUCursor *c) |
678 | { |
679 | |
680 | if (guest_sprite) { |
681 | SDL_FreeCursor(guest_sprite); |
682 | } |
683 | |
684 | if (guest_sprite_surface) { |
685 | SDL_FreeSurface(guest_sprite_surface); |
686 | } |
687 | |
688 | guest_sprite_surface = |
689 | SDL_CreateRGBSurfaceFrom(c->data, c->width, c->height, 32, c->width * 4, |
690 | 0xff0000, 0x00ff00, 0xff, 0xff000000); |
691 | |
692 | if (!guest_sprite_surface) { |
693 | fprintf(stderr, "Failed to make rgb surface from %p\n" , c); |
694 | return; |
695 | } |
696 | guest_sprite = SDL_CreateColorCursor(guest_sprite_surface, |
697 | c->hot_x, c->hot_y); |
698 | if (!guest_sprite) { |
699 | fprintf(stderr, "Failed to make color cursor from %p\n" , c); |
700 | return; |
701 | } |
702 | if (guest_cursor && |
703 | (gui_grab || qemu_input_is_absolute() || absolute_enabled)) { |
704 | SDL_SetCursor(guest_sprite); |
705 | } |
706 | } |
707 | |
708 | static void sdl_cleanup(void) |
709 | { |
710 | if (guest_sprite) { |
711 | SDL_FreeCursor(guest_sprite); |
712 | } |
713 | SDL_QuitSubSystem(SDL_INIT_VIDEO); |
714 | } |
715 | |
716 | static const DisplayChangeListenerOps dcl_2d_ops = { |
717 | .dpy_name = "sdl2-2d" , |
718 | .dpy_gfx_update = sdl2_2d_update, |
719 | .dpy_gfx_switch = sdl2_2d_switch, |
720 | .dpy_gfx_check_format = sdl2_2d_check_format, |
721 | .dpy_refresh = sdl2_2d_refresh, |
722 | .dpy_mouse_set = sdl_mouse_warp, |
723 | .dpy_cursor_define = sdl_mouse_define, |
724 | }; |
725 | |
726 | #ifdef CONFIG_OPENGL |
727 | static const DisplayChangeListenerOps dcl_gl_ops = { |
728 | .dpy_name = "sdl2-gl" , |
729 | .dpy_gfx_update = sdl2_gl_update, |
730 | .dpy_gfx_switch = sdl2_gl_switch, |
731 | .dpy_gfx_check_format = console_gl_check_format, |
732 | .dpy_refresh = sdl2_gl_refresh, |
733 | .dpy_mouse_set = sdl_mouse_warp, |
734 | .dpy_cursor_define = sdl_mouse_define, |
735 | |
736 | .dpy_gl_ctx_create = sdl2_gl_create_context, |
737 | .dpy_gl_ctx_destroy = sdl2_gl_destroy_context, |
738 | .dpy_gl_ctx_make_current = sdl2_gl_make_context_current, |
739 | .dpy_gl_ctx_get_current = sdl2_gl_get_current_context, |
740 | .dpy_gl_scanout_disable = sdl2_gl_scanout_disable, |
741 | .dpy_gl_scanout_texture = sdl2_gl_scanout_texture, |
742 | .dpy_gl_update = sdl2_gl_scanout_flush, |
743 | }; |
744 | #endif |
745 | |
746 | static void sdl2_display_early_init(DisplayOptions *o) |
747 | { |
748 | assert(o->type == DISPLAY_TYPE_SDL); |
749 | if (o->has_gl && o->gl) { |
750 | #ifdef CONFIG_OPENGL |
751 | display_opengl = 1; |
752 | #endif |
753 | } |
754 | } |
755 | |
756 | static void sdl2_display_init(DisplayState *ds, DisplayOptions *o) |
757 | { |
758 | uint8_t data = 0; |
759 | int i; |
760 | SDL_SysWMinfo info; |
761 | SDL_Surface *icon = NULL; |
762 | |
763 | assert(o->type == DISPLAY_TYPE_SDL); |
764 | |
765 | #ifdef __linux__ |
766 | /* on Linux, SDL may use fbcon|directfb|svgalib when run without |
767 | * accessible $DISPLAY to open X11 window. This is often the case |
768 | * when qemu is run using sudo. But in this case, and when actually |
769 | * run in X11 environment, SDL fights with X11 for the video card, |
770 | * making current display unavailable, often until reboot. |
771 | * So make x11 the default SDL video driver if this variable is unset. |
772 | * This is a bit hackish but saves us from bigger problem. |
773 | * Maybe it's a good idea to fix this in SDL instead. |
774 | */ |
775 | setenv("SDL_VIDEODRIVER" , "x11" , 0); |
776 | #endif |
777 | |
778 | if (SDL_Init(SDL_INIT_VIDEO)) { |
779 | fprintf(stderr, "Could not initialize SDL(%s) - exiting\n" , |
780 | SDL_GetError()); |
781 | exit(1); |
782 | } |
783 | #ifdef SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR /* only available since SDL 2.0.8 */ |
784 | SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0" ); |
785 | #endif |
786 | SDL_SetHint(SDL_HINT_GRAB_KEYBOARD, "1" ); |
787 | memset(&info, 0, sizeof(info)); |
788 | SDL_VERSION(&info.version); |
789 | |
790 | gui_fullscreen = o->has_full_screen && o->full_screen; |
791 | |
792 | for (i = 0;; i++) { |
793 | QemuConsole *con = qemu_console_lookup_by_index(i); |
794 | if (!con) { |
795 | break; |
796 | } |
797 | } |
798 | sdl2_num_outputs = i; |
799 | if (sdl2_num_outputs == 0) { |
800 | return; |
801 | } |
802 | sdl2_console = g_new0(struct sdl2_console, sdl2_num_outputs); |
803 | for (i = 0; i < sdl2_num_outputs; i++) { |
804 | QemuConsole *con = qemu_console_lookup_by_index(i); |
805 | assert(con != NULL); |
806 | if (!qemu_console_is_graphic(con) && |
807 | qemu_console_get_index(con) != 0) { |
808 | sdl2_console[i].hidden = true; |
809 | } |
810 | sdl2_console[i].idx = i; |
811 | sdl2_console[i].opts = o; |
812 | #ifdef CONFIG_OPENGL |
813 | sdl2_console[i].opengl = display_opengl; |
814 | sdl2_console[i].dcl.ops = display_opengl ? &dcl_gl_ops : &dcl_2d_ops; |
815 | #else |
816 | sdl2_console[i].opengl = 0; |
817 | sdl2_console[i].dcl.ops = &dcl_2d_ops; |
818 | #endif |
819 | sdl2_console[i].dcl.con = con; |
820 | sdl2_console[i].kbd = qkbd_state_init(con); |
821 | register_displaychangelistener(&sdl2_console[i].dcl); |
822 | |
823 | #if defined(SDL_VIDEO_DRIVER_WINDOWS) || defined(SDL_VIDEO_DRIVER_X11) |
824 | if (SDL_GetWindowWMInfo(sdl2_console[i].real_window, &info)) { |
825 | #if defined(SDL_VIDEO_DRIVER_WINDOWS) |
826 | qemu_console_set_window_id(con, (uintptr_t)info.info.win.window); |
827 | #elif defined(SDL_VIDEO_DRIVER_X11) |
828 | qemu_console_set_window_id(con, info.info.x11.window); |
829 | #endif |
830 | } |
831 | #endif |
832 | } |
833 | |
834 | #ifdef CONFIG_SDL_IMAGE |
835 | icon = IMG_Load(CONFIG_QEMU_ICONDIR "/hicolor/128x128/apps/qemu.png" ); |
836 | #else |
837 | /* Load a 32x32x4 image. White pixels are transparent. */ |
838 | icon = SDL_LoadBMP(CONFIG_QEMU_ICONDIR "/hicolor/32x32/apps/qemu.bmp" ); |
839 | if (icon) { |
840 | uint32_t colorkey = SDL_MapRGB(icon->format, 255, 255, 255); |
841 | SDL_SetColorKey(icon, SDL_TRUE, colorkey); |
842 | } |
843 | #endif |
844 | if (icon) { |
845 | SDL_SetWindowIcon(sdl2_console[0].real_window, icon); |
846 | } |
847 | |
848 | gui_grab = 0; |
849 | if (gui_fullscreen) { |
850 | sdl_grab_start(0); |
851 | } |
852 | |
853 | mouse_mode_notifier.notify = sdl_mouse_mode_change; |
854 | qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier); |
855 | |
856 | sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0); |
857 | sdl_cursor_normal = SDL_GetCursor(); |
858 | |
859 | atexit(sdl_cleanup); |
860 | } |
861 | |
862 | static QemuDisplay qemu_display_sdl2 = { |
863 | .type = DISPLAY_TYPE_SDL, |
864 | .early_init = sdl2_display_early_init, |
865 | .init = sdl2_display_init, |
866 | }; |
867 | |
868 | static void register_sdl1(void) |
869 | { |
870 | qemu_display_register(&qemu_display_sdl2); |
871 | } |
872 | |
873 | type_init(register_sdl1); |
874 | |