4 * Copyright IBM, Corp. 2012
7 * Anthony Liguori <aliguori@us.ibm.com>
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.
12 * Portions from gtk-vnc:
16 * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
17 * Copyright (C) 2009-2010 Daniel P. Berrange <dan@berrange.com>
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.
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.
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
34 #define GETTEXT_PACKAGE "qemu"
35 #define LOCALEDIR "po"
37 #include "qemu-common.h"
39 #include "ui/console.h"
42 #include <glib/gi18n.h>
44 #if defined(CONFIG_VTE)
51 #include "sysemu/sysemu.h"
52 #include "qmp-commands.h"
55 #include "sysemu/char.h"
56 #include "qom/object.h"
59 #define VC_WINDOW_X_MIN 320
60 #define VC_WINDOW_Y_MIN 240
61 #define VC_TERM_X_MIN 80
62 #define VC_TERM_Y_MIN 25
63 #define VC_SCALE_MIN 0.25
64 #define VC_SCALE_STEP 0.25
66 #if !defined(CONFIG_VTE)
67 # define VTE_CHECK_VERSION(a, b, c) 0
70 #if defined(CONFIG_VTE) && !GTK_CHECK_VERSION(3, 0, 0)
72 * The gtk2 vte terminal widget seriously messes up the window resize
73 * for some reason. You basically can't make the qemu window smaller
74 * any more because the toplevel window geoemtry hints are overridden.
76 * Workaround that by hiding all vte widgets, except the one in the
79 * Luckily everything works smooth in gtk3.
81 # define VTE_RESIZE_HACK 1
84 #if !GTK_CHECK_VERSION(2, 20, 0)
85 #define gtk_widget_get_realized(widget) GTK_WIDGET_REALIZED(widget)
88 #ifndef GDK_IS_X11_DISPLAY
89 #define GDK_IS_X11_DISPLAY(dpy) (dpy == dpy)
91 #ifndef GDK_IS_WIN32_DISPLAY
92 #define GDK_IS_WIN32_DISPLAY(dpy) (dpy == dpy)
96 #define GDK_KEY_0 GDK_0
97 #define GDK_KEY_1 GDK_1
98 #define GDK_KEY_2 GDK_2
99 #define GDK_KEY_f GDK_f
100 #define GDK_KEY_g GDK_g
101 #define GDK_KEY_q GDK_q
102 #define GDK_KEY_plus GDK_plus
103 #define GDK_KEY_minus GDK_minus
104 #define GDK_KEY_Pause GDK_Pause
107 #define HOTKEY_MODIFIERS (GDK_CONTROL_MASK | GDK_MOD1_MASK)
109 static const int modifier_keycode
[] = {
110 /* shift, control, alt keys, meta keys, both left & right */
111 0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8, 0xdb, 0xdd,
114 struct GtkDisplayState
{
119 GtkAccelGroup
*accel_group
;
121 GtkWidget
*machine_menu_item
;
122 GtkWidget
*machine_menu
;
123 GtkWidget
*pause_item
;
124 GtkWidget
*reset_item
;
125 GtkWidget
*powerdown_item
;
126 GtkWidget
*quit_item
;
128 GtkWidget
*view_menu_item
;
129 GtkWidget
*view_menu
;
130 GtkWidget
*full_screen_item
;
131 GtkWidget
*zoom_in_item
;
132 GtkWidget
*zoom_out_item
;
133 GtkWidget
*zoom_fixed_item
;
134 GtkWidget
*zoom_fit_item
;
135 GtkWidget
*grab_item
;
136 GtkWidget
*grab_on_hover_item
;
139 VirtualConsole vc
[MAX_VCS
];
141 GtkWidget
*show_tabs_item
;
142 GtkWidget
*untabify_item
;
152 VirtualConsole
*kbd_owner
;
153 VirtualConsole
*ptr_owner
;
155 gboolean full_screen
;
157 GdkCursor
*null_cursor
;
158 Notifier mouse_mode_notifier
;
161 bool external_pause_update
;
163 bool modifier_pressed
[ARRAY_SIZE(modifier_keycode
)];
168 static void gd_grab_pointer(VirtualConsole
*vc
, const char *reason
);
169 static void gd_ungrab_pointer(GtkDisplayState
*s
);
170 static void gd_grab_keyboard(VirtualConsole
*vc
, const char *reason
);
171 static void gd_ungrab_keyboard(GtkDisplayState
*s
);
173 /** Utility Functions **/
175 static VirtualConsole
*gd_vc_find_by_menu(GtkDisplayState
*s
)
180 for (i
= 0; i
< s
->nb_vcs
; i
++) {
182 if (gtk_check_menu_item_get_active
183 (GTK_CHECK_MENU_ITEM(vc
->menu_item
))) {
190 static VirtualConsole
*gd_vc_find_by_page(GtkDisplayState
*s
, gint page
)
195 for (i
= 0; i
< s
->nb_vcs
; i
++) {
197 p
= gtk_notebook_page_num(GTK_NOTEBOOK(s
->notebook
), vc
->tab_item
);
205 static VirtualConsole
*gd_vc_find_current(GtkDisplayState
*s
)
209 page
= gtk_notebook_get_current_page(GTK_NOTEBOOK(s
->notebook
));
210 return gd_vc_find_by_page(s
, page
);
213 static bool gd_is_grab_active(GtkDisplayState
*s
)
215 return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s
->grab_item
));
218 static bool gd_grab_on_hover(GtkDisplayState
*s
)
220 return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s
->grab_on_hover_item
));
223 static void gd_update_cursor(VirtualConsole
*vc
)
225 GtkDisplayState
*s
= vc
->s
;
228 if (vc
->type
!= GD_VC_GFX
||
229 !qemu_console_is_graphic(vc
->gfx
.dcl
.con
)) {
233 if (!gtk_widget_get_realized(vc
->gfx
.drawing_area
)) {
237 window
= gtk_widget_get_window(GTK_WIDGET(vc
->gfx
.drawing_area
));
238 if (s
->full_screen
|| qemu_input_is_absolute() || s
->ptr_owner
== vc
) {
239 gdk_window_set_cursor(window
, s
->null_cursor
);
241 gdk_window_set_cursor(window
, NULL
);
245 static void gd_update_caption(GtkDisplayState
*s
)
247 const char *status
= "";
250 const char *grab
= "";
251 bool is_paused
= !runstate_is_running();
255 prefix
= g_strdup_printf("QEMU (%s)", qemu_name
);
257 prefix
= g_strdup_printf("QEMU");
260 if (s
->ptr_owner
!= NULL
&&
261 s
->ptr_owner
->window
== NULL
) {
262 grab
= _(" - Press Ctrl+Alt+G to release grab");
266 status
= _(" [Paused]");
268 s
->external_pause_update
= true;
269 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s
->pause_item
),
271 s
->external_pause_update
= false;
273 title
= g_strdup_printf("%s%s%s", prefix
, status
, grab
);
274 gtk_window_set_title(GTK_WINDOW(s
->window
), title
);
277 for (i
= 0; i
< s
->nb_vcs
; i
++) {
278 VirtualConsole
*vc
= &s
->vc
[i
];
283 title
= g_strdup_printf("%s: %s%s%s", prefix
, vc
->label
,
284 vc
== s
->kbd_owner
? " +kbd" : "",
285 vc
== s
->ptr_owner
? " +ptr" : "");
286 gtk_window_set_title(GTK_WINDOW(vc
->window
), title
);
293 static void gd_update_geometry_hints(VirtualConsole
*vc
)
295 GtkDisplayState
*s
= vc
->s
;
296 GdkWindowHints mask
= 0;
297 GdkGeometry geo
= {};
298 GtkWidget
*geo_widget
= NULL
;
299 GtkWindow
*geo_window
;
301 if (vc
->type
== GD_VC_GFX
) {
306 geo
.min_width
= surface_width(vc
->gfx
.ds
) * VC_SCALE_MIN
;
307 geo
.min_height
= surface_height(vc
->gfx
.ds
) * VC_SCALE_MIN
;
308 mask
|= GDK_HINT_MIN_SIZE
;
310 geo
.min_width
= surface_width(vc
->gfx
.ds
) * vc
->gfx
.scale_x
;
311 geo
.min_height
= surface_height(vc
->gfx
.ds
) * vc
->gfx
.scale_y
;
312 mask
|= GDK_HINT_MIN_SIZE
;
314 geo_widget
= vc
->gfx
.drawing_area
;
315 gtk_widget_set_size_request(geo_widget
, geo
.min_width
, geo
.min_height
);
317 #if defined(CONFIG_VTE)
318 } else if (vc
->type
== GD_VC_VTE
) {
319 VteTerminal
*term
= VTE_TERMINAL(vc
->vte
.terminal
);
322 geo
.width_inc
= vte_terminal_get_char_width(term
);
323 geo
.height_inc
= vte_terminal_get_char_height(term
);
324 mask
|= GDK_HINT_RESIZE_INC
;
325 geo
.base_width
= geo
.width_inc
;
326 geo
.base_height
= geo
.height_inc
;
327 mask
|= GDK_HINT_BASE_SIZE
;
328 geo
.min_width
= geo
.width_inc
* VC_TERM_X_MIN
;
329 geo
.min_height
= geo
.height_inc
* VC_TERM_Y_MIN
;
330 mask
|= GDK_HINT_MIN_SIZE
;
331 gtk_widget_style_get(vc
->vte
.terminal
, "inner-border", &ib
, NULL
);
332 geo
.base_width
+= ib
->left
+ ib
->right
;
333 geo
.base_height
+= ib
->top
+ ib
->bottom
;
334 geo
.min_width
+= ib
->left
+ ib
->right
;
335 geo
.min_height
+= ib
->top
+ ib
->bottom
;
336 geo_widget
= vc
->vte
.terminal
;
340 geo_window
= GTK_WINDOW(vc
->window
? vc
->window
: s
->window
);
341 gtk_window_set_geometry_hints(geo_window
, geo_widget
, &geo
, mask
);
344 void gd_update_windowsize(VirtualConsole
*vc
)
346 GtkDisplayState
*s
= vc
->s
;
348 gd_update_geometry_hints(vc
);
350 if (vc
->type
== GD_VC_GFX
&& !s
->full_screen
&& !s
->free_scale
) {
351 gtk_window_resize(GTK_WINDOW(vc
->window
? vc
->window
: s
->window
),
352 VC_WINDOW_X_MIN
, VC_WINDOW_Y_MIN
);
356 static void gd_update_full_redraw(VirtualConsole
*vc
)
358 GtkWidget
*area
= vc
->gfx
.drawing_area
;
360 gdk_drawable_get_size(gtk_widget_get_window(area
), &ww
, &wh
);
361 gtk_widget_queue_draw_area(area
, 0, 0, ww
, wh
);
364 static void gtk_release_modifiers(GtkDisplayState
*s
)
366 VirtualConsole
*vc
= gd_vc_find_current(s
);
369 if (vc
->type
!= GD_VC_GFX
||
370 !qemu_console_is_graphic(vc
->gfx
.dcl
.con
)) {
373 for (i
= 0; i
< ARRAY_SIZE(modifier_keycode
); i
++) {
374 keycode
= modifier_keycode
[i
];
375 if (!s
->modifier_pressed
[i
]) {
378 qemu_input_event_send_key_number(vc
->gfx
.dcl
.con
, keycode
, false);
379 s
->modifier_pressed
[i
] = false;
383 static void gd_widget_reparent(GtkWidget
*from
, GtkWidget
*to
,
386 g_object_ref(G_OBJECT(widget
));
387 gtk_container_remove(GTK_CONTAINER(from
), widget
);
388 gtk_container_add(GTK_CONTAINER(to
), widget
);
389 g_object_unref(G_OBJECT(widget
));
392 /** DisplayState Callbacks **/
394 static void gd_update(DisplayChangeListener
*dcl
,
395 int x
, int y
, int w
, int h
)
397 VirtualConsole
*vc
= container_of(dcl
, VirtualConsole
, gfx
.dcl
);
404 trace_gd_update(vc
->label
, x
, y
, w
, h
);
406 if (!gtk_widget_get_realized(vc
->gfx
.drawing_area
)) {
410 if (vc
->gfx
.convert
) {
411 pixman_image_composite(PIXMAN_OP_SRC
, vc
->gfx
.ds
->image
,
412 NULL
, vc
->gfx
.convert
,
413 x
, y
, 0, 0, x
, y
, w
, h
);
416 x1
= floor(x
* vc
->gfx
.scale_x
);
417 y1
= floor(y
* vc
->gfx
.scale_y
);
419 x2
= ceil(x
* vc
->gfx
.scale_x
+ w
* vc
->gfx
.scale_x
);
420 y2
= ceil(y
* vc
->gfx
.scale_y
+ h
* vc
->gfx
.scale_y
);
422 fbw
= surface_width(vc
->gfx
.ds
) * vc
->gfx
.scale_x
;
423 fbh
= surface_height(vc
->gfx
.ds
) * vc
->gfx
.scale_y
;
425 win
= gtk_widget_get_window(vc
->gfx
.drawing_area
);
429 gdk_drawable_get_size(win
, &ww
, &wh
);
439 gtk_widget_queue_draw_area(vc
->gfx
.drawing_area
,
440 mx
+ x1
, my
+ y1
, (x2
- x1
), (y2
- y1
));
443 static void gd_refresh(DisplayChangeListener
*dcl
)
445 graphic_hw_update(dcl
->con
);
448 #if GTK_CHECK_VERSION(3, 0, 0)
449 static void gd_mouse_set(DisplayChangeListener
*dcl
,
450 int x
, int y
, int visible
)
452 VirtualConsole
*vc
= container_of(dcl
, VirtualConsole
, gfx
.dcl
);
454 GdkDeviceManager
*mgr
;
457 if (qemu_input_is_absolute()) {
461 dpy
= gtk_widget_get_display(vc
->gfx
.drawing_area
);
462 mgr
= gdk_display_get_device_manager(dpy
);
463 gdk_window_get_root_coords(gtk_widget_get_window(vc
->gfx
.drawing_area
),
464 x
, y
, &x_root
, &y_root
);
465 gdk_device_warp(gdk_device_manager_get_client_pointer(mgr
),
466 gtk_widget_get_screen(vc
->gfx
.drawing_area
),
472 static void gd_mouse_set(DisplayChangeListener
*dcl
,
473 int x
, int y
, int visible
)
475 VirtualConsole
*vc
= container_of(dcl
, VirtualConsole
, gfx
.dcl
);
478 if (qemu_input_is_absolute()) {
482 gdk_window_get_root_coords(gtk_widget_get_window(vc
->gfx
.drawing_area
),
483 x
, y
, &x_root
, &y_root
);
484 gdk_display_warp_pointer(gtk_widget_get_display(vc
->gfx
.drawing_area
),
485 gtk_widget_get_screen(vc
->gfx
.drawing_area
),
490 static void gd_cursor_define(DisplayChangeListener
*dcl
,
493 VirtualConsole
*vc
= container_of(dcl
, VirtualConsole
, gfx
.dcl
);
497 if (!gtk_widget_get_realized(vc
->gfx
.drawing_area
)) {
501 pixbuf
= gdk_pixbuf_new_from_data((guchar
*)(c
->data
),
502 GDK_COLORSPACE_RGB
, true, 8,
503 c
->width
, c
->height
, c
->width
* 4,
505 cursor
= gdk_cursor_new_from_pixbuf
506 (gtk_widget_get_display(vc
->gfx
.drawing_area
),
507 pixbuf
, c
->hot_x
, c
->hot_y
);
508 gdk_window_set_cursor(gtk_widget_get_window(vc
->gfx
.drawing_area
), cursor
);
509 g_object_unref(pixbuf
);
510 #if !GTK_CHECK_VERSION(3, 0, 0)
511 gdk_cursor_unref(cursor
);
513 g_object_unref(cursor
);
517 static void gd_switch(DisplayChangeListener
*dcl
,
518 DisplaySurface
*surface
)
520 VirtualConsole
*vc
= container_of(dcl
, VirtualConsole
, gfx
.dcl
);
523 trace_gd_switch(vc
->label
,
524 surface
? surface_width(surface
) : 0,
525 surface
? surface_height(surface
) : 0);
527 if (vc
->gfx
.surface
) {
528 cairo_surface_destroy(vc
->gfx
.surface
);
529 vc
->gfx
.surface
= NULL
;
531 if (vc
->gfx
.convert
) {
532 pixman_image_unref(vc
->gfx
.convert
);
533 vc
->gfx
.convert
= NULL
;
536 if (vc
->gfx
.ds
&& surface
&&
537 surface_width(vc
->gfx
.ds
) == surface_width(surface
) &&
538 surface_height(vc
->gfx
.ds
) == surface_height(surface
)) {
541 vc
->gfx
.ds
= surface
;
547 if (surface
->format
== PIXMAN_x8r8g8b8
) {
549 * PIXMAN_x8r8g8b8 == CAIRO_FORMAT_RGB24
551 * No need to convert, use surface directly. Should be the
552 * common case as this is qemu_default_pixelformat(32) too.
554 vc
->gfx
.surface
= cairo_image_surface_create_for_data
555 (surface_data(surface
),
557 surface_width(surface
),
558 surface_height(surface
),
559 surface_stride(surface
));
561 /* Must convert surface, use pixman to do it. */
562 vc
->gfx
.convert
= pixman_image_create_bits(PIXMAN_x8r8g8b8
,
563 surface_width(surface
),
564 surface_height(surface
),
566 vc
->gfx
.surface
= cairo_image_surface_create_for_data
567 ((void *)pixman_image_get_data(vc
->gfx
.convert
),
569 pixman_image_get_width(vc
->gfx
.convert
),
570 pixman_image_get_height(vc
->gfx
.convert
),
571 pixman_image_get_stride(vc
->gfx
.convert
));
572 pixman_image_composite(PIXMAN_OP_SRC
, vc
->gfx
.ds
->image
,
573 NULL
, vc
->gfx
.convert
,
575 pixman_image_get_width(vc
->gfx
.convert
),
576 pixman_image_get_height(vc
->gfx
.convert
));
580 gd_update_windowsize(vc
);
582 gd_update_full_redraw(vc
);
586 static const DisplayChangeListenerOps dcl_ops
= {
588 .dpy_gfx_update
= gd_update
,
589 .dpy_gfx_switch
= gd_switch
,
590 .dpy_gfx_check_format
= qemu_pixman_check_format
,
591 .dpy_refresh
= gd_refresh
,
592 .dpy_mouse_set
= gd_mouse_set
,
593 .dpy_cursor_define
= gd_cursor_define
,
597 #if defined(CONFIG_OPENGL)
599 /** DisplayState Callbacks (opengl version) **/
601 static const DisplayChangeListenerOps dcl_egl_ops
= {
602 .dpy_name
= "gtk-egl",
603 .dpy_gfx_update
= gd_egl_update
,
604 .dpy_gfx_switch
= gd_egl_switch
,
605 .dpy_gfx_check_format
= console_gl_check_format
,
606 .dpy_refresh
= gd_egl_refresh
,
607 .dpy_mouse_set
= gd_mouse_set
,
608 .dpy_cursor_define
= gd_cursor_define
,
615 static void gd_change_runstate(void *opaque
, int running
, RunState state
)
617 GtkDisplayState
*s
= opaque
;
619 gd_update_caption(s
);
622 static void gd_mouse_mode_change(Notifier
*notify
, void *data
)
627 s
= container_of(notify
, GtkDisplayState
, mouse_mode_notifier
);
628 /* release the grab at switching to absolute mode */
629 if (qemu_input_is_absolute() && gd_is_grab_active(s
)) {
630 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s
->grab_item
),
633 for (i
= 0; i
< s
->nb_vcs
; i
++) {
634 VirtualConsole
*vc
= &s
->vc
[i
];
635 gd_update_cursor(vc
);
641 static gboolean
gd_window_close(GtkWidget
*widget
, GdkEvent
*event
,
644 GtkDisplayState
*s
= opaque
;
648 for (i
= 0; i
< s
->nb_vcs
; i
++) {
649 if (s
->vc
[i
].type
!= GD_VC_GFX
) {
652 unregister_displaychangelistener(&s
->vc
[i
].gfx
.dcl
);
661 static gboolean
gd_draw_event(GtkWidget
*widget
, cairo_t
*cr
, void *opaque
)
663 VirtualConsole
*vc
= opaque
;
664 GtkDisplayState
*s
= vc
->s
;
669 #if defined(CONFIG_OPENGL)
676 if (!gtk_widget_get_realized(widget
)) {
683 fbw
= surface_width(vc
->gfx
.ds
);
684 fbh
= surface_height(vc
->gfx
.ds
);
686 gdk_drawable_get_size(gtk_widget_get_window(widget
), &ww
, &wh
);
688 if (s
->full_screen
) {
689 vc
->gfx
.scale_x
= (double)ww
/ fbw
;
690 vc
->gfx
.scale_y
= (double)wh
/ fbh
;
691 } else if (s
->free_scale
) {
694 sx
= (double)ww
/ fbw
;
695 sy
= (double)wh
/ fbh
;
697 vc
->gfx
.scale_x
= vc
->gfx
.scale_y
= MIN(sx
, sy
);
700 fbw
*= vc
->gfx
.scale_x
;
701 fbh
*= vc
->gfx
.scale_y
;
711 cairo_rectangle(cr
, 0, 0, ww
, wh
);
713 /* Optionally cut out the inner area where the pixmap
714 will be drawn. This avoids 'flashing' since we're
715 not double-buffering. Note we're using the undocumented
716 behaviour of drawing the rectangle from right to left
717 to cut out the whole */
718 cairo_rectangle(cr
, mx
+ fbw
, my
,
722 cairo_scale(cr
, vc
->gfx
.scale_x
, vc
->gfx
.scale_y
);
723 cairo_set_source_surface(cr
, vc
->gfx
.surface
,
724 mx
/ vc
->gfx
.scale_x
, my
/ vc
->gfx
.scale_y
);
730 #if !GTK_CHECK_VERSION(3, 0, 0)
731 static gboolean
gd_expose_event(GtkWidget
*widget
, GdkEventExpose
*expose
,
737 cr
= gdk_cairo_create(gtk_widget_get_window(widget
));
742 expose
->area
.height
);
745 ret
= gd_draw_event(widget
, cr
, opaque
);
753 static gboolean
gd_motion_event(GtkWidget
*widget
, GdkEventMotion
*motion
,
756 VirtualConsole
*vc
= opaque
;
757 GtkDisplayState
*s
= vc
->s
;
767 fbw
= surface_width(vc
->gfx
.ds
) * vc
->gfx
.scale_x
;
768 fbh
= surface_height(vc
->gfx
.ds
) * vc
->gfx
.scale_y
;
770 gdk_drawable_get_size(gtk_widget_get_window(vc
->gfx
.drawing_area
),
781 x
= (motion
->x
- mx
) / vc
->gfx
.scale_x
;
782 y
= (motion
->y
- my
) / vc
->gfx
.scale_y
;
784 if (qemu_input_is_absolute()) {
785 if (x
< 0 || y
< 0 ||
786 x
>= surface_width(vc
->gfx
.ds
) ||
787 y
>= surface_height(vc
->gfx
.ds
)) {
790 qemu_input_queue_abs(vc
->gfx
.dcl
.con
, INPUT_AXIS_X
, x
,
791 surface_width(vc
->gfx
.ds
));
792 qemu_input_queue_abs(vc
->gfx
.dcl
.con
, INPUT_AXIS_Y
, y
,
793 surface_height(vc
->gfx
.ds
));
794 qemu_input_event_sync();
795 } else if (s
->last_set
&& s
->ptr_owner
== vc
) {
796 qemu_input_queue_rel(vc
->gfx
.dcl
.con
, INPUT_AXIS_X
, x
- s
->last_x
);
797 qemu_input_queue_rel(vc
->gfx
.dcl
.con
, INPUT_AXIS_Y
, y
- s
->last_y
);
798 qemu_input_event_sync();
804 if (!qemu_input_is_absolute() && s
->ptr_owner
== vc
) {
805 GdkScreen
*screen
= gtk_widget_get_screen(vc
->gfx
.drawing_area
);
806 int x
= (int)motion
->x_root
;
807 int y
= (int)motion
->y_root
;
809 /* In relative mode check to see if client pointer hit
810 * one of the screen edges, and if so move it back by
811 * 200 pixels. This is important because the pointer
812 * in the server doesn't correspond 1-for-1, and so
813 * may still be only half way across the screen. Without
814 * this warp, the server pointer would thus appear to hit
815 * an invisible wall */
822 if (x
== (gdk_screen_get_width(screen
) - 1)) {
825 if (y
== (gdk_screen_get_height(screen
) - 1)) {
829 if (x
!= (int)motion
->x_root
|| y
!= (int)motion
->y_root
) {
830 #if GTK_CHECK_VERSION(3, 0, 0)
831 GdkDevice
*dev
= gdk_event_get_device((GdkEvent
*)motion
);
832 gdk_device_warp(dev
, screen
, x
, y
);
834 GdkDisplay
*display
= gtk_widget_get_display(widget
);
835 gdk_display_warp_pointer(display
, screen
, x
, y
);
844 static gboolean
gd_button_event(GtkWidget
*widget
, GdkEventButton
*button
,
847 VirtualConsole
*vc
= opaque
;
848 GtkDisplayState
*s
= vc
->s
;
851 /* implicitly grab the input at the first click in the relative mode */
852 if (button
->button
== 1 && button
->type
== GDK_BUTTON_PRESS
&&
853 !qemu_input_is_absolute() && s
->ptr_owner
!= vc
) {
855 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s
->grab_item
),
858 gd_grab_pointer(vc
, "relative-mode-click");
863 if (button
->button
== 1) {
864 btn
= INPUT_BUTTON_LEFT
;
865 } else if (button
->button
== 2) {
866 btn
= INPUT_BUTTON_MIDDLE
;
867 } else if (button
->button
== 3) {
868 btn
= INPUT_BUTTON_RIGHT
;
873 qemu_input_queue_btn(vc
->gfx
.dcl
.con
, btn
,
874 button
->type
== GDK_BUTTON_PRESS
);
875 qemu_input_event_sync();
879 static gboolean
gd_scroll_event(GtkWidget
*widget
, GdkEventScroll
*scroll
,
882 VirtualConsole
*vc
= opaque
;
885 if (scroll
->direction
== GDK_SCROLL_UP
) {
886 btn
= INPUT_BUTTON_WHEEL_UP
;
887 } else if (scroll
->direction
== GDK_SCROLL_DOWN
) {
888 btn
= INPUT_BUTTON_WHEEL_DOWN
;
893 qemu_input_queue_btn(vc
->gfx
.dcl
.con
, btn
, true);
894 qemu_input_event_sync();
895 qemu_input_queue_btn(vc
->gfx
.dcl
.con
, btn
, false);
896 qemu_input_event_sync();
900 static int gd_map_keycode(GtkDisplayState
*s
, GdkDisplay
*dpy
, int gdk_keycode
)
904 #ifdef GDK_WINDOWING_WIN32
905 if (GDK_IS_WIN32_DISPLAY(dpy
)) {
906 qemu_keycode
= MapVirtualKey(gdk_keycode
, MAPVK_VK_TO_VSC
);
907 switch (qemu_keycode
) {
908 case 103: /* alt gr */
909 qemu_keycode
= 56 | SCANCODE_GREY
;
916 if (gdk_keycode
< 9) {
918 } else if (gdk_keycode
< 97) {
919 qemu_keycode
= gdk_keycode
- 8;
920 #ifdef GDK_WINDOWING_X11
921 } else if (GDK_IS_X11_DISPLAY(dpy
) && gdk_keycode
< 158) {
923 qemu_keycode
= translate_evdev_keycode(gdk_keycode
- 97);
925 qemu_keycode
= translate_xfree86_keycode(gdk_keycode
- 97);
928 } else if (gdk_keycode
== 208) { /* Hiragana_Katakana */
930 } else if (gdk_keycode
== 211) { /* backslash */
939 static gboolean
gd_text_key_down(GtkWidget
*widget
,
940 GdkEventKey
*key
, void *opaque
)
942 VirtualConsole
*vc
= opaque
;
943 QemuConsole
*con
= vc
->gfx
.dcl
.con
;
946 kbd_put_string_console(con
, key
->string
, key
->length
);
948 int num
= gd_map_keycode(vc
->s
, gtk_widget_get_display(widget
),
949 key
->hardware_keycode
);
950 int qcode
= qemu_input_key_number_to_qcode(num
);
951 kbd_put_qcode_console(con
, qcode
);
956 static gboolean
gd_key_event(GtkWidget
*widget
, GdkEventKey
*key
, void *opaque
)
958 VirtualConsole
*vc
= opaque
;
959 GtkDisplayState
*s
= vc
->s
;
960 int gdk_keycode
= key
->hardware_keycode
;
964 if (s
->ignore_keys
) {
965 s
->ignore_keys
= (key
->type
== GDK_KEY_PRESS
);
969 if (key
->keyval
== GDK_KEY_Pause
) {
970 qemu_input_event_send_key_qcode(vc
->gfx
.dcl
.con
, Q_KEY_CODE_PAUSE
,
971 key
->type
== GDK_KEY_PRESS
);
975 qemu_keycode
= gd_map_keycode(s
, gtk_widget_get_display(widget
),
978 trace_gd_key_event(vc
->label
, gdk_keycode
, qemu_keycode
,
979 (key
->type
== GDK_KEY_PRESS
) ? "down" : "up");
981 for (i
= 0; i
< ARRAY_SIZE(modifier_keycode
); i
++) {
982 if (qemu_keycode
== modifier_keycode
[i
]) {
983 s
->modifier_pressed
[i
] = (key
->type
== GDK_KEY_PRESS
);
987 qemu_input_event_send_key_number(vc
->gfx
.dcl
.con
, qemu_keycode
,
988 key
->type
== GDK_KEY_PRESS
);
993 static gboolean
gd_event(GtkWidget
*widget
, GdkEvent
*event
, void *opaque
)
995 if (event
->type
== GDK_MOTION_NOTIFY
) {
996 return gd_motion_event(widget
, &event
->motion
, opaque
);
1001 /** Window Menu Actions **/
1003 static void gd_menu_pause(GtkMenuItem
*item
, void *opaque
)
1005 GtkDisplayState
*s
= opaque
;
1007 if (s
->external_pause_update
) {
1010 if (runstate_is_running()) {
1017 static void gd_menu_reset(GtkMenuItem
*item
, void *opaque
)
1019 qmp_system_reset(NULL
);
1022 static void gd_menu_powerdown(GtkMenuItem
*item
, void *opaque
)
1024 qmp_system_powerdown(NULL
);
1027 static void gd_menu_quit(GtkMenuItem
*item
, void *opaque
)
1032 static void gd_menu_switch_vc(GtkMenuItem
*item
, void *opaque
)
1034 GtkDisplayState
*s
= opaque
;
1035 VirtualConsole
*vc
= gd_vc_find_by_menu(s
);
1036 GtkNotebook
*nb
= GTK_NOTEBOOK(s
->notebook
);
1039 gtk_release_modifiers(s
);
1041 page
= gtk_notebook_page_num(nb
, vc
->tab_item
);
1042 gtk_notebook_set_current_page(nb
, page
);
1043 gtk_widget_grab_focus(vc
->focus
);
1045 s
->ignore_keys
= false;
1048 static void gd_accel_switch_vc(void *opaque
)
1050 VirtualConsole
*vc
= opaque
;
1052 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc
->menu_item
), TRUE
);
1053 #if !GTK_CHECK_VERSION(3, 0, 0)
1054 /* GTK2 sends the accel key to the target console - ignore this until */
1055 vc
->s
->ignore_keys
= true;
1059 static void gd_menu_show_tabs(GtkMenuItem
*item
, void *opaque
)
1061 GtkDisplayState
*s
= opaque
;
1062 VirtualConsole
*vc
= gd_vc_find_current(s
);
1064 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s
->show_tabs_item
))) {
1065 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s
->notebook
), TRUE
);
1067 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s
->notebook
), FALSE
);
1069 gd_update_windowsize(vc
);
1072 static gboolean
gd_tab_window_close(GtkWidget
*widget
, GdkEvent
*event
,
1075 VirtualConsole
*vc
= opaque
;
1076 GtkDisplayState
*s
= vc
->s
;
1078 gtk_widget_set_sensitive(vc
->menu_item
, true);
1079 gd_widget_reparent(vc
->window
, s
->notebook
, vc
->tab_item
);
1080 gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(s
->notebook
),
1081 vc
->tab_item
, vc
->label
);
1082 gtk_widget_destroy(vc
->window
);
1087 static gboolean
gd_win_grab(void *opaque
)
1089 VirtualConsole
*vc
= opaque
;
1091 fprintf(stderr
, "%s: %s\n", __func__
, vc
->label
);
1092 if (vc
->s
->ptr_owner
) {
1093 gd_ungrab_pointer(vc
->s
);
1095 gd_grab_pointer(vc
, "user-request-detached-tab");
1100 static void gd_menu_untabify(GtkMenuItem
*item
, void *opaque
)
1102 GtkDisplayState
*s
= opaque
;
1103 VirtualConsole
*vc
= gd_vc_find_current(s
);
1105 if (vc
->type
== GD_VC_GFX
&&
1106 qemu_console_is_graphic(vc
->gfx
.dcl
.con
)) {
1107 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s
->grab_item
),
1111 gtk_widget_set_sensitive(vc
->menu_item
, false);
1112 vc
->window
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
1113 gd_widget_reparent(s
->notebook
, vc
->window
, vc
->tab_item
);
1115 g_signal_connect(vc
->window
, "delete-event",
1116 G_CALLBACK(gd_tab_window_close
), vc
);
1117 gtk_widget_show_all(vc
->window
);
1119 if (qemu_console_is_graphic(vc
->gfx
.dcl
.con
)) {
1120 GtkAccelGroup
*ag
= gtk_accel_group_new();
1121 gtk_window_add_accel_group(GTK_WINDOW(vc
->window
), ag
);
1123 GClosure
*cb
= g_cclosure_new_swap(G_CALLBACK(gd_win_grab
),
1125 gtk_accel_group_connect(ag
, GDK_KEY_g
, HOTKEY_MODIFIERS
, 0, cb
);
1128 gd_update_geometry_hints(vc
);
1129 gd_update_caption(s
);
1133 static void gd_menu_full_screen(GtkMenuItem
*item
, void *opaque
)
1135 GtkDisplayState
*s
= opaque
;
1136 VirtualConsole
*vc
= gd_vc_find_current(s
);
1138 if (!s
->full_screen
) {
1139 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s
->notebook
), FALSE
);
1140 gtk_widget_hide(s
->menu_bar
);
1141 if (vc
->type
== GD_VC_GFX
) {
1142 gtk_widget_set_size_request(vc
->gfx
.drawing_area
, -1, -1);
1144 gtk_window_fullscreen(GTK_WINDOW(s
->window
));
1145 s
->full_screen
= TRUE
;
1147 gtk_window_unfullscreen(GTK_WINDOW(s
->window
));
1148 gd_menu_show_tabs(GTK_MENU_ITEM(s
->show_tabs_item
), s
);
1149 gtk_widget_show(s
->menu_bar
);
1150 s
->full_screen
= FALSE
;
1151 if (vc
->type
== GD_VC_GFX
) {
1152 vc
->gfx
.scale_x
= 1.0;
1153 vc
->gfx
.scale_y
= 1.0;
1154 gd_update_windowsize(vc
);
1158 gd_update_cursor(vc
);
1161 static void gd_accel_full_screen(void *opaque
)
1163 GtkDisplayState
*s
= opaque
;
1164 gtk_menu_item_activate(GTK_MENU_ITEM(s
->full_screen_item
));
1167 static void gd_menu_zoom_in(GtkMenuItem
*item
, void *opaque
)
1169 GtkDisplayState
*s
= opaque
;
1170 VirtualConsole
*vc
= gd_vc_find_current(s
);
1172 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s
->zoom_fit_item
),
1175 vc
->gfx
.scale_x
+= VC_SCALE_STEP
;
1176 vc
->gfx
.scale_y
+= VC_SCALE_STEP
;
1178 gd_update_windowsize(vc
);
1181 static void gd_menu_zoom_out(GtkMenuItem
*item
, void *opaque
)
1183 GtkDisplayState
*s
= opaque
;
1184 VirtualConsole
*vc
= gd_vc_find_current(s
);
1186 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s
->zoom_fit_item
),
1189 vc
->gfx
.scale_x
-= VC_SCALE_STEP
;
1190 vc
->gfx
.scale_y
-= VC_SCALE_STEP
;
1192 vc
->gfx
.scale_x
= MAX(vc
->gfx
.scale_x
, VC_SCALE_MIN
);
1193 vc
->gfx
.scale_y
= MAX(vc
->gfx
.scale_y
, VC_SCALE_MIN
);
1195 gd_update_windowsize(vc
);
1198 static void gd_menu_zoom_fixed(GtkMenuItem
*item
, void *opaque
)
1200 GtkDisplayState
*s
= opaque
;
1201 VirtualConsole
*vc
= gd_vc_find_current(s
);
1203 vc
->gfx
.scale_x
= 1.0;
1204 vc
->gfx
.scale_y
= 1.0;
1206 gd_update_windowsize(vc
);
1209 static void gd_menu_zoom_fit(GtkMenuItem
*item
, void *opaque
)
1211 GtkDisplayState
*s
= opaque
;
1212 VirtualConsole
*vc
= gd_vc_find_current(s
);
1214 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s
->zoom_fit_item
))) {
1215 s
->free_scale
= TRUE
;
1217 s
->free_scale
= FALSE
;
1218 vc
->gfx
.scale_x
= 1.0;
1219 vc
->gfx
.scale_y
= 1.0;
1222 gd_update_windowsize(vc
);
1223 gd_update_full_redraw(vc
);
1226 #if GTK_CHECK_VERSION(3, 0, 0)
1227 static void gd_grab_devices(VirtualConsole
*vc
, bool grab
,
1228 GdkInputSource source
, GdkEventMask mask
,
1231 GdkDisplay
*display
= gtk_widget_get_display(vc
->gfx
.drawing_area
);
1232 GdkDeviceManager
*mgr
= gdk_display_get_device_manager(display
);
1233 GList
*devs
= gdk_device_manager_list_devices(mgr
, GDK_DEVICE_TYPE_MASTER
);
1236 for (tmp
= devs
; tmp
; tmp
= tmp
->next
) {
1237 GdkDevice
*dev
= tmp
->data
;
1238 if (gdk_device_get_source(dev
) != source
) {
1242 GdkWindow
*win
= gtk_widget_get_window(vc
->gfx
.drawing_area
);
1243 gdk_device_grab(dev
, win
, GDK_OWNERSHIP_NONE
, FALSE
,
1244 mask
, cursor
, GDK_CURRENT_TIME
);
1246 gdk_device_ungrab(dev
, GDK_CURRENT_TIME
);
1253 static void gd_grab_keyboard(VirtualConsole
*vc
, const char *reason
)
1255 if (vc
->s
->kbd_owner
) {
1256 if (vc
->s
->kbd_owner
== vc
) {
1259 gd_ungrab_keyboard(vc
->s
);
1263 #if GTK_CHECK_VERSION(3, 0, 0)
1264 gd_grab_devices(vc
, true, GDK_SOURCE_KEYBOARD
,
1265 GDK_KEY_PRESS_MASK
| GDK_KEY_RELEASE_MASK
,
1268 gdk_keyboard_grab(gtk_widget_get_window(vc
->gfx
.drawing_area
),
1272 vc
->s
->kbd_owner
= vc
;
1273 gd_update_caption(vc
->s
);
1274 trace_gd_grab(vc
->label
, "kbd", reason
);
1277 static void gd_ungrab_keyboard(GtkDisplayState
*s
)
1279 VirtualConsole
*vc
= s
->kbd_owner
;
1284 s
->kbd_owner
= NULL
;
1286 #if GTK_CHECK_VERSION(3, 0, 0)
1287 gd_grab_devices(vc
, false, GDK_SOURCE_KEYBOARD
, 0, NULL
);
1289 gdk_keyboard_ungrab(GDK_CURRENT_TIME
);
1291 gd_update_caption(s
);
1292 trace_gd_ungrab(vc
->label
, "kbd");
1295 static void gd_grab_pointer(VirtualConsole
*vc
, const char *reason
)
1297 GdkDisplay
*display
= gtk_widget_get_display(vc
->gfx
.drawing_area
);
1299 if (vc
->s
->ptr_owner
) {
1300 if (vc
->s
->ptr_owner
== vc
) {
1303 gd_ungrab_pointer(vc
->s
);
1307 #if GTK_CHECK_VERSION(3, 0, 0)
1308 GdkDeviceManager
*mgr
= gdk_display_get_device_manager(display
);
1309 gd_grab_devices(vc
, true, GDK_SOURCE_MOUSE
,
1310 GDK_POINTER_MOTION_MASK
|
1311 GDK_BUTTON_PRESS_MASK
|
1312 GDK_BUTTON_RELEASE_MASK
|
1313 GDK_BUTTON_MOTION_MASK
|
1315 vc
->s
->null_cursor
);
1316 gdk_device_get_position(gdk_device_manager_get_client_pointer(mgr
),
1317 NULL
, &vc
->s
->grab_x_root
, &vc
->s
->grab_y_root
);
1319 gdk_pointer_grab(gtk_widget_get_window(vc
->gfx
.drawing_area
),
1320 FALSE
, /* All events to come to our window directly */
1321 GDK_POINTER_MOTION_MASK
|
1322 GDK_BUTTON_PRESS_MASK
|
1323 GDK_BUTTON_RELEASE_MASK
|
1324 GDK_BUTTON_MOTION_MASK
|
1326 NULL
, /* Allow cursor to move over entire desktop */
1329 gdk_display_get_pointer(display
, NULL
,
1330 &vc
->s
->grab_x_root
, &vc
->s
->grab_y_root
, NULL
);
1332 vc
->s
->ptr_owner
= vc
;
1333 gd_update_caption(vc
->s
);
1334 trace_gd_grab(vc
->label
, "ptr", reason
);
1337 static void gd_ungrab_pointer(GtkDisplayState
*s
)
1339 VirtualConsole
*vc
= s
->ptr_owner
;
1344 s
->ptr_owner
= NULL
;
1346 GdkDisplay
*display
= gtk_widget_get_display(vc
->gfx
.drawing_area
);
1347 #if GTK_CHECK_VERSION(3, 0, 0)
1348 GdkDeviceManager
*mgr
= gdk_display_get_device_manager(display
);
1349 gd_grab_devices(vc
, false, GDK_SOURCE_MOUSE
, 0, NULL
);
1350 gdk_device_warp(gdk_device_manager_get_client_pointer(mgr
),
1351 gtk_widget_get_screen(vc
->gfx
.drawing_area
),
1352 vc
->s
->grab_x_root
, vc
->s
->grab_y_root
);
1354 gdk_pointer_ungrab(GDK_CURRENT_TIME
);
1355 gdk_display_warp_pointer(display
,
1356 gtk_widget_get_screen(vc
->gfx
.drawing_area
),
1357 vc
->s
->grab_x_root
, vc
->s
->grab_y_root
);
1359 gd_update_caption(s
);
1360 trace_gd_ungrab(vc
->label
, "ptr");
1363 static void gd_menu_grab_input(GtkMenuItem
*item
, void *opaque
)
1365 GtkDisplayState
*s
= opaque
;
1366 VirtualConsole
*vc
= gd_vc_find_current(s
);
1368 if (gd_is_grab_active(s
)) {
1369 gd_grab_keyboard(vc
, "user-request-main-window");
1370 gd_grab_pointer(vc
, "user-request-main-window");
1372 gd_ungrab_keyboard(s
);
1373 gd_ungrab_pointer(s
);
1376 gd_update_cursor(vc
);
1379 static void gd_change_page(GtkNotebook
*nb
, gpointer arg1
, guint arg2
,
1382 GtkDisplayState
*s
= data
;
1386 if (!gtk_widget_get_realized(s
->notebook
)) {
1390 #ifdef VTE_RESIZE_HACK
1391 vc
= gd_vc_find_current(s
);
1392 if (vc
&& vc
->type
== GD_VC_VTE
) {
1393 gtk_widget_hide(vc
->vte
.terminal
);
1396 vc
= gd_vc_find_by_page(s
, arg2
);
1400 #ifdef VTE_RESIZE_HACK
1401 if (vc
->type
== GD_VC_VTE
) {
1402 gtk_widget_show(vc
->vte
.terminal
);
1405 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc
->menu_item
),
1407 on_vga
= (vc
->type
== GD_VC_GFX
&&
1408 qemu_console_is_graphic(vc
->gfx
.dcl
.con
));
1410 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s
->grab_item
),
1412 } else if (s
->full_screen
) {
1413 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s
->grab_item
),
1416 gtk_widget_set_sensitive(s
->grab_item
, on_vga
);
1418 gd_update_windowsize(vc
);
1419 gd_update_cursor(vc
);
1422 static gboolean
gd_enter_event(GtkWidget
*widget
, GdkEventCrossing
*crossing
,
1425 VirtualConsole
*vc
= opaque
;
1426 GtkDisplayState
*s
= vc
->s
;
1428 if (gd_grab_on_hover(s
)) {
1429 gd_grab_keyboard(vc
, "grab-on-hover");
1434 static gboolean
gd_leave_event(GtkWidget
*widget
, GdkEventCrossing
*crossing
,
1437 VirtualConsole
*vc
= opaque
;
1438 GtkDisplayState
*s
= vc
->s
;
1440 if (gd_grab_on_hover(s
)) {
1441 gd_ungrab_keyboard(s
);
1446 static gboolean
gd_focus_out_event(GtkWidget
*widget
,
1447 GdkEventCrossing
*crossing
, gpointer opaque
)
1449 VirtualConsole
*vc
= opaque
;
1450 GtkDisplayState
*s
= vc
->s
;
1452 gtk_release_modifiers(s
);
1456 static gboolean
gd_configure(GtkWidget
*widget
,
1457 GdkEventConfigure
*cfg
, gpointer opaque
)
1459 VirtualConsole
*vc
= opaque
;
1462 memset(&info
, 0, sizeof(info
));
1463 info
.width
= cfg
->width
;
1464 info
.height
= cfg
->height
;
1465 dpy_set_ui_info(vc
->gfx
.dcl
.con
, &info
);
1469 /** Virtual Console Callbacks **/
1471 static GSList
*gd_vc_menu_init(GtkDisplayState
*s
, VirtualConsole
*vc
,
1472 int idx
, GSList
*group
, GtkWidget
*view_menu
)
1474 vc
->menu_item
= gtk_radio_menu_item_new_with_mnemonic(group
, vc
->label
);
1475 gtk_accel_group_connect(s
->accel_group
, GDK_KEY_1
+ idx
,
1476 HOTKEY_MODIFIERS
, 0,
1477 g_cclosure_new_swap(G_CALLBACK(gd_accel_switch_vc
), vc
, NULL
));
1478 #if GTK_CHECK_VERSION(3, 8, 0)
1479 gtk_accel_label_set_accel(
1480 GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(vc
->menu_item
))),
1481 GDK_KEY_1
+ idx
, HOTKEY_MODIFIERS
);
1484 g_signal_connect(vc
->menu_item
, "activate",
1485 G_CALLBACK(gd_menu_switch_vc
), s
);
1486 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), vc
->menu_item
);
1488 group
= gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(vc
->menu_item
));
1492 #if defined(CONFIG_VTE)
1493 static void gd_vc_adjustment_changed(GtkAdjustment
*adjustment
, void *opaque
)
1495 VirtualConsole
*vc
= opaque
;
1497 if (gtk_adjustment_get_upper(adjustment
) >
1498 gtk_adjustment_get_page_size(adjustment
)) {
1499 gtk_widget_show(vc
->vte
.scrollbar
);
1501 gtk_widget_hide(vc
->vte
.scrollbar
);
1505 static int gd_vc_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1507 VirtualConsole
*vc
= chr
->opaque
;
1509 vte_terminal_feed(VTE_TERMINAL(vc
->vte
.terminal
), (const char *)buf
, len
);
1514 static CharDriverState
*vcs
[MAX_VCS
];
1516 static CharDriverState
*gd_vc_handler(ChardevVC
*unused
)
1518 CharDriverState
*chr
;
1520 chr
= g_malloc0(sizeof(*chr
));
1521 chr
->chr_write
= gd_vc_chr_write
;
1522 /* defer OPENED events until our vc is fully initialized */
1523 chr
->explicit_be_open
= true;
1525 vcs
[nb_vcs
++] = chr
;
1530 static gboolean
gd_vc_in(VteTerminal
*terminal
, gchar
*text
, guint size
,
1533 VirtualConsole
*vc
= user_data
;
1535 qemu_chr_be_write(vc
->vte
.chr
, (uint8_t *)text
, (unsigned int)size
);
1539 static GSList
*gd_vc_vte_init(GtkDisplayState
*s
, VirtualConsole
*vc
,
1540 CharDriverState
*chr
, int idx
,
1541 GSList
*group
, GtkWidget
*view_menu
)
1545 GtkWidget
*scrollbar
;
1546 GtkAdjustment
*vadjustment
;
1551 snprintf(buffer
, sizeof(buffer
), "vc%d", idx
);
1552 vc
->label
= g_strdup_printf("%s", vc
->vte
.chr
->label
1553 ? vc
->vte
.chr
->label
: buffer
);
1554 group
= gd_vc_menu_init(s
, vc
, idx
, group
, view_menu
);
1556 vc
->vte
.terminal
= vte_terminal_new();
1557 g_signal_connect(vc
->vte
.terminal
, "commit", G_CALLBACK(gd_vc_in
), vc
);
1559 vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc
->vte
.terminal
), -1);
1560 vte_terminal_set_size(VTE_TERMINAL(vc
->vte
.terminal
),
1561 VC_TERM_X_MIN
, VC_TERM_Y_MIN
);
1563 #if VTE_CHECK_VERSION(0, 28, 0) && GTK_CHECK_VERSION(3, 0, 0)
1564 vadjustment
= gtk_scrollable_get_vadjustment
1565 (GTK_SCROLLABLE(vc
->vte
.terminal
));
1567 vadjustment
= vte_terminal_get_adjustment(VTE_TERMINAL(vc
->vte
.terminal
));
1570 #if GTK_CHECK_VERSION(3, 0, 0)
1571 box
= gtk_box_new(GTK_ORIENTATION_HORIZONTAL
, 2);
1572 scrollbar
= gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL
, vadjustment
);
1574 box
= gtk_hbox_new(false, 2);
1575 scrollbar
= gtk_vscrollbar_new(vadjustment
);
1578 gtk_box_pack_start(GTK_BOX(box
), vc
->vte
.terminal
, TRUE
, TRUE
, 0);
1579 gtk_box_pack_start(GTK_BOX(box
), scrollbar
, FALSE
, FALSE
, 0);
1581 vc
->vte
.chr
->opaque
= vc
;
1583 vc
->vte
.scrollbar
= scrollbar
;
1585 g_signal_connect(vadjustment
, "changed",
1586 G_CALLBACK(gd_vc_adjustment_changed
), vc
);
1588 vc
->type
= GD_VC_VTE
;
1590 vc
->focus
= vc
->vte
.terminal
;
1591 gtk_notebook_append_page(GTK_NOTEBOOK(s
->notebook
), vc
->tab_item
,
1592 gtk_label_new(vc
->label
));
1594 qemu_chr_be_generic_open(vc
->vte
.chr
);
1595 if (vc
->vte
.chr
->init
) {
1596 vc
->vte
.chr
->init(vc
->vte
.chr
);
1602 static void gd_vcs_init(GtkDisplayState
*s
, GSList
*group
,
1603 GtkWidget
*view_menu
)
1607 for (i
= 0; i
< nb_vcs
; i
++) {
1608 VirtualConsole
*vc
= &s
->vc
[s
->nb_vcs
];
1609 group
= gd_vc_vte_init(s
, vc
, vcs
[i
], s
->nb_vcs
, group
, view_menu
);
1613 #endif /* CONFIG_VTE */
1615 /** Window Creation **/
1617 static void gd_connect_vc_gfx_signals(VirtualConsole
*vc
)
1619 #if GTK_CHECK_VERSION(3, 0, 0)
1620 g_signal_connect(vc
->gfx
.drawing_area
, "draw",
1621 G_CALLBACK(gd_draw_event
), vc
);
1623 g_signal_connect(vc
->gfx
.drawing_area
, "expose-event",
1624 G_CALLBACK(gd_expose_event
), vc
);
1626 if (qemu_console_is_graphic(vc
->gfx
.dcl
.con
)) {
1627 g_signal_connect(vc
->gfx
.drawing_area
, "event",
1628 G_CALLBACK(gd_event
), vc
);
1629 g_signal_connect(vc
->gfx
.drawing_area
, "button-press-event",
1630 G_CALLBACK(gd_button_event
), vc
);
1631 g_signal_connect(vc
->gfx
.drawing_area
, "button-release-event",
1632 G_CALLBACK(gd_button_event
), vc
);
1633 g_signal_connect(vc
->gfx
.drawing_area
, "scroll-event",
1634 G_CALLBACK(gd_scroll_event
), vc
);
1635 g_signal_connect(vc
->gfx
.drawing_area
, "key-press-event",
1636 G_CALLBACK(gd_key_event
), vc
);
1637 g_signal_connect(vc
->gfx
.drawing_area
, "key-release-event",
1638 G_CALLBACK(gd_key_event
), vc
);
1640 g_signal_connect(vc
->gfx
.drawing_area
, "enter-notify-event",
1641 G_CALLBACK(gd_enter_event
), vc
);
1642 g_signal_connect(vc
->gfx
.drawing_area
, "leave-notify-event",
1643 G_CALLBACK(gd_leave_event
), vc
);
1644 g_signal_connect(vc
->gfx
.drawing_area
, "focus-out-event",
1645 G_CALLBACK(gd_focus_out_event
), vc
);
1646 g_signal_connect(vc
->gfx
.drawing_area
, "configure-event",
1647 G_CALLBACK(gd_configure
), vc
);
1649 g_signal_connect(vc
->gfx
.drawing_area
, "key-press-event",
1650 G_CALLBACK(gd_text_key_down
), vc
);
1654 static void gd_connect_signals(GtkDisplayState
*s
)
1656 g_signal_connect(s
->show_tabs_item
, "activate",
1657 G_CALLBACK(gd_menu_show_tabs
), s
);
1658 g_signal_connect(s
->untabify_item
, "activate",
1659 G_CALLBACK(gd_menu_untabify
), s
);
1661 g_signal_connect(s
->window
, "delete-event",
1662 G_CALLBACK(gd_window_close
), s
);
1664 g_signal_connect(s
->pause_item
, "activate",
1665 G_CALLBACK(gd_menu_pause
), s
);
1666 g_signal_connect(s
->reset_item
, "activate",
1667 G_CALLBACK(gd_menu_reset
), s
);
1668 g_signal_connect(s
->powerdown_item
, "activate",
1669 G_CALLBACK(gd_menu_powerdown
), s
);
1670 g_signal_connect(s
->quit_item
, "activate",
1671 G_CALLBACK(gd_menu_quit
), s
);
1672 g_signal_connect(s
->full_screen_item
, "activate",
1673 G_CALLBACK(gd_menu_full_screen
), s
);
1674 g_signal_connect(s
->zoom_in_item
, "activate",
1675 G_CALLBACK(gd_menu_zoom_in
), s
);
1676 g_signal_connect(s
->zoom_out_item
, "activate",
1677 G_CALLBACK(gd_menu_zoom_out
), s
);
1678 g_signal_connect(s
->zoom_fixed_item
, "activate",
1679 G_CALLBACK(gd_menu_zoom_fixed
), s
);
1680 g_signal_connect(s
->zoom_fit_item
, "activate",
1681 G_CALLBACK(gd_menu_zoom_fit
), s
);
1682 g_signal_connect(s
->grab_item
, "activate",
1683 G_CALLBACK(gd_menu_grab_input
), s
);
1684 g_signal_connect(s
->notebook
, "switch-page",
1685 G_CALLBACK(gd_change_page
), s
);
1688 static GtkWidget
*gd_create_menu_machine(GtkDisplayState
*s
)
1690 GtkWidget
*machine_menu
;
1691 GtkWidget
*separator
;
1693 machine_menu
= gtk_menu_new();
1694 gtk_menu_set_accel_group(GTK_MENU(machine_menu
), s
->accel_group
);
1696 s
->pause_item
= gtk_check_menu_item_new_with_mnemonic(_("_Pause"));
1697 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu
), s
->pause_item
);
1699 separator
= gtk_separator_menu_item_new();
1700 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu
), separator
);
1702 s
->reset_item
= gtk_menu_item_new_with_mnemonic(_("_Reset"));
1703 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu
), s
->reset_item
);
1705 s
->powerdown_item
= gtk_menu_item_new_with_mnemonic(_("Power _Down"));
1706 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu
), s
->powerdown_item
);
1708 separator
= gtk_separator_menu_item_new();
1709 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu
), separator
);
1711 s
->quit_item
= gtk_menu_item_new_with_mnemonic(_("_Quit"));
1712 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s
->quit_item
),
1713 "<QEMU>/Machine/Quit");
1714 gtk_accel_map_add_entry("<QEMU>/Machine/Quit",
1715 GDK_KEY_q
, HOTKEY_MODIFIERS
);
1716 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu
), s
->quit_item
);
1718 return machine_menu
;
1721 static GSList
*gd_vc_gfx_init(GtkDisplayState
*s
, VirtualConsole
*vc
,
1722 QemuConsole
*con
, int idx
,
1723 GSList
*group
, GtkWidget
*view_menu
)
1725 vc
->label
= qemu_console_get_label(con
);
1727 vc
->gfx
.scale_x
= 1.0;
1728 vc
->gfx
.scale_y
= 1.0;
1730 vc
->gfx
.drawing_area
= gtk_drawing_area_new();
1731 gtk_widget_add_events(vc
->gfx
.drawing_area
,
1732 GDK_POINTER_MOTION_MASK
|
1733 GDK_BUTTON_PRESS_MASK
|
1734 GDK_BUTTON_RELEASE_MASK
|
1735 GDK_BUTTON_MOTION_MASK
|
1736 GDK_ENTER_NOTIFY_MASK
|
1737 GDK_LEAVE_NOTIFY_MASK
|
1739 GDK_KEY_PRESS_MASK
);
1740 gtk_widget_set_can_focus(vc
->gfx
.drawing_area
, TRUE
);
1742 vc
->type
= GD_VC_GFX
;
1743 vc
->tab_item
= vc
->gfx
.drawing_area
;
1744 vc
->focus
= vc
->gfx
.drawing_area
;
1745 gtk_notebook_append_page(GTK_NOTEBOOK(s
->notebook
),
1746 vc
->tab_item
, gtk_label_new(vc
->label
));
1748 #if defined(CONFIG_OPENGL)
1749 if (display_opengl
) {
1751 * gtk_widget_set_double_buffered() was deprecated in 3.14.
1752 * It is required for opengl rendering on X11 though. A
1753 * proper replacement (native opengl support) is only
1754 * available in 3.16+. Silence the warning if possible.
1756 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
1757 #pragma GCC diagnostic push
1758 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1760 gtk_widget_set_double_buffered(vc
->gfx
.drawing_area
, FALSE
);
1761 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
1762 #pragma GCC diagnostic pop
1764 vc
->gfx
.dcl
.ops
= &dcl_egl_ops
;
1768 vc
->gfx
.dcl
.ops
= &dcl_ops
;
1771 vc
->gfx
.dcl
.con
= con
;
1772 register_displaychangelistener(&vc
->gfx
.dcl
);
1774 gd_connect_vc_gfx_signals(vc
);
1775 group
= gd_vc_menu_init(s
, vc
, idx
, group
, view_menu
);
1777 if (dpy_ui_info_supported(vc
->gfx
.dcl
.con
)) {
1778 gtk_menu_item_activate(GTK_MENU_ITEM(s
->zoom_fit_item
));
1779 s
->free_scale
= true;
1785 static GtkWidget
*gd_create_menu_view(GtkDisplayState
*s
)
1787 GSList
*group
= NULL
;
1788 GtkWidget
*view_menu
;
1789 GtkWidget
*separator
;
1793 view_menu
= gtk_menu_new();
1794 gtk_menu_set_accel_group(GTK_MENU(view_menu
), s
->accel_group
);
1796 s
->full_screen_item
= gtk_menu_item_new_with_mnemonic(_("_Fullscreen"));
1798 gtk_accel_group_connect(s
->accel_group
, GDK_KEY_f
, HOTKEY_MODIFIERS
, 0,
1799 g_cclosure_new_swap(G_CALLBACK(gd_accel_full_screen
), s
, NULL
));
1800 #if GTK_CHECK_VERSION(3, 8, 0)
1801 gtk_accel_label_set_accel(
1802 GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(s
->full_screen_item
))),
1803 GDK_KEY_f
, HOTKEY_MODIFIERS
);
1805 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), s
->full_screen_item
);
1807 separator
= gtk_separator_menu_item_new();
1808 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), separator
);
1810 s
->zoom_in_item
= gtk_menu_item_new_with_mnemonic(_("Zoom _In"));
1811 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s
->zoom_in_item
),
1812 "<QEMU>/View/Zoom In");
1813 gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus
,
1815 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), s
->zoom_in_item
);
1817 s
->zoom_out_item
= gtk_menu_item_new_with_mnemonic(_("Zoom _Out"));
1818 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s
->zoom_out_item
),
1819 "<QEMU>/View/Zoom Out");
1820 gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus
,
1822 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), s
->zoom_out_item
);
1824 s
->zoom_fixed_item
= gtk_menu_item_new_with_mnemonic(_("Best _Fit"));
1825 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s
->zoom_fixed_item
),
1826 "<QEMU>/View/Zoom Fixed");
1827 gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0
,
1829 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), s
->zoom_fixed_item
);
1831 s
->zoom_fit_item
= gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit"));
1832 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), s
->zoom_fit_item
);
1834 separator
= gtk_separator_menu_item_new();
1835 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), separator
);
1837 s
->grab_on_hover_item
= gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover"));
1838 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), s
->grab_on_hover_item
);
1840 s
->grab_item
= gtk_check_menu_item_new_with_mnemonic(_("_Grab Input"));
1841 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s
->grab_item
),
1842 "<QEMU>/View/Grab Input");
1843 gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g
,
1845 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), s
->grab_item
);
1847 separator
= gtk_separator_menu_item_new();
1848 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), separator
);
1851 for (vc
= 0;; vc
++) {
1852 con
= qemu_console_lookup_by_index(vc
);
1856 group
= gd_vc_gfx_init(s
, &s
->vc
[vc
], con
,
1857 vc
, group
, view_menu
);
1861 #if defined(CONFIG_VTE)
1863 gd_vcs_init(s
, group
, view_menu
);
1866 separator
= gtk_separator_menu_item_new();
1867 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), separator
);
1869 s
->show_tabs_item
= gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs"));
1870 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), s
->show_tabs_item
);
1872 s
->untabify_item
= gtk_menu_item_new_with_mnemonic(_("Detach Tab"));
1873 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu
), s
->untabify_item
);
1878 static void gd_create_menus(GtkDisplayState
*s
)
1880 s
->accel_group
= gtk_accel_group_new();
1881 s
->machine_menu
= gd_create_menu_machine(s
);
1882 s
->view_menu
= gd_create_menu_view(s
);
1884 s
->machine_menu_item
= gtk_menu_item_new_with_mnemonic(_("_Machine"));
1885 gtk_menu_item_set_submenu(GTK_MENU_ITEM(s
->machine_menu_item
),
1887 gtk_menu_shell_append(GTK_MENU_SHELL(s
->menu_bar
), s
->machine_menu_item
);
1889 s
->view_menu_item
= gtk_menu_item_new_with_mnemonic(_("_View"));
1890 gtk_menu_item_set_submenu(GTK_MENU_ITEM(s
->view_menu_item
), s
->view_menu
);
1891 gtk_menu_shell_append(GTK_MENU_SHELL(s
->menu_bar
), s
->view_menu_item
);
1893 g_object_set_data(G_OBJECT(s
->window
), "accel_group", s
->accel_group
);
1894 gtk_window_add_accel_group(GTK_WINDOW(s
->window
), s
->accel_group
);
1897 static void gd_set_keycode_type(GtkDisplayState
*s
)
1899 #ifdef GDK_WINDOWING_X11
1900 GdkDisplay
*display
= gtk_widget_get_display(s
->window
);
1901 if (GDK_IS_X11_DISPLAY(display
)) {
1902 Display
*x11_display
= gdk_x11_display_get_xdisplay(display
);
1903 XkbDescPtr desc
= XkbGetKeyboard(x11_display
, XkbGBN_AllComponentsMask
,
1905 char *keycodes
= NULL
;
1907 if (desc
&& desc
->names
) {
1908 keycodes
= XGetAtomName(x11_display
, desc
->names
->keycodes
);
1910 if (keycodes
== NULL
) {
1911 fprintf(stderr
, "could not lookup keycode name\n");
1912 } else if (strstart(keycodes
, "evdev", NULL
)) {
1913 s
->has_evdev
= true;
1914 } else if (!strstart(keycodes
, "xfree86", NULL
)) {
1915 fprintf(stderr
, "unknown keycodes `%s', please report to "
1916 "qemu-devel@nongnu.org\n", keycodes
);
1920 XkbFreeKeyboard(desc
, XkbGBN_AllComponentsMask
, True
);
1929 static gboolean gtkinit
;
1931 void gtk_display_init(DisplayState
*ds
, bool full_screen
, bool grab_on_hover
)
1933 GtkDisplayState
*s
= g_malloc0(sizeof(*s
));
1935 GdkDisplay
*window_display
;
1938 fprintf(stderr
, "gtk initialization failed\n");
1942 s
->window
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
1943 #if GTK_CHECK_VERSION(3, 2, 0)
1944 s
->vbox
= gtk_box_new(GTK_ORIENTATION_VERTICAL
, 0);
1946 s
->vbox
= gtk_vbox_new(FALSE
, 0);
1948 s
->notebook
= gtk_notebook_new();
1949 s
->menu_bar
= gtk_menu_bar_new();
1951 s
->free_scale
= FALSE
;
1953 /* LC_MESSAGES only. See early_gtk_display_init() for details */
1954 setlocale(LC_MESSAGES
, "");
1955 bindtextdomain("qemu", CONFIG_QEMU_LOCALEDIR
);
1958 window_display
= gtk_widget_get_display(s
->window
);
1959 s
->null_cursor
= gdk_cursor_new_for_display(window_display
,
1962 s
->mouse_mode_notifier
.notify
= gd_mouse_mode_change
;
1963 qemu_add_mouse_mode_change_notifier(&s
->mouse_mode_notifier
);
1964 qemu_add_vm_change_state_handler(gd_change_runstate
, s
);
1966 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, "qemu_logo_no_text.svg");
1968 GError
*error
= NULL
;
1969 GdkPixbuf
*pixbuf
= gdk_pixbuf_new_from_file(filename
, &error
);
1971 gtk_window_set_icon(GTK_WINDOW(s
->window
), pixbuf
);
1973 g_error_free(error
);
1980 gd_connect_signals(s
);
1982 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s
->notebook
), FALSE
);
1983 gtk_notebook_set_show_border(GTK_NOTEBOOK(s
->notebook
), FALSE
);
1985 gd_update_caption(s
);
1987 gtk_box_pack_start(GTK_BOX(s
->vbox
), s
->menu_bar
, FALSE
, TRUE
, 0);
1988 gtk_box_pack_start(GTK_BOX(s
->vbox
), s
->notebook
, TRUE
, TRUE
, 0);
1990 gtk_container_add(GTK_CONTAINER(s
->window
), s
->vbox
);
1992 gtk_widget_show_all(s
->window
);
1994 #ifdef VTE_RESIZE_HACK
1996 VirtualConsole
*cur
= gd_vc_find_current(s
);
2000 for (i
= 0; i
< s
->nb_vcs
; i
++) {
2001 VirtualConsole
*vc
= &s
->vc
[i
];
2002 if (vc
&& vc
->type
== GD_VC_VTE
&& vc
!= cur
) {
2003 gtk_widget_hide(vc
->vte
.terminal
);
2006 gd_update_windowsize(cur
);
2012 gtk_menu_item_activate(GTK_MENU_ITEM(s
->full_screen_item
));
2014 if (grab_on_hover
) {
2015 gtk_menu_item_activate(GTK_MENU_ITEM(s
->grab_on_hover_item
));
2018 gd_set_keycode_type(s
);
2021 void early_gtk_display_init(int opengl
)
2023 /* The QEMU code relies on the assumption that it's always run in
2024 * the C locale. Therefore it is not prepared to deal with
2025 * operations that produce different results depending on the
2026 * locale, such as printf's formatting of decimal numbers, and
2029 * Since GTK+ calls setlocale() by default -importing the locale
2030 * settings from the environment- we must prevent it from doing so
2031 * using gtk_disable_setlocale().
2033 * QEMU's GTK+ UI, however, _does_ have translations for some of
2034 * the menu items. As a trade-off between a functionally correct
2035 * QEMU and a fully internationalized UI we support importing
2036 * LC_MESSAGES from the environment (see the setlocale() call
2037 * earlier in this file). This allows us to display translated
2038 * messages leaving everything else untouched.
2040 gtk_disable_setlocale();
2041 gtkinit
= gtk_init_check(NULL
, NULL
);
2043 /* don't exit yet, that'll break -help */
2048 case -1: /* default */
2052 #if defined(CONFIG_OPENGL)
2057 g_assert_not_reached();
2061 #if defined(CONFIG_VTE)
2062 register_vc_handler(gd_vc_handler
);