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