?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sdhci.c: Limit the maximum block size
[qemu/ar7.git] / ui / gtk.c
blob3057cdc3f79f4aa330783afaf40a71ec8b1797cc
1 /*
2 * GTK UI
3 *
4 * Copyright IBM, Corp. 2012
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 *
12 * Portions from gtk-vnc:
13 *
14 * GTK VNC Widget
15 *
16 * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
17 * Copyright (C) 2009-2010 Daniel P. Berrange <dan@berrange.com>
18 *
19 * This library is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU Lesser General Public
21 * License as published by the Free Software Foundation; either
22 * version 2.0 of the License, or (at your option) any later version.
23 *
24 * This library is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27 * Lesser General Public License for more details.
28 *
29 * You should have received a copy of the GNU Lesser General Public
30 * License along with this library; if not, write to the Free Software
31 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
32 */
33
34 #define GETTEXT_PACKAGE "qemu"
35 #define LOCALEDIR "po"
36
37 #include "qemu-common.h"
38
39 #include "ui/console.h"
40 #include "ui/gtk.h"
41
42 #include <glib/gi18n.h>
43 #include <locale.h>
44 #if defined(CONFIG_VTE)
45 #include <vte/vte.h>
46 #endif
47 #include <math.h>
48
49 #include "trace.h"
50 #include "ui/input.h"
51 #include "sysemu/sysemu.h"
52 #include "qmp-commands.h"
53 #include "x_keymap.h"
54 #include "keymaps.h"
55 #include "sysemu/char.h"
56 #include "qom/object.h"
57
58 #define MAX_VCS 10
59 #define VC_WINDOW_X_MIN 320
60 #define VC_WINDOW_Y_MIN 240
61 #define VC_TERM_X_MIN 80
62 #define VC_TERM_Y_MIN 25
63 #define VC_SCALE_MIN 0.25
64 #define VC_SCALE_STEP 0.25
65
66 #if !defined(CONFIG_VTE)
67 # define VTE_CHECK_VERSION(a, b, c) 0
68 #endif
69
70 #if defined(CONFIG_VTE) && !GTK_CHECK_VERSION(3, 0, 0)
71 /*
72 * The gtk2 vte terminal widget seriously messes up the window resize
73 * for some reason. You basically can't make the qemu window smaller
74 * any more because the toplevel window geoemtry hints are overridden.
75 *
76 * Workaround that by hiding all vte widgets, except the one in the
77 * current tab.
78 *
79 * Luckily everything works smooth in gtk3.
80 */
81 # define VTE_RESIZE_HACK 1
82 #endif
83
84 #if !GTK_CHECK_VERSION(2, 20, 0)
85 #define gtk_widget_get_realized(widget) GTK_WIDGET_REALIZED(widget)
86 #endif
87
88 #ifndef GDK_IS_X11_DISPLAY
89 #define GDK_IS_X11_DISPLAY(dpy) (dpy == dpy)
90 #endif
91 #ifndef GDK_IS_WIN32_DISPLAY
92 #define GDK_IS_WIN32_DISPLAY(dpy) (dpy == dpy)
93 #endif
94
95 #ifndef GDK_KEY_0
96 #define GDK_KEY_0 GDK_0
97 #define GDK_KEY_1 GDK_1
98 #define GDK_KEY_2 GDK_2
99 #define GDK_KEY_f GDK_f
100 #define GDK_KEY_g GDK_g
101 #define GDK_KEY_q GDK_q
102 #define GDK_KEY_plus GDK_plus
103 #define GDK_KEY_minus GDK_minus
104 #define GDK_KEY_Pause GDK_Pause
105 #endif
106
107 /* Some older mingw versions lack this constant or have
108 * it conditionally defined */
109 #ifdef _WIN32
110 # ifndef MAPVK_VK_TO_VSC
111 # define MAPVK_VK_TO_VSC 0
112 # endif
113 #endif
114
115
116 #define HOTKEY_MODIFIERS (GDK_CONTROL_MASK | GDK_MOD1_MASK)
117
118 static const int modifier_keycode[] = {
119 /* shift, control, alt keys, meta keys, both left & right */
120 0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8, 0xdb, 0xdd,
121 };
122
123 struct GtkDisplayState {
124 GtkWidget *window;
125
126 GtkWidget *menu_bar;
127
128 GtkAccelGroup *accel_group;
129
130 GtkWidget *machine_menu_item;
131 GtkWidget *machine_menu;
132 GtkWidget *pause_item;
133 GtkWidget *reset_item;
134 GtkWidget *powerdown_item;
135 GtkWidget *quit_item;
136
137 GtkWidget *view_menu_item;
138 GtkWidget *view_menu;
139 GtkWidget *full_screen_item;
140 GtkWidget *zoom_in_item;
141 GtkWidget *zoom_out_item;
142 GtkWidget *zoom_fixed_item;
143 GtkWidget *zoom_fit_item;
144 GtkWidget *grab_item;
145 GtkWidget *grab_on_hover_item;
146
147 int nb_vcs;
148 VirtualConsole vc[MAX_VCS];
149
150 GtkWidget *show_tabs_item;
151 GtkWidget *untabify_item;
152
153 GtkWidget *vbox;
154 GtkWidget *notebook;
155 int button_mask;
156 gboolean last_set;
157 int last_x;
158 int last_y;
159 int grab_x_root;
160 int grab_y_root;
161 VirtualConsole *kbd_owner;
162 VirtualConsole *ptr_owner;
163
164 gboolean full_screen;
165
166 GdkCursor *null_cursor;
167 Notifier mouse_mode_notifier;
168 gboolean free_scale;
169
170 bool external_pause_update;
171
172 bool modifier_pressed[ARRAY_SIZE(modifier_keycode)];
173 bool has_evdev;
174 bool ignore_keys;
175 };
176
177 static void gd_grab_pointer(VirtualConsole *vc, const char *reason);
178 static void gd_ungrab_pointer(GtkDisplayState *s);
179 static void gd_grab_keyboard(VirtualConsole *vc, const char *reason);
180 static void gd_ungrab_keyboard(GtkDisplayState *s);
181
182 /** Utility Functions **/
183
184 static VirtualConsole *gd_vc_find_by_menu(GtkDisplayState *s)
185 {
186 VirtualConsole *vc;
187 gint i;
188
189 for (i = 0; i < s->nb_vcs; i++) {
190 vc = &s->vc[i];
191 if (gtk_check_menu_item_get_active
192 (GTK_CHECK_MENU_ITEM(vc->menu_item))) {
193 return vc;
194 }
195 }
196 return NULL;
197 }
198
199 static VirtualConsole *gd_vc_find_by_page(GtkDisplayState *s, gint page)
200 {
201 VirtualConsole *vc;
202 gint i, p;
203
204 for (i = 0; i < s->nb_vcs; i++) {
205 vc = &s->vc[i];
206 p = gtk_notebook_page_num(GTK_NOTEBOOK(s->notebook), vc->tab_item);
207 if (p == page) {
208 return vc;
209 }
210 }
211 return NULL;
212 }
213
214 static VirtualConsole *gd_vc_find_current(GtkDisplayState *s)
215 {
216 gint page;
217
218 page = gtk_notebook_get_current_page(GTK_NOTEBOOK(s->notebook));
219 return gd_vc_find_by_page(s, page);
220 }
221
222 static bool gd_is_grab_active(GtkDisplayState *s)
223 {
224 return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_item));
225 }
226
227 static bool gd_grab_on_hover(GtkDisplayState *s)
228 {
229 return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_on_hover_item));
230 }
231
232 static void gd_update_cursor(VirtualConsole *vc)
233 {
234 GtkDisplayState *s = vc->s;
235 GdkWindow *window;
236
237 if (vc->type != GD_VC_GFX ||
238 !qemu_console_is_graphic(vc->gfx.dcl.con)) {
239 return;
240 }
241
242 if (!gtk_widget_get_realized(vc->gfx.drawing_area)) {
243 return;
244 }
245
246 window = gtk_widget_get_window(GTK_WIDGET(vc->gfx.drawing_area));
247 if (s->full_screen || qemu_input_is_absolute() || s->ptr_owner == vc) {
248 gdk_window_set_cursor(window, s->null_cursor);
249 } else {
250 gdk_window_set_cursor(window, NULL);
251 }
252 }
253
254 static void gd_update_caption(GtkDisplayState *s)
255 {
256 const char *status = "";
257 gchar *prefix;
258 gchar *title;
259 const char *grab = "";
260 bool is_paused = !runstate_is_running();
261 int i;
262
263 if (qemu_name) {
264 prefix = g_strdup_printf("QEMU (%s)", qemu_name);
265 } else {
266 prefix = g_strdup_printf("QEMU");
267 }
268
269 if (s->ptr_owner != NULL &&
270 s->ptr_owner->window == NULL) {
271 grab = _(" - Press Ctrl+Alt+G to release grab");
272 }
273
274 if (is_paused) {
275 status = _(" [Paused]");
276 }
277 s->external_pause_update = true;
278 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->pause_item),
279 is_paused);
280 s->external_pause_update = false;
281
282 title = g_strdup_printf("%s%s%s", prefix, status, grab);
283 gtk_window_set_title(GTK_WINDOW(s->window), title);
284 g_free(title);
285
286 for (i = 0; i < s->nb_vcs; i++) {
287 VirtualConsole *vc = &s->vc[i];
288
289 if (!vc->window) {
290 continue;
291 }
292 title = g_strdup_printf("%s: %s%s%s", prefix, vc->label,
293 vc == s->kbd_owner ? " +kbd" : "",
294 vc == s->ptr_owner ? " +ptr" : "");
295 gtk_window_set_title(GTK_WINDOW(vc->window), title);
296 g_free(title);
297 }
298
299 g_free(prefix);
300 }
301
302 static void gd_update_geometry_hints(VirtualConsole *vc)
303 {
304 GtkDisplayState *s = vc->s;
305 GdkWindowHints mask = 0;
306 GdkGeometry geo = {};
307 GtkWidget *geo_widget = NULL;
308 GtkWindow *geo_window;
309
310 if (vc->type == GD_VC_GFX) {
311 if (!vc->gfx.ds) {
312 return;
313 }
314 if (s->free_scale) {
315 geo.min_width = surface_width(vc->gfx.ds) * VC_SCALE_MIN;
316 geo.min_height = surface_height(vc->gfx.ds) * VC_SCALE_MIN;
317 mask |= GDK_HINT_MIN_SIZE;
318 } else {
319 geo.min_width = surface_width(vc->gfx.ds) * vc->gfx.scale_x;
320 geo.min_height = surface_height(vc->gfx.ds) * vc->gfx.scale_y;
321 mask |= GDK_HINT_MIN_SIZE;
322 }
323 geo_widget = vc->gfx.drawing_area;
324 gtk_widget_set_size_request(geo_widget, geo.min_width, geo.min_height);
325
326 #if defined(CONFIG_VTE)
327 } else if (vc->type == GD_VC_VTE) {
328 VteTerminal *term = VTE_TERMINAL(vc->vte.terminal);
329 GtkBorder *ib;
330
331 geo.width_inc = vte_terminal_get_char_width(term);
332 geo.height_inc = vte_terminal_get_char_height(term);
333 mask |= GDK_HINT_RESIZE_INC;
334 geo.base_width = geo.width_inc;
335 geo.base_height = geo.height_inc;
336 mask |= GDK_HINT_BASE_SIZE;
337 geo.min_width = geo.width_inc * VC_TERM_X_MIN;
338 geo.min_height = geo.height_inc * VC_TERM_Y_MIN;
339 mask |= GDK_HINT_MIN_SIZE;
340 gtk_widget_style_get(vc->vte.terminal, "inner-border", &ib, NULL);
341 geo.base_width += ib->left + ib->right;
342 geo.base_height += ib->top + ib->bottom;
343 geo.min_width += ib->left + ib->right;
344 geo.min_height += ib->top + ib->bottom;
345 geo_widget = vc->vte.terminal;
346 #endif
347 }
348
349 geo_window = GTK_WINDOW(vc->window ? vc->window : s->window);
350 gtk_window_set_geometry_hints(geo_window, geo_widget, &geo, mask);
351 }
352
353 void gd_update_windowsize(VirtualConsole *vc)
354 {
355 GtkDisplayState *s = vc->s;
356
357 gd_update_geometry_hints(vc);
358
359 if (vc->type == GD_VC_GFX && !s->full_screen && !s->free_scale) {
360 gtk_window_resize(GTK_WINDOW(vc->window ? vc->window : s->window),
361 VC_WINDOW_X_MIN, VC_WINDOW_Y_MIN);
362 }
363 }
364
365 static void gd_update_full_redraw(VirtualConsole *vc)
366 {
367 GtkWidget *area = vc->gfx.drawing_area;
368 int ww, wh;
369 gdk_drawable_get_size(gtk_widget_get_window(area), &ww, &wh);
370 gtk_widget_queue_draw_area(area, 0, 0, ww, wh);
371 }
372
373 static void gtk_release_modifiers(GtkDisplayState *s)
374 {
375 VirtualConsole *vc = gd_vc_find_current(s);
376 int i, keycode;
377
378 if (vc->type != GD_VC_GFX ||
379 !qemu_console_is_graphic(vc->gfx.dcl.con)) {
380 return;
381 }
382 for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) {
383 keycode = modifier_keycode[i];
384 if (!s->modifier_pressed[i]) {
385 continue;
386 }
387 qemu_input_event_send_key_number(vc->gfx.dcl.con, keycode, false);
388 s->modifier_pressed[i] = false;
389 }
390 }
391
392 static void gd_widget_reparent(GtkWidget *from, GtkWidget *to,
393 GtkWidget *widget)
394 {
395 g_object_ref(G_OBJECT(widget));
396 gtk_container_remove(GTK_CONTAINER(from), widget);
397 gtk_container_add(GTK_CONTAINER(to), widget);
398 g_object_unref(G_OBJECT(widget));
399 }
400
401 /** DisplayState Callbacks **/
402
403 static void gd_update(DisplayChangeListener *dcl,
404 int x, int y, int w, int h)
405 {
406 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
407 GdkWindow *win;
408 int x1, x2, y1, y2;
409 int mx, my;
410 int fbw, fbh;
411 int ww, wh;
412
413 trace_gd_update(vc->label, x, y, w, h);
414
415 if (!gtk_widget_get_realized(vc->gfx.drawing_area)) {
416 return;
417 }
418
419 if (vc->gfx.convert) {
420 pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image,
421 NULL, vc->gfx.convert,
422 x, y, 0, 0, x, y, w, h);
423 }
424
425 x1 = floor(x * vc->gfx.scale_x);
426 y1 = floor(y * vc->gfx.scale_y);
427
428 x2 = ceil(x * vc->gfx.scale_x + w * vc->gfx.scale_x);
429 y2 = ceil(y * vc->gfx.scale_y + h * vc->gfx.scale_y);
430
431 fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x;
432 fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y;
433
434 win = gtk_widget_get_window(vc->gfx.drawing_area);
435 if (!win) {
436 return;
437 }
438 gdk_drawable_get_size(win, &ww, &wh);
439
440 mx = my = 0;
441 if (ww > fbw) {
442 mx = (ww - fbw) / 2;
443 }
444 if (wh > fbh) {
445 my = (wh - fbh) / 2;
446 }
447
448 gtk_widget_queue_draw_area(vc->gfx.drawing_area,
449 mx + x1, my + y1, (x2 - x1), (y2 - y1));
450 }
451
452 static void gd_refresh(DisplayChangeListener *dcl)
453 {
454 graphic_hw_update(dcl->con);
455 }
456
457 #if GTK_CHECK_VERSION(3, 0, 0)
458 static void gd_mouse_set(DisplayChangeListener *dcl,
459 int x, int y, int visible)
460 {
461 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
462 GdkDisplay *dpy;
463 GdkDeviceManager *mgr;
464 gint x_root, y_root;
465
466 if (qemu_input_is_absolute()) {
467 return;
468 }
469
470 dpy = gtk_widget_get_display(vc->gfx.drawing_area);
471 mgr = gdk_display_get_device_manager(dpy);
472 gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area),
473 x, y, &x_root, &y_root);
474 gdk_device_warp(gdk_device_manager_get_client_pointer(mgr),
475 gtk_widget_get_screen(vc->gfx.drawing_area),
476 x_root, y_root);
477 vc->s->last_x = x;
478 vc->s->last_y = y;
479 }
480 #else
481 static void gd_mouse_set(DisplayChangeListener *dcl,
482 int x, int y, int visible)
483 {
484 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
485 gint x_root, y_root;
486
487 if (qemu_input_is_absolute()) {
488 return;
489 }
490
491 gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area),
492 x, y, &x_root, &y_root);
493 gdk_display_warp_pointer(gtk_widget_get_display(vc->gfx.drawing_area),
494 gtk_widget_get_screen(vc->gfx.drawing_area),
495 x_root, y_root);
496 }
497 #endif
498
499 static void gd_cursor_define(DisplayChangeListener *dcl,
500 QEMUCursor *c)
501 {
502 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
503 GdkPixbuf *pixbuf;
504 GdkCursor *cursor;
505
506 if (!gtk_widget_get_realized(vc->gfx.drawing_area)) {
507 return;
508 }
509
510 pixbuf = gdk_pixbuf_new_from_data((guchar *)(c->data),
511 GDK_COLORSPACE_RGB, true, 8,
512 c->width, c->height, c->width * 4,
513 NULL, NULL);
514 cursor = gdk_cursor_new_from_pixbuf
515 (gtk_widget_get_display(vc->gfx.drawing_area),
516 pixbuf, c->hot_x, c->hot_y);
517 gdk_window_set_cursor(gtk_widget_get_window(vc->gfx.drawing_area), cursor);
518 g_object_unref(pixbuf);
519 #if !GTK_CHECK_VERSION(3, 0, 0)
520 gdk_cursor_unref(cursor);
521 #else
522 g_object_unref(cursor);
523 #endif
524 }
525
526 static void gd_switch(DisplayChangeListener *dcl,
527 DisplaySurface *surface)
528 {
529 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
530 bool resized = true;
531
532 trace_gd_switch(vc->label,
533 surface ? surface_width(surface) : 0,
534 surface ? surface_height(surface) : 0);
535
536 if (vc->gfx.surface) {
537 cairo_surface_destroy(vc->gfx.surface);
538 vc->gfx.surface = NULL;
539 }
540 if (vc->gfx.convert) {
541 pixman_image_unref(vc->gfx.convert);
542 vc->gfx.convert = NULL;
543 }
544
545 if (vc->gfx.ds && surface &&
546 surface_width(vc->gfx.ds) == surface_width(surface) &&
547 surface_height(vc->gfx.ds) == surface_height(surface)) {
548 resized = false;
549 }
550 vc->gfx.ds = surface;
551
552 if (!surface) {
553 return;
554 }
555
556 if (surface->format == PIXMAN_x8r8g8b8) {
557 /*
558 * PIXMAN_x8r8g8b8 == CAIRO_FORMAT_RGB24
559 *
560 * No need to convert, use surface directly. Should be the
561 * common case as this is qemu_default_pixelformat(32) too.
562 */
563 vc->gfx.surface = cairo_image_surface_create_for_data
564 (surface_data(surface),
565 CAIRO_FORMAT_RGB24,
566 surface_width(surface),
567 surface_height(surface),
568 surface_stride(surface));
569 } else {
570 /* Must convert surface, use pixman to do it. */
571 vc->gfx.convert = pixman_image_create_bits(PIXMAN_x8r8g8b8,
572 surface_width(surface),
573 surface_height(surface),
574 NULL, 0);
575 vc->gfx.surface = cairo_image_surface_create_for_data
576 ((void *)pixman_image_get_data(vc->gfx.convert),
577 CAIRO_FORMAT_RGB24,
578 pixman_image_get_width(vc->gfx.convert),
579 pixman_image_get_height(vc->gfx.convert),
580 pixman_image_get_stride(vc->gfx.convert));
581 pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image,
582 NULL, vc->gfx.convert,
583 0, 0, 0, 0, 0, 0,
584 pixman_image_get_width(vc->gfx.convert),
585 pixman_image_get_height(vc->gfx.convert));
586 }
587
588 if (resized) {
589 gd_update_windowsize(vc);
590 } else {
591 gd_update_full_redraw(vc);
592 }
593 }
594
595 static const DisplayChangeListenerOps dcl_ops = {
596 .dpy_name = "gtk",
597 .dpy_gfx_update = gd_update,
598 .dpy_gfx_switch = gd_switch,
599 .dpy_gfx_check_format = qemu_pixman_check_format,
600 .dpy_refresh = gd_refresh,
601 .dpy_mouse_set = gd_mouse_set,
602 .dpy_cursor_define = gd_cursor_define,
603 };
604
605
606 #if defined(CONFIG_OPENGL)
607
608 /** DisplayState Callbacks (opengl version) **/
609
610 static const DisplayChangeListenerOps dcl_egl_ops = {
611 .dpy_name = "gtk-egl",
612 .dpy_gfx_update = gd_egl_update,
613 .dpy_gfx_switch = gd_egl_switch,
614 .dpy_gfx_check_format = console_gl_check_format,
615 .dpy_refresh = gd_egl_refresh,
616 .dpy_mouse_set = gd_mouse_set,
617 .dpy_cursor_define = gd_cursor_define,
618 };
619
620 #endif
621
622 /** QEMU Events **/
623
624 static void gd_change_runstate(void *opaque, int running, RunState state)
625 {
626 GtkDisplayState *s = opaque;
627
628 gd_update_caption(s);
629 }
630
631 static void gd_mouse_mode_change(Notifier *notify, void *data)
632 {
633 GtkDisplayState *s;
634 int i;
635
636 s = container_of(notify, GtkDisplayState, mouse_mode_notifier);
637 /* release the grab at switching to absolute mode */
638 if (qemu_input_is_absolute() && gd_is_grab_active(s)) {
639 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
640 FALSE);
641 }
642 for (i = 0; i < s->nb_vcs; i++) {
643 VirtualConsole *vc = &s->vc[i];
644 gd_update_cursor(vc);
645 }
646 }
647
648 /** GTK Events **/
649
650 static gboolean gd_window_close(GtkWidget *widget, GdkEvent *event,
651 void *opaque)
652 {
653 GtkDisplayState *s = opaque;
654 int i;
655
656 if (!no_quit) {
657 for (i = 0; i < s->nb_vcs; i++) {
658 if (s->vc[i].type != GD_VC_GFX) {
659 continue;
660 }
661 unregister_displaychangelistener(&s->vc[i].gfx.dcl);
662 }
663 qmp_quit(NULL);
664 return FALSE;
665 }
666
667 return TRUE;
668 }
669
670 static gboolean gd_draw_event(GtkWidget *widget, cairo_t *cr, void *opaque)
671 {
672 VirtualConsole *vc = opaque;
673 GtkDisplayState *s = vc->s;
674 int mx, my;
675 int ww, wh;
676 int fbw, fbh;
677
678 #if defined(CONFIG_OPENGL)
679 if (vc->gfx.gls) {
680 gd_egl_draw(vc);
681 return TRUE;
682 }
683 #endif
684
685 if (!gtk_widget_get_realized(widget)) {
686 return FALSE;
687 }
688 if (!vc->gfx.ds) {
689 return FALSE;
690 }
691
692 fbw = surface_width(vc->gfx.ds);
693 fbh = surface_height(vc->gfx.ds);
694
695 gdk_drawable_get_size(gtk_widget_get_window(widget), &ww, &wh);
696
697 if (s->full_screen) {
698 vc->gfx.scale_x = (double)ww / fbw;
699 vc->gfx.scale_y = (double)wh / fbh;
700 } else if (s->free_scale) {
701 double sx, sy;
702
703 sx = (double)ww / fbw;
704 sy = (double)wh / fbh;
705
706 vc->gfx.scale_x = vc->gfx.scale_y = MIN(sx, sy);
707 }
708
709 fbw *= vc->gfx.scale_x;
710 fbh *= vc->gfx.scale_y;
711
712 mx = my = 0;
713 if (ww > fbw) {
714 mx = (ww - fbw) / 2;
715 }
716 if (wh > fbh) {
717 my = (wh - fbh) / 2;
718 }
719
720 cairo_rectangle(cr, 0, 0, ww, wh);
721
722 /* Optionally cut out the inner area where the pixmap
723 will be drawn. This avoids 'flashing' since we're
724 not double-buffering. Note we're using the undocumented
725 behaviour of drawing the rectangle from right to left
726 to cut out the whole */
727 cairo_rectangle(cr, mx + fbw, my,
728 -1 * fbw, fbh);
729 cairo_fill(cr);
730
731 cairo_scale(cr, vc->gfx.scale_x, vc->gfx.scale_y);
732 cairo_set_source_surface(cr, vc->gfx.surface,
733 mx / vc->gfx.scale_x, my / vc->gfx.scale_y);
734 cairo_paint(cr);
735
736 return TRUE;
737 }
738
739 #if !GTK_CHECK_VERSION(3, 0, 0)
740 static gboolean gd_expose_event(GtkWidget *widget, GdkEventExpose *expose,
741 void *opaque)
742 {
743 cairo_t *cr;
744 gboolean ret;
745
746 cr = gdk_cairo_create(gtk_widget_get_window(widget));
747 cairo_rectangle(cr,
748 expose->area.x,
749 expose->area.y,
750 expose->area.width,
751 expose->area.height);
752 cairo_clip(cr);
753
754 ret = gd_draw_event(widget, cr, opaque);
755
756 cairo_destroy(cr);
757
758 return ret;
759 }
760 #endif
761
762 static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion,
763 void *opaque)
764 {
765 VirtualConsole *vc = opaque;
766 GtkDisplayState *s = vc->s;
767 int x, y;
768 int mx, my;
769 int fbh, fbw;
770 int ww, wh;
771
772 if (!vc->gfx.ds) {
773 return TRUE;
774 }
775
776 fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x;
777 fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y;
778
779 gdk_drawable_get_size(gtk_widget_get_window(vc->gfx.drawing_area),
780 &ww, &wh);
781
782 mx = my = 0;
783 if (ww > fbw) {
784 mx = (ww - fbw) / 2;
785 }
786 if (wh > fbh) {
787 my = (wh - fbh) / 2;
788 }
789
790 x = (motion->x - mx) / vc->gfx.scale_x;
791 y = (motion->y - my) / vc->gfx.scale_y;
792
793 if (qemu_input_is_absolute()) {
794 if (x < 0 || y < 0 ||
795 x >= surface_width(vc->gfx.ds) ||
796 y >= surface_height(vc->gfx.ds)) {
797 return TRUE;
798 }
799 qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_X, x,
800 surface_width(vc->gfx.ds));
801 qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_Y, y,
802 surface_height(vc->gfx.ds));
803 qemu_input_event_sync();
804 } else if (s->last_set && s->ptr_owner == vc) {
805 qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_X, x - s->last_x);
806 qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_Y, y - s->last_y);
807 qemu_input_event_sync();
808 }
809 s->last_x = x;
810 s->last_y = y;
811 s->last_set = TRUE;
812
813 if (!qemu_input_is_absolute() && s->ptr_owner == vc) {
814 GdkScreen *screen = gtk_widget_get_screen(vc->gfx.drawing_area);
815 int x = (int)motion->x_root;
816 int y = (int)motion->y_root;
817
818 /* In relative mode check to see if client pointer hit
819 * one of the screen edges, and if so move it back by
820 * 200 pixels. This is important because the pointer
821 * in the server doesn't correspond 1-for-1, and so
822 * may still be only half way across the screen. Without
823 * this warp, the server pointer would thus appear to hit
824 * an invisible wall */
825 if (x == 0) {
826 x += 200;
827 }
828 if (y == 0) {
829 y += 200;
830 }
831 if (x == (gdk_screen_get_width(screen) - 1)) {
832 x -= 200;
833 }
834 if (y == (gdk_screen_get_height(screen) - 1)) {
835 y -= 200;
836 }
837
838 if (x != (int)motion->x_root || y != (int)motion->y_root) {
839 #if GTK_CHECK_VERSION(3, 0, 0)
840 GdkDevice *dev = gdk_event_get_device((GdkEvent *)motion);
841 gdk_device_warp(dev, screen, x, y);
842 #else
843 GdkDisplay *display = gtk_widget_get_display(widget);
844 gdk_display_warp_pointer(display, screen, x, y);
845 #endif
846 s->last_set = FALSE;
847 return FALSE;
848 }
849 }
850 return TRUE;
851 }
852
853 static gboolean gd_button_event(GtkWidget *widget, GdkEventButton *button,
854 void *opaque)
855 {
856 VirtualConsole *vc = opaque;
857 GtkDisplayState *s = vc->s;
858 InputButton btn;
859
860 /* implicitly grab the input at the first click in the relative mode */
861 if (button->button == 1 && button->type == GDK_BUTTON_PRESS &&
862 !qemu_input_is_absolute() && s->ptr_owner != vc) {
863 if (!vc->window) {
864 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
865 TRUE);
866 } else {
867 gd_grab_pointer(vc, "relative-mode-click");
868 }
869 return TRUE;
870 }
871
872 if (button->button == 1) {
873 btn = INPUT_BUTTON_LEFT;
874 } else if (button->button == 2) {
875 btn = INPUT_BUTTON_MIDDLE;
876 } else if (button->button == 3) {
877 btn = INPUT_BUTTON_RIGHT;
878 } else {
879 return TRUE;
880 }
881
882 qemu_input_queue_btn(vc->gfx.dcl.con, btn,
883 button->type == GDK_BUTTON_PRESS);
884 qemu_input_event_sync();
885 return TRUE;
886 }
887
888 static gboolean gd_scroll_event(GtkWidget *widget, GdkEventScroll *scroll,
889 void *opaque)
890 {
891 VirtualConsole *vc = opaque;
892 InputButton btn;
893
894 if (scroll->direction == GDK_SCROLL_UP) {
895 btn = INPUT_BUTTON_WHEEL_UP;
896 } else if (scroll->direction == GDK_SCROLL_DOWN) {
897 btn = INPUT_BUTTON_WHEEL_DOWN;
898 } else {
899 return TRUE;
900 }
901
902 qemu_input_queue_btn(vc->gfx.dcl.con, btn, true);
903 qemu_input_event_sync();
904 qemu_input_queue_btn(vc->gfx.dcl.con, btn, false);
905 qemu_input_event_sync();
906 return TRUE;
907 }
908
909 static int gd_map_keycode(GtkDisplayState *s, GdkDisplay *dpy, int gdk_keycode)
910 {
911 int qemu_keycode;
912
913 #ifdef GDK_WINDOWING_WIN32
914 if (GDK_IS_WIN32_DISPLAY(dpy)) {
915 qemu_keycode = MapVirtualKey(gdk_keycode, MAPVK_VK_TO_VSC);
916 switch (qemu_keycode) {
917 case 103: /* alt gr */
918 qemu_keycode = 56 | SCANCODE_GREY;
919 break;
920 }
921 return qemu_keycode;
922 }
923 #endif
924
925 if (gdk_keycode < 9) {
926 qemu_keycode = 0;
927 } else if (gdk_keycode < 97) {
928 qemu_keycode = gdk_keycode - 8;
929 #ifdef GDK_WINDOWING_X11
930 } else if (GDK_IS_X11_DISPLAY(dpy) && gdk_keycode < 158) {
931 if (s->has_evdev) {
932 qemu_keycode = translate_evdev_keycode(gdk_keycode - 97);
933 } else {
934 qemu_keycode = translate_xfree86_keycode(gdk_keycode - 97);
935 }
936 #endif
937 } else if (gdk_keycode == 208) { /* Hiragana_Katakana */
938 qemu_keycode = 0x70;
939 } else if (gdk_keycode == 211) { /* backslash */
940 qemu_keycode = 0x73;
941 } else {
942 qemu_keycode = 0;
943 }
944
945 return qemu_keycode;
946 }
947
948 static gboolean gd_text_key_down(GtkWidget *widget,
949 GdkEventKey *key, void *opaque)
950 {
951 VirtualConsole *vc = opaque;
952 QemuConsole *con = vc->gfx.dcl.con;
953
954 if (key->length) {
955 kbd_put_string_console(con, key->string, key->length);
956 } else {
957 int num = gd_map_keycode(vc->s, gtk_widget_get_display(widget),
958 key->hardware_keycode);
959 int qcode = qemu_input_key_number_to_qcode(num);
960 kbd_put_qcode_console(con, qcode);
961 }
962 return TRUE;
963 }
964
965 static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
966 {
967 VirtualConsole *vc = opaque;
968 GtkDisplayState *s = vc->s;
969 int gdk_keycode = key->hardware_keycode;
970 int qemu_keycode;
971 int i;
972
973 if (s->ignore_keys) {
974 s->ignore_keys = (key->type == GDK_KEY_PRESS);
975 return TRUE;
976 }
977
978 if (key->keyval == GDK_KEY_Pause) {
979 qemu_input_event_send_key_qcode(vc->gfx.dcl.con, Q_KEY_CODE_PAUSE,
980 key->type == GDK_KEY_PRESS);
981 return TRUE;
982 }
983
984 qemu_keycode = gd_map_keycode(s, gtk_widget_get_display(widget),
985 gdk_keycode);
986
987 trace_gd_key_event(vc->label, gdk_keycode, qemu_keycode,
988 (key->type == GDK_KEY_PRESS) ? "down" : "up");
989
990 for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) {
991 if (qemu_keycode == modifier_keycode[i]) {
992 s->modifier_pressed[i] = (key->type == GDK_KEY_PRESS);
993 }
994 }
995
996 qemu_input_event_send_key_number(vc->gfx.dcl.con, qemu_keycode,
997 key->type == GDK_KEY_PRESS);
998
999 return TRUE;
1000 }
1001
1002 static gboolean gd_event(GtkWidget *widget, GdkEvent *event, void *opaque)
1003 {
1004 if (event->type == GDK_MOTION_NOTIFY) {
1005 return gd_motion_event(widget, &event->motion, opaque);
1006 }
1007 return FALSE;
1008 }
1009
1010 /** Window Menu Actions **/
1011
1012 static void gd_menu_pause(GtkMenuItem *item, void *opaque)
1013 {
1014 GtkDisplayState *s = opaque;
1015
1016 if (s->external_pause_update) {
1017 return;
1018 }
1019 if (runstate_is_running()) {
1020 qmp_stop(NULL);
1021 } else {
1022 qmp_cont(NULL);
1023 }
1024 }
1025
1026 static void gd_menu_reset(GtkMenuItem *item, void *opaque)
1027 {
1028 qmp_system_reset(NULL);
1029 }
1030
1031 static void gd_menu_powerdown(GtkMenuItem *item, void *opaque)
1032 {
1033 qmp_system_powerdown(NULL);
1034 }
1035
1036 static void gd_menu_quit(GtkMenuItem *item, void *opaque)
1037 {
1038 qmp_quit(NULL);
1039 }
1040
1041 static void gd_menu_switch_vc(GtkMenuItem *item, void *opaque)
1042 {
1043 GtkDisplayState *s = opaque;
1044 VirtualConsole *vc = gd_vc_find_by_menu(s);
1045 GtkNotebook *nb = GTK_NOTEBOOK(s->notebook);
1046 gint page;
1047
1048 gtk_release_modifiers(s);
1049 if (vc) {
1050 page = gtk_notebook_page_num(nb, vc->tab_item);
1051 gtk_notebook_set_current_page(nb, page);
1052 gtk_widget_grab_focus(vc->focus);
1053 }
1054 s->ignore_keys = false;
1055 }
1056
1057 static void gd_accel_switch_vc(void *opaque)
1058 {
1059 VirtualConsole *vc = opaque;
1060
1061 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), TRUE);
1062 #if !GTK_CHECK_VERSION(3, 0, 0)
1063 /* GTK2 sends the accel key to the target console - ignore this until */
1064 vc->s->ignore_keys = true;
1065 #endif
1066 }
1067
1068 static void gd_menu_show_tabs(GtkMenuItem *item, void *opaque)
1069 {
1070 GtkDisplayState *s = opaque;
1071 VirtualConsole *vc = gd_vc_find_current(s);
1072
1073 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->show_tabs_item))) {
1074 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), TRUE);
1075 } else {
1076 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
1077 }
1078 gd_update_windowsize(vc);
1079 }
1080
1081 static gboolean gd_tab_window_close(GtkWidget *widget, GdkEvent *event,
1082 void *opaque)
1083 {
1084 VirtualConsole *vc = opaque;
1085 GtkDisplayState *s = vc->s;
1086
1087 gtk_widget_set_sensitive(vc->menu_item, true);
1088 gd_widget_reparent(vc->window, s->notebook, vc->tab_item);
1089 gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(s->notebook),
1090 vc->tab_item, vc->label);
1091 gtk_widget_destroy(vc->window);
1092 vc->window = NULL;
1093 return TRUE;
1094 }
1095
1096 static gboolean gd_win_grab(void *opaque)
1097 {
1098 VirtualConsole *vc = opaque;
1099
1100 fprintf(stderr, "%s: %s\n", __func__, vc->label);
1101 if (vc->s->ptr_owner) {
1102 gd_ungrab_pointer(vc->s);
1103 } else {
1104 gd_grab_pointer(vc, "user-request-detached-tab");
1105 }
1106 return TRUE;
1107 }
1108
1109 static void gd_menu_untabify(GtkMenuItem *item, void *opaque)
1110 {
1111 GtkDisplayState *s = opaque;
1112 VirtualConsole *vc = gd_vc_find_current(s);
1113
1114 if (vc->type == GD_VC_GFX &&
1115 qemu_console_is_graphic(vc->gfx.dcl.con)) {
1116 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
1117 FALSE);
1118 }
1119 if (!vc->window) {
1120 gtk_widget_set_sensitive(vc->menu_item, false);
1121 vc->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1122 gd_widget_reparent(s->notebook, vc->window, vc->tab_item);
1123
1124 g_signal_connect(vc->window, "delete-event",
1125 G_CALLBACK(gd_tab_window_close), vc);
1126 gtk_widget_show_all(vc->window);
1127
1128 if (qemu_console_is_graphic(vc->gfx.dcl.con)) {
1129 GtkAccelGroup *ag = gtk_accel_group_new();
1130 gtk_window_add_accel_group(GTK_WINDOW(vc->window), ag);
1131
1132 GClosure *cb = g_cclosure_new_swap(G_CALLBACK(gd_win_grab),
1133 vc, NULL);
1134 gtk_accel_group_connect(ag, GDK_KEY_g, HOTKEY_MODIFIERS, 0, cb);
1135 }
1136
1137 gd_update_geometry_hints(vc);
1138 gd_update_caption(s);
1139 }
1140 }
1141
1142 static void gd_menu_full_screen(GtkMenuItem *item, void *opaque)
1143 {
1144 GtkDisplayState *s = opaque;
1145 VirtualConsole *vc = gd_vc_find_current(s);
1146
1147 if (!s->full_screen) {
1148 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
1149 gtk_widget_hide(s->menu_bar);
1150 if (vc->type == GD_VC_GFX) {
1151 gtk_widget_set_size_request(vc->gfx.drawing_area, -1, -1);
1152 }
1153 gtk_window_fullscreen(GTK_WINDOW(s->window));
1154 s->full_screen = TRUE;
1155 } else {
1156 gtk_window_unfullscreen(GTK_WINDOW(s->window));
1157 gd_menu_show_tabs(GTK_MENU_ITEM(s->show_tabs_item), s);
1158 gtk_widget_show(s->menu_bar);
1159 s->full_screen = FALSE;
1160 if (vc->type == GD_VC_GFX) {
1161 vc->gfx.scale_x = 1.0;
1162 vc->gfx.scale_y = 1.0;
1163 gd_update_windowsize(vc);
1164 }
1165 }
1166
1167 gd_update_cursor(vc);
1168 }
1169
1170 static void gd_accel_full_screen(void *opaque)
1171 {
1172 GtkDisplayState *s = opaque;
1173 gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item));
1174 }
1175
1176 static void gd_menu_zoom_in(GtkMenuItem *item, void *opaque)
1177 {
1178 GtkDisplayState *s = opaque;
1179 VirtualConsole *vc = gd_vc_find_current(s);
1180
1181 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item),
1182 FALSE);
1183
1184 vc->gfx.scale_x += VC_SCALE_STEP;
1185 vc->gfx.scale_y += VC_SCALE_STEP;
1186
1187 gd_update_windowsize(vc);
1188 }
1189
1190 static void gd_menu_zoom_out(GtkMenuItem *item, void *opaque)
1191 {
1192 GtkDisplayState *s = opaque;
1193 VirtualConsole *vc = gd_vc_find_current(s);
1194
1195 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item),
1196 FALSE);
1197
1198 vc->gfx.scale_x -= VC_SCALE_STEP;
1199 vc->gfx.scale_y -= VC_SCALE_STEP;
1200
1201 vc->gfx.scale_x = MAX(vc->gfx.scale_x, VC_SCALE_MIN);
1202 vc->gfx.scale_y = MAX(vc->gfx.scale_y, VC_SCALE_MIN);
1203
1204 gd_update_windowsize(vc);
1205 }
1206
1207 static void gd_menu_zoom_fixed(GtkMenuItem *item, void *opaque)
1208 {
1209 GtkDisplayState *s = opaque;
1210 VirtualConsole *vc = gd_vc_find_current(s);
1211
1212 vc->gfx.scale_x = 1.0;
1213 vc->gfx.scale_y = 1.0;
1214
1215 gd_update_windowsize(vc);
1216 }
1217
1218 static void gd_menu_zoom_fit(GtkMenuItem *item, void *opaque)
1219 {
1220 GtkDisplayState *s = opaque;
1221 VirtualConsole *vc = gd_vc_find_current(s);
1222
1223 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item))) {
1224 s->free_scale = TRUE;
1225 } else {
1226 s->free_scale = FALSE;
1227 vc->gfx.scale_x = 1.0;
1228 vc->gfx.scale_y = 1.0;
1229 }
1230
1231 gd_update_windowsize(vc);
1232 gd_update_full_redraw(vc);
1233 }
1234
1235 #if GTK_CHECK_VERSION(3, 0, 0)
1236 static void gd_grab_devices(VirtualConsole *vc, bool grab,
1237 GdkInputSource source, GdkEventMask mask,
1238 GdkCursor *cursor)
1239 {
1240 GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
1241 GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
1242 GList *devs = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER);
1243 GList *tmp = devs;
1244
1245 for (tmp = devs; tmp; tmp = tmp->next) {
1246 GdkDevice *dev = tmp->data;
1247 if (gdk_device_get_source(dev) != source) {
1248 continue;
1249 }
1250 if (grab) {
1251 GdkWindow *win = gtk_widget_get_window(vc->gfx.drawing_area);
1252 gdk_device_grab(dev, win, GDK_OWNERSHIP_NONE, FALSE,
1253 mask, cursor, GDK_CURRENT_TIME);
1254 } else {
1255 gdk_device_ungrab(dev, GDK_CURRENT_TIME);
1256 }
1257 }
1258 g_list_free(devs);
1259 }
1260 #endif
1261
1262 static void gd_grab_keyboard(VirtualConsole *vc, const char *reason)
1263 {
1264 if (vc->s->kbd_owner) {
1265 if (vc->s->kbd_owner == vc) {
1266 return;
1267 } else {
1268 gd_ungrab_keyboard(vc->s);
1269 }
1270 }
1271
1272 #if GTK_CHECK_VERSION(3, 0, 0)
1273 gd_grab_devices(vc, true, GDK_SOURCE_KEYBOARD,
1274 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
1275 NULL);
1276 #else
1277 gdk_keyboard_grab(gtk_widget_get_window(vc->gfx.drawing_area),
1278 FALSE,
1279 GDK_CURRENT_TIME);
1280 #endif
1281 vc->s->kbd_owner = vc;
1282 gd_update_caption(vc->s);
1283 trace_gd_grab(vc->label, "kbd", reason);
1284 }
1285
1286 static void gd_ungrab_keyboard(GtkDisplayState *s)
1287 {
1288 VirtualConsole *vc = s->kbd_owner;
1289
1290 if (vc == NULL) {
1291 return;
1292 }
1293 s->kbd_owner = NULL;
1294
1295 #if GTK_CHECK_VERSION(3, 0, 0)
1296 gd_grab_devices(vc, false, GDK_SOURCE_KEYBOARD, 0, NULL);
1297 #else
1298 gdk_keyboard_ungrab(GDK_CURRENT_TIME);
1299 #endif
1300 gd_update_caption(s);
1301 trace_gd_ungrab(vc->label, "kbd");
1302 }
1303
1304 static void gd_grab_pointer(VirtualConsole *vc, const char *reason)
1305 {
1306 GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
1307
1308 if (vc->s->ptr_owner) {
1309 if (vc->s->ptr_owner == vc) {
1310 return;
1311 } else {
1312 gd_ungrab_pointer(vc->s);
1313 }
1314 }
1315
1316 #if GTK_CHECK_VERSION(3, 0, 0)
1317 GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
1318 gd_grab_devices(vc, true, GDK_SOURCE_MOUSE,
1319 GDK_POINTER_MOTION_MASK |
1320 GDK_BUTTON_PRESS_MASK |
1321 GDK_BUTTON_RELEASE_MASK |
1322 GDK_BUTTON_MOTION_MASK |
1323 GDK_SCROLL_MASK,
1324 vc->s->null_cursor);
1325 gdk_device_get_position(gdk_device_manager_get_client_pointer(mgr),
1326 NULL, &vc->s->grab_x_root, &vc->s->grab_y_root);
1327 #else
1328 gdk_pointer_grab(gtk_widget_get_window(vc->gfx.drawing_area),
1329 FALSE, /* All events to come to our window directly */
1330 GDK_POINTER_MOTION_MASK |
1331 GDK_BUTTON_PRESS_MASK |
1332 GDK_BUTTON_RELEASE_MASK |
1333 GDK_BUTTON_MOTION_MASK |
1334 GDK_SCROLL_MASK,
1335 NULL, /* Allow cursor to move over entire desktop */
1336 vc->s->null_cursor,
1337 GDK_CURRENT_TIME);
1338 gdk_display_get_pointer(display, NULL,
1339 &vc->s->grab_x_root, &vc->s->grab_y_root, NULL);
1340 #endif
1341 vc->s->ptr_owner = vc;
1342 gd_update_caption(vc->s);
1343 trace_gd_grab(vc->label, "ptr", reason);
1344 }
1345
1346 static void gd_ungrab_pointer(GtkDisplayState *s)
1347 {
1348 VirtualConsole *vc = s->ptr_owner;
1349
1350 if (vc == NULL) {
1351 return;
1352 }
1353 s->ptr_owner = NULL;
1354
1355 GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
1356 #if GTK_CHECK_VERSION(3, 0, 0)
1357 GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
1358 gd_grab_devices(vc, false, GDK_SOURCE_MOUSE, 0, NULL);
1359 gdk_device_warp(gdk_device_manager_get_client_pointer(mgr),
1360 gtk_widget_get_screen(vc->gfx.drawing_area),
1361 vc->s->grab_x_root, vc->s->grab_y_root);
1362 #else
1363 gdk_pointer_ungrab(GDK_CURRENT_TIME);
1364 gdk_display_warp_pointer(display,
1365 gtk_widget_get_screen(vc->gfx.drawing_area),
1366 vc->s->grab_x_root, vc->s->grab_y_root);
1367 #endif
1368 gd_update_caption(s);
1369 trace_gd_ungrab(vc->label, "ptr");
1370 }
1371
1372 static void gd_menu_grab_input(GtkMenuItem *item, void *opaque)
1373 {
1374 GtkDisplayState *s = opaque;
1375 VirtualConsole *vc = gd_vc_find_current(s);
1376
1377 if (gd_is_grab_active(s)) {
1378 gd_grab_keyboard(vc, "user-request-main-window");
1379 gd_grab_pointer(vc, "user-request-main-window");
1380 } else {
1381 gd_ungrab_keyboard(s);
1382 gd_ungrab_pointer(s);
1383 }
1384
1385 gd_update_cursor(vc);
1386 }
1387
1388 static void gd_change_page(GtkNotebook *nb, gpointer arg1, guint arg2,
1389 gpointer data)
1390 {
1391 GtkDisplayState *s = data;
1392 VirtualConsole *vc;
1393 gboolean on_vga;
1394
1395 if (!gtk_widget_get_realized(s->notebook)) {
1396 return;
1397 }
1398
1399 #ifdef VTE_RESIZE_HACK
1400 vc = gd_vc_find_current(s);
1401 if (vc && vc->type == GD_VC_VTE) {
1402 gtk_widget_hide(vc->vte.terminal);
1403 }
1404 #endif
1405 vc = gd_vc_find_by_page(s, arg2);
1406 if (!vc) {
1407 return;
1408 }
1409 #ifdef VTE_RESIZE_HACK
1410 if (vc->type == GD_VC_VTE) {
1411 gtk_widget_show(vc->vte.terminal);
1412 }
1413 #endif
1414 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item),
1415 TRUE);
1416 on_vga = (vc->type == GD_VC_GFX &&
1417 qemu_console_is_graphic(vc->gfx.dcl.con));
1418 if (!on_vga) {
1419 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
1420 FALSE);
1421 } else if (s->full_screen) {
1422 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
1423 TRUE);
1424 }
1425 gtk_widget_set_sensitive(s->grab_item, on_vga);
1426
1427 gd_update_windowsize(vc);
1428 gd_update_cursor(vc);
1429 }
1430
1431 static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing,
1432 gpointer opaque)
1433 {
1434 VirtualConsole *vc = opaque;
1435 GtkDisplayState *s = vc->s;
1436
1437 if (gd_grab_on_hover(s)) {
1438 gd_grab_keyboard(vc, "grab-on-hover");
1439 }
1440 return TRUE;
1441 }
1442
1443 static gboolean gd_leave_event(GtkWidget *widget, GdkEventCrossing *crossing,
1444 gpointer opaque)
1445 {
1446 VirtualConsole *vc = opaque;
1447 GtkDisplayState *s = vc->s;
1448
1449 if (gd_grab_on_hover(s)) {
1450 gd_ungrab_keyboard(s);
1451 }
1452 return TRUE;
1453 }
1454
1455 static gboolean gd_focus_out_event(GtkWidget *widget,
1456 GdkEventCrossing *crossing, gpointer opaque)
1457 {
1458 VirtualConsole *vc = opaque;
1459 GtkDisplayState *s = vc->s;
1460
1461 gtk_release_modifiers(s);
1462 return TRUE;
1463 }
1464
1465 static gboolean gd_configure(GtkWidget *widget,
1466 GdkEventConfigure *cfg, gpointer opaque)
1467 {
1468 VirtualConsole *vc = opaque;
1469 QemuUIInfo info;
1470
1471 memset(&info, 0, sizeof(info));
1472 info.width = cfg->width;
1473 info.height = cfg->height;
1474 dpy_set_ui_info(vc->gfx.dcl.con, &info);
1475 return FALSE;
1476 }
1477
1478 /** Virtual Console Callbacks **/
1479
1480 static GSList *gd_vc_menu_init(GtkDisplayState *s, VirtualConsole *vc,
1481 int idx, GSList *group, GtkWidget *view_menu)
1482 {
1483 vc->menu_item = gtk_radio_menu_item_new_with_mnemonic(group, vc->label);
1484 gtk_accel_group_connect(s->accel_group, GDK_KEY_1 + idx,
1485 HOTKEY_MODIFIERS, 0,
1486 g_cclosure_new_swap(G_CALLBACK(gd_accel_switch_vc), vc, NULL));
1487 #if GTK_CHECK_VERSION(3, 8, 0)
1488 gtk_accel_label_set_accel(
1489 GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(vc->menu_item))),
1490 GDK_KEY_1 + idx, HOTKEY_MODIFIERS);
1491 #endif
1492
1493 g_signal_connect(vc->menu_item, "activate",
1494 G_CALLBACK(gd_menu_switch_vc), s);
1495 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), vc->menu_item);
1496
1497 group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(vc->menu_item));
1498 return group;
1499 }
1500
1501 #if defined(CONFIG_VTE)
1502 static void gd_vc_adjustment_changed(GtkAdjustment *adjustment, void *opaque)
1503 {
1504 VirtualConsole *vc = opaque;
1505
1506 if (gtk_adjustment_get_upper(adjustment) >
1507 gtk_adjustment_get_page_size(adjustment)) {
1508 gtk_widget_show(vc->vte.scrollbar);
1509 } else {
1510 gtk_widget_hide(vc->vte.scrollbar);
1511 }
1512 }
1513
1514 static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1515 {
1516 VirtualConsole *vc = chr->opaque;
1517
1518 vte_terminal_feed(VTE_TERMINAL(vc->vte.terminal), (const char *)buf, len);
1519 return len;
1520 }
1521
1522 static int nb_vcs;
1523 static CharDriverState *vcs[MAX_VCS];
1524
1525 static CharDriverState *gd_vc_handler(ChardevVC *unused)
1526 {
1527 CharDriverState *chr;
1528
1529 chr = g_malloc0(sizeof(*chr));
1530 chr->chr_write = gd_vc_chr_write;
1531 /* defer OPENED events until our vc is fully initialized */
1532 chr->explicit_be_open = true;
1533
1534 vcs[nb_vcs++] = chr;
1535
1536 return chr;
1537 }
1538
1539 static gboolean gd_vc_in(VteTerminal *terminal, gchar *text, guint size,
1540 gpointer user_data)
1541 {
1542 VirtualConsole *vc = user_data;
1543
1544 qemu_chr_be_write(vc->vte.chr, (uint8_t *)text, (unsigned int)size);
1545 return TRUE;
1546 }
1547
1548 static GSList *gd_vc_vte_init(GtkDisplayState *s, VirtualConsole *vc,
1549 CharDriverState *chr, int idx,
1550 GSList *group, GtkWidget *view_menu)
1551 {
1552 char buffer[32];
1553 GtkWidget *box;
1554 GtkWidget *scrollbar;
1555 GtkAdjustment *vadjustment;
1556
1557 vc->s = s;
1558 vc->vte.chr = chr;
1559
1560 snprintf(buffer, sizeof(buffer), "vc%d", idx);
1561 vc->label = g_strdup_printf("%s", vc->vte.chr->label
1562 ? vc->vte.chr->label : buffer);
1563 group = gd_vc_menu_init(s, vc, idx, group, view_menu);
1564
1565 vc->vte.terminal = vte_terminal_new();
1566 g_signal_connect(vc->vte.terminal, "commit", G_CALLBACK(gd_vc_in), vc);
1567
1568 vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->vte.terminal), -1);
1569 vte_terminal_set_size(VTE_TERMINAL(vc->vte.terminal),
1570 VC_TERM_X_MIN, VC_TERM_Y_MIN);
1571
1572 #if VTE_CHECK_VERSION(0, 28, 0) && GTK_CHECK_VERSION(3, 0, 0)
1573 vadjustment = gtk_scrollable_get_vadjustment
1574 (GTK_SCROLLABLE(vc->vte.terminal));
1575 #else
1576 vadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->vte.terminal));
1577 #endif
1578
1579 #if GTK_CHECK_VERSION(3, 0, 0)
1580 box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
1581 scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, vadjustment);
1582 #else
1583 box = gtk_hbox_new(false, 2);
1584 scrollbar = gtk_vscrollbar_new(vadjustment);
1585 #endif
1586
1587 gtk_box_pack_start(GTK_BOX(box), vc->vte.terminal, TRUE, TRUE, 0);
1588 gtk_box_pack_start(GTK_BOX(box), scrollbar, FALSE, FALSE, 0);
1589
1590 vc->vte.chr->opaque = vc;
1591 vc->vte.box = box;
1592 vc->vte.scrollbar = scrollbar;
1593
1594 g_signal_connect(vadjustment, "changed",
1595 G_CALLBACK(gd_vc_adjustment_changed), vc);
1596
1597 vc->type = GD_VC_VTE;
1598 vc->tab_item = box;
1599 vc->focus = vc->vte.terminal;
1600 gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), vc->tab_item,
1601 gtk_label_new(vc->label));
1602
1603 qemu_chr_be_generic_open(vc->vte.chr);
1604 if (vc->vte.chr->init) {
1605 vc->vte.chr->init(vc->vte.chr);
1606 }
1607
1608 return group;
1609 }
1610
1611 static void gd_vcs_init(GtkDisplayState *s, GSList *group,
1612 GtkWidget *view_menu)
1613 {
1614 int i;
1615
1616 for (i = 0; i < nb_vcs; i++) {
1617 VirtualConsole *vc = &s->vc[s->nb_vcs];
1618 group = gd_vc_vte_init(s, vc, vcs[i], s->nb_vcs, group, view_menu);
1619 s->nb_vcs++;
1620 }
1621 }
1622 #endif /* CONFIG_VTE */
1623
1624 /** Window Creation **/
1625
1626 static void gd_connect_vc_gfx_signals(VirtualConsole *vc)
1627 {
1628 #if GTK_CHECK_VERSION(3, 0, 0)
1629 g_signal_connect(vc->gfx.drawing_area, "draw",
1630 G_CALLBACK(gd_draw_event), vc);
1631 #else
1632 g_signal_connect(vc->gfx.drawing_area, "expose-event",
1633 G_CALLBACK(gd_expose_event), vc);
1634 #endif
1635 if (qemu_console_is_graphic(vc->gfx.dcl.con)) {
1636 g_signal_connect(vc->gfx.drawing_area, "event",
1637 G_CALLBACK(gd_event), vc);
1638 g_signal_connect(vc->gfx.drawing_area, "button-press-event",
1639 G_CALLBACK(gd_button_event), vc);
1640 g_signal_connect(vc->gfx.drawing_area, "button-release-event",
1641 G_CALLBACK(gd_button_event), vc);
1642 g_signal_connect(vc->gfx.drawing_area, "scroll-event",
1643 G_CALLBACK(gd_scroll_event), vc);
1644 g_signal_connect(vc->gfx.drawing_area, "key-press-event",
1645 G_CALLBACK(gd_key_event), vc);
1646 g_signal_connect(vc->gfx.drawing_area, "key-release-event",
1647 G_CALLBACK(gd_key_event), vc);
1648
1649 g_signal_connect(vc->gfx.drawing_area, "enter-notify-event",
1650 G_CALLBACK(gd_enter_event), vc);
1651 g_signal_connect(vc->gfx.drawing_area, "leave-notify-event",
1652 G_CALLBACK(gd_leave_event), vc);
1653 g_signal_connect(vc->gfx.drawing_area, "focus-out-event",
1654 G_CALLBACK(gd_focus_out_event), vc);
1655 g_signal_connect(vc->gfx.drawing_area, "configure-event",
1656 G_CALLBACK(gd_configure), vc);
1657 } else {
1658 g_signal_connect(vc->gfx.drawing_area, "key-press-event",
1659 G_CALLBACK(gd_text_key_down), vc);
1660 }
1661 }
1662
1663 static void gd_connect_signals(GtkDisplayState *s)
1664 {
1665 g_signal_connect(s->show_tabs_item, "activate",
1666 G_CALLBACK(gd_menu_show_tabs), s);
1667 g_signal_connect(s->untabify_item, "activate",
1668 G_CALLBACK(gd_menu_untabify), s);
1669
1670 g_signal_connect(s->window, "delete-event",
1671 G_CALLBACK(gd_window_close), s);
1672
1673 g_signal_connect(s->pause_item, "activate",
1674 G_CALLBACK(gd_menu_pause), s);
1675 g_signal_connect(s->reset_item, "activate",
1676 G_CALLBACK(gd_menu_reset), s);
1677 g_signal_connect(s->powerdown_item, "activate",
1678 G_CALLBACK(gd_menu_powerdown), s);
1679 g_signal_connect(s->quit_item, "activate",
1680 G_CALLBACK(gd_menu_quit), s);
1681 g_signal_connect(s->full_screen_item, "activate",
1682 G_CALLBACK(gd_menu_full_screen), s);
1683 g_signal_connect(s->zoom_in_item, "activate",
1684 G_CALLBACK(gd_menu_zoom_in), s);
1685 g_signal_connect(s->zoom_out_item, "activate",
1686 G_CALLBACK(gd_menu_zoom_out), s);
1687 g_signal_connect(s->zoom_fixed_item, "activate",
1688 G_CALLBACK(gd_menu_zoom_fixed), s);
1689 g_signal_connect(s->zoom_fit_item, "activate",
1690 G_CALLBACK(gd_menu_zoom_fit), s);
1691 g_signal_connect(s->grab_item, "activate",
1692 G_CALLBACK(gd_menu_grab_input), s);
1693 g_signal_connect(s->notebook, "switch-page",
1694 G_CALLBACK(gd_change_page), s);
1695 }
1696
1697 static GtkWidget *gd_create_menu_machine(GtkDisplayState *s)
1698 {
1699 GtkWidget *machine_menu;
1700 GtkWidget *separator;
1701
1702 machine_menu = gtk_menu_new();
1703 gtk_menu_set_accel_group(GTK_MENU(machine_menu), s->accel_group);
1704
1705 s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause"));
1706 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->pause_item);
1707
1708 separator = gtk_separator_menu_item_new();
1709 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
1710
1711 s->reset_item = gtk_menu_item_new_with_mnemonic(_("_Reset"));
1712 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->reset_item);
1713
1714 s->powerdown_item = gtk_menu_item_new_with_mnemonic(_("Power _Down"));
1715 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->powerdown_item);
1716
1717 separator = gtk_separator_menu_item_new();
1718 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
1719
1720 s->quit_item = gtk_menu_item_new_with_mnemonic(_("_Quit"));
1721 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item),
1722 "<QEMU>/Machine/Quit");
1723 gtk_accel_map_add_entry("<QEMU>/Machine/Quit",
1724 GDK_KEY_q, HOTKEY_MODIFIERS);
1725 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->quit_item);
1726
1727 return machine_menu;
1728 }
1729
1730 static GSList *gd_vc_gfx_init(GtkDisplayState *s, VirtualConsole *vc,
1731 QemuConsole *con, int idx,
1732 GSList *group, GtkWidget *view_menu)
1733 {
1734 vc->label = qemu_console_get_label(con);
1735 vc->s = s;
1736 vc->gfx.scale_x = 1.0;
1737 vc->gfx.scale_y = 1.0;
1738
1739 vc->gfx.drawing_area = gtk_drawing_area_new();
1740 gtk_widget_add_events(vc->gfx.drawing_area,
1741 GDK_POINTER_MOTION_MASK |
1742 GDK_BUTTON_PRESS_MASK |
1743 GDK_BUTTON_RELEASE_MASK |
1744 GDK_BUTTON_MOTION_MASK |
1745 GDK_ENTER_NOTIFY_MASK |
1746 GDK_LEAVE_NOTIFY_MASK |
1747 GDK_SCROLL_MASK |
1748 GDK_KEY_PRESS_MASK);
1749 gtk_widget_set_can_focus(vc->gfx.drawing_area, TRUE);
1750
1751 vc->type = GD_VC_GFX;
1752 vc->tab_item = vc->gfx.drawing_area;
1753 vc->focus = vc->gfx.drawing_area;
1754 gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook),
1755 vc->tab_item, gtk_label_new(vc->label));
1756
1757 #if defined(CONFIG_OPENGL)
1758 if (display_opengl) {
1759 /*
1760 * gtk_widget_set_double_buffered() was deprecated in 3.14.
1761 * It is required for opengl rendering on X11 though. A
1762 * proper replacement (native opengl support) is only
1763 * available in 3.16+. Silence the warning if possible.
1764 */
1765 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
1766 #pragma GCC diagnostic push
1767 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1768 #endif
1769 gtk_widget_set_double_buffered(vc->gfx.drawing_area, FALSE);
1770 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
1771 #pragma GCC diagnostic pop
1772 #endif
1773 vc->gfx.dcl.ops = &dcl_egl_ops;
1774 } else
1775 #endif
1776 {
1777 vc->gfx.dcl.ops = &dcl_ops;
1778 }
1779
1780 vc->gfx.dcl.con = con;
1781 register_displaychangelistener(&vc->gfx.dcl);
1782
1783 gd_connect_vc_gfx_signals(vc);
1784 group = gd_vc_menu_init(s, vc, idx, group, view_menu);
1785
1786 if (dpy_ui_info_supported(vc->gfx.dcl.con)) {
1787 gtk_menu_item_activate(GTK_MENU_ITEM(s->zoom_fit_item));
1788 s->free_scale = true;
1789 }
1790
1791 return group;
1792 }
1793
1794 static GtkWidget *gd_create_menu_view(GtkDisplayState *s)
1795 {
1796 GSList *group = NULL;
1797 GtkWidget *view_menu;
1798 GtkWidget *separator;
1799 QemuConsole *con;
1800 int vc;
1801
1802 view_menu = gtk_menu_new();
1803 gtk_menu_set_accel_group(GTK_MENU(view_menu), s->accel_group);
1804
1805 s->full_screen_item = gtk_menu_item_new_with_mnemonic(_("_Fullscreen"));
1806
1807 gtk_accel_group_connect(s->accel_group, GDK_KEY_f, HOTKEY_MODIFIERS, 0,
1808 g_cclosure_new_swap(G_CALLBACK(gd_accel_full_screen), s, NULL));
1809 #if GTK_CHECK_VERSION(3, 8, 0)
1810 gtk_accel_label_set_accel(
1811 GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(s->full_screen_item))),
1812 GDK_KEY_f, HOTKEY_MODIFIERS);
1813 #endif
1814 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->full_screen_item);
1815
1816 separator = gtk_separator_menu_item_new();
1817 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1818
1819 s->zoom_in_item = gtk_menu_item_new_with_mnemonic(_("Zoom _In"));
1820 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_in_item),
1821 "<QEMU>/View/Zoom In");
1822 gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus,
1823 HOTKEY_MODIFIERS);
1824 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_in_item);
1825
1826 s->zoom_out_item = gtk_menu_item_new_with_mnemonic(_("Zoom _Out"));
1827 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_out_item),
1828 "<QEMU>/View/Zoom Out");
1829 gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus,
1830 HOTKEY_MODIFIERS);
1831 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_out_item);
1832
1833 s->zoom_fixed_item = gtk_menu_item_new_with_mnemonic(_("Best _Fit"));
1834 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_fixed_item),
1835 "<QEMU>/View/Zoom Fixed");
1836 gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0,
1837 HOTKEY_MODIFIERS);
1838 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fixed_item);
1839
1840 s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit"));
1841 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fit_item);
1842
1843 separator = gtk_separator_menu_item_new();
1844 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1845
1846 s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover"));
1847 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_on_hover_item);
1848
1849 s->grab_item = gtk_check_menu_item_new_with_mnemonic(_("_Grab Input"));
1850 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->grab_item),
1851 "<QEMU>/View/Grab Input");
1852 gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g,
1853 HOTKEY_MODIFIERS);
1854 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_item);
1855
1856 separator = gtk_separator_menu_item_new();
1857 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1858
1859 /* gfx */
1860 for (vc = 0;; vc++) {
1861 con = qemu_console_lookup_by_index(vc);
1862 if (!con) {
1863 break;
1864 }
1865 group = gd_vc_gfx_init(s, &s->vc[vc], con,
1866 vc, group, view_menu);
1867 s->nb_vcs++;
1868 }
1869
1870 #if defined(CONFIG_VTE)
1871 /* vte */
1872 gd_vcs_init(s, group, view_menu);
1873 #endif
1874
1875 separator = gtk_separator_menu_item_new();
1876 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1877
1878 s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs"));
1879 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_tabs_item);
1880
1881 s->untabify_item = gtk_menu_item_new_with_mnemonic(_("Detach Tab"));
1882 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->untabify_item);
1883
1884 return view_menu;
1885 }
1886
1887 static void gd_create_menus(GtkDisplayState *s)
1888 {
1889 s->accel_group = gtk_accel_group_new();
1890 s->machine_menu = gd_create_menu_machine(s);
1891 s->view_menu = gd_create_menu_view(s);
1892
1893 s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine"));
1894 gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->machine_menu_item),
1895 s->machine_menu);
1896 gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->machine_menu_item);
1897
1898 s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View"));
1899 gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->view_menu_item), s->view_menu);
1900 gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item);
1901
1902 g_object_set_data(G_OBJECT(s->window), "accel_group", s->accel_group);
1903 gtk_window_add_accel_group(GTK_WINDOW(s->window), s->accel_group);
1904 }
1905
1906 static void gd_set_keycode_type(GtkDisplayState *s)
1907 {
1908 #ifdef GDK_WINDOWING_X11
1909 GdkDisplay *display = gtk_widget_get_display(s->window);
1910 if (GDK_IS_X11_DISPLAY(display)) {
1911 Display *x11_display = gdk_x11_display_get_xdisplay(display);
1912 XkbDescPtr desc = XkbGetKeyboard(x11_display, XkbGBN_AllComponentsMask,
1913 XkbUseCoreKbd);
1914 char *keycodes = NULL;
1915
1916 if (desc && desc->names) {
1917 keycodes = XGetAtomName(x11_display, desc->names->keycodes);
1918 }
1919 if (keycodes == NULL) {
1920 fprintf(stderr, "could not lookup keycode name\n");
1921 } else if (strstart(keycodes, "evdev", NULL)) {
1922 s->has_evdev = true;
1923 } else if (!strstart(keycodes, "xfree86", NULL)) {
1924 fprintf(stderr, "unknown keycodes `%s', please report to "
1925 "qemu-devel@nongnu.org\n", keycodes);
1926 }
1927
1928 if (desc) {
1929 XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True);
1930 }
1931 if (keycodes) {
1932 XFree(keycodes);
1933 }
1934 }
1935 #endif
1936 }
1937
1938 static gboolean gtkinit;
1939
1940 void gtk_display_init(DisplayState *ds, bool full_screen, bool grab_on_hover)
1941 {
1942 GtkDisplayState *s = g_malloc0(sizeof(*s));
1943 char *filename;
1944 GdkDisplay *window_display;
1945
1946 if (!gtkinit) {
1947 fprintf(stderr, "gtk initialization failed\n");
1948 exit(1);
1949 }
1950
1951 s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1952 #if GTK_CHECK_VERSION(3, 2, 0)
1953 s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
1954 #else
1955 s->vbox = gtk_vbox_new(FALSE, 0);
1956 #endif
1957 s->notebook = gtk_notebook_new();
1958 s->menu_bar = gtk_menu_bar_new();
1959
1960 s->free_scale = FALSE;
1961
1962 /* LC_MESSAGES only. See early_gtk_display_init() for details */
1963 setlocale(LC_MESSAGES, "");
1964 bindtextdomain("qemu", CONFIG_QEMU_LOCALEDIR);
1965 textdomain("qemu");
1966
1967 window_display = gtk_widget_get_display(s->window);
1968 s->null_cursor = gdk_cursor_new_for_display(window_display,
1969 GDK_BLANK_CURSOR);
1970
1971 s->mouse_mode_notifier.notify = gd_mouse_mode_change;
1972 qemu_add_mouse_mode_change_notifier(&s->mouse_mode_notifier);
1973 qemu_add_vm_change_state_handler(gd_change_runstate, s);
1974
1975 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu_logo_no_text.svg");
1976 if (filename) {
1977 GError *error = NULL;
1978 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(filename, &error);
1979 if (pixbuf) {
1980 gtk_window_set_icon(GTK_WINDOW(s->window), pixbuf);
1981 } else {
1982 g_error_free(error);
1983 }
1984 g_free(filename);
1985 }
1986
1987 gd_create_menus(s);
1988
1989 gd_connect_signals(s);
1990
1991 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
1992 gtk_notebook_set_show_border(GTK_NOTEBOOK(s->notebook), FALSE);
1993
1994 gd_update_caption(s);
1995
1996 gtk_box_pack_start(GTK_BOX(s->vbox), s->menu_bar, FALSE, TRUE, 0);
1997 gtk_box_pack_start(GTK_BOX(s->vbox), s->notebook, TRUE, TRUE, 0);
1998
1999 gtk_container_add(GTK_CONTAINER(s->window), s->vbox);
2000
2001 gtk_widget_show_all(s->window);
2002
2003 #ifdef VTE_RESIZE_HACK
2004 {
2005 VirtualConsole *cur = gd_vc_find_current(s);
2006 if (cur) {
2007 int i;
2008
2009 for (i = 0; i < s->nb_vcs; i++) {
2010 VirtualConsole *vc = &s->vc[i];
2011 if (vc && vc->type == GD_VC_VTE && vc != cur) {
2012 gtk_widget_hide(vc->vte.terminal);
2013 }
2014 }
2015 gd_update_windowsize(cur);
2016 }
2017 }
2018 #endif
2019
2020 if (full_screen) {
2021 gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item));
2022 }
2023 if (grab_on_hover) {
2024 gtk_menu_item_activate(GTK_MENU_ITEM(s->grab_on_hover_item));
2025 }
2026
2027 gd_set_keycode_type(s);
2028 }
2029
2030 void early_gtk_display_init(int opengl)
2031 {
2032 /* The QEMU code relies on the assumption that it's always run in
2033 * the C locale. Therefore it is not prepared to deal with
2034 * operations that produce different results depending on the
2035 * locale, such as printf's formatting of decimal numbers, and
2036 * possibly others.
2037 *
2038 * Since GTK+ calls setlocale() by default -importing the locale
2039 * settings from the environment- we must prevent it from doing so
2040 * using gtk_disable_setlocale().
2041 *
2042 * QEMU's GTK+ UI, however, _does_ have translations for some of
2043 * the menu items. As a trade-off between a functionally correct
2044 * QEMU and a fully internationalized UI we support importing
2045 * LC_MESSAGES from the environment (see the setlocale() call
2046 * earlier in this file). This allows us to display translated
2047 * messages leaving everything else untouched.
2048 */
2049 gtk_disable_setlocale();
2050 gtkinit = gtk_init_check(NULL, NULL);
2051 if (!gtkinit) {
2052 /* don't exit yet, that'll break -help */
2053 return;
2054 }
2055
2056 switch (opengl) {
2057 case -1: /* default */
2058 case 0: /* off */
2059 break;
2060 case 1: /* on */
2061 #if defined(CONFIG_OPENGL)
2062 gtk_egl_init();
2063 #endif
2064 break;
2065 default:
2066 g_assert_not_reached();
2067 break;
2068 }
2069
2070 #if defined(CONFIG_VTE)
2071 register_vc_handler(gd_vc_handler);
2072 #endif
2073 }
AR7 emulation for QEMU