gtk.c · samitouri/QOSamiQemu · siGit Code & Deploy

Code Commits Issues Pulls Sessions CI/CD

master

c 2,917 lines 87.3 KB

Raw

1	/*
2	* GTK UI
3	*
4	* Copyright IBM, Corp. 2012
5	*
6	* Authors:
7	* Anthony Liguori <aliguori@us.ibm.com>
8	*
9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License as published by
11	* the Free Software Foundation; either version 2 of the License, or
12	* (at your option) any later version.
13	*
14	* This program is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17	* General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with this program; if not, see <http://www.gnu.org/licenses/>.
21	*
22	* Portions from gtk-vnc (originally licensed under the LGPL v2+):
23	*
24	* GTK VNC Widget
25	*
26	* Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
27	* Copyright (C) 2009-2010 Daniel P. Berrange <dan@berrange.com>
28	*/
29
30	#define GETTEXT_PACKAGE "qemu"
31	#define LOCALEDIR "po"
32
33	#include "qemu/osdep.h"
34	#include "qapi/error.h"
35	#include "qapi/qapi-commands-control.h"
36	#include "qapi/qapi-commands-machine.h"
37	#include "qapi/qapi-commands-misc.h"
38	#include "qemu/cutils.h"
39	#include "qemu/error-report.h"
40	#include "qemu/main-loop.h"
41	#include "qemu-main.h"
42
43	#include "ui/console.h"
44	#include "ui/gtk.h"
45	#ifdef G_OS_WIN32
46	#include <gdk/gdkwin32.h>
47	#endif
48	#include "ui/win32-kbd-hook.h"
49
50	#include <glib/gi18n.h>
51	#include <locale.h>
52	#if defined(CONFIG_VTE)
53	#include <vte/vte.h>
54	#endif
55	#include <math.h>
56
57	#include "trace.h"
58	#include "standard-headers/linux/input-event-codes.h"
59	#include "ui/input.h"
60	#include "system/runstate.h"
61	#include "system/system.h"
62	#include "keymaps.h"
63	#include "chardev/char.h"
64	#include "qom/object.h"
65
66	#define VC_WINDOW_X_MIN 320
67	#define VC_WINDOW_Y_MIN 240
68	#define VC_TERM_X_MIN 80
69	#define VC_TERM_Y_MIN 25
70	#define VC_SCALE_MIN 0.25
71	#define VC_SCALE_MAX 4
72	#define VC_SCALE_STEP 0.25
73
74	#ifdef GDK_WINDOWING_X11
75	#include "x_keymap.h"
76
77	/* Gtk2 compat */
78	#ifndef GDK_IS_X11_DISPLAY
79	#define GDK_IS_X11_DISPLAY(dpy) (dpy != NULL)
80	#endif
81	#endif
82
83
84	#ifdef GDK_WINDOWING_WAYLAND
85	/* Gtk2 compat */
86	#ifndef GDK_IS_WAYLAND_DISPLAY
87	#define GDK_IS_WAYLAND_DISPLAY(dpy) (dpy != NULL)
88	#endif
89	#endif
90
91
92	#ifdef GDK_WINDOWING_WIN32
93	/* Gtk2 compat */
94	#ifndef GDK_IS_WIN32_DISPLAY
95	#define GDK_IS_WIN32_DISPLAY(dpy) (dpy != NULL)
96	#endif
97	#endif
98
99
100	#ifdef GDK_WINDOWING_BROADWAY
101	/* Gtk2 compat */
102	#ifndef GDK_IS_BROADWAY_DISPLAY
103	#define GDK_IS_BROADWAY_DISPLAY(dpy) (dpy != NULL)
104	#endif
105	#endif
106
107
108	#ifdef GDK_WINDOWING_QUARTZ
109	/* Gtk2 compat */
110	#ifndef GDK_IS_QUARTZ_DISPLAY
111	#define GDK_IS_QUARTZ_DISPLAY(dpy) (dpy != NULL)
112	#endif
113	#endif
114
115
116	#if !defined(CONFIG_VTE)
117	# define VTE_CHECK_VERSION(a, b, c) 0
118	#endif
119
120	#define HOTKEY_MODIFIERS (GDK_CONTROL_MASK \| GDK_MOD1_MASK)
121
122	static const guint16 *keycode_map;
123	static size_t keycode_maplen;
124	static bool keycode_xorgevdev;
125
126	struct VCChardev {
127	Chardev parent;
128	VirtualConsole *console;
129	bool echo;
130	};
131	typedef struct VCChardev VCChardev;
132
133	#define TYPE_CHARDEV_VC "chardev-vc"
134	DECLARE_INSTANCE_CHECKER(VCChardev, VC_CHARDEV,
135	TYPE_CHARDEV_VC)
136
137	static struct touch_slot touch_slots[INPUT_EVENT_SLOTS_MAX];
138
139	bool gtk_use_gl_area;
140
141	static void gd_grab_pointer(VirtualConsole vc, const char reason);
142	static void gd_ungrab_pointer(GtkDisplayState *s);
143	static void gd_grab_keyboard(VirtualConsole vc, const char reason);
144	static void gd_ungrab_keyboard(GtkDisplayState *s);
145	static void gd_rebuild_vc_menu(GtkDisplayState *s);
146
147	/ Utility Functions /
148
149	static VirtualConsole gd_vc_find_by_menu(GtkDisplayState s)
150	{
151	VirtualConsole *vc;
152	gint i;
153
154	for (i = 0; i < s->vcs->len; i++) {
155	vc = g_ptr_array_index(s->vcs, i);
156	if (gtk_check_menu_item_get_active
157	(GTK_CHECK_MENU_ITEM(vc->menu_item))) {
158	return vc;
159	}
160	}
161	return NULL;
162	}
163
164	static VirtualConsole gd_vc_find_by_page(GtkDisplayState s, gint page)
165	{
166	VirtualConsole *vc;
167	gint i, p;
168
169	if (!s->vcs) {
170	return NULL;
171	}
172	for (i = 0; i < s->vcs->len; i++) {
173	vc = g_ptr_array_index(s->vcs, i);
174	p = gtk_notebook_page_num(GTK_NOTEBOOK(s->notebook), vc->tab_item);
175	if (p == page) {
176	return vc;
177	}
178	}
179	return NULL;
180	}
181
182	static VirtualConsole gd_vc_find_current(GtkDisplayState s)
183	{
184	gint page;
185
186	page = gtk_notebook_get_current_page(GTK_NOTEBOOK(s->notebook));
187	return gd_vc_find_by_page(s, page);
188	}
189
190	static bool gd_is_grab_active(GtkDisplayState *s)
191	{
192	return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_item));
193	}
194
195	static bool gd_grab_on_hover(GtkDisplayState *s)
196	{
197	return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_on_hover_item));
198	}
199
200	static void gd_update_cursor(VirtualConsole *vc)
201	{
202	GtkDisplayState *s = vc->s;
203	GdkWindow *window;
204
205	if (vc->type != GD_VC_GFX \|\|
206	!qemu_console_is_graphic(vc->gfx.dcl.con)) {
207	return;
208	}
209
210	if (!gtk_widget_get_realized(vc->gfx.drawing_area)) {
211	return;
212	}
213
214	window = gtk_widget_get_window(GTK_WIDGET(vc->gfx.drawing_area));
215	if (s->full_screen \|\| qemu_input_is_absolute(vc->gfx.dcl.con) \|\| s->ptr_owner == vc) {
216	gdk_window_set_cursor(window, s->null_cursor);
217	} else {
218	gdk_window_set_cursor(window, NULL);
219	}
220	}
221
222	static void gd_update_caption(GtkDisplayState *s)
223	{
224	const char *status = "";
225	gchar *prefix;
226	gchar *title;
227	const char *grab = "";
228	bool is_paused = !runstate_is_running();
229	int i;
230
231	if (qemu_name) {
232	prefix = g_strdup_printf("QEMU (%s)", qemu_name);
233	} else {
234	prefix = g_strdup_printf("QEMU");
235	}
236
237	if (s->ptr_owner != NULL &&
238	s->ptr_owner->window == NULL) {
239	grab = _(" - Press Ctrl+Alt+G to release grab");
240	}
241
242	if (is_paused) {
243	status = _(" [Paused]");
244	}
245	s->external_pause_update = true;
246	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->pause_item),
247	is_paused);
248	s->external_pause_update = false;
249
250	title = g_strdup_printf("%s%s%s", prefix, status, grab);
251	gtk_window_set_title(GTK_WINDOW(s->window), title);
252	g_free(title);
253
254	for (i = 0; i < s->vcs->len; i++) {
255	VirtualConsole *vc = g_ptr_array_index(s->vcs, i);
256
257	if (!vc->window) {
258	continue;
259	}
260	title = g_strdup_printf("%s: %s%s%s", prefix, vc->label,
261	vc == s->kbd_owner ? " +kbd" : "",
262	vc == s->ptr_owner ? " +ptr" : "");
263	gtk_window_set_title(GTK_WINDOW(vc->window), title);
264	g_free(title);
265	}
266
267	g_free(prefix);
268	}
269
270	static void gd_update_geometry_hints(VirtualConsole *vc)
271	{
272	GtkDisplayState *s = vc->s;
273	GdkWindowHints mask = 0;
274	GdkGeometry geo = {};
275	GtkWidget *geo_widget = NULL;
276	GtkWindow *geo_window;
277
278	if (vc->type == GD_VC_GFX) {
279	if (!vc->gfx.ds) {
280	return;
281	}
282	double scale_x = s->free_scale ? VC_SCALE_MIN : vc->gfx.scale_x;
283	double scale_y = s->free_scale ? VC_SCALE_MIN : vc->gfx.scale_y;
284	geo.min_width = surface_width(vc->gfx.ds) * scale_x;
285	geo.min_height = surface_height(vc->gfx.ds) * scale_y;
286	mask \|= GDK_HINT_MIN_SIZE;
287	geo_widget = vc->gfx.drawing_area;
288	gtk_widget_set_size_request(geo_widget, geo.min_width, geo.min_height);
289
290	#if defined(CONFIG_VTE)
291	} else if (vc->type == GD_VC_VTE) {
292	VteTerminal *term = VTE_TERMINAL(vc->vte.terminal);
293	GtkBorder padding = { 0 };
294
295	#if VTE_CHECK_VERSION(0, 37, 0)
296	gtk_style_context_get_padding(
297	gtk_widget_get_style_context(vc->vte.terminal),
298	gtk_widget_get_state_flags(vc->vte.terminal),
299	&padding);
300	#else
301	{
302	GtkBorder *ib = NULL;
303	gtk_widget_style_get(vc->vte.terminal, "inner-border", &ib, NULL);
304	if (ib) {
305	padding = *ib;
306	gtk_border_free(ib);
307	}
308	}
309	#endif
310
311	geo.width_inc = vte_terminal_get_char_width(term);
312	geo.height_inc = vte_terminal_get_char_height(term);
313	mask \|= GDK_HINT_RESIZE_INC;
314	geo.base_width = geo.width_inc;
315	geo.base_height = geo.height_inc;
316	mask \|= GDK_HINT_BASE_SIZE;
317	geo.min_width = geo.width_inc * VC_TERM_X_MIN;
318	geo.min_height = geo.height_inc * VC_TERM_Y_MIN;
319	mask \|= GDK_HINT_MIN_SIZE;
320
321	geo.base_width += padding.left + padding.right;
322	geo.base_height += padding.top + padding.bottom;
323	geo.min_width += padding.left + padding.right;
324	geo.min_height += padding.top + padding.bottom;
325	geo_widget = vc->vte.terminal;
326	#endif
327	}
328
329	geo_window = GTK_WINDOW(vc->window ? vc->window : s->window);
330	gtk_window_set_geometry_hints(geo_window, geo_widget, &geo, mask);
331	}
332
333	void gd_update_windowsize(VirtualConsole *vc)
334	{
335	GtkDisplayState *s = vc->s;
336
337	gd_update_geometry_hints(vc);
338
339	if (vc->type == GD_VC_GFX && !s->full_screen && !s->free_scale) {
340	gtk_window_resize(GTK_WINDOW(vc->window ? vc->window : s->window),
341	VC_WINDOW_X_MIN, VC_WINDOW_Y_MIN);
342	}
343	}
344
345	static void gd_update_full_redraw(VirtualConsole *vc)
346	{
347	GtkWidget *area = vc->gfx.drawing_area;
348	int ww, wh;
349	ww = gdk_window_get_width(gtk_widget_get_window(area));
350	wh = gdk_window_get_height(gtk_widget_get_window(area));
351	#if defined(CONFIG_OPENGL)
352	if (vc->gfx.gls && gtk_use_gl_area) {
353	gtk_gl_area_queue_render(GTK_GL_AREA(vc->gfx.drawing_area));
354	return;
355	}
356	#endif
357	gtk_widget_queue_draw_area(area, 0, 0, ww, wh);
358	}
359
360	static void gtk_release_modifiers(GtkDisplayState *s)
361	{
362	VirtualConsole *vc = gd_vc_find_current(s);
363
364	if (!vc \|\| vc->type != GD_VC_GFX \|\|
365	!qemu_console_is_graphic(vc->gfx.dcl.con)) {
366	return;
367	}
368	qkbd_state_lift_all_keys(vc->gfx.kbd);
369	}
370
371	static void gd_widget_reparent(GtkWidget from, GtkWidget to,
372	GtkWidget *widget)
373	{
374	g_object_ref(G_OBJECT(widget));
375	gtk_container_remove(GTK_CONTAINER(from), widget);
376	gtk_container_add(GTK_CONTAINER(to), widget);
377	g_object_unref(G_OBJECT(widget));
378	}
379
380	static void gd_win32_get_hwnd(VirtualConsole vc)
381	{
382	#ifdef G_OS_WIN32
383	return gdk_win32_window_get_impl_hwnd(
384	gtk_widget_get_window(vc->window ? vc->window : vc->s->window));
385	#else
386	return NULL;
387	#endif
388	}
389
390	/ DisplayState Callbacks /
391
392	static void gd_update(DisplayChangeListener *dcl,
393	int fbx, int fby, int fbw, int fbh)
394	{
395	VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
396	GdkWindow *win;
397	int wx1, wx2, wy1, wy2;
398	int wx_offset, wy_offset;
399	int ww_surface, wh_surface;
400	int ww_widget, wh_widget;
401
402	trace_gd_update(vc->label, fbx, fby, fbw, fbh);
403
404	if (!gtk_widget_get_realized(vc->gfx.drawing_area)) {
405	return;
406	}
407
408	if (vc->gfx.convert) {
409	pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image,
410	NULL, vc->gfx.convert,
411	fbx, fby, 0, 0, fbx, fby, fbw, fbh);
412	}
413
414	wx1 = floor(fbx * vc->gfx.scale_x);
415	wy1 = floor(fby * vc->gfx.scale_y);
416
417	wx2 = ceil(fbx * vc->gfx.scale_x + fbw * vc->gfx.scale_x);
418	wy2 = ceil(fby * vc->gfx.scale_y + fbh * vc->gfx.scale_y);
419
420	ww_surface = surface_width(vc->gfx.ds) * vc->gfx.scale_x;
421	wh_surface = surface_height(vc->gfx.ds) * vc->gfx.scale_y;
422
423	win = gtk_widget_get_window(vc->gfx.drawing_area);
424	if (!win) {
425	return;
426	}
427	ww_widget = gdk_window_get_width(win);
428	wh_widget = gdk_window_get_height(win);
429
430	wx_offset = wy_offset = 0;
431	if (ww_widget > ww_surface) {
432	wx_offset = (ww_widget - ww_surface) / 2;
433	}
434	if (wh_widget > wh_surface) {
435	wy_offset = (wh_widget - wh_surface) / 2;
436	}
437
438	gtk_widget_queue_draw_area(vc->gfx.drawing_area,
439	wx_offset + wx1, wy_offset + wy1,
440	(wx2 - wx1), (wy2 - wy1));
441	}
442
443	static void gd_refresh(DisplayChangeListener *dcl)
444	{
445	qemu_console_hw_update(dcl->con);
446	}
447
448	static GdkDevice gd_get_pointer(GdkDisplay dpy)
449	{
450	return gdk_seat_get_pointer(gdk_display_get_default_seat(dpy));
451	}
452
453	static void gd_mouse_set(DisplayChangeListener *dcl,
454	int x, int y, bool visible)
455	{
456	VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
457	GdkDisplay *dpy;
458	gint x_root, y_root;
459
460	if (!gtk_widget_get_realized(vc->gfx.drawing_area) \|\|
461	qemu_input_is_absolute(dcl->con)) {
462	return;
463	}
464
465	dpy = gtk_widget_get_display(vc->gfx.drawing_area);
466	gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area),
467	x, y, &x_root, &y_root);
468	gdk_device_warp(gd_get_pointer(dpy),
469	gtk_widget_get_screen(vc->gfx.drawing_area),
470	x_root, y_root);
471	vc->s->last_x = x;
472	vc->s->last_y = y;
473	}
474
475	static void gd_cursor_define(DisplayChangeListener *dcl,
476	QEMUCursor *c)
477	{
478	VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
479	GdkPixbuf *pixbuf;
480	GdkCursor *cursor;
481
482	if (!gtk_widget_get_realized(vc->gfx.drawing_area)) {
483	return;
484	}
485
486	pixbuf = gdk_pixbuf_new_from_data((guchar *)(c->data),
487	GDK_COLORSPACE_RGB, true, 8,
488	c->width, c->height, c->width * 4,
489	NULL, NULL);
490	cursor = gdk_cursor_new_from_pixbuf
491	(gtk_widget_get_display(vc->gfx.drawing_area),
492	pixbuf, c->hot_x, c->hot_y);
493	gdk_window_set_cursor(gtk_widget_get_window(vc->gfx.drawing_area), cursor);
494	g_object_unref(pixbuf);
495	g_object_unref(cursor);
496	}
497
498	static void gd_switch(DisplayChangeListener *dcl,
499	DisplaySurface *surface)
500	{
501	VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
502	bool resized = true;
503
504	trace_gd_switch(vc->label, surface_width(surface), surface_height(surface));
505
506	if (vc->gfx.surface) {
507	cairo_surface_destroy(vc->gfx.surface);
508	vc->gfx.surface = NULL;
509	}
510	if (vc->gfx.convert) {
511	pixman_image_unref(vc->gfx.convert);
512	vc->gfx.convert = NULL;
513	}
514
515	if (vc->gfx.ds &&
516	surface_width(vc->gfx.ds) == surface_width(surface) &&
517	surface_height(vc->gfx.ds) == surface_height(surface)) {
518	resized = false;
519	}
520	vc->gfx.ds = surface;
521
522	if (surface_format(surface) == PIXMAN_x8r8g8b8) {
523	/*
524	* PIXMAN_x8r8g8b8 == CAIRO_FORMAT_RGB24
525	*
526	* No need to convert, use surface directly. Should be the
527	* common case as this is qemu_default_pixelformat(32) too.
528	*/
529	vc->gfx.surface = cairo_image_surface_create_for_data
530	(surface_data(surface),
531	CAIRO_FORMAT_RGB24,
532	surface_width(surface),
533	surface_height(surface),
534	surface_stride(surface));
535	} else {
536	/* Must convert surface, use pixman to do it. */
537	vc->gfx.convert = pixman_image_create_bits(PIXMAN_x8r8g8b8,
538	surface_width(surface),
539	surface_height(surface),
540	NULL, 0);
541	vc->gfx.surface = cairo_image_surface_create_for_data
542	((void *)pixman_image_get_data(vc->gfx.convert),
543	CAIRO_FORMAT_RGB24,
544	pixman_image_get_width(vc->gfx.convert),
545	pixman_image_get_height(vc->gfx.convert),
546	pixman_image_get_stride(vc->gfx.convert));
547	pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image,
548	NULL, vc->gfx.convert,
549	0, 0, 0, 0, 0, 0,
550	pixman_image_get_width(vc->gfx.convert),
551	pixman_image_get_height(vc->gfx.convert));
552	}
553
554	if (resized) {
555	gd_update_windowsize(vc);
556	} else {
557	gd_update_full_redraw(vc);
558	}
559	}
560
561	static const DisplayChangeListenerOps dcl_ops = {
562	.dpy_name = "gtk",
563	.dpy_gfx_update = gd_update,
564	.dpy_gfx_switch = gd_switch,
565	.dpy_gfx_check_format = qemu_pixman_check_format,
566	.dpy_refresh = gd_refresh,
567	.dpy_mouse_set = gd_mouse_set,
568	.dpy_cursor_define = gd_cursor_define,
569	};
570
571
572	#if defined(CONFIG_OPENGL)
573
574	static bool gd_has_dmabuf(DisplayChangeListener *dcl)
575	{
576	VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
577
578	if (gtk_use_gl_area && !gtk_widget_get_realized(vc->gfx.drawing_area)) {
579	/* FIXME: Assume it will work, actual check done after realize */
580	/* fixing this would require delaying listener registration */
581	return true;
582	}
583
584	return vc->gfx.has_dmabuf;
585	}
586
587	static void gd_gl_release_dmabuf(DisplayChangeListener *dcl,
588	QemuDmaBuf *dmabuf)
589	{
590	#ifdef CONFIG_GBM
591	VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
592
593	egl_dmabuf_release_texture(dmabuf);
594	if (vc->gfx.guest_fb.dmabuf == dmabuf) {
595	vc->gfx.guest_fb.dmabuf = NULL;
596	}
597	#endif
598	}
599
600	void gd_hw_gl_flushed(void *vcon)
601	{
602	VirtualConsole *vc = vcon;
603	QemuDmaBuf *dmabuf = vc->gfx.guest_fb.dmabuf;
604	int fence_fd;
605
606	fence_fd = qemu_dmabuf_get_fence_fd(dmabuf);
607	if (fence_fd >= 0) {
608	qemu_set_fd_handler(fence_fd, NULL, NULL, NULL);
609	close(fence_fd);
610	qemu_dmabuf_set_fence_fd(dmabuf, -1);
611	qemu_console_hw_gl_block(vc->gfx.dcl.con, false);
612	}
613	}
614
615	/ DisplayState Callbacks (opengl version) /
616
617	static const DisplayChangeListenerOps dcl_gl_area_ops = {
618	.dpy_name = "gtk-egl",
619	.dpy_gfx_update = gd_gl_area_update,
620	.dpy_gfx_switch = gd_gl_area_switch,
621	.dpy_gfx_check_format = console_gl_check_format,
622	.dpy_refresh = gd_gl_area_refresh,
623	.dpy_mouse_set = gd_mouse_set,
624	.dpy_cursor_define = gd_cursor_define,
625
626	.dpy_gl_scanout_texture = gd_gl_area_scanout_texture,
627	.dpy_gl_scanout_disable = gd_gl_area_scanout_disable,
628	.dpy_gl_update = gd_gl_area_scanout_flush,
629	.dpy_gl_scanout_dmabuf = gd_gl_area_scanout_dmabuf,
630	.dpy_gl_release_dmabuf = gd_gl_release_dmabuf,
631	.dpy_has_dmabuf = gd_has_dmabuf,
632	};
633
634	static bool
635	gd_gl_area_is_compatible_dcl(DisplayGLCtx *dgc,
636	DisplayChangeListener *dcl)
637	{
638	return dcl->ops == &dcl_gl_area_ops;
639	}
640
641	static const DisplayGLCtxOps gl_area_ctx_ops = {
642	.dpy_gl_ctx_is_compatible_dcl = gd_gl_area_is_compatible_dcl,
643	.dpy_gl_ctx_create = gd_gl_area_create_context,
644	.dpy_gl_ctx_destroy = gd_gl_area_destroy_context,
645	.dpy_gl_ctx_make_current = gd_gl_area_make_current,
646	};
647
648	#ifdef CONFIG_X11
649	static const DisplayChangeListenerOps dcl_egl_ops = {
650	.dpy_name = "gtk-egl",
651	.dpy_gfx_update = gd_egl_update,
652	.dpy_gfx_switch = gd_egl_switch,
653	.dpy_gfx_check_format = console_gl_check_format,
654	.dpy_refresh = gd_egl_refresh,
655	.dpy_mouse_set = gd_mouse_set,
656	.dpy_cursor_define = gd_cursor_define,
657
658	.dpy_gl_scanout_disable = gd_egl_scanout_disable,
659	.dpy_gl_scanout_texture = gd_egl_scanout_texture,
660	.dpy_gl_scanout_dmabuf = gd_egl_scanout_dmabuf,
661	.dpy_gl_cursor_dmabuf = gd_egl_cursor_dmabuf,
662	.dpy_gl_cursor_position = gd_egl_cursor_position,
663	.dpy_gl_update = gd_egl_flush,
664	.dpy_gl_release_dmabuf = gd_gl_release_dmabuf,
665	.dpy_has_dmabuf = gd_has_dmabuf,
666	};
667
668	static bool
669	gd_egl_is_compatible_dcl(DisplayGLCtx *dgc,
670	DisplayChangeListener *dcl)
671	{
672	return dcl->ops == &dcl_egl_ops;
673	}
674
675	static const DisplayGLCtxOps egl_ctx_ops = {
676	.dpy_gl_ctx_is_compatible_dcl = gd_egl_is_compatible_dcl,
677	.dpy_gl_ctx_create = gd_egl_create_context,
678	.dpy_gl_ctx_destroy = qemu_egl_destroy_context,
679	.dpy_gl_ctx_make_current = gd_egl_make_current,
680	};
681	#endif
682
683	#endif /* CONFIG_OPENGL */
684
685	/ QEMU Events /
686
687	static void gd_change_runstate(void *opaque, bool running, RunState state)
688	{
689	GtkDisplayState *s = opaque;
690
691	gd_update_caption(s);
692	}
693
694	static void gd_mouse_mode_change(Notifier notify, void data)
695	{
696	GtkDisplayState *s;
697	int i;
698
699	s = container_of(notify, GtkDisplayState, mouse_mode_notifier);
700	/* release the grab at switching to absolute mode */
701	if (s->ptr_owner && qemu_input_is_absolute(s->ptr_owner->gfx.dcl.con)) {
702	if (!s->ptr_owner->window) {
703	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
704	FALSE);
705	} else {
706	gd_ungrab_pointer(s);
707	}
708	}
709	for (i = 0; i < s->vcs->len; i++) {
710	VirtualConsole *vc = g_ptr_array_index(s->vcs, i);
711	gd_update_cursor(vc);
712	}
713	}
714
715	/ GTK Events /
716
717	static gboolean gd_window_close(GtkWidget widget, GdkEvent event,
718	void *opaque)
719	{
720	GtkDisplayState *s = opaque;
721	bool allow_close = true;
722
723	if (s->opts->has_window_close && !s->opts->window_close) {
724	allow_close = false;
725	}
726
727	if (allow_close) {
728	qmp_quit(NULL);
729	}
730
731	return TRUE;
732	}
733
734	static void gd_set_ui_refresh_rate(VirtualConsole *vc, int refresh_rate)
735	{
736	QemuUIInfo info;
737
738	if (!qemu_console_ui_info_supported(vc->gfx.dcl.con)) {
739	return;
740	}
741
742	info = *qemu_console_get_ui_info(vc->gfx.dcl.con);
743	info.refresh_rate = refresh_rate;
744	qemu_console_set_ui_info(vc->gfx.dcl.con, &info, true);
745	}
746
747	static void gd_set_ui_size(VirtualConsole *vc, gint width, gint height)
748	{
749	QemuUIInfo info;
750
751	if (!qemu_console_ui_info_supported(vc->gfx.dcl.con)) {
752	return;
753	}
754
755	info = *qemu_console_get_ui_info(vc->gfx.dcl.con);
756	info.width = width;
757	info.height = height;
758	qemu_console_set_ui_info(vc->gfx.dcl.con, &info, true);
759	}
760
761	#if defined(CONFIG_OPENGL)
762
763	static gboolean gd_render_event(GtkGLArea area, GdkGLContext context,
764	void *opaque)
765	{
766	VirtualConsole *vc = opaque;
767
768	if (vc->gfx.gls) {
769	gd_gl_area_draw(vc);
770	}
771	return TRUE;
772	}
773
774	static void gd_resize_event(GtkGLArea *area,
775	gint width, gint height, gpointer opaque)
776	{
777	VirtualConsole *vc = opaque;
778	double pw = width, ph = height;
779	double sx = vc->gfx.scale_x, sy = vc->gfx.scale_y;
780	GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(area));
781	const int gs = gdk_window_get_scale_factor(window);
782
783	if (!vc->s->free_scale && !vc->s->full_screen) {
784	pw /= sx;
785	ph /= sy;
786	}
787
788	/**
789	* width and height here are in pixel coordinate, so we must divide it
790	* by global window scale (gs)
791	*/
792	gd_set_ui_size(vc, pw / gs, ph / gs);
793	}
794
795	#endif
796
797	void gd_update_monitor_refresh_rate(VirtualConsole vc, GtkWidget widget)
798	{
799	#ifdef GDK_VERSION_3_22
800	GdkWindow *win = gtk_widget_get_window(widget);
801	int refresh_rate;
802
803	if (win) {
804	GdkDisplay *dpy = gtk_widget_get_display(widget);
805	GdkMonitor *monitor = gdk_display_get_monitor_at_window(dpy, win);
806	refresh_rate = gdk_monitor_get_refresh_rate(monitor); /* [mHz] */
807	} else {
808	refresh_rate = 0;
809	}
810
811	gd_set_ui_refresh_rate(vc, refresh_rate);
812
813	/* T = 1 / f = 1 [sHz] / f = 10001000 [msmHz] / f /
814	vc->gfx.dcl.update_interval = refresh_rate ?
815	MIN(1000 * 1000 / refresh_rate, GUI_REFRESH_INTERVAL_DEFAULT) :
816	GUI_REFRESH_INTERVAL_DEFAULT;
817	#endif
818	}
819
820	void gd_update_scale(VirtualConsole *vc, int ww, int wh, int fbw, int fbh)
821	{
822	if (!vc) {
823	return;
824	}
825
826	if (vc->s->full_screen) {
827	vc->gfx.scale_x = (double)ww / fbw;
828	vc->gfx.scale_y = (double)wh / fbh;
829	} else if (vc->s->free_scale) {
830	double sx, sy;
831
832	sx = (double)ww / fbw;
833	sy = (double)wh / fbh;
834	if (vc->s->keep_aspect_ratio) {
835	vc->gfx.scale_x = vc->gfx.scale_y = MIN(sx, sy);
836	} else {
837	vc->gfx.scale_x = sx;
838	vc->gfx.scale_y = sy;
839	}
840	}
841	}
842	/**
843	* DOC: Coordinate handling.
844	*
845	* We are coping with sizes and positions in various coordinates and the
846	* handling of these coordinates is somewhat confusing. It would benefit us
847	* all if we define these coordinates explicitly and clearly. Besides, it's
848	* also helpful to follow the same naming convention for variables
849	* representing values in different coordinates.
850	*
851	* I. Definitions
852	*
853	* - (guest) buffer coordinate: this is the coordinates that the guest will
854	* see. The x/y offsets and width/height specified in commands sent by
855	* guest is basically in buffer coordinate.
856	*
857	* - (host) pixel coordinate: this is the coordinate in pixel level on the
858	* host destop. A window/widget of width 300 in pixel coordinate means it
859	* occupies 300 pixels horizontally.
860	*
861	* - (host) logical window coordinate: the existence of global scaling
862	* factor in desktop level makes this kind of coordinate play a role. It
863	* always holds that (logical window size) * (global scale factor) =
864	* (pixel size).
865	*
866	* - global scale factor: this is specified in desktop level and is
867	* typically invariant during the life cycle of the process. Users with
868	* high-DPI monitors might set this scale, for example, to 2, in order to
869	* make the UI look larger.
870	*
871	* - zooming scale: this can be freely controlled by the QEMU user to zoom
872	* in/out the guest content.
873	*
874	* II. Representation
875	*
876	* We'd like to use consistent representation for variables in different
877	* coordinates:
878	* - buffer coordinate: prefix fb
879	* - pixel coordinate: prefix p
880	* - logical window coordinate: prefix w
881	*
882	* For scales:
883	* - global scale factor: prefix gs
884	* - zooming scale: prefix scale/s
885	*
886	* Example: fbw, pw, ww for width in different coordinates
887	*
888	* III. Equation
889	*
890	* - fbw * gs * scale_x = pw
891	* - pw = gs * ww
892	*
893	* Consequently we have
894	*
895	* - fbw * scale_x = ww
896	*
897	* Example: assuming we are running QEMU on a 3840x2160 screen and have set
898	* global scaling factor to 2, if the guest buffer size is 1920x1080 and the
899	* zooming scale is 0.5, then we have:
900	* - fbw = 1920, fbh = 1080
901	* - pw = 1920, ph = 1080
902	* - ww = 960, wh = 540
903	* A bonus of this configuration is that we can achieve pixel to pixel
904	* presentation of the guest content.
905	*/
906
907	static gboolean gd_draw_event(GtkWidget widget, cairo_t cr, void *opaque)
908	{
909	VirtualConsole *vc = opaque;
910	GtkDisplayState *s = vc->s;
911	int wx_offset, wy_offset;
912	int ww_widget, wh_widget, ww_surface, wh_surface;
913	int fbw, fbh;
914
915	#if defined(CONFIG_OPENGL)
916	if (vc->gfx.gls) {
917	if (gtk_use_gl_area) {
918	/* invoke render callback please */
919	return FALSE;
920	} else {
921	#ifdef CONFIG_X11
922	gd_egl_draw(vc);
923	return TRUE;
924	#else
925	abort();
926	#endif
927	}
928	}
929	#endif
930
931	if (!gtk_widget_get_realized(widget)) {
932	return FALSE;
933	}
934	if (!vc->gfx.ds) {
935	return FALSE;
936	}
937	if (!vc->gfx.surface) {
938	return FALSE;
939	}
940
941	gd_update_monitor_refresh_rate(vc, vc->window ? vc->window : s->window);
942
943	fbw = surface_width(vc->gfx.ds);
944	fbh = surface_height(vc->gfx.ds);
945
946	ww_widget = gdk_window_get_width(gtk_widget_get_window(widget));
947	wh_widget = gdk_window_get_height(gtk_widget_get_window(widget));
948
949	gd_update_scale(vc, ww_widget, wh_widget, fbw, fbh);
950
951	ww_surface = fbw * vc->gfx.scale_x;
952	wh_surface = fbh * vc->gfx.scale_y;
953
954	wx_offset = wy_offset = 0;
955	if (ww_widget > ww_surface) {
956	wx_offset = (ww_widget - ww_surface) / 2;
957	}
958	if (wh_widget > wh_surface) {
959	wy_offset = (wh_widget - wh_surface) / 2;
960	}
961
962	cairo_rectangle(cr, 0, 0, ww_widget, wh_widget);
963
964	/* Optionally cut out the inner area where the pixmap
965	will be drawn. This avoids 'flashing' since we're
966	not double-buffering. Note we're using the undocumented
967	behaviour of drawing the rectangle from right to left
968	to cut out the whole */
969	cairo_rectangle(cr, wx_offset + ww_surface, wy_offset,
970	-1 * ww_surface, wh_surface);
971	cairo_fill(cr);
972
973	cairo_scale(cr, vc->gfx.scale_x, vc->gfx.scale_y);
974	cairo_set_source_surface(cr, vc->gfx.surface,
975	wx_offset / vc->gfx.scale_x,
976	wy_offset / vc->gfx.scale_y);
977	cairo_paint(cr);
978
979	return TRUE;
980	}
981
982	static gboolean gd_motion_event(GtkWidget widget, GdkEventMotion motion,
983	void *opaque)
984	{
985	VirtualConsole *vc = opaque;
986	GtkDisplayState *s = vc->s;
987	int fbx, fby;
988	int wx_offset, wy_offset;
989	int wh_surface, ww_surface;
990	int ww_widget, wh_widget;
991
992	if (!vc->gfx.ds) {
993	return TRUE;
994	}
995
996	ww_surface = surface_width(vc->gfx.ds) * vc->gfx.scale_x;
997	wh_surface = surface_height(vc->gfx.ds) * vc->gfx.scale_y;
998	ww_widget = gtk_widget_get_allocated_width(widget);
999	wh_widget = gtk_widget_get_allocated_height(widget);
1000
1001	/*
1002	* `widget` may not have the same size with the frame buffer.
1003	* In such cases, some paddings are needed around the `vc`.
1004	* To achieve that, `vc` will be displayed at (mx, my)
1005	* so that it is displayed at the center of the widget.
1006	*/
1007	wx_offset = wy_offset = 0;
1008	if (ww_widget > ww_surface) {
1009	wx_offset = (ww_widget - ww_surface) / 2;
1010	}
1011	if (wh_widget > wh_surface) {
1012	wy_offset = (wh_widget - wh_surface) / 2;
1013	}
1014
1015	/*
1016	* `motion` is reported in `widget` coordinates
1017	* so translating it to the coordinates in `vc`.
1018	*/
1019	fbx = (motion->x - wx_offset) / vc->gfx.scale_x;
1020	fby = (motion->y - wy_offset) / vc->gfx.scale_y;
1021
1022	trace_gd_motion_event(ww_widget, wh_widget,
1023	gtk_widget_get_scale_factor(widget), fbx, fby);
1024
1025	if (qemu_input_is_absolute(vc->gfx.dcl.con)) {
1026	if (fbx < 0 \|\| fby < 0 \|\|
1027	fbx >= surface_width(vc->gfx.ds) \|\|
1028	fby >= surface_height(vc->gfx.ds)) {
1029	return TRUE;
1030	}
1031	qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_X, fbx,
1032	0, surface_width(vc->gfx.ds));
1033	qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_Y, fby,
1034	0, surface_height(vc->gfx.ds));
1035	qemu_input_event_sync();
1036	} else if (s->last_set && s->ptr_owner == vc) {
1037	qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_X, fbx - s->last_x);
1038	qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_Y, fby - s->last_y);
1039	qemu_input_event_sync();
1040	}
1041	s->last_x = fbx;
1042	s->last_y = fby;
1043	s->last_set = TRUE;
1044
1045	if (!qemu_input_is_absolute(vc->gfx.dcl.con) && s->ptr_owner == vc) {
1046	GdkScreen *screen = gtk_widget_get_screen(vc->gfx.drawing_area);
1047	GdkDisplay *dpy = gtk_widget_get_display(widget);
1048	GdkWindow *win = gtk_widget_get_window(widget);
1049	GdkMonitor *monitor = gdk_display_get_monitor_at_window(dpy, win);
1050	GdkRectangle geometry;
1051
1052	int xr = (int)motion->x_root;
1053	int yr = (int)motion->y_root;
1054
1055	gdk_monitor_get_geometry(monitor, &geometry);
1056
1057	/* In relative mode check to see if client pointer hit
1058	* one of the monitor edges, and if so move it back to the
1059	* center of the monitor. This is important because the pointer
1060	* in the server doesn't correspond 1-for-1, and so
1061	* may still be only half way across the screen. Without
1062	* this warp, the server pointer would thus appear to hit
1063	* an invisible wall */
1064	if (xr <= geometry.x \|\| xr - geometry.x >= geometry.width - 1 \|\|
1065	yr <= geometry.y \|\| yr - geometry.y >= geometry.height - 1) {
1066	GdkDevice dev = gdk_event_get_device((GdkEvent )motion);
1067	xr = geometry.x + geometry.width / 2;
1068	yr = geometry.y + geometry.height / 2;
1069
1070	gdk_device_warp(dev, screen, xr, yr);
1071	s->last_set = FALSE;
1072	return FALSE;
1073	}
1074	}
1075	return TRUE;
1076	}
1077
1078	static gboolean gd_button_event(GtkWidget widget, GdkEventButton button,
1079	void *opaque)
1080	{
1081	VirtualConsole *vc = opaque;
1082	GtkDisplayState *s = vc->s;
1083	InputButton btn;
1084
1085	/* implicitly grab the input at the first click in the relative mode */
1086	if (button->button == 1 && button->type == GDK_BUTTON_PRESS &&
1087	!qemu_input_is_absolute(vc->gfx.dcl.con) && s->ptr_owner != vc) {
1088	if (!vc->window) {
1089	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
1090	TRUE);
1091	} else {
1092	gd_grab_pointer(vc, "relative-mode-click");
1093	}
1094	return TRUE;
1095	}
1096
1097	if (button->button == 1) {
1098	btn = INPUT_BUTTON_LEFT;
1099	} else if (button->button == 2) {
1100	btn = INPUT_BUTTON_MIDDLE;
1101	} else if (button->button == 3) {
1102	btn = INPUT_BUTTON_RIGHT;
1103	} else if (button->button == 8) {
1104	btn = INPUT_BUTTON_SIDE;
1105	} else if (button->button == 9) {
1106	btn = INPUT_BUTTON_EXTRA;
1107	} else {
1108	return TRUE;
1109	}
1110
1111	if (button->type == GDK_2BUTTON_PRESS \|\| button->type == GDK_3BUTTON_PRESS) {
1112	return TRUE;
1113	}
1114
1115	qemu_input_queue_btn(vc->gfx.dcl.con, btn,
1116	button->type == GDK_BUTTON_PRESS);
1117	qemu_input_event_sync();
1118	return TRUE;
1119	}
1120
1121	static gboolean gd_scroll_event(GtkWidget widget, GdkEventScroll scroll,
1122	void *opaque)
1123	{
1124	VirtualConsole *vc = opaque;
1125	InputButton btn_vertical;
1126	InputButton btn_horizontal;
1127	bool has_vertical = false;
1128	bool has_horizontal = false;
1129
1130	if (scroll->direction == GDK_SCROLL_UP) {
1131	btn_vertical = INPUT_BUTTON_WHEEL_UP;
1132	has_vertical = true;
1133	} else if (scroll->direction == GDK_SCROLL_DOWN) {
1134	btn_vertical = INPUT_BUTTON_WHEEL_DOWN;
1135	has_vertical = true;
1136	} else if (scroll->direction == GDK_SCROLL_LEFT) {
1137	btn_horizontal = INPUT_BUTTON_WHEEL_LEFT;
1138	has_horizontal = true;
1139	} else if (scroll->direction == GDK_SCROLL_RIGHT) {
1140	btn_horizontal = INPUT_BUTTON_WHEEL_RIGHT;
1141	has_horizontal = true;
1142	} else if (scroll->direction == GDK_SCROLL_SMOOTH) {
1143	gdouble delta_x, delta_y;
1144	if (!gdk_event_get_scroll_deltas((GdkEvent *)scroll,
1145	&delta_x, &delta_y)) {
1146	return TRUE;
1147	}
1148
1149	if (delta_y > 0) {
1150	btn_vertical = INPUT_BUTTON_WHEEL_DOWN;
1151	has_vertical = true;
1152	} else if (delta_y < 0) {
1153	btn_vertical = INPUT_BUTTON_WHEEL_UP;
1154	has_vertical = true;
1155	} else if (delta_x > 0) {
1156	btn_horizontal = INPUT_BUTTON_WHEEL_RIGHT;
1157	has_horizontal = true;
1158	} else if (delta_x < 0) {
1159	btn_horizontal = INPUT_BUTTON_WHEEL_LEFT;
1160	has_horizontal = true;
1161	} else {
1162	return TRUE;
1163	}
1164	} else {
1165	return TRUE;
1166	}
1167
1168	if (has_vertical) {
1169	qemu_input_queue_btn(vc->gfx.dcl.con, btn_vertical, true);
1170	qemu_input_event_sync();
1171	qemu_input_queue_btn(vc->gfx.dcl.con, btn_vertical, false);
1172	qemu_input_event_sync();
1173	}
1174
1175	if (has_horizontal) {
1176	qemu_input_queue_btn(vc->gfx.dcl.con, btn_horizontal, true);
1177	qemu_input_event_sync();
1178	qemu_input_queue_btn(vc->gfx.dcl.con, btn_horizontal, false);
1179	qemu_input_event_sync();
1180	}
1181
1182	return TRUE;
1183	}
1184
1185
1186	static gboolean gd_touch_event(GtkWidget widget, GdkEventTouch touch,
1187	void *opaque)
1188	{
1189	VirtualConsole *vc = opaque;
1190	Error *err = NULL;
1191	uint64_t num_slot = GPOINTER_TO_UINT(touch->sequence);
1192	int type = -1;
1193
1194	switch (touch->type) {
1195	case GDK_TOUCH_BEGIN:
1196	type = INPUT_MULTI_TOUCH_TYPE_BEGIN;
1197	break;
1198	case GDK_TOUCH_UPDATE:
1199	type = INPUT_MULTI_TOUCH_TYPE_UPDATE;
1200	break;
1201	case GDK_TOUCH_END:
1202	case GDK_TOUCH_CANCEL:
1203	type = INPUT_MULTI_TOUCH_TYPE_END;
1204	break;
1205	default:
1206	warn_report("gtk: unexpected touch event type");
1207	return FALSE;
1208	}
1209
1210	qemu_input_touch_event(vc->gfx.dcl.con, touch_slots,
1211	num_slot, surface_width(vc->gfx.ds),
1212	surface_height(vc->gfx.ds), touch->x,
1213	touch->y, type, &err);
1214	if (err) {
1215	warn_report_err(err);
1216	}
1217	return TRUE;
1218	}
1219
1220	static const guint16 gd_get_keymap(size_t maplen, bool *xorgevdev)
1221	{
1222	GdkDisplay *dpy = gdk_display_get_default();
1223
1224	*maplen = 0;
1225	*xorgevdev = false;
1226
1227	#ifdef GDK_WINDOWING_X11
1228	if (GDK_IS_X11_DISPLAY(dpy)) {
1229	trace_gd_keymap_windowing("x11");
1230	return qemu_xkeymap_mapping_table(
1231	gdk_x11_display_get_xdisplay(dpy), maplen, xorgevdev);
1232	}
1233	#endif
1234
1235	#ifdef GDK_WINDOWING_WAYLAND
1236	if (GDK_IS_WAYLAND_DISPLAY(dpy)) {
1237	trace_gd_keymap_windowing("wayland");
1238	*xorgevdev = true;
1239	return NULL;
1240	}
1241	#endif
1242
1243	#ifdef GDK_WINDOWING_WIN32
1244	if (GDK_IS_WIN32_DISPLAY(dpy)) {
1245	trace_gd_keymap_windowing("win32");
1246	*maplen = qemu_input_map_atset1_to_linux_len;
1247	return qemu_input_map_atset1_to_linux;
1248	}
1249	#endif
1250
1251	#ifdef GDK_WINDOWING_QUARTZ
1252	if (GDK_IS_QUARTZ_DISPLAY(dpy)) {
1253	trace_gd_keymap_windowing("quartz");
1254	*maplen = qemu_input_map_osx_to_linux_len;
1255	return qemu_input_map_osx_to_linux;
1256	}
1257	#endif
1258
1259	#ifdef GDK_WINDOWING_BROADWAY
1260	if (GDK_IS_BROADWAY_DISPLAY(dpy)) {
1261	trace_gd_keymap_windowing("broadway");
1262	g_warning("experimental: using broadway, x11 virtual keysym\n"
1263	"mapping - with very limited support. See also\n"
1264	"https://bugzilla.gnome.org/show_bug.cgi?id=700105");
1265	*maplen = qemu_input_map_x11_to_linux_len;
1266	return qemu_input_map_x11_to_linux;
1267	}
1268	#endif
1269
1270	g_warning("Unsupported GDK Windowing platform.\n"
1271	"Disabling extended keycode tables.\n"
1272	"Please report to qemu-devel@nongnu.org\n"
1273	"including the following information:\n"
1274	"\n"
1275	" - Operating system\n"
1276	" - GDK Windowing system build\n");
1277	return NULL;
1278	}
1279
1280
1281	static unsigned int gd_map_keycode(int scancode)
1282	{
1283	if (keycode_xorgevdev) {
1284	return scancode < 8 ? KEY_RESERVED : scancode - 8;
1285	}
1286	if (!keycode_map) {
1287	return 0;
1288	}
1289	if (scancode > keycode_maplen) {
1290	return 0;
1291	}
1292
1293	return keycode_map[scancode];
1294	}
1295
1296	static int gd_get_keycode(GdkEventKey *key)
1297	{
1298	#ifdef G_OS_WIN32
1299	int scancode = gdk_event_get_scancode((GdkEvent *)key);
1300
1301	/* translate Windows native scancodes to atset1 keycodes */
1302	switch (scancode & (KF_EXTENDED \| 0xff)) {
1303	case 0x145: /* NUMLOCK */
1304	return scancode & 0xff;
1305	}
1306
1307	return scancode & KF_EXTENDED ?
1308	0xe000 \| (scancode & 0xff) : scancode & 0xff;
1309
1310	#else
1311	return key->hardware_keycode;
1312	#endif
1313	}
1314
1315	static gboolean gd_text_key_down(GtkWidget *widget,
1316	GdkEventKey key, void opaque)
1317	{
1318	VirtualConsole *vc = opaque;
1319	QemuTextConsole *con = QEMU_TEXT_CONSOLE(vc->gfx.dcl.con);
1320
1321	if (key->keyval == GDK_KEY_Delete) {
1322	qemu_text_console_put_linux(con, KEY_DELETE, false);
1323	} else if (key->length) {
1324	qemu_text_console_put_string(con, key->string, key->length);
1325	} else {
1326	unsigned int lnx = gd_map_keycode(gd_get_keycode(key));
1327	qemu_text_console_put_linux(con, lnx, false);
1328	}
1329	return TRUE;
1330	}
1331
1332	static gboolean gd_key_event(GtkWidget widget, GdkEventKey key, void *opaque)
1333	{
1334	VirtualConsole *vc = opaque;
1335	int keycode;
1336	unsigned int lnx;
1337
1338	#ifdef G_OS_WIN32
1339	/* on windows, we ought to ignore the reserved key event? */
1340	if (key->hardware_keycode == 0xff)
1341	return false;
1342
1343	if (!vc->s->kbd_owner) {
1344	if (key->hardware_keycode == VK_LWIN \|\|
1345	key->hardware_keycode == VK_RWIN) {
1346	return FALSE;
1347	}
1348	}
1349	#endif
1350
1351	if (key->keyval == GDK_KEY_Pause
1352	#ifdef G_OS_WIN32
1353	/* for some reason GDK does not fill keyval for VK_PAUSE
1354	* See https://bugzilla.gnome.org/show_bug.cgi?id=769214
1355	*/
1356	\|\| key->hardware_keycode == VK_PAUSE
1357	#endif
1358	) {
1359	qkbd_state_key_event(vc->gfx.kbd, KEY_PAUSE,
1360	key->type == GDK_KEY_PRESS);
1361	return TRUE;
1362	}
1363
1364	keycode = gd_get_keycode(key);
1365	lnx = gd_map_keycode(keycode);
1366
1367	trace_gd_key_event(vc->label, keycode, lnx,
1368	(key->type == GDK_KEY_PRESS) ? "down" : "up");
1369
1370	qkbd_state_key_event(vc->gfx.kbd, lnx, key->type == GDK_KEY_PRESS);
1371
1372	return TRUE;
1373	}
1374
1375	static gboolean gd_grab_broken_event(GtkWidget *widget,
1376	GdkEventGrabBroken event, void opaque)
1377	{
1378	#ifdef CONFIG_WIN32
1379	/*
1380	* On Windows the Ctrl-Alt-Del key combination can't be grabbed. This
1381	* key combination leaves all three keys in a stuck condition. We use
1382	* the grab-broken-event to release all keys.
1383	*/
1384	if (event->keyboard) {
1385	VirtualConsole *vc = opaque;
1386	GtkDisplayState *s = vc->s;
1387
1388	gtk_release_modifiers(s);
1389	}
1390	#endif
1391	return TRUE;
1392	}
1393
1394	static gboolean gd_event(GtkWidget widget, GdkEvent event, void *opaque)
1395	{
1396	if (event->type == GDK_MOTION_NOTIFY) {
1397	return gd_motion_event(widget, &event->motion, opaque);
1398	}
1399	return FALSE;
1400	}
1401
1402	/ Window Menu Actions /
1403
1404	static void gd_menu_pause(GtkMenuItem item, void opaque)
1405	{
1406	GtkDisplayState *s = opaque;
1407
1408	if (s->external_pause_update) {
1409	return;
1410	}
1411	if (runstate_is_running()) {
1412	qmp_stop(NULL);
1413	} else {
1414	qmp_cont(NULL);
1415	}
1416	}
1417
1418	static void gd_menu_reset(GtkMenuItem item, void opaque)
1419	{
1420	qmp_system_reset(NULL);
1421	}
1422
1423	static void gd_menu_powerdown(GtkMenuItem item, void opaque)
1424	{
1425	qmp_system_powerdown(NULL);
1426	}
1427
1428	static void gd_menu_quit(GtkMenuItem item, void opaque)
1429	{
1430	qmp_quit(NULL);
1431	}
1432
1433	static void gd_menu_switch_vc(GtkMenuItem item, void opaque)
1434	{
1435	GtkDisplayState *s = opaque;
1436	VirtualConsole *vc = gd_vc_find_by_menu(s);
1437	GtkNotebook *nb = GTK_NOTEBOOK(s->notebook);
1438	gint page;
1439
1440	gtk_release_modifiers(s);
1441	if (vc) {
1442	page = gtk_notebook_page_num(nb, vc->tab_item);
1443	gtk_notebook_set_current_page(nb, page);
1444	gtk_widget_grab_focus(vc->focus);
1445	}
1446	}
1447
1448	static void gd_accel_switch_vc(void *opaque)
1449	{
1450	VirtualConsole *vc = opaque;
1451
1452	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), TRUE);
1453	}
1454
1455	static void gd_menu_show_tabs(GtkMenuItem item, void opaque)
1456	{
1457	GtkDisplayState *s = opaque;
1458	VirtualConsole *vc = gd_vc_find_current(s);
1459
1460	if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->show_tabs_item))) {
1461	gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), TRUE);
1462	} else {
1463	gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
1464	}
1465	gd_update_windowsize(vc);
1466	}
1467
1468	static int gd_vc_notebook_pos(GtkDisplayState s, VirtualConsole target)
1469	{
1470	int pos = 0;
1471	guint i;
1472
1473	for (i = 0; i < s->vcs->len; i++) {
1474	VirtualConsole *vc = g_ptr_array_index(s->vcs, i);
1475	if (vc == target) {
1476	return pos;
1477	}
1478	if (!vc->window) {
1479	pos++;
1480	}
1481	}
1482	g_assert_not_reached();
1483	}
1484
1485	static gboolean gd_tab_window_close(GtkWidget widget, GdkEvent event,
1486	void *opaque)
1487	{
1488	VirtualConsole *vc = opaque;
1489	GtkDisplayState *s = vc->s;
1490	int page;
1491
1492	g_object_ref(vc->tab_item);
1493	gtk_container_remove(GTK_CONTAINER(vc->window), vc->tab_item);
1494	page = gd_vc_notebook_pos(s, vc);
1495	gtk_notebook_insert_page(GTK_NOTEBOOK(s->notebook),
1496	vc->tab_item, gtk_label_new(vc->label), page);
1497	g_object_unref(vc->tab_item);
1498	gtk_widget_destroy(vc->window);
1499	vc->window = NULL;
1500	#if defined(CONFIG_OPENGL)
1501	if (vc->gfx.esurface) {
1502	eglDestroySurface(qemu_egl_display, vc->gfx.esurface);
1503	vc->gfx.esurface = NULL;
1504	}
1505	if (vc->gfx.ectx) {
1506	eglDestroyContext(qemu_egl_display, vc->gfx.ectx);
1507	vc->gfx.ectx = NULL;
1508	}
1509	#endif
1510
1511	gd_rebuild_vc_menu(s);
1512
1513	if (vc == gd_vc_find_by_menu(s)) {
1514	gtk_widget_grab_focus(vc->focus);
1515	}
1516
1517	return TRUE;
1518	}
1519
1520	static gboolean gd_win_grab(void *opaque)
1521	{
1522	VirtualConsole *vc = opaque;
1523
1524	fprintf(stderr, "%s: %s\n", __func__, vc->label);
1525	if (vc->s->ptr_owner) {
1526	gd_ungrab_pointer(vc->s);
1527	} else {
1528	gd_grab_pointer(vc, "user-request-detached-tab");
1529	}
1530	return TRUE;
1531	}
1532
1533	static void gd_menu_untabify(GtkMenuItem item, void opaque)
1534	{
1535	GtkDisplayState *s = opaque;
1536	VirtualConsole *vc = gd_vc_find_current(s);
1537
1538	if (vc->type == GD_VC_GFX &&
1539	qemu_console_is_graphic(vc->gfx.dcl.con)) {
1540	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
1541	FALSE);
1542	}
1543	if (!vc->window) {
1544	vc->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1545	#if defined(CONFIG_OPENGL)
1546	if (vc->gfx.esurface) {
1547	eglDestroySurface(qemu_egl_display, vc->gfx.esurface);
1548	vc->gfx.esurface = NULL;
1549	}
1550	if (vc->gfx.ectx) {
1551	eglDestroyContext(qemu_egl_display, vc->gfx.ectx);
1552	vc->gfx.ectx = NULL;
1553	}
1554	#endif
1555	gd_widget_reparent(s->notebook, vc->window, vc->tab_item);
1556
1557	g_signal_connect(vc->window, "delete-event",
1558	G_CALLBACK(gd_tab_window_close), vc);
1559	gtk_widget_show_all(vc->window);
1560
1561	if (qemu_console_is_graphic(vc->gfx.dcl.con)) {
1562	GtkAccelGroup *ag = gtk_accel_group_new();
1563	gtk_window_add_accel_group(GTK_WINDOW(vc->window), ag);
1564
1565	GClosure *cb = g_cclosure_new_swap(G_CALLBACK(gd_win_grab),
1566	vc, NULL);
1567	gtk_accel_group_connect(ag, GDK_KEY_g, HOTKEY_MODIFIERS, 0, cb);
1568	}
1569
1570	gd_rebuild_vc_menu(s);
1571	gd_update_geometry_hints(vc);
1572	gd_update_caption(s);
1573	}
1574	}
1575
1576	static void gd_menu_show_menubar(GtkMenuItem item, void opaque)
1577	{
1578	GtkDisplayState *s = opaque;
1579	VirtualConsole *vc = gd_vc_find_current(s);
1580
1581	if (s->full_screen) {
1582	return;
1583	}
1584
1585	if (gtk_check_menu_item_get_active(
1586	GTK_CHECK_MENU_ITEM(s->show_menubar_item))) {
1587	gtk_widget_show(s->menu_bar);
1588	} else {
1589	gtk_widget_hide(s->menu_bar);
1590	}
1591	gd_update_windowsize(vc);
1592	}
1593
1594	static void gd_accel_show_menubar(void *opaque)
1595	{
1596	GtkDisplayState *s = opaque;
1597	gtk_menu_item_activate(GTK_MENU_ITEM(s->show_menubar_item));
1598	}
1599
1600	static void gd_menu_full_screen(GtkMenuItem item, void opaque)
1601	{
1602	GtkDisplayState *s = opaque;
1603	VirtualConsole *vc = gd_vc_find_current(s);
1604
1605	if (!s->full_screen) {
1606	gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
1607	gtk_widget_hide(s->menu_bar);
1608	if (vc->type == GD_VC_GFX) {
1609	gtk_widget_set_size_request(vc->gfx.drawing_area, -1, -1);
1610	}
1611	gtk_window_fullscreen(GTK_WINDOW(s->window));
1612	s->full_screen = TRUE;
1613	} else {
1614	gtk_window_unfullscreen(GTK_WINDOW(s->window));
1615	gd_menu_show_tabs(GTK_MENU_ITEM(s->show_tabs_item), s);
1616	if (gtk_check_menu_item_get_active(
1617	GTK_CHECK_MENU_ITEM(s->show_menubar_item))) {
1618	gtk_widget_show(s->menu_bar);
1619	}
1620	s->full_screen = FALSE;
1621	if (vc->type == GD_VC_GFX) {
1622	vc->gfx.scale_x = vc->gfx.preferred_scale;
1623	vc->gfx.scale_y = vc->gfx.preferred_scale;
1624	gd_update_windowsize(vc);
1625	}
1626	}
1627
1628	gd_update_cursor(vc);
1629	}
1630
1631	static void gd_accel_full_screen(void *opaque)
1632	{
1633	GtkDisplayState *s = opaque;
1634	gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item));
1635	}
1636
1637	static void gd_menu_zoom_in(GtkMenuItem item, void opaque)
1638	{
1639	GtkDisplayState *s = opaque;
1640	VirtualConsole *vc = gd_vc_find_current(s);
1641
1642	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item),
1643	FALSE);
1644
1645	vc->gfx.scale_x += VC_SCALE_STEP;
1646	vc->gfx.scale_y += VC_SCALE_STEP;
1647
1648	gd_update_windowsize(vc);
1649	}
1650
1651	static void gd_accel_zoom_in(void *opaque)
1652	{
1653	GtkDisplayState *s = opaque;
1654	gtk_menu_item_activate(GTK_MENU_ITEM(s->zoom_in_item));
1655	}
1656
1657	static void gd_menu_zoom_out(GtkMenuItem item, void opaque)
1658	{
1659	GtkDisplayState *s = opaque;
1660	VirtualConsole *vc = gd_vc_find_current(s);
1661
1662	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item),
1663	FALSE);
1664
1665	vc->gfx.scale_x -= VC_SCALE_STEP;
1666	vc->gfx.scale_y -= VC_SCALE_STEP;
1667
1668	vc->gfx.scale_x = MAX(vc->gfx.scale_x, VC_SCALE_MIN);
1669	vc->gfx.scale_y = MAX(vc->gfx.scale_y, VC_SCALE_MIN);
1670
1671	gd_update_windowsize(vc);
1672	}
1673
1674	static void gd_menu_zoom_fixed(GtkMenuItem item, void opaque)
1675	{
1676	GtkDisplayState *s = opaque;
1677	VirtualConsole *vc = gd_vc_find_current(s);
1678
1679	vc->gfx.scale_x = vc->gfx.preferred_scale;
1680	vc->gfx.scale_y = vc->gfx.preferred_scale;
1681
1682	gd_update_windowsize(vc);
1683	}
1684
1685	static void gd_menu_zoom_fit(GtkMenuItem item, void opaque)
1686	{
1687	GtkDisplayState *s = opaque;
1688	VirtualConsole *vc = gd_vc_find_current(s);
1689
1690	if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item))) {
1691	s->free_scale = TRUE;
1692	} else {
1693	s->free_scale = FALSE;
1694	vc->gfx.scale_x = vc->gfx.preferred_scale;
1695	vc->gfx.scale_y = vc->gfx.preferred_scale;
1696	}
1697
1698	gd_update_windowsize(vc);
1699	gd_update_full_redraw(vc);
1700	}
1701
1702	static void gd_grab_update(VirtualConsole *vc, bool kbd, bool ptr)
1703	{
1704	GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
1705	GdkSeat *seat = gdk_display_get_default_seat(display);
1706	GdkWindow *window = gtk_widget_get_window(vc->gfx.drawing_area);
1707	GdkSeatCapabilities caps = 0;
1708	GdkCursor *cursor = NULL;
1709
1710	if (kbd) {
1711	caps \|= GDK_SEAT_CAPABILITY_KEYBOARD;
1712	}
1713	if (ptr) {
1714	caps \|= GDK_SEAT_CAPABILITY_ALL_POINTING;
1715	cursor = vc->s->null_cursor;
1716	}
1717
1718	if (caps) {
1719	gdk_seat_grab(seat, window, caps, false, cursor,
1720	NULL, NULL, NULL);
1721	} else {
1722	gdk_seat_ungrab(seat);
1723	}
1724	}
1725
1726	static void gd_grab_keyboard(VirtualConsole vc, const char reason)
1727	{
1728	if (vc->s->kbd_owner) {
1729	if (vc->s->kbd_owner == vc) {
1730	return;
1731	} else {
1732	gd_ungrab_keyboard(vc->s);
1733	}
1734	}
1735
1736	win32_kbd_set_grab(true);
1737	gd_grab_update(vc, true, vc->s->ptr_owner == vc);
1738	vc->s->kbd_owner = vc;
1739	gd_update_caption(vc->s);
1740	trace_gd_grab(vc->label, "kbd", reason);
1741	}
1742
1743	static void gd_ungrab_keyboard(GtkDisplayState *s)
1744	{
1745	VirtualConsole *vc = s->kbd_owner;
1746
1747	if (vc == NULL) {
1748	return;
1749	}
1750	s->kbd_owner = NULL;
1751
1752	win32_kbd_set_grab(false);
1753	gd_grab_update(vc, false, vc->s->ptr_owner == vc);
1754	gd_update_caption(s);
1755	trace_gd_ungrab(vc->label, "kbd");
1756	}
1757
1758	static void gd_grab_pointer(VirtualConsole vc, const char reason)
1759	{
1760	GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
1761
1762	if (vc->s->ptr_owner) {
1763	if (vc->s->ptr_owner == vc) {
1764	return;
1765	} else {
1766	gd_ungrab_pointer(vc->s);
1767	}
1768	}
1769
1770	gd_grab_update(vc, vc->s->kbd_owner == vc, true);
1771	gdk_device_get_position(gd_get_pointer(display),
1772	NULL, &vc->s->grab_x_root, &vc->s->grab_y_root);
1773	vc->s->ptr_owner = vc;
1774	gd_update_caption(vc->s);
1775	trace_gd_grab(vc->label, "ptr", reason);
1776	}
1777
1778	static void gd_ungrab_pointer(GtkDisplayState *s)
1779	{
1780	VirtualConsole *vc = s->ptr_owner;
1781	GdkDisplay *display;
1782
1783	if (vc == NULL) {
1784	return;
1785	}
1786	s->ptr_owner = NULL;
1787
1788	display = gtk_widget_get_display(vc->gfx.drawing_area);
1789	gd_grab_update(vc, vc->s->kbd_owner == vc, false);
1790	gdk_device_warp(gd_get_pointer(display),
1791	gtk_widget_get_screen(vc->gfx.drawing_area),
1792	vc->s->grab_x_root, vc->s->grab_y_root);
1793	gd_update_caption(s);
1794	trace_gd_ungrab(vc->label, "ptr");
1795	}
1796
1797	static void gd_menu_grab_input(GtkMenuItem item, void opaque)
1798	{
1799	GtkDisplayState *s = opaque;
1800	VirtualConsole *vc = gd_vc_find_current(s);
1801
1802	if (gd_is_grab_active(s)) {
1803	gd_grab_keyboard(vc, "user-request-main-window");
1804	gd_grab_pointer(vc, "user-request-main-window");
1805	} else {
1806	gd_ungrab_keyboard(s);
1807	gd_ungrab_pointer(s);
1808	}
1809
1810	gd_update_cursor(vc);
1811	}
1812
1813	static void gd_change_page(GtkNotebook *nb, gpointer arg1, guint arg2,
1814	gpointer data)
1815	{
1816	GtkDisplayState *s = data;
1817	VirtualConsole *vc;
1818	gboolean on_vga;
1819
1820	if (!gtk_widget_get_realized(s->notebook)) {
1821	return;
1822	}
1823
1824	vc = gd_vc_find_by_page(s, arg2);
1825	if (!vc) {
1826	return;
1827	}
1828	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item),
1829	TRUE);
1830	on_vga = (vc->type == GD_VC_GFX &&
1831	qemu_console_is_graphic(vc->gfx.dcl.con));
1832	if (!on_vga) {
1833	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
1834	FALSE);
1835	} else if (s->full_screen) {
1836	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
1837	TRUE);
1838	}
1839	gtk_widget_set_sensitive(s->grab_item, on_vga);
1840	#ifdef CONFIG_VTE
1841	gtk_widget_set_sensitive(s->copy_item, vc->type == GD_VC_VTE);
1842	#endif
1843
1844	gd_update_windowsize(vc);
1845	gd_update_cursor(vc);
1846	}
1847
1848	static gboolean gd_enter_event(GtkWidget widget, GdkEventCrossing crossing,
1849	gpointer opaque)
1850	{
1851	VirtualConsole *vc = opaque;
1852	GtkDisplayState *s = vc->s;
1853
1854	if (gd_grab_on_hover(s)) {
1855	gd_grab_keyboard(vc, "grab-on-hover");
1856	}
1857	return TRUE;
1858	}
1859
1860	static gboolean gd_leave_event(GtkWidget widget, GdkEventCrossing crossing,
1861	gpointer opaque)
1862	{
1863	VirtualConsole *vc = opaque;
1864	GtkDisplayState *s = vc->s;
1865
1866	if (gd_grab_on_hover(s)) {
1867	gd_ungrab_keyboard(s);
1868	}
1869	return TRUE;
1870	}
1871
1872	static gboolean gd_focus_in_event(GtkWidget *widget,
1873	GdkEventFocus *event, gpointer opaque)
1874	{
1875	VirtualConsole *vc = opaque;
1876
1877	win32_kbd_set_window(gd_win32_get_hwnd(vc));
1878	return TRUE;
1879	}
1880
1881	static gboolean gd_focus_out_event(GtkWidget *widget,
1882	GdkEventFocus *event, gpointer opaque)
1883	{
1884	VirtualConsole *vc = opaque;
1885	GtkDisplayState *s = vc->s;
1886
1887	win32_kbd_set_window(NULL);
1888	gtk_release_modifiers(s);
1889	return TRUE;
1890	}
1891
1892	static gboolean gd_configure(GtkWidget *widget,
1893	GdkEventConfigure *cfg, gpointer opaque)
1894	{
1895	VirtualConsole *vc = opaque;
1896	const double sx = vc->gfx.scale_x, sy = vc->gfx.scale_y;
1897	double width = cfg->width, height = cfg->height;
1898
1899	if (!vc->s->free_scale && !vc->s->full_screen) {
1900	width /= sx;
1901	height /= sy;
1902	}
1903
1904	gd_set_ui_size(vc, width, height);
1905
1906	return FALSE;
1907	}
1908
1909	/ Virtual Console Callbacks /
1910
1911	static void gd_rebuild_vc_menu(GtkDisplayState *s)
1912	{
1913	GSList *group = NULL;
1914	VirtualConsole *vc;
1915	GList *children;
1916	gint insert_pos;
1917	int shortcut_idx = 0;
1918	guint i;
1919
1920	for (i = 0; i < s->vcs->len; i++) {
1921	vc = g_ptr_array_index(s->vcs, i);
1922	if (vc->menu_item) {
1923	gtk_widget_destroy(vc->menu_item);
1924	vc->menu_item = NULL;
1925	}
1926	}
1927
1928	for (i = 0; i < 9; i++) {
1929	gtk_accel_group_disconnect_key(s->accel_group,
1930	GDK_KEY_1 + i, HOTKEY_MODIFIERS);
1931	}
1932
1933	/* find insertion position (just before vc_menu_separator) */
1934	children = gtk_container_get_children(GTK_CONTAINER(s->view_menu));
1935	insert_pos = g_list_index(children, s->vc_menu_separator);
1936	g_list_free(children);
1937
1938	/* create new menu items for each console */
1939	for (i = 0; i < s->vcs->len; i++) {
1940	vc = g_ptr_array_index(s->vcs, i);
1941
1942	vc->menu_item = gtk_radio_menu_item_new_with_mnemonic(group,
1943	vc->label);
1944	group = gtk_radio_menu_item_get_group(
1945	GTK_RADIO_MENU_ITEM(vc->menu_item));
1946
1947	if (vc->window) {
1948	gtk_widget_set_sensitive(vc->menu_item, false);
1949	} else if (shortcut_idx < 9) {
1950	guint key = GDK_KEY_1 + shortcut_idx;
1951	gtk_accel_group_connect(s->accel_group, key,
1952	HOTKEY_MODIFIERS, 0,
1953	g_cclosure_new_swap(G_CALLBACK(gd_accel_switch_vc),
1954	vc, NULL));
1955	gtk_accel_label_set_accel(
1956	GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(vc->menu_item))),
1957	key, HOTKEY_MODIFIERS);
1958	shortcut_idx++;
1959	}
1960
1961	g_signal_connect(vc->menu_item, "activate",
1962	G_CALLBACK(gd_menu_switch_vc), s);
1963	gtk_menu_shell_insert(GTK_MENU_SHELL(s->view_menu),
1964	vc->menu_item, insert_pos + i);
1965	gtk_widget_show(vc->menu_item);
1966	}
1967
1968	/* sync active menu item with current notebook page */
1969	vc = gd_vc_find_current(s);
1970	if (vc && vc->menu_item) {
1971	g_signal_handlers_block_by_func(vc->menu_item,
1972	gd_menu_switch_vc, s);
1973	gtk_check_menu_item_set_active(
1974	GTK_CHECK_MENU_ITEM(vc->menu_item), TRUE);
1975	g_signal_handlers_unblock_by_func(vc->menu_item,
1976	gd_menu_switch_vc, s);
1977	}
1978	}
1979
1980	#if defined(CONFIG_VTE)
1981	static void gd_menu_copy(GtkMenuItem item, void opaque)
1982	{
1983	GtkDisplayState *s = opaque;
1984	VirtualConsole *vc = gd_vc_find_current(s);
1985
1986	#if VTE_CHECK_VERSION(0, 50, 0)
1987	vte_terminal_copy_clipboard_format(VTE_TERMINAL(vc->vte.terminal),
1988	VTE_FORMAT_TEXT);
1989	#else
1990	vte_terminal_copy_clipboard(VTE_TERMINAL(vc->vte.terminal));
1991	#endif
1992	}
1993
1994	static void gd_vc_adjustment_changed(GtkAdjustment adjustment, void opaque)
1995	{
1996	VirtualConsole *vc = opaque;
1997
1998	if (gtk_adjustment_get_upper(adjustment) >
1999	gtk_adjustment_get_page_size(adjustment)) {
2000	gtk_widget_show(vc->vte.scrollbar);
2001	} else {
2002	gtk_widget_hide(vc->vte.scrollbar);
2003	}
2004	}
2005
2006	static void gd_vc_send_chars(VirtualConsole *vc)
2007	{
2008	uint32_t len, avail;
2009
2010	len = qemu_chr_be_can_write(vc->vte.chr);
2011	avail = fifo8_num_used(&vc->vte.out_fifo);
2012	while (len > 0 && avail > 0) {
2013	const uint8_t *buf;
2014	uint32_t size;
2015
2016	buf = fifo8_pop_bufptr(&vc->vte.out_fifo, MIN(len, avail), &size);
2017	qemu_chr_be_write(vc->vte.chr, buf, size);
2018	len = qemu_chr_be_can_write(vc->vte.chr);
2019	avail -= size;
2020	}
2021	}
2022
2023	static int gd_vc_chr_write(Chardev chr, const uint8_t buf, int len)
2024	{
2025	VCChardev *vcd = VC_CHARDEV(chr);
2026	VirtualConsole *vc = vcd->console;
2027
2028	vte_terminal_feed(VTE_TERMINAL(vc->vte.terminal), (const char *)buf, len);
2029	return len;
2030	}
2031
2032	static void gd_vc_chr_accept_input(Chardev *chr)
2033	{
2034	VCChardev *vcd = VC_CHARDEV(chr);
2035	VirtualConsole *vc = vcd->console;
2036
2037	if (vc) {
2038	gd_vc_send_chars(vc);
2039	}
2040	}
2041
2042	static void gd_vc_chr_set_echo(Chardev *chr, bool echo)
2043	{
2044	VCChardev *vcd = VC_CHARDEV(chr);
2045	VirtualConsole *vc = vcd->console;
2046
2047	if (vc) {
2048	vc->vte.echo = echo;
2049	} else {
2050	vcd->echo = echo;
2051	}
2052	}
2053
2054	static int nb_vcs;
2055	static Chardev *vcs[MAX_VCS];
2056	static bool gd_vc_chr_open(Chardev chr, ChardevBackend backend, Error **errp)
2057	{
2058	if (nb_vcs == MAX_VCS) {
2059	error_setg(errp, "Maximum number of consoles reached");
2060	return false;
2061	}
2062
2063	vcs[nb_vcs++] = chr;
2064
2065	/*
2066	* console/chardev init sometimes completes elsewhere in a 2nd
2067	* stage, so defer OPENED events until they are fully initialized
2068	*/
2069	return true;
2070	}
2071
2072	static void char_gd_vc_class_init(ObjectClass oc, const void data)
2073	{
2074	ChardevClass *cc = CHARDEV_CLASS(oc);
2075
2076	cc->chr_open = gd_vc_chr_open;
2077	cc->chr_write = gd_vc_chr_write;
2078	cc->chr_accept_input = gd_vc_chr_accept_input;
2079	cc->chr_set_echo = gd_vc_chr_set_echo;
2080	}
2081
2082	static const TypeInfo char_gd_vc_type_info = {
2083	.name = TYPE_CHARDEV_VC,
2084	.parent = TYPE_CHARDEV,
2085	.instance_size = sizeof(VCChardev),
2086	.class_init = char_gd_vc_class_init,
2087	};
2088
2089	static gboolean gd_vc_in(VteTerminal terminal, gchar text, guint size,
2090	gpointer user_data)
2091	{
2092	VirtualConsole *vc = user_data;
2093	uint32_t free;
2094
2095	if (vc->vte.echo) {
2096	VteTerminal *term = VTE_TERMINAL(vc->vte.terminal);
2097	int i;
2098	for (i = 0; i < size; i++) {
2099	uint8_t c = text[i];
2100	if (c >= 128 \|\| isprint(c)) {
2101	/* 8-bit characters are considered printable. */
2102	vte_terminal_feed(term, &text[i], 1);
2103	} else if (c == '\r' \|\| c == '\n') {
2104	vte_terminal_feed(term, "\r\n", 2);
2105	} else {
2106	char ctrl[2] = { '^', 0};
2107	ctrl[1] = text[i] ^ 64;
2108	vte_terminal_feed(term, ctrl, 2);
2109	}
2110	}
2111	}
2112
2113	free = fifo8_num_free(&vc->vte.out_fifo);
2114	fifo8_push_all(&vc->vte.out_fifo, (uint8_t *)text, MIN(free, size));
2115	gd_vc_send_chars(vc);
2116
2117	return TRUE;
2118	}
2119
2120	static void gd_vc_vte_init(GtkDisplayState s, VirtualConsole vc,
2121	Chardev *chr, int idx)
2122	{
2123	char buffer[32];
2124	GtkWidget *box;
2125	GtkWidget *scrollbar;
2126	GtkAdjustment *vadjustment;
2127	VCChardev *vcd = VC_CHARDEV(chr);
2128
2129	vc->s = s;
2130	vc->vte.echo = vcd->echo;
2131	vc->vte.chr = chr;
2132	fifo8_create(&vc->vte.out_fifo, 4096);
2133	vcd->console = vc;
2134
2135	snprintf(buffer, sizeof(buffer), "vc%d", idx);
2136	vc->label = g_strdup(vc->vte.chr->label ? : buffer);
2137
2138	vc->vte.terminal = vte_terminal_new();
2139	g_signal_connect(vc->vte.terminal, "commit", G_CALLBACK(gd_vc_in), vc);
2140
2141	/* The documentation says that the default is UTF-8, but actually it is
2142	* 7-bit ASCII at least in VTE 0.38. The function is deprecated since
2143	* VTE 0.54 (only UTF-8 is supported now). */
2144	#if !VTE_CHECK_VERSION(0, 54, 0)
2145	#if VTE_CHECK_VERSION(0, 38, 0)
2146	vte_terminal_set_encoding(VTE_TERMINAL(vc->vte.terminal), "UTF-8", NULL);
2147	#else
2148	vte_terminal_set_encoding(VTE_TERMINAL(vc->vte.terminal), "UTF-8");
2149	#endif
2150	#endif
2151
2152	vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->vte.terminal), -1);
2153	vte_terminal_set_size(VTE_TERMINAL(vc->vte.terminal),
2154	VC_TERM_X_MIN, VC_TERM_Y_MIN);
2155
2156	#if VTE_CHECK_VERSION(0, 28, 0)
2157	vadjustment = gtk_scrollable_get_vadjustment
2158	(GTK_SCROLLABLE(vc->vte.terminal));
2159	#else
2160	vadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->vte.terminal));
2161	#endif
2162
2163	box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
2164	scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, vadjustment);
2165
2166	gtk_box_pack_end(GTK_BOX(box), scrollbar, FALSE, FALSE, 0);
2167	gtk_box_pack_end(GTK_BOX(box), vc->vte.terminal, TRUE, TRUE, 0);
2168
2169	vc->vte.box = box;
2170	vc->vte.scrollbar = scrollbar;
2171
2172	g_signal_connect(vadjustment, "changed",
2173	G_CALLBACK(gd_vc_adjustment_changed), vc);
2174
2175	vc->type = GD_VC_VTE;
2176	vc->tab_item = box;
2177	vc->focus = vc->vte.terminal;
2178	gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), vc->tab_item,
2179	gtk_label_new(vc->label));
2180
2181	qemu_chr_be_event(vc->vte.chr, CHR_EVENT_OPENED);
2182	}
2183
2184	static void gd_vcs_init(GtkDisplayState *s)
2185	{
2186	int i;
2187
2188	for (i = 0; i < nb_vcs; i++) {
2189	VirtualConsole *vc = g_new0(VirtualConsole, 1);
2190	g_ptr_array_add(s->vcs, vc);
2191	gd_vc_vte_init(s, vc, vcs[i], s->vcs->len - 1);
2192	}
2193	}
2194	#endif /* CONFIG_VTE */
2195
2196	/ Window Creation /
2197
2198	static void gd_connect_vc_gfx_signals(VirtualConsole *vc)
2199	{
2200	g_signal_connect(vc->gfx.drawing_area, "draw",
2201	G_CALLBACK(gd_draw_event), vc);
2202	#if defined(CONFIG_OPENGL)
2203	if (gtk_use_gl_area) {
2204	/* wire up GtkGlArea events */
2205	g_signal_connect(vc->gfx.drawing_area, "render",
2206	G_CALLBACK(gd_render_event), vc);
2207	g_signal_connect(vc->gfx.drawing_area, "resize",
2208	G_CALLBACK(gd_resize_event), vc);
2209	}
2210	#endif
2211	if (qemu_console_is_graphic(vc->gfx.dcl.con)) {
2212	g_signal_connect(vc->gfx.drawing_area, "event",
2213	G_CALLBACK(gd_event), vc);
2214	g_signal_connect(vc->gfx.drawing_area, "button-press-event",
2215	G_CALLBACK(gd_button_event), vc);
2216	g_signal_connect(vc->gfx.drawing_area, "button-release-event",
2217	G_CALLBACK(gd_button_event), vc);
2218	g_signal_connect(vc->gfx.drawing_area, "scroll-event",
2219	G_CALLBACK(gd_scroll_event), vc);
2220	g_signal_connect(vc->gfx.drawing_area, "key-press-event",
2221	G_CALLBACK(gd_key_event), vc);
2222	g_signal_connect(vc->gfx.drawing_area, "key-release-event",
2223	G_CALLBACK(gd_key_event), vc);
2224	g_signal_connect(vc->gfx.drawing_area, "touch-event",
2225	G_CALLBACK(gd_touch_event), vc);
2226
2227	g_signal_connect(vc->gfx.drawing_area, "enter-notify-event",
2228	G_CALLBACK(gd_enter_event), vc);
2229	g_signal_connect(vc->gfx.drawing_area, "leave-notify-event",
2230	G_CALLBACK(gd_leave_event), vc);
2231	g_signal_connect(vc->gfx.drawing_area, "focus-in-event",
2232	G_CALLBACK(gd_focus_in_event), vc);
2233	g_signal_connect(vc->gfx.drawing_area, "focus-out-event",
2234	G_CALLBACK(gd_focus_out_event), vc);
2235	g_signal_connect(vc->gfx.drawing_area, "configure-event",
2236	G_CALLBACK(gd_configure), vc);
2237	g_signal_connect(vc->gfx.drawing_area, "grab-broken-event",
2238	G_CALLBACK(gd_grab_broken_event), vc);
2239	} else {
2240	g_signal_connect(vc->gfx.drawing_area, "key-press-event",
2241	G_CALLBACK(gd_text_key_down), vc);
2242	}
2243	}
2244
2245	static void gd_connect_signals(GtkDisplayState *s)
2246	{
2247	g_signal_connect(s->show_tabs_item, "activate",
2248	G_CALLBACK(gd_menu_show_tabs), s);
2249	g_signal_connect(s->untabify_item, "activate",
2250	G_CALLBACK(gd_menu_untabify), s);
2251	g_signal_connect(s->show_menubar_item, "activate",
2252	G_CALLBACK(gd_menu_show_menubar), s);
2253
2254	g_signal_connect(s->window, "delete-event",
2255	G_CALLBACK(gd_window_close), s);
2256
2257	g_signal_connect(s->pause_item, "activate",
2258	G_CALLBACK(gd_menu_pause), s);
2259	g_signal_connect(s->reset_item, "activate",
2260	G_CALLBACK(gd_menu_reset), s);
2261	g_signal_connect(s->powerdown_item, "activate",
2262	G_CALLBACK(gd_menu_powerdown), s);
2263	g_signal_connect(s->quit_item, "activate",
2264	G_CALLBACK(gd_menu_quit), s);
2265	#if defined(CONFIG_VTE)
2266	g_signal_connect(s->copy_item, "activate",
2267	G_CALLBACK(gd_menu_copy), s);
2268	#endif
2269	g_signal_connect(s->full_screen_item, "activate",
2270	G_CALLBACK(gd_menu_full_screen), s);
2271	g_signal_connect(s->zoom_in_item, "activate",
2272	G_CALLBACK(gd_menu_zoom_in), s);
2273	g_signal_connect(s->zoom_out_item, "activate",
2274	G_CALLBACK(gd_menu_zoom_out), s);
2275	g_signal_connect(s->zoom_fixed_item, "activate",
2276	G_CALLBACK(gd_menu_zoom_fixed), s);
2277	g_signal_connect(s->zoom_fit_item, "activate",
2278	G_CALLBACK(gd_menu_zoom_fit), s);
2279	g_signal_connect(s->grab_item, "activate",
2280	G_CALLBACK(gd_menu_grab_input), s);
2281	g_signal_connect(s->notebook, "switch-page",
2282	G_CALLBACK(gd_change_page), s);
2283	}
2284
2285	static GtkWidget gd_create_menu_machine(GtkDisplayState s)
2286	{
2287	GtkWidget *machine_menu;
2288	GtkWidget *separator;
2289
2290	machine_menu = gtk_menu_new();
2291	gtk_menu_set_accel_group(GTK_MENU(machine_menu), s->accel_group);
2292
2293	s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause"));
2294	gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->pause_item);
2295
2296	separator = gtk_separator_menu_item_new();
2297	gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
2298
2299	s->reset_item = gtk_menu_item_new_with_mnemonic(_("_Reset"));
2300	gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->reset_item);
2301
2302	s->powerdown_item = gtk_menu_item_new_with_mnemonic(_("Power _Down"));
2303	gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->powerdown_item);
2304
2305	separator = gtk_separator_menu_item_new();
2306	gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
2307
2308	s->quit_item = gtk_menu_item_new_with_mnemonic(_("_Quit"));
2309	gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item),
2310	"<QEMU>/Machine/Quit");
2311	gtk_accel_map_add_entry("<QEMU>/Machine/Quit",
2312	GDK_KEY_q, HOTKEY_MODIFIERS);
2313	gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->quit_item);
2314
2315	return machine_menu;
2316	}
2317
2318	#if defined(CONFIG_OPENGL)
2319	static void gl_area_realize(GtkGLArea area, VirtualConsole vc)
2320	{
2321	gtk_gl_area_make_current(area);
2322	qemu_egl_display = eglGetCurrentDisplay();
2323	vc->gfx.has_dmabuf = qemu_egl_has_dmabuf();
2324	if (!vc->gfx.has_dmabuf) {
2325	error_report("GtkGLArea console lacks DMABUF support.");
2326	}
2327	}
2328	#endif
2329
2330	static bool gd_scale_valid(double scale)
2331	{
2332	return scale >= VC_SCALE_MIN && scale <= VC_SCALE_MAX;
2333	}
2334
2335	static VirtualConsole *
2336	add_gfx_console(GtkDisplayState s, QemuConsole con)
2337	{
2338	VirtualConsole *vc = g_new0(VirtualConsole, 1);
2339	const DisplayChangeListenerOps *ops = &dcl_ops;
2340
2341	g_ptr_array_add(s->vcs, vc);
2342	vc->label = qemu_console_get_label(con);
2343	vc->s = s;
2344	vc->gfx.preferred_scale = 1.0;
2345	if (s->opts->u.gtk.has_scale) {
2346	if (gd_scale_valid(s->opts->u.gtk.scale)) {
2347	vc->gfx.preferred_scale = s->opts->u.gtk.scale;
2348	} else {
2349	error_report("Invalid scale value %lf given, being ignored",
2350	s->opts->u.gtk.scale);
2351	s->opts->u.gtk.has_scale = false;
2352	}
2353	}
2354	vc->gfx.scale_x = vc->gfx.preferred_scale;
2355	vc->gfx.scale_y = vc->gfx.preferred_scale;
2356
2357	#if defined(CONFIG_OPENGL)
2358	if (display_opengl) {
2359	if (gtk_use_gl_area) {
2360	vc->gfx.drawing_area = gtk_gl_area_new();
2361	g_signal_connect(vc->gfx.drawing_area, "realize",
2362	G_CALLBACK(gl_area_realize), vc);
2363	ops = &dcl_gl_area_ops;
2364	vc->gfx.dgc.ops = &gl_area_ctx_ops;
2365	} else {
2366	#ifdef CONFIG_X11
2367	vc->gfx.drawing_area = gtk_drawing_area_new();
2368	/*
2369	* gtk_widget_set_double_buffered() was deprecated in 3.14.
2370	* It is required for opengl rendering on X11 though. A
2371	* proper replacement (native opengl support) is only
2372	* available in 3.16+. Silence the warning if possible.
2373	*/
2374	#pragma GCC diagnostic push
2375	#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2376	gtk_widget_set_double_buffered(vc->gfx.drawing_area, FALSE);
2377	#pragma GCC diagnostic pop
2378	ops = &dcl_egl_ops;
2379	vc->gfx.dgc.ops = &egl_ctx_ops;
2380	vc->gfx.has_dmabuf = qemu_egl_has_dmabuf();
2381	#else
2382	abort();
2383	#endif
2384	}
2385	} else
2386	#endif
2387	{
2388	vc->gfx.drawing_area = gtk_drawing_area_new();
2389	}
2390
2391
2392	gtk_widget_add_events(vc->gfx.drawing_area,
2393	GDK_POINTER_MOTION_MASK \|
2394	GDK_BUTTON_PRESS_MASK \|
2395	GDK_BUTTON_RELEASE_MASK \|
2396	GDK_BUTTON_MOTION_MASK \|
2397	GDK_TOUCH_MASK \|
2398	GDK_ENTER_NOTIFY_MASK \|
2399	GDK_LEAVE_NOTIFY_MASK \|
2400	GDK_SCROLL_MASK \|
2401	GDK_SMOOTH_SCROLL_MASK \|
2402	GDK_KEY_PRESS_MASK);
2403	gtk_widget_set_can_focus(vc->gfx.drawing_area, TRUE);
2404
2405	vc->type = GD_VC_GFX;
2406	vc->tab_item = vc->gfx.drawing_area;
2407	vc->focus = vc->gfx.drawing_area;
2408	gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook),
2409	vc->tab_item, gtk_label_new(vc->label));
2410
2411	vc->gfx.kbd = qkbd_state_init(con);
2412	if (display_opengl) {
2413	qemu_console_set_display_gl_ctx(con, &vc->gfx.dgc);
2414	}
2415	qemu_console_register_listener(con, &vc->gfx.dcl, ops);
2416
2417	gd_connect_vc_gfx_signals(vc);
2418	return vc;
2419	}
2420
2421	static void gd_vc_add_gfx(GtkDisplayState s, QemuConsole con)
2422	{
2423	VirtualConsole *vc;
2424	int i;
2425
2426	for (i = 0; i < (int)s->vcs->len; i++) {
2427	VirtualConsole *v = g_ptr_array_index(s->vcs, i);
2428	if (v->type == GD_VC_GFX && v->gfx.dcl.con == con) {
2429	return;
2430	}
2431	}
2432
2433	vc = add_gfx_console(s, con);
2434	gtk_widget_show_all(vc->tab_item);
2435	gtk_widget_realize(vc->gfx.drawing_area);
2436
2437	if (s->free_scale) {
2438	gd_update_windowsize(vc);
2439	}
2440
2441	gd_update_caption(s);
2442	gd_rebuild_vc_menu(s);
2443	}
2444
2445	static void gd_vc_remove_gfx(GtkDisplayState s, QemuConsole con)
2446	{
2447	VirtualConsole *vc = NULL;
2448	guint idx;
2449
2450	for (idx = 0; idx < s->vcs->len; idx++) {
2451	VirtualConsole *v = g_ptr_array_index(s->vcs, idx);
2452	if (v->type == GD_VC_GFX && v->gfx.dcl.con == con) {
2453	vc = v;
2454	break;
2455	}
2456	}
2457	if (!vc) {
2458	return;
2459	}
2460
2461	if (s->kbd_owner == vc) {
2462	gd_ungrab_keyboard(s);
2463	}
2464	if (s->ptr_owner == vc) {
2465	gd_ungrab_pointer(s);
2466	}
2467
2468	g_ptr_array_remove_index(s->vcs, idx);
2469	gd_rebuild_vc_menu(s);
2470	gd_update_caption(s);
2471	}
2472
2473	static void gd_console_notify(Notifier n, void data)
2474	{
2475	GtkDisplayState *s = container_of(n, GtkDisplayState, console_notifier);
2476	QemuConsoleEvent *event = data;
2477
2478	switch (event->type) {
2479	case QEMU_CONSOLE_ADDED:
2480	gd_vc_add_gfx(s, event->con);
2481	break;
2482	case QEMU_CONSOLE_REMOVED:
2483	gd_vc_remove_gfx(s, event->con);
2484	break;
2485	}
2486	}
2487
2488	static void gd_create_menu_view(GtkDisplayState s, DisplayOptions opts)
2489	{
2490	GtkWidget *view_menu;
2491	GtkWidget *separator;
2492	QemuConsole *con;
2493	bool zoom_to_fit = false;
2494	int vc, i;
2495
2496	view_menu = gtk_menu_new();
2497	s->view_menu = view_menu;
2498	gtk_menu_set_accel_group(GTK_MENU(view_menu), s->accel_group);
2499
2500	s->full_screen_item = gtk_menu_item_new_with_mnemonic(_("_Fullscreen"));
2501
2502	#if defined(CONFIG_VTE)
2503	s->copy_item = gtk_menu_item_new_with_mnemonic(_("_Copy"));
2504	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->copy_item);
2505	#endif
2506
2507	gtk_accel_group_connect(s->accel_group, GDK_KEY_f, HOTKEY_MODIFIERS, 0,
2508	g_cclosure_new_swap(G_CALLBACK(gd_accel_full_screen), s, NULL));
2509	gtk_accel_label_set_accel(
2510	GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(s->full_screen_item))),
2511	GDK_KEY_f, HOTKEY_MODIFIERS);
2512	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->full_screen_item);
2513
2514	separator = gtk_separator_menu_item_new();
2515	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
2516
2517	s->zoom_in_item = gtk_menu_item_new_with_mnemonic(_("Zoom _In"));
2518	gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_in_item),
2519	"<QEMU>/View/Zoom In");
2520	gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus,
2521	HOTKEY_MODIFIERS);
2522	gtk_accel_group_connect(s->accel_group, GDK_KEY_equal, HOTKEY_MODIFIERS, 0,
2523	g_cclosure_new_swap(G_CALLBACK(gd_accel_zoom_in), s, NULL));
2524	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_in_item);
2525
2526	s->zoom_out_item = gtk_menu_item_new_with_mnemonic(_("Zoom _Out"));
2527	gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_out_item),
2528	"<QEMU>/View/Zoom Out");
2529	gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus,
2530	HOTKEY_MODIFIERS);
2531	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_out_item);
2532
2533	s->zoom_fixed_item = gtk_menu_item_new_with_mnemonic(_("Best _Fit"));
2534	gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_fixed_item),
2535	"<QEMU>/View/Zoom Fixed");
2536	gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0,
2537	HOTKEY_MODIFIERS);
2538	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fixed_item);
2539
2540	s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit"));
2541	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fit_item);
2542
2543	separator = gtk_separator_menu_item_new();
2544	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
2545
2546	s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover"));
2547	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_on_hover_item);
2548
2549	s->grab_item = gtk_check_menu_item_new_with_mnemonic(_("_Grab Input"));
2550	gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->grab_item),
2551	"<QEMU>/View/Grab Input");
2552	gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g,
2553	HOTKEY_MODIFIERS);
2554	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_item);
2555
2556	separator = gtk_separator_menu_item_new();
2557	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
2558
2559	/* gfx */
2560	for (vc = 0;; vc++) {
2561	con = qemu_console_lookup_by_index(vc);
2562	if (!con) {
2563	break;
2564	}
2565	add_gfx_console(s, con);
2566	if (qemu_console_ui_info_supported(con)) {
2567	zoom_to_fit = true;
2568	}
2569	}
2570
2571	if (s->opts->u.gtk.has_zoom_to_fit) {
2572	zoom_to_fit = s->opts->u.gtk.zoom_to_fit;
2573	}
2574	if (zoom_to_fit) {
2575	gtk_menu_item_activate(GTK_MENU_ITEM(s->zoom_fit_item));
2576	s->free_scale = true;
2577	}
2578
2579	s->keep_aspect_ratio = true;
2580	if (s->opts->u.gtk.has_keep_aspect_ratio) {
2581	s->keep_aspect_ratio = s->opts->u.gtk.keep_aspect_ratio;
2582	}
2583
2584	for (i = 0; i < INPUT_EVENT_SLOTS_MAX; i++) {
2585	struct touch_slot *slot = &touch_slots[i];
2586	slot->tracking_id = -1;
2587	}
2588
2589	#if defined(CONFIG_VTE)
2590	/* vte */
2591	gd_vcs_init(s);
2592	#endif
2593
2594	s->vc_menu_separator = gtk_separator_menu_item_new();
2595	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->vc_menu_separator);
2596
2597	gd_rebuild_vc_menu(s);
2598
2599	s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs"));
2600	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_tabs_item);
2601
2602	s->untabify_item = gtk_menu_item_new_with_mnemonic(_("Detach Tab"));
2603	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->untabify_item);
2604
2605	s->show_menubar_item = gtk_check_menu_item_new_with_mnemonic(
2606	_("Show Menubar"));
2607	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->show_menubar_item),
2608	!opts->u.gtk.has_show_menubar \|\|
2609	opts->u.gtk.show_menubar);
2610	gtk_accel_group_connect(s->accel_group, GDK_KEY_m, HOTKEY_MODIFIERS, 0,
2611	g_cclosure_new_swap(G_CALLBACK(gd_accel_show_menubar), s, NULL));
2612	gtk_accel_label_set_accel(
2613	GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(s->show_menubar_item))),
2614	GDK_KEY_m, HOTKEY_MODIFIERS);
2615	gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_menubar_item);
2616	}
2617
2618	static void gd_create_menus(GtkDisplayState s, DisplayOptions opts)
2619	{
2620	GtkSettings *settings;
2621
2622	s->accel_group = gtk_accel_group_new();
2623	s->machine_menu = gd_create_menu_machine(s);
2624	gd_create_menu_view(s, opts);
2625
2626	s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine"));
2627	gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->machine_menu_item),
2628	s->machine_menu);
2629	gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->machine_menu_item);
2630
2631	s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View"));
2632	gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->view_menu_item), s->view_menu);
2633	gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item);
2634
2635	g_object_set_data(G_OBJECT(s->window), "accel_group", s->accel_group);
2636	gtk_window_add_accel_group(GTK_WINDOW(s->window), s->accel_group);
2637
2638	/* Disable the default "F10" menu shortcut. */
2639	settings = gtk_widget_get_settings(s->window);
2640	g_object_set(G_OBJECT(settings), "gtk-menu-bar-accel", "", NULL);
2641	}
2642
2643
2644	static void gd_vc_free(void *p)
2645	{
2646	VirtualConsole *vc = p;
2647
2648	switch (vc->type) {
2649	case GD_VC_GFX:
2650	qemu_console_unregister_listener(&vc->gfx.dcl);
2651	#if defined(CONFIG_OPENGL)
2652	if (display_opengl) {
2653	qemu_console_set_display_gl_ctx(vc->gfx.dcl.con, NULL);
2654	}
2655	if (vc->gfx.ectx) {
2656	eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
2657	vc->gfx.esurface, vc->gfx.ectx);
2658	} else if (gtk_use_gl_area) {
2659	gtk_gl_area_make_current(GTK_GL_AREA(vc->gfx.drawing_area));
2660	}
2661	if (vc->gfx.gls) {
2662	surface_gl_destroy_texture(vc->gfx.gls, vc->gfx.ds);
2663	qemu_gl_fini_shader(vc->gfx.gls);
2664	}
2665	egl_fb_destroy(&vc->gfx.guest_fb);
2666	egl_fb_destroy(&vc->gfx.win_fb);
2667	egl_fb_destroy(&vc->gfx.cursor_fb);
2668	if (vc->gfx.esurface) {
2669	eglDestroySurface(qemu_egl_display, vc->gfx.esurface);
2670	}
2671	if (vc->gfx.ectx) {
2672	eglDestroyContext(qemu_egl_display, vc->gfx.ectx);
2673	}
2674	#endif
2675	qkbd_state_free(vc->gfx.kbd);
2676	if (vc->gfx.surface) {
2677	cairo_surface_destroy(vc->gfx.surface);
2678	}
2679	if (vc->gfx.convert) {
2680	pixman_image_unref(vc->gfx.convert);
2681	}
2682	break;
2683	case GD_VC_VTE:
2684	#ifdef CONFIG_VTE
2685	fifo8_destroy(&vc->vte.out_fifo);
2686	#endif
2687	break;
2688	}
2689
2690	if (vc->window) {
2691	gtk_widget_destroy(vc->window);
2692	} else if (vc->tab_item) {
2693	gtk_widget_destroy(vc->tab_item);
2694	}
2695	if (vc->menu_item) {
2696	gtk_widget_destroy(vc->menu_item);
2697	}
2698	g_free(vc->label);
2699	g_free(vc);
2700	}
2701
2702	static GtkDisplayState *gtk_display_state;
2703	static gboolean gtkinit;
2704
2705	static void gtk_display_init(DisplayState ds, DisplayOptions opts)
2706	{
2707	VirtualConsole *vc;
2708
2709	GtkDisplayState *s;
2710	GdkDisplay *window_display;
2711	GtkIconTheme *theme;
2712	char *dir;
2713	int idx;
2714
2715	if (!gtkinit) {
2716	fprintf(stderr, "gtk initialization failed\n");
2717	exit(1);
2718	}
2719	assert(opts->type == DISPLAY_TYPE_GTK);
2720	s = g_malloc0(sizeof(*s));
2721	gtk_display_state = s;
2722	s->vcs = g_ptr_array_new_with_free_func(gd_vc_free);
2723	s->opts = opts;
2724
2725	theme = gtk_icon_theme_get_default();
2726	dir = get_relocated_path(CONFIG_QEMU_ICONDIR);
2727	gtk_icon_theme_prepend_search_path(theme, dir);
2728	g_free(dir);
2729	g_set_prgname("qemu");
2730
2731	s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2732	s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
2733	s->notebook = gtk_notebook_new();
2734	s->menu_bar = gtk_menu_bar_new();
2735
2736	s->free_scale = FALSE;
2737
2738	/* Mostly LC_MESSAGES only. See early_gtk_display_init() for details. For
2739	* LC_CTYPE, we need to make sure that non-ASCII characters are considered
2740	* printable, but without changing any of the character classes to make
2741	* sure that we don't accidentally break implicit assumptions. */
2742	setlocale(LC_MESSAGES, "");
2743	setlocale(LC_CTYPE, "C.UTF-8");
2744	dir = get_relocated_path(CONFIG_QEMU_LOCALEDIR);
2745	bindtextdomain("qemu", dir);
2746	g_free(dir);
2747	bind_textdomain_codeset("qemu", "UTF-8");
2748	textdomain("qemu");
2749
2750	window_display = gtk_widget_get_display(s->window);
2751	if (s->opts->has_show_cursor && s->opts->show_cursor) {
2752	s->null_cursor = NULL; /* default pointer */
2753	} else {
2754	s->null_cursor = gdk_cursor_new_for_display(window_display,
2755	GDK_BLANK_CURSOR);
2756	}
2757
2758	s->mouse_mode_notifier.notify = gd_mouse_mode_change;
2759	qemu_add_mouse_mode_change_notifier(&s->mouse_mode_notifier);
2760	s->vmse = qemu_add_vm_change_state_handler(gd_change_runstate, s);
2761
2762	gtk_window_set_icon_name(GTK_WINDOW(s->window), "qemu");
2763
2764	gd_create_menus(s, opts);
2765
2766	s->console_notifier.notify = gd_console_notify;
2767	qemu_console_add_notifier(&s->console_notifier);
2768
2769	gd_connect_signals(s);
2770
2771	gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
2772	gtk_notebook_set_show_border(GTK_NOTEBOOK(s->notebook), FALSE);
2773
2774	gd_update_caption(s);
2775
2776	gtk_box_pack_start(GTK_BOX(s->vbox), s->menu_bar, FALSE, TRUE, 0);
2777	gtk_box_pack_start(GTK_BOX(s->vbox), s->notebook, TRUE, TRUE, 0);
2778
2779	gtk_container_add(GTK_CONTAINER(s->window), s->vbox);
2780
2781	gtk_widget_show_all(s->window);
2782
2783	for (idx = 0; idx < s->vcs->len; idx++) {
2784	VirtualConsole *v = g_ptr_array_index(s->vcs, idx);
2785	if (v->type == GD_VC_GFX) {
2786	gtk_widget_realize(v->gfx.drawing_area);
2787	}
2788	}
2789
2790	if (opts->u.gtk.has_show_menubar &&
2791	!opts->u.gtk.show_menubar) {
2792	gtk_widget_hide(s->menu_bar);
2793	}
2794
2795	vc = gd_vc_find_current(s);
2796	gtk_widget_set_sensitive(s->view_menu, vc != NULL);
2797	#ifdef CONFIG_VTE
2798	gtk_widget_set_sensitive(s->copy_item,
2799	vc && vc->type == GD_VC_VTE);
2800	#endif
2801
2802	if (opts->has_full_screen &&
2803	opts->full_screen) {
2804	gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item));
2805	}
2806	if (opts->u.gtk.has_grab_on_hover &&
2807	opts->u.gtk.grab_on_hover) {
2808	gtk_menu_item_activate(GTK_MENU_ITEM(s->grab_on_hover_item));
2809	}
2810	if (opts->u.gtk.has_show_tabs &&
2811	opts->u.gtk.show_tabs) {
2812	gtk_menu_item_activate(GTK_MENU_ITEM(s->show_tabs_item));
2813	}
2814
2815	if (opts->u.gtk.has_clipboard &&
2816	opts->u.gtk.clipboard) {
2817	gd_clipboard_init(s);
2818	}
2819
2820	/* GTK's event polling must happen on the main thread. */
2821	qemu_main = NULL;
2822	}
2823
2824	static void early_gtk_display_init(DisplayOptions *opts)
2825	{
2826	/* The QEMU code relies on the assumption that it's always run in
2827	* the C locale. Therefore it is not prepared to deal with
2828	* operations that produce different results depending on the
2829	* locale, such as printf's formatting of decimal numbers, and
2830	* possibly others.
2831	*
2832	* Since GTK+ calls setlocale() by default -importing the locale
2833	* settings from the environment- we must prevent it from doing so
2834	* using gtk_disable_setlocale().
2835	*
2836	* QEMU's GTK+ UI, however, _does_ have translations for some of
2837	* the menu items. As a trade-off between a functionally correct
2838	* QEMU and a fully internationalized UI we support importing
2839	* LC_MESSAGES from the environment (see the setlocale() call
2840	* earlier in this file). This allows us to display translated
2841	* messages leaving everything else untouched.
2842	*/
2843	gtk_disable_setlocale();
2844	gtkinit = gtk_init_check(NULL, NULL);
2845	if (!gtkinit) {
2846	/* don't exit yet, that'll break -help */
2847	return;
2848	}
2849
2850	assert(opts->type == DISPLAY_TYPE_GTK);
2851	if (opts->has_gl && opts->gl != DISPLAY_GL_MODE_OFF) {
2852	#if defined(CONFIG_OPENGL)
2853	#if defined(GDK_WINDOWING_WAYLAND)
2854	if (GDK_IS_WAYLAND_DISPLAY(gdk_display_get_default())) {
2855	gtk_use_gl_area = true;
2856	gtk_gl_area_init();
2857	} else
2858	#endif
2859	#if defined(GDK_WINDOWING_WIN32)
2860	if (GDK_IS_WIN32_DISPLAY(gdk_display_get_default())) {
2861	gtk_use_gl_area = true;
2862	gtk_gl_area_init();
2863	} else
2864	#endif
2865	{
2866	#ifdef CONFIG_X11
2867	DisplayGLMode mode = opts->has_gl ? opts->gl : DISPLAY_GL_MODE_ON;
2868	gtk_egl_init(mode);
2869	#endif
2870	}
2871	#endif
2872	}
2873
2874	keycode_map = gd_get_keymap(&keycode_maplen, &keycode_xorgevdev);
2875
2876	#if defined(CONFIG_VTE)
2877	type_register_static(&char_gd_vc_type_info);
2878	#endif
2879	}
2880
2881	static void gtk_display_cleanup(void)
2882	{
2883	GtkDisplayState *s = gtk_display_state;
2884
2885	if (!s) {
2886	return;
2887	}
2888	qemu_del_vm_change_state_handler(s->vmse);
2889	qemu_console_remove_notifier(&s->console_notifier);
2890	qemu_remove_mouse_mode_change_notifier(&s->mouse_mode_notifier);
2891	gd_clipboard_cleanup(s);
2892	g_signal_handlers_disconnect_by_func(s->notebook,
2893	G_CALLBACK(gd_change_page), s);
2894	g_clear_pointer(&s->vcs, g_ptr_array_unref);
2895	g_clear_pointer(&s->window, gtk_widget_destroy);
2896	g_clear_object(&s->null_cursor);
2897	g_clear_pointer(&gtk_display_state, g_free);
2898	}
2899
2900	static QemuDisplay qemu_display_gtk = {
2901	.type = DISPLAY_TYPE_GTK,
2902	.early_init = early_gtk_display_init,
2903	.init = gtk_display_init,
2904	.cleanup = gtk_display_cleanup,
2905	.vc = "vc",
2906	};
2907
2908	static void register_gtk(void)
2909	{
2910	qemu_display_register(&qemu_display_gtk);
2911	}
2912
2913	type_init(register_gtk);
2914
2915	#ifdef CONFIG_OPENGL
2916	module_dep("ui-opengl");
2917	#endif