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