1a4ccabcfSAnthony Liguori /* 2a4ccabcfSAnthony Liguori * GTK UI 3a4ccabcfSAnthony Liguori * 4a4ccabcfSAnthony Liguori * Copyright IBM, Corp. 2012 5a4ccabcfSAnthony Liguori * 6a4ccabcfSAnthony Liguori * Authors: 7a4ccabcfSAnthony Liguori * Anthony Liguori <aliguori@us.ibm.com> 8a4ccabcfSAnthony Liguori * 9a4ccabcfSAnthony Liguori * This work is licensed under the terms of the GNU GPL, version 2 or later. 10a4ccabcfSAnthony Liguori * See the COPYING file in the top-level directory. 11a4ccabcfSAnthony Liguori * 12a4ccabcfSAnthony Liguori * Portions from gtk-vnc: 13a4ccabcfSAnthony Liguori * 14a4ccabcfSAnthony Liguori * GTK VNC Widget 15a4ccabcfSAnthony Liguori * 16a4ccabcfSAnthony Liguori * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws> 17a4ccabcfSAnthony Liguori * Copyright (C) 2009-2010 Daniel P. Berrange <dan@berrange.com> 18a4ccabcfSAnthony Liguori * 19a4ccabcfSAnthony Liguori * This library is free software; you can redistribute it and/or 20a4ccabcfSAnthony Liguori * modify it under the terms of the GNU Lesser General Public 21a4ccabcfSAnthony Liguori * License as published by the Free Software Foundation; either 22a4ccabcfSAnthony Liguori * version 2.0 of the License, or (at your option) any later version. 23a4ccabcfSAnthony Liguori * 24a4ccabcfSAnthony Liguori * This library is distributed in the hope that it will be useful, 25a4ccabcfSAnthony Liguori * but WITHOUT ANY WARRANTY; without even the implied warranty of 26a4ccabcfSAnthony Liguori * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 27a4ccabcfSAnthony Liguori * Lesser General Public License for more details. 28a4ccabcfSAnthony Liguori * 29a4ccabcfSAnthony Liguori * You should have received a copy of the GNU Lesser General Public 30a4ccabcfSAnthony Liguori * License along with this library; if not, write to the Free Software 31a4ccabcfSAnthony Liguori * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 32a4ccabcfSAnthony Liguori */ 33a4ccabcfSAnthony Liguori 34834574eaSAnthony Liguori #define GETTEXT_PACKAGE "qemu" 35834574eaSAnthony Liguori #define LOCALEDIR "po" 36834574eaSAnthony Liguori 37e16f4c87SPeter Maydell #include "qemu/osdep.h" 38c95e3080SKevin Wolf #include "qemu-common.h" 39f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 40c95e3080SKevin Wolf 41dc7ff344SGerd Hoffmann #include "ui/console.h" 42dc7ff344SGerd Hoffmann #include "ui/gtk.h" 43c95e3080SKevin Wolf 44834574eaSAnthony Liguori #include <glib/gi18n.h> 453f58eadeSStefan Weil #include <locale.h> 46bbbf9bfbSStefan Weil #if defined(CONFIG_VTE) 47a4ccabcfSAnthony Liguori #include <vte/vte.h> 48bbbf9bfbSStefan Weil #endif 49a4ccabcfSAnthony Liguori #include <math.h> 50a4ccabcfSAnthony Liguori 51ef0dd982SStefan Weil #include "trace.h" 52af98ba92SGerd Hoffmann #include "ui/input.h" 53a4ccabcfSAnthony Liguori #include "sysemu/sysemu.h" 54a4ccabcfSAnthony Liguori #include "qmp-commands.h" 55a4ccabcfSAnthony Liguori #include "x_keymap.h" 56a4ccabcfSAnthony Liguori #include "keymaps.h" 57dccfcd0eSPaolo Bonzini #include "sysemu/char.h" 586a24ced5SGerd Hoffmann #include "qom/object.h" 59a4ccabcfSAnthony Liguori 60d861def3SAnthony Liguori #define MAX_VCS 10 6182fc1809SGerd Hoffmann #define VC_WINDOW_X_MIN 320 6282fc1809SGerd Hoffmann #define VC_WINDOW_Y_MIN 240 6382fc1809SGerd Hoffmann #define VC_TERM_X_MIN 80 6482fc1809SGerd Hoffmann #define VC_TERM_Y_MIN 25 6582fc1809SGerd Hoffmann #define VC_SCALE_MIN 0.25 6682fc1809SGerd Hoffmann #define VC_SCALE_STEP 0.25 67d861def3SAnthony Liguori 68bbbf9bfbSStefan Weil #if !defined(CONFIG_VTE) 69bbbf9bfbSStefan Weil # define VTE_CHECK_VERSION(a, b, c) 0 70bbbf9bfbSStefan Weil #endif 71cba68834SDaniel P. Berrange 726fa27697SGerd Hoffmann #if defined(CONFIG_VTE) && !GTK_CHECK_VERSION(3, 0, 0) 736fa27697SGerd Hoffmann /* 746fa27697SGerd Hoffmann * The gtk2 vte terminal widget seriously messes up the window resize 756fa27697SGerd Hoffmann * for some reason. You basically can't make the qemu window smaller 766fa27697SGerd Hoffmann * any more because the toplevel window geoemtry hints are overridden. 776fa27697SGerd Hoffmann * 786fa27697SGerd Hoffmann * Workaround that by hiding all vte widgets, except the one in the 796fa27697SGerd Hoffmann * current tab. 806fa27697SGerd Hoffmann * 816fa27697SGerd Hoffmann * Luckily everything works smooth in gtk3. 826fa27697SGerd Hoffmann */ 836fa27697SGerd Hoffmann # define VTE_RESIZE_HACK 1 846fa27697SGerd Hoffmann #endif 856fa27697SGerd Hoffmann 86ef6413a2SDaniel P. Berrange #if !GTK_CHECK_VERSION(2, 20, 0) 87ef6413a2SDaniel P. Berrange #define gtk_widget_get_realized(widget) GTK_WIDGET_REALIZED(widget) 88ef6413a2SDaniel P. Berrange #endif 89ef6413a2SDaniel P. Berrange 900a337ed0SGerd Hoffmann #ifndef GDK_IS_X11_DISPLAY 910a337ed0SGerd Hoffmann #define GDK_IS_X11_DISPLAY(dpy) (dpy == dpy) 920a337ed0SGerd Hoffmann #endif 93a8ffb372SDaniel P. Berrange #ifndef GDK_IS_WAYLAND_DISPLAY 94a8ffb372SDaniel P. Berrange #define GDK_IS_WAYLAND_DISPLAY(dpy) (dpy == dpy) 95a8ffb372SDaniel P. Berrange #endif 960a337ed0SGerd Hoffmann #ifndef GDK_IS_WIN32_DISPLAY 970a337ed0SGerd Hoffmann #define GDK_IS_WIN32_DISPLAY(dpy) (dpy == dpy) 980a337ed0SGerd Hoffmann #endif 990a337ed0SGerd Hoffmann 100204af15bSThomas Huth #if !GTK_CHECK_VERSION(2, 22, 0) 101bc0477c7SDaniel P. Berrange #define GDK_KEY_0 GDK_0 102bc0477c7SDaniel P. Berrange #define GDK_KEY_1 GDK_1 103bc0477c7SDaniel P. Berrange #define GDK_KEY_2 GDK_2 104bc0477c7SDaniel P. Berrange #define GDK_KEY_f GDK_f 105bc0477c7SDaniel P. Berrange #define GDK_KEY_g GDK_g 106db1da1f2SCole Robinson #define GDK_KEY_q GDK_q 107bc0477c7SDaniel P. Berrange #define GDK_KEY_plus GDK_plus 108bc0477c7SDaniel P. Berrange #define GDK_KEY_minus GDK_minus 109dc520171SGerd Hoffmann #define GDK_KEY_Pause GDK_Pause 110204af15bSThomas Huth #define GDK_KEY_Delete GDK_Delete 111bc0477c7SDaniel P. Berrange #endif 112ef6413a2SDaniel P. Berrange 113c8f3f17cSDaniel P. Berrange /* Some older mingw versions lack this constant or have 114c8f3f17cSDaniel P. Berrange * it conditionally defined */ 115c8f3f17cSDaniel P. Berrange #ifdef _WIN32 116c8f3f17cSDaniel P. Berrange # ifndef MAPVK_VK_TO_VSC 117c8f3f17cSDaniel P. Berrange # define MAPVK_VK_TO_VSC 0 118c8f3f17cSDaniel P. Berrange # endif 119c8f3f17cSDaniel P. Berrange #endif 120c8f3f17cSDaniel P. Berrange 121c8f3f17cSDaniel P. Berrange 122b1e749c0SJan Kiszka #define HOTKEY_MODIFIERS (GDK_CONTROL_MASK | GDK_MOD1_MASK) 123b1e749c0SJan Kiszka 1246db253caSJan Kiszka static const int modifier_keycode[] = { 1256db253caSJan Kiszka /* shift, control, alt keys, meta keys, both left & right */ 1266db253caSJan Kiszka 0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8, 0xdb, 0xdd, 1276db253caSJan Kiszka }; 1286db253caSJan Kiszka 129e3500d1fSGerd Hoffmann struct GtkDisplayState { 130a4ccabcfSAnthony Liguori GtkWidget *window; 131a4ccabcfSAnthony Liguori 132a4ccabcfSAnthony Liguori GtkWidget *menu_bar; 133a4ccabcfSAnthony Liguori 13473d4dc71SAnthony Liguori GtkAccelGroup *accel_group; 13573d4dc71SAnthony Liguori 13630e8f22bSJan Kiszka GtkWidget *machine_menu_item; 13730e8f22bSJan Kiszka GtkWidget *machine_menu; 13830e8f22bSJan Kiszka GtkWidget *pause_item; 13930e8f22bSJan Kiszka GtkWidget *reset_item; 14030e8f22bSJan Kiszka GtkWidget *powerdown_item; 141a4ccabcfSAnthony Liguori GtkWidget *quit_item; 142a4ccabcfSAnthony Liguori 143a4ccabcfSAnthony Liguori GtkWidget *view_menu_item; 144a4ccabcfSAnthony Liguori GtkWidget *view_menu; 145c6158483SAnthony Liguori GtkWidget *full_screen_item; 14644b31e0bSMichael S. Tsirkin GtkWidget *copy_item; 147c6158483SAnthony Liguori GtkWidget *zoom_in_item; 148c6158483SAnthony Liguori GtkWidget *zoom_out_item; 149c6158483SAnthony Liguori GtkWidget *zoom_fixed_item; 150c6158483SAnthony Liguori GtkWidget *zoom_fit_item; 1515104a1f6SAnthony Liguori GtkWidget *grab_item; 1525104a1f6SAnthony Liguori GtkWidget *grab_on_hover_item; 153a4ccabcfSAnthony Liguori 154d861def3SAnthony Liguori int nb_vcs; 155d861def3SAnthony Liguori VirtualConsole vc[MAX_VCS]; 156d861def3SAnthony Liguori 157a4ccabcfSAnthony Liguori GtkWidget *show_tabs_item; 158cdeb7090SGerd Hoffmann GtkWidget *untabify_item; 159a4ccabcfSAnthony Liguori 160a4ccabcfSAnthony Liguori GtkWidget *vbox; 161a4ccabcfSAnthony Liguori GtkWidget *notebook; 162a4ccabcfSAnthony Liguori int button_mask; 163e61031cdSTakashi Iwai gboolean last_set; 164a4ccabcfSAnthony Liguori int last_x; 165a4ccabcfSAnthony Liguori int last_y; 166ecce1929STakashi Iwai int grab_x_root; 167ecce1929STakashi Iwai int grab_y_root; 1684c638e2eSGerd Hoffmann VirtualConsole *kbd_owner; 1694c638e2eSGerd Hoffmann VirtualConsole *ptr_owner; 170a4ccabcfSAnthony Liguori 171c6158483SAnthony Liguori gboolean full_screen; 172a4ccabcfSAnthony Liguori 173a4ccabcfSAnthony Liguori GdkCursor *null_cursor; 174a4ccabcfSAnthony Liguori Notifier mouse_mode_notifier; 175c6158483SAnthony Liguori gboolean free_scale; 17630e8f22bSJan Kiszka 17730e8f22bSJan Kiszka bool external_pause_update; 1786db253caSJan Kiszka 1796db253caSJan Kiszka bool modifier_pressed[ARRAY_SIZE(modifier_keycode)]; 1803158a348SBruce Rogers bool has_evdev; 1811a01716aSJan Kiszka bool ignore_keys; 182e3500d1fSGerd Hoffmann }; 183a4ccabcfSAnthony Liguori 184*0ec7b3e7SMarc-André Lureau typedef struct VCChardev { 185*0ec7b3e7SMarc-André Lureau Chardev parent; 18641ac54b2SMarc-André Lureau VirtualConsole *console; 18741ac54b2SMarc-André Lureau bool echo; 188*0ec7b3e7SMarc-André Lureau } VCChardev; 18941ac54b2SMarc-André Lureau 190d531deefSGerd Hoffmann static void gd_grab_pointer(VirtualConsole *vc, const char *reason); 1912884cf5bSGerd Hoffmann static void gd_ungrab_pointer(GtkDisplayState *s); 192d531deefSGerd Hoffmann static void gd_grab_keyboard(VirtualConsole *vc, const char *reason); 193aa4f4058SGerd Hoffmann static void gd_ungrab_keyboard(GtkDisplayState *s); 1942884cf5bSGerd Hoffmann 195a4ccabcfSAnthony Liguori /** Utility Functions **/ 196a4ccabcfSAnthony Liguori 197271a25c0SGerd Hoffmann static VirtualConsole *gd_vc_find_by_menu(GtkDisplayState *s) 198271a25c0SGerd Hoffmann { 199271a25c0SGerd Hoffmann VirtualConsole *vc; 200271a25c0SGerd Hoffmann gint i; 201271a25c0SGerd Hoffmann 202271a25c0SGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 203271a25c0SGerd Hoffmann vc = &s->vc[i]; 204271a25c0SGerd Hoffmann if (gtk_check_menu_item_get_active 205271a25c0SGerd Hoffmann (GTK_CHECK_MENU_ITEM(vc->menu_item))) { 206271a25c0SGerd Hoffmann return vc; 207271a25c0SGerd Hoffmann } 208271a25c0SGerd Hoffmann } 209271a25c0SGerd Hoffmann return NULL; 210271a25c0SGerd Hoffmann } 211271a25c0SGerd Hoffmann 212271a25c0SGerd Hoffmann static VirtualConsole *gd_vc_find_by_page(GtkDisplayState *s, gint page) 213271a25c0SGerd Hoffmann { 214271a25c0SGerd Hoffmann VirtualConsole *vc; 215271a25c0SGerd Hoffmann gint i, p; 216271a25c0SGerd Hoffmann 217271a25c0SGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 218271a25c0SGerd Hoffmann vc = &s->vc[i]; 219271a25c0SGerd Hoffmann p = gtk_notebook_page_num(GTK_NOTEBOOK(s->notebook), vc->tab_item); 220271a25c0SGerd Hoffmann if (p == page) { 221271a25c0SGerd Hoffmann return vc; 222271a25c0SGerd Hoffmann } 223271a25c0SGerd Hoffmann } 224271a25c0SGerd Hoffmann return NULL; 225271a25c0SGerd Hoffmann } 226271a25c0SGerd Hoffmann 227e3500d1fSGerd Hoffmann static VirtualConsole *gd_vc_find_current(GtkDisplayState *s) 228e3500d1fSGerd Hoffmann { 229e3500d1fSGerd Hoffmann gint page; 230e3500d1fSGerd Hoffmann 231e3500d1fSGerd Hoffmann page = gtk_notebook_get_current_page(GTK_NOTEBOOK(s->notebook)); 232e3500d1fSGerd Hoffmann return gd_vc_find_by_page(s, page); 233e3500d1fSGerd Hoffmann } 234e3500d1fSGerd Hoffmann 2355104a1f6SAnthony Liguori static bool gd_is_grab_active(GtkDisplayState *s) 2365104a1f6SAnthony Liguori { 2375104a1f6SAnthony Liguori return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_item)); 2385104a1f6SAnthony Liguori } 2395104a1f6SAnthony Liguori 2405104a1f6SAnthony Liguori static bool gd_grab_on_hover(GtkDisplayState *s) 2415104a1f6SAnthony Liguori { 2425104a1f6SAnthony Liguori return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_on_hover_item)); 2435104a1f6SAnthony Liguori } 2445104a1f6SAnthony Liguori 245e3500d1fSGerd Hoffmann static void gd_update_cursor(VirtualConsole *vc) 2465104a1f6SAnthony Liguori { 247e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 248e3500d1fSGerd Hoffmann GdkWindow *window; 249832189c9SGerd Hoffmann 250f8c223f6SGerd Hoffmann if (vc->type != GD_VC_GFX || 251f8c223f6SGerd Hoffmann !qemu_console_is_graphic(vc->gfx.dcl.con)) { 252e3500d1fSGerd Hoffmann return; 2535104a1f6SAnthony Liguori } 2545104a1f6SAnthony Liguori 2554cdfc935SHervé Poussineau if (!gtk_widget_get_realized(vc->gfx.drawing_area)) { 2564cdfc935SHervé Poussineau return; 2574cdfc935SHervé Poussineau } 2584cdfc935SHervé Poussineau 259e3500d1fSGerd Hoffmann window = gtk_widget_get_window(GTK_WIDGET(vc->gfx.drawing_area)); 2602884cf5bSGerd Hoffmann if (s->full_screen || qemu_input_is_absolute() || s->ptr_owner == vc) { 261a4ccabcfSAnthony Liguori gdk_window_set_cursor(window, s->null_cursor); 262a4ccabcfSAnthony Liguori } else { 263a4ccabcfSAnthony Liguori gdk_window_set_cursor(window, NULL); 264a4ccabcfSAnthony Liguori } 265a4ccabcfSAnthony Liguori } 266a4ccabcfSAnthony Liguori 267a4ccabcfSAnthony Liguori static void gd_update_caption(GtkDisplayState *s) 268a4ccabcfSAnthony Liguori { 269a4ccabcfSAnthony Liguori const char *status = ""; 2704eeaa3a8SGerd Hoffmann gchar *prefix; 271a4ccabcfSAnthony Liguori gchar *title; 2725104a1f6SAnthony Liguori const char *grab = ""; 27330e8f22bSJan Kiszka bool is_paused = !runstate_is_running(); 2744eeaa3a8SGerd Hoffmann int i; 2755104a1f6SAnthony Liguori 2764eeaa3a8SGerd Hoffmann if (qemu_name) { 2774eeaa3a8SGerd Hoffmann prefix = g_strdup_printf("QEMU (%s)", qemu_name); 2784eeaa3a8SGerd Hoffmann } else { 2794eeaa3a8SGerd Hoffmann prefix = g_strdup_printf("QEMU"); 2804eeaa3a8SGerd Hoffmann } 2814eeaa3a8SGerd Hoffmann 2824eeaa3a8SGerd Hoffmann if (s->ptr_owner != NULL && 2834eeaa3a8SGerd Hoffmann s->ptr_owner->window == NULL) { 284d8da9ee8SAurelien Jarno grab = _(" - Press Ctrl+Alt+G to release grab"); 2855104a1f6SAnthony Liguori } 286a4ccabcfSAnthony Liguori 28730e8f22bSJan Kiszka if (is_paused) { 288d8da9ee8SAurelien Jarno status = _(" [Paused]"); 289a4ccabcfSAnthony Liguori } 29030e8f22bSJan Kiszka s->external_pause_update = true; 29130e8f22bSJan Kiszka gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->pause_item), 29230e8f22bSJan Kiszka is_paused); 29330e8f22bSJan Kiszka s->external_pause_update = false; 294a4ccabcfSAnthony Liguori 2954eeaa3a8SGerd Hoffmann title = g_strdup_printf("%s%s%s", prefix, status, grab); 2964eeaa3a8SGerd Hoffmann gtk_window_set_title(GTK_WINDOW(s->window), title); 2974eeaa3a8SGerd Hoffmann g_free(title); 2984eeaa3a8SGerd Hoffmann 2994eeaa3a8SGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 3004eeaa3a8SGerd Hoffmann VirtualConsole *vc = &s->vc[i]; 3014eeaa3a8SGerd Hoffmann 3024eeaa3a8SGerd Hoffmann if (!vc->window) { 3034eeaa3a8SGerd Hoffmann continue; 3044eeaa3a8SGerd Hoffmann } 3054eeaa3a8SGerd Hoffmann title = g_strdup_printf("%s: %s%s%s", prefix, vc->label, 3064eeaa3a8SGerd Hoffmann vc == s->kbd_owner ? " +kbd" : "", 3074eeaa3a8SGerd Hoffmann vc == s->ptr_owner ? " +ptr" : ""); 3084eeaa3a8SGerd Hoffmann gtk_window_set_title(GTK_WINDOW(vc->window), title); 3094eeaa3a8SGerd Hoffmann g_free(title); 310a4ccabcfSAnthony Liguori } 311a4ccabcfSAnthony Liguori 3124eeaa3a8SGerd Hoffmann g_free(prefix); 313a4ccabcfSAnthony Liguori } 314a4ccabcfSAnthony Liguori 31582fc1809SGerd Hoffmann static void gd_update_geometry_hints(VirtualConsole *vc) 31682fc1809SGerd Hoffmann { 31782fc1809SGerd Hoffmann GtkDisplayState *s = vc->s; 31882fc1809SGerd Hoffmann GdkWindowHints mask = 0; 31982fc1809SGerd Hoffmann GdkGeometry geo = {}; 32082fc1809SGerd Hoffmann GtkWidget *geo_widget = NULL; 32182fc1809SGerd Hoffmann GtkWindow *geo_window; 32282fc1809SGerd Hoffmann 32382fc1809SGerd Hoffmann if (vc->type == GD_VC_GFX) { 324f98f43eaSGerd Hoffmann if (!vc->gfx.ds) { 325f98f43eaSGerd Hoffmann return; 326f98f43eaSGerd Hoffmann } 32782fc1809SGerd Hoffmann if (s->free_scale) { 32882fc1809SGerd Hoffmann geo.min_width = surface_width(vc->gfx.ds) * VC_SCALE_MIN; 32982fc1809SGerd Hoffmann geo.min_height = surface_height(vc->gfx.ds) * VC_SCALE_MIN; 33082fc1809SGerd Hoffmann mask |= GDK_HINT_MIN_SIZE; 33182fc1809SGerd Hoffmann } else { 33282fc1809SGerd Hoffmann geo.min_width = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 33382fc1809SGerd Hoffmann geo.min_height = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 33482fc1809SGerd Hoffmann mask |= GDK_HINT_MIN_SIZE; 33582fc1809SGerd Hoffmann } 33682fc1809SGerd Hoffmann geo_widget = vc->gfx.drawing_area; 33782fc1809SGerd Hoffmann gtk_widget_set_size_request(geo_widget, geo.min_width, geo.min_height); 33882fc1809SGerd Hoffmann 33982fc1809SGerd Hoffmann #if defined(CONFIG_VTE) 34082fc1809SGerd Hoffmann } else if (vc->type == GD_VC_VTE) { 34182fc1809SGerd Hoffmann VteTerminal *term = VTE_TERMINAL(vc->vte.terminal); 3426978dc4aSAlberto Garcia GtkBorder padding = { 0 }; 34382fc1809SGerd Hoffmann 34484e2dc4bSCole Robinson #if VTE_CHECK_VERSION(0, 37, 0) 34584e2dc4bSCole Robinson gtk_style_context_get_padding( 34684e2dc4bSCole Robinson gtk_widget_get_style_context(vc->vte.terminal), 34784e2dc4bSCole Robinson gtk_widget_get_state_flags(vc->vte.terminal), 34884e2dc4bSCole Robinson &padding); 34984e2dc4bSCole Robinson #else 3506978dc4aSAlberto Garcia { 3516978dc4aSAlberto Garcia GtkBorder *ib = NULL; 35284e2dc4bSCole Robinson gtk_widget_style_get(vc->vte.terminal, "inner-border", &ib, NULL); 3536978dc4aSAlberto Garcia if (ib) { 3546978dc4aSAlberto Garcia padding = *ib; 3556978dc4aSAlberto Garcia gtk_border_free(ib); 3566978dc4aSAlberto Garcia } 3576978dc4aSAlberto Garcia } 35884e2dc4bSCole Robinson #endif 35984e2dc4bSCole Robinson 36082fc1809SGerd Hoffmann geo.width_inc = vte_terminal_get_char_width(term); 36182fc1809SGerd Hoffmann geo.height_inc = vte_terminal_get_char_height(term); 36282fc1809SGerd Hoffmann mask |= GDK_HINT_RESIZE_INC; 36382fc1809SGerd Hoffmann geo.base_width = geo.width_inc; 36482fc1809SGerd Hoffmann geo.base_height = geo.height_inc; 36582fc1809SGerd Hoffmann mask |= GDK_HINT_BASE_SIZE; 36682fc1809SGerd Hoffmann geo.min_width = geo.width_inc * VC_TERM_X_MIN; 36782fc1809SGerd Hoffmann geo.min_height = geo.height_inc * VC_TERM_Y_MIN; 36882fc1809SGerd Hoffmann mask |= GDK_HINT_MIN_SIZE; 36984e2dc4bSCole Robinson 3706978dc4aSAlberto Garcia geo.base_width += padding.left + padding.right; 3716978dc4aSAlberto Garcia geo.base_height += padding.top + padding.bottom; 3726978dc4aSAlberto Garcia geo.min_width += padding.left + padding.right; 3736978dc4aSAlberto Garcia geo.min_height += padding.top + padding.bottom; 37482fc1809SGerd Hoffmann geo_widget = vc->vte.terminal; 37582fc1809SGerd Hoffmann #endif 37682fc1809SGerd Hoffmann } 37782fc1809SGerd Hoffmann 37882fc1809SGerd Hoffmann geo_window = GTK_WINDOW(vc->window ? vc->window : s->window); 37982fc1809SGerd Hoffmann gtk_window_set_geometry_hints(geo_window, geo_widget, &geo, mask); 38082fc1809SGerd Hoffmann } 38182fc1809SGerd Hoffmann 38297edf3bdSGerd Hoffmann void gd_update_windowsize(VirtualConsole *vc) 383a4ccabcfSAnthony Liguori { 384e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 385c6158483SAnthony Liguori 38682fc1809SGerd Hoffmann gd_update_geometry_hints(vc); 387c6158483SAnthony Liguori 38882fc1809SGerd Hoffmann if (vc->type == GD_VC_GFX && !s->full_screen && !s->free_scale) { 38982fc1809SGerd Hoffmann gtk_window_resize(GTK_WINDOW(vc->window ? vc->window : s->window), 39082fc1809SGerd Hoffmann VC_WINDOW_X_MIN, VC_WINDOW_Y_MIN); 391a4ccabcfSAnthony Liguori } 392aa0a55d4SGerd Hoffmann } 393a4ccabcfSAnthony Liguori 394e3500d1fSGerd Hoffmann static void gd_update_full_redraw(VirtualConsole *vc) 3959d9801cfSGerd Hoffmann { 396e3500d1fSGerd Hoffmann GtkWidget *area = vc->gfx.drawing_area; 3979d9801cfSGerd Hoffmann int ww, wh; 398e3500d1fSGerd Hoffmann gdk_drawable_get_size(gtk_widget_get_window(area), &ww, &wh); 399925a0400SGerd Hoffmann #if defined(CONFIG_GTK_GL) 400925a0400SGerd Hoffmann if (vc->gfx.gls) { 401925a0400SGerd Hoffmann gtk_gl_area_queue_render(GTK_GL_AREA(vc->gfx.drawing_area)); 402925a0400SGerd Hoffmann return; 403925a0400SGerd Hoffmann } 404925a0400SGerd Hoffmann #endif 405e3500d1fSGerd Hoffmann gtk_widget_queue_draw_area(area, 0, 0, ww, wh); 4069d9801cfSGerd Hoffmann } 4079d9801cfSGerd Hoffmann 4086db253caSJan Kiszka static void gtk_release_modifiers(GtkDisplayState *s) 4096db253caSJan Kiszka { 410e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 4116db253caSJan Kiszka int i, keycode; 4126db253caSJan Kiszka 413f8c223f6SGerd Hoffmann if (vc->type != GD_VC_GFX || 414f8c223f6SGerd Hoffmann !qemu_console_is_graphic(vc->gfx.dcl.con)) { 4156db253caSJan Kiszka return; 4166db253caSJan Kiszka } 4176db253caSJan Kiszka for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) { 4186db253caSJan Kiszka keycode = modifier_keycode[i]; 4196db253caSJan Kiszka if (!s->modifier_pressed[i]) { 4206db253caSJan Kiszka continue; 4216db253caSJan Kiszka } 422e3500d1fSGerd Hoffmann qemu_input_event_send_key_number(vc->gfx.dcl.con, keycode, false); 4236db253caSJan Kiszka s->modifier_pressed[i] = false; 4246db253caSJan Kiszka } 4256db253caSJan Kiszka } 4266db253caSJan Kiszka 427316cb068SGerd Hoffmann static void gd_widget_reparent(GtkWidget *from, GtkWidget *to, 428316cb068SGerd Hoffmann GtkWidget *widget) 429316cb068SGerd Hoffmann { 430316cb068SGerd Hoffmann g_object_ref(G_OBJECT(widget)); 431316cb068SGerd Hoffmann gtk_container_remove(GTK_CONTAINER(from), widget); 432316cb068SGerd Hoffmann gtk_container_add(GTK_CONTAINER(to), widget); 433316cb068SGerd Hoffmann g_object_unref(G_OBJECT(widget)); 434316cb068SGerd Hoffmann } 435316cb068SGerd Hoffmann 4369d9801cfSGerd Hoffmann /** DisplayState Callbacks **/ 4379d9801cfSGerd Hoffmann 4389d9801cfSGerd Hoffmann static void gd_update(DisplayChangeListener *dcl, 439bc2ed970SGerd Hoffmann int x, int y, int w, int h) 4409d9801cfSGerd Hoffmann { 441e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 442f8c223f6SGerd Hoffmann GdkWindow *win; 4439d9801cfSGerd Hoffmann int x1, x2, y1, y2; 4449d9801cfSGerd Hoffmann int mx, my; 4459d9801cfSGerd Hoffmann int fbw, fbh; 4469d9801cfSGerd Hoffmann int ww, wh; 4479d9801cfSGerd Hoffmann 44874444bc1SGerd Hoffmann trace_gd_update(vc->label, x, y, w, h); 4499d9801cfSGerd Hoffmann 4504cdfc935SHervé Poussineau if (!gtk_widget_get_realized(vc->gfx.drawing_area)) { 4514cdfc935SHervé Poussineau return; 4524cdfc935SHervé Poussineau } 4534cdfc935SHervé Poussineau 454e3500d1fSGerd Hoffmann if (vc->gfx.convert) { 455e3500d1fSGerd Hoffmann pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image, 456e3500d1fSGerd Hoffmann NULL, vc->gfx.convert, 457f0875536SGerd Hoffmann x, y, 0, 0, x, y, w, h); 458f0875536SGerd Hoffmann } 459f0875536SGerd Hoffmann 460e3500d1fSGerd Hoffmann x1 = floor(x * vc->gfx.scale_x); 461e3500d1fSGerd Hoffmann y1 = floor(y * vc->gfx.scale_y); 4629d9801cfSGerd Hoffmann 463e3500d1fSGerd Hoffmann x2 = ceil(x * vc->gfx.scale_x + w * vc->gfx.scale_x); 464e3500d1fSGerd Hoffmann y2 = ceil(y * vc->gfx.scale_y + h * vc->gfx.scale_y); 4659d9801cfSGerd Hoffmann 466e3500d1fSGerd Hoffmann fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 467e3500d1fSGerd Hoffmann fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 4689d9801cfSGerd Hoffmann 469f8c223f6SGerd Hoffmann win = gtk_widget_get_window(vc->gfx.drawing_area); 470f8c223f6SGerd Hoffmann if (!win) { 471f8c223f6SGerd Hoffmann return; 472f8c223f6SGerd Hoffmann } 473f8c223f6SGerd Hoffmann gdk_drawable_get_size(win, &ww, &wh); 4749d9801cfSGerd Hoffmann 4759d9801cfSGerd Hoffmann mx = my = 0; 4769d9801cfSGerd Hoffmann if (ww > fbw) { 4779d9801cfSGerd Hoffmann mx = (ww - fbw) / 2; 4789d9801cfSGerd Hoffmann } 4799d9801cfSGerd Hoffmann if (wh > fbh) { 4809d9801cfSGerd Hoffmann my = (wh - fbh) / 2; 4819d9801cfSGerd Hoffmann } 4829d9801cfSGerd Hoffmann 483e3500d1fSGerd Hoffmann gtk_widget_queue_draw_area(vc->gfx.drawing_area, 484e3500d1fSGerd Hoffmann mx + x1, my + y1, (x2 - x1), (y2 - y1)); 4859d9801cfSGerd Hoffmann } 4869d9801cfSGerd Hoffmann 487bc2ed970SGerd Hoffmann static void gd_refresh(DisplayChangeListener *dcl) 4889d9801cfSGerd Hoffmann { 489284d1c6bSGerd Hoffmann graphic_hw_update(dcl->con); 4909d9801cfSGerd Hoffmann } 4919d9801cfSGerd Hoffmann 492b087143bSIgor Mitsyanko #if GTK_CHECK_VERSION(3, 0, 0) 493bb732ee7SCole Robinson static GdkDevice *gd_get_pointer(GdkDisplay *dpy) 494bb732ee7SCole Robinson { 495bb732ee7SCole Robinson #if GTK_CHECK_VERSION(3, 20, 0) 496bb732ee7SCole Robinson return gdk_seat_get_pointer(gdk_display_get_default_seat(dpy)); 497bb732ee7SCole Robinson #else 498bb732ee7SCole Robinson return gdk_device_manager_get_client_pointer( 499bb732ee7SCole Robinson gdk_display_get_device_manager(dpy)); 500bb732ee7SCole Robinson #endif 501bb732ee7SCole Robinson } 502bb732ee7SCole Robinson 503b087143bSIgor Mitsyanko static void gd_mouse_set(DisplayChangeListener *dcl, 504b087143bSIgor Mitsyanko int x, int y, int visible) 505b087143bSIgor Mitsyanko { 506e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 507b087143bSIgor Mitsyanko GdkDisplay *dpy; 508b087143bSIgor Mitsyanko gint x_root, y_root; 509b087143bSIgor Mitsyanko 5102bda6602SCole Robinson if (qemu_input_is_absolute()) { 5112bda6602SCole Robinson return; 5122bda6602SCole Robinson } 5132bda6602SCole Robinson 514e3500d1fSGerd Hoffmann dpy = gtk_widget_get_display(vc->gfx.drawing_area); 515e3500d1fSGerd Hoffmann gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area), 516b087143bSIgor Mitsyanko x, y, &x_root, &y_root); 517bb732ee7SCole Robinson gdk_device_warp(gd_get_pointer(dpy), 518e3500d1fSGerd Hoffmann gtk_widget_get_screen(vc->gfx.drawing_area), 519298526feSCole Robinson x_root, y_root); 5201271f7f7SGerd Hoffmann vc->s->last_x = x; 5211271f7f7SGerd Hoffmann vc->s->last_y = y; 522b087143bSIgor Mitsyanko } 523b087143bSIgor Mitsyanko #else 5249697f5d2SGerd Hoffmann static void gd_mouse_set(DisplayChangeListener *dcl, 5259697f5d2SGerd Hoffmann int x, int y, int visible) 5269697f5d2SGerd Hoffmann { 527e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 5289697f5d2SGerd Hoffmann gint x_root, y_root; 5299697f5d2SGerd Hoffmann 5302bda6602SCole Robinson if (qemu_input_is_absolute()) { 5312bda6602SCole Robinson return; 5322bda6602SCole Robinson } 5332bda6602SCole Robinson 534e3500d1fSGerd Hoffmann gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area), 5359697f5d2SGerd Hoffmann x, y, &x_root, &y_root); 536e3500d1fSGerd Hoffmann gdk_display_warp_pointer(gtk_widget_get_display(vc->gfx.drawing_area), 537e3500d1fSGerd Hoffmann gtk_widget_get_screen(vc->gfx.drawing_area), 5389697f5d2SGerd Hoffmann x_root, y_root); 5399697f5d2SGerd Hoffmann } 540b087143bSIgor Mitsyanko #endif 5419697f5d2SGerd Hoffmann 5429697f5d2SGerd Hoffmann static void gd_cursor_define(DisplayChangeListener *dcl, 5439697f5d2SGerd Hoffmann QEMUCursor *c) 5449697f5d2SGerd Hoffmann { 545e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 5469697f5d2SGerd Hoffmann GdkPixbuf *pixbuf; 5479697f5d2SGerd Hoffmann GdkCursor *cursor; 5489697f5d2SGerd Hoffmann 5494cdfc935SHervé Poussineau if (!gtk_widget_get_realized(vc->gfx.drawing_area)) { 5504cdfc935SHervé Poussineau return; 5514cdfc935SHervé Poussineau } 5524cdfc935SHervé Poussineau 5539697f5d2SGerd Hoffmann pixbuf = gdk_pixbuf_new_from_data((guchar *)(c->data), 5549697f5d2SGerd Hoffmann GDK_COLORSPACE_RGB, true, 8, 5559697f5d2SGerd Hoffmann c->width, c->height, c->width * 4, 5569697f5d2SGerd Hoffmann NULL, NULL); 557e3500d1fSGerd Hoffmann cursor = gdk_cursor_new_from_pixbuf 558e3500d1fSGerd Hoffmann (gtk_widget_get_display(vc->gfx.drawing_area), 5599697f5d2SGerd Hoffmann pixbuf, c->hot_x, c->hot_y); 560e3500d1fSGerd Hoffmann gdk_window_set_cursor(gtk_widget_get_window(vc->gfx.drawing_area), cursor); 5619697f5d2SGerd Hoffmann g_object_unref(pixbuf); 562030b4b7dSStefan Weil #if !GTK_CHECK_VERSION(3, 0, 0) 56317139240SAnthony Liguori gdk_cursor_unref(cursor); 564030b4b7dSStefan Weil #else 565030b4b7dSStefan Weil g_object_unref(cursor); 566030b4b7dSStefan Weil #endif 5679697f5d2SGerd Hoffmann } 5689697f5d2SGerd Hoffmann 5699d9801cfSGerd Hoffmann static void gd_switch(DisplayChangeListener *dcl, 5709d9801cfSGerd Hoffmann DisplaySurface *surface) 5719d9801cfSGerd Hoffmann { 572e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 5739d9801cfSGerd Hoffmann bool resized = true; 5749d9801cfSGerd Hoffmann 575f98f43eaSGerd Hoffmann trace_gd_switch(vc->label, 576f98f43eaSGerd Hoffmann surface ? surface_width(surface) : 0, 577f98f43eaSGerd Hoffmann surface ? surface_height(surface) : 0); 5789d9801cfSGerd Hoffmann 579e3500d1fSGerd Hoffmann if (vc->gfx.surface) { 580e3500d1fSGerd Hoffmann cairo_surface_destroy(vc->gfx.surface); 581f98f43eaSGerd Hoffmann vc->gfx.surface = NULL; 582f98f43eaSGerd Hoffmann } 583f98f43eaSGerd Hoffmann if (vc->gfx.convert) { 584f98f43eaSGerd Hoffmann pixman_image_unref(vc->gfx.convert); 585f98f43eaSGerd Hoffmann vc->gfx.convert = NULL; 5869d9801cfSGerd Hoffmann } 5879d9801cfSGerd Hoffmann 588f98f43eaSGerd Hoffmann if (vc->gfx.ds && surface && 589e3500d1fSGerd Hoffmann surface_width(vc->gfx.ds) == surface_width(surface) && 590e3500d1fSGerd Hoffmann surface_height(vc->gfx.ds) == surface_height(surface)) { 5919d9801cfSGerd Hoffmann resized = false; 5929d9801cfSGerd Hoffmann } 593e3500d1fSGerd Hoffmann vc->gfx.ds = surface; 594f0875536SGerd Hoffmann 595f98f43eaSGerd Hoffmann if (!surface) { 596f98f43eaSGerd Hoffmann return; 5979d9801cfSGerd Hoffmann } 5989d9801cfSGerd Hoffmann 599f0875536SGerd Hoffmann if (surface->format == PIXMAN_x8r8g8b8) { 600f0875536SGerd Hoffmann /* 601f0875536SGerd Hoffmann * PIXMAN_x8r8g8b8 == CAIRO_FORMAT_RGB24 602f0875536SGerd Hoffmann * 603f0875536SGerd Hoffmann * No need to convert, use surface directly. Should be the 604f0875536SGerd Hoffmann * common case as this is qemu_default_pixelformat(32) too. 605f0875536SGerd Hoffmann */ 606e3500d1fSGerd Hoffmann vc->gfx.surface = cairo_image_surface_create_for_data 607f0875536SGerd Hoffmann (surface_data(surface), 608f0875536SGerd Hoffmann CAIRO_FORMAT_RGB24, 6099d9801cfSGerd Hoffmann surface_width(surface), 6109d9801cfSGerd Hoffmann surface_height(surface), 6119d9801cfSGerd Hoffmann surface_stride(surface)); 612f0875536SGerd Hoffmann } else { 613f0875536SGerd Hoffmann /* Must convert surface, use pixman to do it. */ 614e3500d1fSGerd Hoffmann vc->gfx.convert = pixman_image_create_bits(PIXMAN_x8r8g8b8, 615f0875536SGerd Hoffmann surface_width(surface), 616f0875536SGerd Hoffmann surface_height(surface), 617f0875536SGerd Hoffmann NULL, 0); 618e3500d1fSGerd Hoffmann vc->gfx.surface = cairo_image_surface_create_for_data 619e3500d1fSGerd Hoffmann ((void *)pixman_image_get_data(vc->gfx.convert), 620f0875536SGerd Hoffmann CAIRO_FORMAT_RGB24, 621e3500d1fSGerd Hoffmann pixman_image_get_width(vc->gfx.convert), 622e3500d1fSGerd Hoffmann pixman_image_get_height(vc->gfx.convert), 623e3500d1fSGerd Hoffmann pixman_image_get_stride(vc->gfx.convert)); 624e3500d1fSGerd Hoffmann pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image, 625e3500d1fSGerd Hoffmann NULL, vc->gfx.convert, 626f0875536SGerd Hoffmann 0, 0, 0, 0, 0, 0, 627e3500d1fSGerd Hoffmann pixman_image_get_width(vc->gfx.convert), 628e3500d1fSGerd Hoffmann pixman_image_get_height(vc->gfx.convert)); 629f0875536SGerd Hoffmann } 6309d9801cfSGerd Hoffmann 6319d9801cfSGerd Hoffmann if (resized) { 632e3500d1fSGerd Hoffmann gd_update_windowsize(vc); 6339d9801cfSGerd Hoffmann } else { 634e3500d1fSGerd Hoffmann gd_update_full_redraw(vc); 6359d9801cfSGerd Hoffmann } 6369d9801cfSGerd Hoffmann } 6379d9801cfSGerd Hoffmann 63897edf3bdSGerd Hoffmann static const DisplayChangeListenerOps dcl_ops = { 63997edf3bdSGerd Hoffmann .dpy_name = "gtk", 64097edf3bdSGerd Hoffmann .dpy_gfx_update = gd_update, 64197edf3bdSGerd Hoffmann .dpy_gfx_switch = gd_switch, 64297edf3bdSGerd Hoffmann .dpy_gfx_check_format = qemu_pixman_check_format, 64397edf3bdSGerd Hoffmann .dpy_refresh = gd_refresh, 64497edf3bdSGerd Hoffmann .dpy_mouse_set = gd_mouse_set, 64597edf3bdSGerd Hoffmann .dpy_cursor_define = gd_cursor_define, 64697edf3bdSGerd Hoffmann }; 64797edf3bdSGerd Hoffmann 64897edf3bdSGerd Hoffmann 64997edf3bdSGerd Hoffmann #if defined(CONFIG_OPENGL) 65097edf3bdSGerd Hoffmann 65197edf3bdSGerd Hoffmann /** DisplayState Callbacks (opengl version) **/ 65297edf3bdSGerd Hoffmann 653925a0400SGerd Hoffmann #if defined(CONFIG_GTK_GL) 654925a0400SGerd Hoffmann 655925a0400SGerd Hoffmann static const DisplayChangeListenerOps dcl_gl_area_ops = { 656925a0400SGerd Hoffmann .dpy_name = "gtk-egl", 657925a0400SGerd Hoffmann .dpy_gfx_update = gd_gl_area_update, 658925a0400SGerd Hoffmann .dpy_gfx_switch = gd_gl_area_switch, 659925a0400SGerd Hoffmann .dpy_gfx_check_format = console_gl_check_format, 660925a0400SGerd Hoffmann .dpy_refresh = gd_gl_area_refresh, 661925a0400SGerd Hoffmann .dpy_mouse_set = gd_mouse_set, 662925a0400SGerd Hoffmann .dpy_cursor_define = gd_cursor_define, 663925a0400SGerd Hoffmann 664925a0400SGerd Hoffmann .dpy_gl_ctx_create = gd_gl_area_create_context, 665925a0400SGerd Hoffmann .dpy_gl_ctx_destroy = gd_gl_area_destroy_context, 666925a0400SGerd Hoffmann .dpy_gl_ctx_make_current = gd_gl_area_make_current, 667925a0400SGerd Hoffmann .dpy_gl_ctx_get_current = gd_gl_area_get_current_context, 668925a0400SGerd Hoffmann .dpy_gl_scanout = gd_gl_area_scanout, 669925a0400SGerd Hoffmann .dpy_gl_update = gd_gl_area_scanout_flush, 670925a0400SGerd Hoffmann }; 671925a0400SGerd Hoffmann 672925a0400SGerd Hoffmann #else 673925a0400SGerd Hoffmann 67497edf3bdSGerd Hoffmann static const DisplayChangeListenerOps dcl_egl_ops = { 67597edf3bdSGerd Hoffmann .dpy_name = "gtk-egl", 67697edf3bdSGerd Hoffmann .dpy_gfx_update = gd_egl_update, 67797edf3bdSGerd Hoffmann .dpy_gfx_switch = gd_egl_switch, 67897edf3bdSGerd Hoffmann .dpy_gfx_check_format = console_gl_check_format, 67997edf3bdSGerd Hoffmann .dpy_refresh = gd_egl_refresh, 68097edf3bdSGerd Hoffmann .dpy_mouse_set = gd_mouse_set, 68197edf3bdSGerd Hoffmann .dpy_cursor_define = gd_cursor_define, 6824782aeb7SGerd Hoffmann 6834782aeb7SGerd Hoffmann .dpy_gl_ctx_create = gd_egl_create_context, 6844782aeb7SGerd Hoffmann .dpy_gl_ctx_destroy = qemu_egl_destroy_context, 6854782aeb7SGerd Hoffmann .dpy_gl_ctx_make_current = gd_egl_make_current, 6864782aeb7SGerd Hoffmann .dpy_gl_ctx_get_current = qemu_egl_get_current_context, 6874782aeb7SGerd Hoffmann .dpy_gl_scanout = gd_egl_scanout, 6884782aeb7SGerd Hoffmann .dpy_gl_update = gd_egl_scanout_flush, 68997edf3bdSGerd Hoffmann }; 69097edf3bdSGerd Hoffmann 691925a0400SGerd Hoffmann #endif /* CONFIG_GTK_GL */ 692925a0400SGerd Hoffmann #endif /* CONFIG_OPENGL */ 69397edf3bdSGerd Hoffmann 694a4ccabcfSAnthony Liguori /** QEMU Events **/ 695a4ccabcfSAnthony Liguori 696a4ccabcfSAnthony Liguori static void gd_change_runstate(void *opaque, int running, RunState state) 697a4ccabcfSAnthony Liguori { 698a4ccabcfSAnthony Liguori GtkDisplayState *s = opaque; 699a4ccabcfSAnthony Liguori 700a4ccabcfSAnthony Liguori gd_update_caption(s); 701a4ccabcfSAnthony Liguori } 702a4ccabcfSAnthony Liguori 703a4ccabcfSAnthony Liguori static void gd_mouse_mode_change(Notifier *notify, void *data) 704a4ccabcfSAnthony Liguori { 705800b0e81STakashi Iwai GtkDisplayState *s; 70699623c90SGerd Hoffmann int i; 707800b0e81STakashi Iwai 708800b0e81STakashi Iwai s = container_of(notify, GtkDisplayState, mouse_mode_notifier); 709800b0e81STakashi Iwai /* release the grab at switching to absolute mode */ 710800b0e81STakashi Iwai if (qemu_input_is_absolute() && gd_is_grab_active(s)) { 711800b0e81STakashi Iwai gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 712a4ccabcfSAnthony Liguori FALSE); 713a4ccabcfSAnthony Liguori } 71499623c90SGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 71599623c90SGerd Hoffmann VirtualConsole *vc = &s->vc[i]; 71699623c90SGerd Hoffmann gd_update_cursor(vc); 71799623c90SGerd Hoffmann } 718800b0e81STakashi Iwai } 719a4ccabcfSAnthony Liguori 720a4ccabcfSAnthony Liguori /** GTK Events **/ 721a4ccabcfSAnthony Liguori 722a4ccabcfSAnthony Liguori static gboolean gd_window_close(GtkWidget *widget, GdkEvent *event, 723a4ccabcfSAnthony Liguori void *opaque) 724a4ccabcfSAnthony Liguori { 725a4ccabcfSAnthony Liguori GtkDisplayState *s = opaque; 726e3500d1fSGerd Hoffmann int i; 727a4ccabcfSAnthony Liguori 728a4ccabcfSAnthony Liguori if (!no_quit) { 729e3500d1fSGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 730e3500d1fSGerd Hoffmann if (s->vc[i].type != GD_VC_GFX) { 731e3500d1fSGerd Hoffmann continue; 732e3500d1fSGerd Hoffmann } 733e3500d1fSGerd Hoffmann unregister_displaychangelistener(&s->vc[i].gfx.dcl); 734e3500d1fSGerd Hoffmann } 735a4ccabcfSAnthony Liguori qmp_quit(NULL); 736a4ccabcfSAnthony Liguori return FALSE; 737a4ccabcfSAnthony Liguori } 738a4ccabcfSAnthony Liguori 739a4ccabcfSAnthony Liguori return TRUE; 740a4ccabcfSAnthony Liguori } 741a4ccabcfSAnthony Liguori 742925a0400SGerd Hoffmann static void gd_set_ui_info(VirtualConsole *vc, gint width, gint height) 743925a0400SGerd Hoffmann { 744925a0400SGerd Hoffmann QemuUIInfo info; 745925a0400SGerd Hoffmann 746925a0400SGerd Hoffmann memset(&info, 0, sizeof(info)); 747925a0400SGerd Hoffmann info.width = width; 748925a0400SGerd Hoffmann info.height = height; 749925a0400SGerd Hoffmann dpy_set_ui_info(vc->gfx.dcl.con, &info); 750925a0400SGerd Hoffmann } 751925a0400SGerd Hoffmann 752925a0400SGerd Hoffmann #if defined(CONFIG_GTK_GL) 753925a0400SGerd Hoffmann 754925a0400SGerd Hoffmann static gboolean gd_render_event(GtkGLArea *area, GdkGLContext *context, 755925a0400SGerd Hoffmann void *opaque) 756925a0400SGerd Hoffmann { 757925a0400SGerd Hoffmann VirtualConsole *vc = opaque; 758925a0400SGerd Hoffmann 759925a0400SGerd Hoffmann if (vc->gfx.gls) { 760925a0400SGerd Hoffmann gd_gl_area_draw(vc); 761925a0400SGerd Hoffmann } 762925a0400SGerd Hoffmann return TRUE; 763925a0400SGerd Hoffmann } 764925a0400SGerd Hoffmann 765925a0400SGerd Hoffmann static void gd_resize_event(GtkGLArea *area, 766925a0400SGerd Hoffmann gint width, gint height, gpointer *opaque) 767925a0400SGerd Hoffmann { 768925a0400SGerd Hoffmann VirtualConsole *vc = (void *)opaque; 769925a0400SGerd Hoffmann 770925a0400SGerd Hoffmann gd_set_ui_info(vc, width, height); 771925a0400SGerd Hoffmann } 772925a0400SGerd Hoffmann 773925a0400SGerd Hoffmann #endif 774925a0400SGerd Hoffmann 775a4ccabcfSAnthony Liguori static gboolean gd_draw_event(GtkWidget *widget, cairo_t *cr, void *opaque) 776a4ccabcfSAnthony Liguori { 777e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 778e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 779c6158483SAnthony Liguori int mx, my; 780a4ccabcfSAnthony Liguori int ww, wh; 781a4ccabcfSAnthony Liguori int fbw, fbh; 782a4ccabcfSAnthony Liguori 78397edf3bdSGerd Hoffmann #if defined(CONFIG_OPENGL) 78497edf3bdSGerd Hoffmann if (vc->gfx.gls) { 785925a0400SGerd Hoffmann #if defined(CONFIG_GTK_GL) 786925a0400SGerd Hoffmann /* invoke render callback please */ 787925a0400SGerd Hoffmann return FALSE; 788925a0400SGerd Hoffmann #else 78997edf3bdSGerd Hoffmann gd_egl_draw(vc); 79097edf3bdSGerd Hoffmann return TRUE; 791925a0400SGerd Hoffmann #endif 79297edf3bdSGerd Hoffmann } 79397edf3bdSGerd Hoffmann #endif 79497edf3bdSGerd Hoffmann 795c6158483SAnthony Liguori if (!gtk_widget_get_realized(widget)) { 796c6158483SAnthony Liguori return FALSE; 797c6158483SAnthony Liguori } 798f98f43eaSGerd Hoffmann if (!vc->gfx.ds) { 799f98f43eaSGerd Hoffmann return FALSE; 800f98f43eaSGerd Hoffmann } 801c6158483SAnthony Liguori 802e3500d1fSGerd Hoffmann fbw = surface_width(vc->gfx.ds); 803e3500d1fSGerd Hoffmann fbh = surface_height(vc->gfx.ds); 804a4ccabcfSAnthony Liguori 805a4ccabcfSAnthony Liguori gdk_drawable_get_size(gtk_widget_get_window(widget), &ww, &wh); 806a4ccabcfSAnthony Liguori 807c6158483SAnthony Liguori if (s->full_screen) { 808e3500d1fSGerd Hoffmann vc->gfx.scale_x = (double)ww / fbw; 809e3500d1fSGerd Hoffmann vc->gfx.scale_y = (double)wh / fbh; 810c6158483SAnthony Liguori } else if (s->free_scale) { 811c6158483SAnthony Liguori double sx, sy; 812c6158483SAnthony Liguori 813c6158483SAnthony Liguori sx = (double)ww / fbw; 814c6158483SAnthony Liguori sy = (double)wh / fbh; 815c6158483SAnthony Liguori 816e3500d1fSGerd Hoffmann vc->gfx.scale_x = vc->gfx.scale_y = MIN(sx, sy); 817a4ccabcfSAnthony Liguori } 818a4ccabcfSAnthony Liguori 819e3500d1fSGerd Hoffmann fbw *= vc->gfx.scale_x; 820e3500d1fSGerd Hoffmann fbh *= vc->gfx.scale_y; 8215104a1f6SAnthony Liguori 822c6158483SAnthony Liguori mx = my = 0; 823c6158483SAnthony Liguori if (ww > fbw) { 824c6158483SAnthony Liguori mx = (ww - fbw) / 2; 825c6158483SAnthony Liguori } 826c6158483SAnthony Liguori if (wh > fbh) { 827c6158483SAnthony Liguori my = (wh - fbh) / 2; 828c6158483SAnthony Liguori } 829c6158483SAnthony Liguori 830c6158483SAnthony Liguori cairo_rectangle(cr, 0, 0, ww, wh); 831c6158483SAnthony Liguori 832c6158483SAnthony Liguori /* Optionally cut out the inner area where the pixmap 833c6158483SAnthony Liguori will be drawn. This avoids 'flashing' since we're 834c6158483SAnthony Liguori not double-buffering. Note we're using the undocumented 835c6158483SAnthony Liguori behaviour of drawing the rectangle from right to left 836c6158483SAnthony Liguori to cut out the whole */ 837c6158483SAnthony Liguori cairo_rectangle(cr, mx + fbw, my, 838c6158483SAnthony Liguori -1 * fbw, fbh); 839c6158483SAnthony Liguori cairo_fill(cr); 840c6158483SAnthony Liguori 841e3500d1fSGerd Hoffmann cairo_scale(cr, vc->gfx.scale_x, vc->gfx.scale_y); 842e3500d1fSGerd Hoffmann cairo_set_source_surface(cr, vc->gfx.surface, 843e3500d1fSGerd Hoffmann mx / vc->gfx.scale_x, my / vc->gfx.scale_y); 844a4ccabcfSAnthony Liguori cairo_paint(cr); 845a4ccabcfSAnthony Liguori 846a4ccabcfSAnthony Liguori return TRUE; 847a4ccabcfSAnthony Liguori } 848a4ccabcfSAnthony Liguori 849fe43bca8SDaniel P. Berrange #if !GTK_CHECK_VERSION(3, 0, 0) 850a4ccabcfSAnthony Liguori static gboolean gd_expose_event(GtkWidget *widget, GdkEventExpose *expose, 851a4ccabcfSAnthony Liguori void *opaque) 852a4ccabcfSAnthony Liguori { 853a4ccabcfSAnthony Liguori cairo_t *cr; 854a4ccabcfSAnthony Liguori gboolean ret; 855a4ccabcfSAnthony Liguori 856a4ccabcfSAnthony Liguori cr = gdk_cairo_create(gtk_widget_get_window(widget)); 857a4ccabcfSAnthony Liguori cairo_rectangle(cr, 858a4ccabcfSAnthony Liguori expose->area.x, 859a4ccabcfSAnthony Liguori expose->area.y, 860a4ccabcfSAnthony Liguori expose->area.width, 861a4ccabcfSAnthony Liguori expose->area.height); 862a4ccabcfSAnthony Liguori cairo_clip(cr); 863a4ccabcfSAnthony Liguori 864a4ccabcfSAnthony Liguori ret = gd_draw_event(widget, cr, opaque); 865a4ccabcfSAnthony Liguori 866a4ccabcfSAnthony Liguori cairo_destroy(cr); 867a4ccabcfSAnthony Liguori 868a4ccabcfSAnthony Liguori return ret; 869a4ccabcfSAnthony Liguori } 870fe43bca8SDaniel P. Berrange #endif 871a4ccabcfSAnthony Liguori 872a4ccabcfSAnthony Liguori static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion, 873a4ccabcfSAnthony Liguori void *opaque) 874a4ccabcfSAnthony Liguori { 875e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 876e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 877a4ccabcfSAnthony Liguori int x, y; 878c6158483SAnthony Liguori int mx, my; 879c6158483SAnthony Liguori int fbh, fbw; 880c6158483SAnthony Liguori int ww, wh; 881a4ccabcfSAnthony Liguori 882f98f43eaSGerd Hoffmann if (!vc->gfx.ds) { 883f98f43eaSGerd Hoffmann return TRUE; 884f98f43eaSGerd Hoffmann } 885f98f43eaSGerd Hoffmann 886e3500d1fSGerd Hoffmann fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 887e3500d1fSGerd Hoffmann fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 888c6158483SAnthony Liguori 889e3500d1fSGerd Hoffmann gdk_drawable_get_size(gtk_widget_get_window(vc->gfx.drawing_area), 890e3500d1fSGerd Hoffmann &ww, &wh); 891c6158483SAnthony Liguori 892c6158483SAnthony Liguori mx = my = 0; 893c6158483SAnthony Liguori if (ww > fbw) { 894c6158483SAnthony Liguori mx = (ww - fbw) / 2; 895c6158483SAnthony Liguori } 896c6158483SAnthony Liguori if (wh > fbh) { 897c6158483SAnthony Liguori my = (wh - fbh) / 2; 898c6158483SAnthony Liguori } 899c6158483SAnthony Liguori 900e3500d1fSGerd Hoffmann x = (motion->x - mx) / vc->gfx.scale_x; 901e3500d1fSGerd Hoffmann y = (motion->y - my) / vc->gfx.scale_y; 902c6158483SAnthony Liguori 903e61031cdSTakashi Iwai if (qemu_input_is_absolute()) { 904c6158483SAnthony Liguori if (x < 0 || y < 0 || 905e3500d1fSGerd Hoffmann x >= surface_width(vc->gfx.ds) || 906e3500d1fSGerd Hoffmann y >= surface_height(vc->gfx.ds)) { 907c6158483SAnthony Liguori return TRUE; 908c6158483SAnthony Liguori } 909e3500d1fSGerd Hoffmann qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_X, x, 910e3500d1fSGerd Hoffmann surface_width(vc->gfx.ds)); 911e3500d1fSGerd Hoffmann qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_Y, y, 912e3500d1fSGerd Hoffmann surface_height(vc->gfx.ds)); 913192f81bfSGerd Hoffmann qemu_input_event_sync(); 9142884cf5bSGerd Hoffmann } else if (s->last_set && s->ptr_owner == vc) { 915e3500d1fSGerd Hoffmann qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_X, x - s->last_x); 916e3500d1fSGerd Hoffmann qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_Y, y - s->last_y); 917192f81bfSGerd Hoffmann qemu_input_event_sync(); 918a4ccabcfSAnthony Liguori } 919a4ccabcfSAnthony Liguori s->last_x = x; 920a4ccabcfSAnthony Liguori s->last_y = y; 921e61031cdSTakashi Iwai s->last_set = TRUE; 922a4ccabcfSAnthony Liguori 9232884cf5bSGerd Hoffmann if (!qemu_input_is_absolute() && s->ptr_owner == vc) { 924e3500d1fSGerd Hoffmann GdkScreen *screen = gtk_widget_get_screen(vc->gfx.drawing_area); 92576d8f93bSAlberto Garcia int screen_width, screen_height; 92676d8f93bSAlberto Garcia 9275104a1f6SAnthony Liguori int x = (int)motion->x_root; 9285104a1f6SAnthony Liguori int y = (int)motion->y_root; 9295104a1f6SAnthony Liguori 93076d8f93bSAlberto Garcia #if GTK_CHECK_VERSION(3, 22, 0) 93176d8f93bSAlberto Garcia { 93276d8f93bSAlberto Garcia GdkDisplay *dpy = gtk_widget_get_display(widget); 93376d8f93bSAlberto Garcia GdkWindow *win = gtk_widget_get_window(widget); 93476d8f93bSAlberto Garcia GdkMonitor *monitor = gdk_display_get_monitor_at_window(dpy, win); 93576d8f93bSAlberto Garcia GdkRectangle geometry; 93676d8f93bSAlberto Garcia gdk_monitor_get_geometry(monitor, &geometry); 93776d8f93bSAlberto Garcia screen_width = geometry.width; 93876d8f93bSAlberto Garcia screen_height = geometry.height; 93976d8f93bSAlberto Garcia } 94076d8f93bSAlberto Garcia #else 94176d8f93bSAlberto Garcia { 94276d8f93bSAlberto Garcia screen_width = gdk_screen_get_width(screen); 94376d8f93bSAlberto Garcia screen_height = gdk_screen_get_height(screen); 94476d8f93bSAlberto Garcia } 94576d8f93bSAlberto Garcia #endif 94676d8f93bSAlberto Garcia 9475104a1f6SAnthony Liguori /* In relative mode check to see if client pointer hit 9485104a1f6SAnthony Liguori * one of the screen edges, and if so move it back by 9495104a1f6SAnthony Liguori * 200 pixels. This is important because the pointer 9505104a1f6SAnthony Liguori * in the server doesn't correspond 1-for-1, and so 9515104a1f6SAnthony Liguori * may still be only half way across the screen. Without 9525104a1f6SAnthony Liguori * this warp, the server pointer would thus appear to hit 9535104a1f6SAnthony Liguori * an invisible wall */ 9545104a1f6SAnthony Liguori if (x == 0) { 9555104a1f6SAnthony Liguori x += 200; 9565104a1f6SAnthony Liguori } 9575104a1f6SAnthony Liguori if (y == 0) { 9585104a1f6SAnthony Liguori y += 200; 9595104a1f6SAnthony Liguori } 96076d8f93bSAlberto Garcia if (x == (screen_width - 1)) { 9615104a1f6SAnthony Liguori x -= 200; 9625104a1f6SAnthony Liguori } 96376d8f93bSAlberto Garcia if (y == (screen_height - 1)) { 9645104a1f6SAnthony Liguori y -= 200; 9655104a1f6SAnthony Liguori } 9665104a1f6SAnthony Liguori 9675104a1f6SAnthony Liguori if (x != (int)motion->x_root || y != (int)motion->y_root) { 9688906de76SDaniel P. Berrange #if GTK_CHECK_VERSION(3, 0, 0) 9698906de76SDaniel P. Berrange GdkDevice *dev = gdk_event_get_device((GdkEvent *)motion); 9708906de76SDaniel P. Berrange gdk_device_warp(dev, screen, x, y); 9718906de76SDaniel P. Berrange #else 9728906de76SDaniel P. Berrange GdkDisplay *display = gtk_widget_get_display(widget); 9735104a1f6SAnthony Liguori gdk_display_warp_pointer(display, screen, x, y); 9748906de76SDaniel P. Berrange #endif 975e61031cdSTakashi Iwai s->last_set = FALSE; 9765104a1f6SAnthony Liguori return FALSE; 9775104a1f6SAnthony Liguori } 9785104a1f6SAnthony Liguori } 979a4ccabcfSAnthony Liguori return TRUE; 980a4ccabcfSAnthony Liguori } 981a4ccabcfSAnthony Liguori 982a4ccabcfSAnthony Liguori static gboolean gd_button_event(GtkWidget *widget, GdkEventButton *button, 983a4ccabcfSAnthony Liguori void *opaque) 984a4ccabcfSAnthony Liguori { 985e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 986e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 987192f81bfSGerd Hoffmann InputButton btn; 988a4ccabcfSAnthony Liguori 989800b0e81STakashi Iwai /* implicitly grab the input at the first click in the relative mode */ 990800b0e81STakashi Iwai if (button->button == 1 && button->type == GDK_BUTTON_PRESS && 9912884cf5bSGerd Hoffmann !qemu_input_is_absolute() && s->ptr_owner != vc) { 9922884cf5bSGerd Hoffmann if (!vc->window) { 993800b0e81STakashi Iwai gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 994800b0e81STakashi Iwai TRUE); 9952884cf5bSGerd Hoffmann } else { 996d531deefSGerd Hoffmann gd_grab_pointer(vc, "relative-mode-click"); 9972884cf5bSGerd Hoffmann } 998800b0e81STakashi Iwai return TRUE; 999800b0e81STakashi Iwai } 1000800b0e81STakashi Iwai 1001a4ccabcfSAnthony Liguori if (button->button == 1) { 1002192f81bfSGerd Hoffmann btn = INPUT_BUTTON_LEFT; 1003a4ccabcfSAnthony Liguori } else if (button->button == 2) { 1004192f81bfSGerd Hoffmann btn = INPUT_BUTTON_MIDDLE; 1005a4ccabcfSAnthony Liguori } else if (button->button == 3) { 1006192f81bfSGerd Hoffmann btn = INPUT_BUTTON_RIGHT; 1007a4ccabcfSAnthony Liguori } else { 1008192f81bfSGerd Hoffmann return TRUE; 1009a4ccabcfSAnthony Liguori } 1010a4ccabcfSAnthony Liguori 1011e3500d1fSGerd Hoffmann qemu_input_queue_btn(vc->gfx.dcl.con, btn, 1012e3500d1fSGerd Hoffmann button->type == GDK_BUTTON_PRESS); 1013192f81bfSGerd Hoffmann qemu_input_event_sync(); 1014a4ccabcfSAnthony Liguori return TRUE; 1015a4ccabcfSAnthony Liguori } 1016a4ccabcfSAnthony Liguori 1017d58b9122SJan Kiszka static gboolean gd_scroll_event(GtkWidget *widget, GdkEventScroll *scroll, 1018d58b9122SJan Kiszka void *opaque) 1019d58b9122SJan Kiszka { 1020e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 1021d58b9122SJan Kiszka InputButton btn; 1022d58b9122SJan Kiszka 1023d58b9122SJan Kiszka if (scroll->direction == GDK_SCROLL_UP) { 1024f22d0af0SGerd Hoffmann btn = INPUT_BUTTON_WHEEL_UP; 1025d58b9122SJan Kiszka } else if (scroll->direction == GDK_SCROLL_DOWN) { 1026f22d0af0SGerd Hoffmann btn = INPUT_BUTTON_WHEEL_DOWN; 1027d58b9122SJan Kiszka } else { 1028d58b9122SJan Kiszka return TRUE; 1029d58b9122SJan Kiszka } 1030d58b9122SJan Kiszka 1031e3500d1fSGerd Hoffmann qemu_input_queue_btn(vc->gfx.dcl.con, btn, true); 1032d58b9122SJan Kiszka qemu_input_event_sync(); 1033e3500d1fSGerd Hoffmann qemu_input_queue_btn(vc->gfx.dcl.con, btn, false); 1034d58b9122SJan Kiszka qemu_input_event_sync(); 1035d58b9122SJan Kiszka return TRUE; 1036d58b9122SJan Kiszka } 1037d58b9122SJan Kiszka 10380a337ed0SGerd Hoffmann static int gd_map_keycode(GtkDisplayState *s, GdkDisplay *dpy, int gdk_keycode) 1039a4ccabcfSAnthony Liguori { 1040932f2d7eSGerd Hoffmann int qemu_keycode; 1041a4ccabcfSAnthony Liguori 10420a337ed0SGerd Hoffmann #ifdef GDK_WINDOWING_WIN32 10430a337ed0SGerd Hoffmann if (GDK_IS_WIN32_DISPLAY(dpy)) { 1044932f2d7eSGerd Hoffmann qemu_keycode = MapVirtualKey(gdk_keycode, MAPVK_VK_TO_VSC); 10452777ccc5SStefan Weil switch (qemu_keycode) { 10462777ccc5SStefan Weil case 103: /* alt gr */ 10472777ccc5SStefan Weil qemu_keycode = 56 | SCANCODE_GREY; 10482777ccc5SStefan Weil break; 10492777ccc5SStefan Weil } 10500a337ed0SGerd Hoffmann return qemu_keycode; 10510a337ed0SGerd Hoffmann } 10520a337ed0SGerd Hoffmann #endif 1053a4ccabcfSAnthony Liguori 1054a4ccabcfSAnthony Liguori if (gdk_keycode < 9) { 1055a4ccabcfSAnthony Liguori qemu_keycode = 0; 1056a4ccabcfSAnthony Liguori } else if (gdk_keycode < 97) { 1057a4ccabcfSAnthony Liguori qemu_keycode = gdk_keycode - 8; 10580a337ed0SGerd Hoffmann #ifdef GDK_WINDOWING_X11 10590a337ed0SGerd Hoffmann } else if (GDK_IS_X11_DISPLAY(dpy) && gdk_keycode < 158) { 10603158a348SBruce Rogers if (s->has_evdev) { 1061a4ccabcfSAnthony Liguori qemu_keycode = translate_evdev_keycode(gdk_keycode - 97); 10623158a348SBruce Rogers } else { 10633158a348SBruce Rogers qemu_keycode = translate_xfree86_keycode(gdk_keycode - 97); 10643158a348SBruce Rogers } 10650a337ed0SGerd Hoffmann #endif 1066a8ffb372SDaniel P. Berrange #ifdef GDK_WINDOWING_WAYLAND 1067a8ffb372SDaniel P. Berrange } else if (GDK_IS_WAYLAND_DISPLAY(dpy) && gdk_keycode < 158) { 1068a8ffb372SDaniel P. Berrange qemu_keycode = translate_evdev_keycode(gdk_keycode - 97); 1069a8ffb372SDaniel P. Berrange #endif 1070a4ccabcfSAnthony Liguori } else if (gdk_keycode == 208) { /* Hiragana_Katakana */ 1071a4ccabcfSAnthony Liguori qemu_keycode = 0x70; 1072a4ccabcfSAnthony Liguori } else if (gdk_keycode == 211) { /* backslash */ 1073a4ccabcfSAnthony Liguori qemu_keycode = 0x73; 1074a4ccabcfSAnthony Liguori } else { 1075a4ccabcfSAnthony Liguori qemu_keycode = 0; 1076a4ccabcfSAnthony Liguori } 1077a4ccabcfSAnthony Liguori 1078932f2d7eSGerd Hoffmann return qemu_keycode; 1079932f2d7eSGerd Hoffmann } 1080932f2d7eSGerd Hoffmann 1081f8c223f6SGerd Hoffmann static gboolean gd_text_key_down(GtkWidget *widget, 1082f8c223f6SGerd Hoffmann GdkEventKey *key, void *opaque) 1083f8c223f6SGerd Hoffmann { 1084f8c223f6SGerd Hoffmann VirtualConsole *vc = opaque; 1085f8c223f6SGerd Hoffmann QemuConsole *con = vc->gfx.dcl.con; 1086f8c223f6SGerd Hoffmann 108785617885SThomas Huth if (key->keyval == GDK_KEY_Delete) { 108885617885SThomas Huth kbd_put_qcode_console(con, Q_KEY_CODE_DELETE); 108985617885SThomas Huth } else if (key->length) { 1090f8c223f6SGerd Hoffmann kbd_put_string_console(con, key->string, key->length); 1091f8c223f6SGerd Hoffmann } else { 1092f8c223f6SGerd Hoffmann int num = gd_map_keycode(vc->s, gtk_widget_get_display(widget), 1093f8c223f6SGerd Hoffmann key->hardware_keycode); 1094f8c223f6SGerd Hoffmann int qcode = qemu_input_key_number_to_qcode(num); 1095f8c223f6SGerd Hoffmann kbd_put_qcode_console(con, qcode); 1096f8c223f6SGerd Hoffmann } 1097f8c223f6SGerd Hoffmann return TRUE; 1098f8c223f6SGerd Hoffmann } 1099f8c223f6SGerd Hoffmann 1100932f2d7eSGerd Hoffmann static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque) 1101932f2d7eSGerd Hoffmann { 1102932f2d7eSGerd Hoffmann VirtualConsole *vc = opaque; 1103932f2d7eSGerd Hoffmann GtkDisplayState *s = vc->s; 1104932f2d7eSGerd Hoffmann int gdk_keycode = key->hardware_keycode; 1105932f2d7eSGerd Hoffmann int qemu_keycode; 1106932f2d7eSGerd Hoffmann int i; 1107932f2d7eSGerd Hoffmann 11081a01716aSJan Kiszka if (s->ignore_keys) { 11091a01716aSJan Kiszka s->ignore_keys = (key->type == GDK_KEY_PRESS); 11101a01716aSJan Kiszka return TRUE; 11111a01716aSJan Kiszka } 11121a01716aSJan Kiszka 11135c960521SMartin Decky if (key->keyval == GDK_KEY_Pause) { 11145c960521SMartin Decky qemu_input_event_send_key_qcode(vc->gfx.dcl.con, Q_KEY_CODE_PAUSE, 11155c960521SMartin Decky key->type == GDK_KEY_PRESS); 11165c960521SMartin Decky return TRUE; 11175c960521SMartin Decky } 11185c960521SMartin Decky 11190a337ed0SGerd Hoffmann qemu_keycode = gd_map_keycode(s, gtk_widget_get_display(widget), 11200a337ed0SGerd Hoffmann gdk_keycode); 1121932f2d7eSGerd Hoffmann 112274444bc1SGerd Hoffmann trace_gd_key_event(vc->label, gdk_keycode, qemu_keycode, 1123a4ccabcfSAnthony Liguori (key->type == GDK_KEY_PRESS) ? "down" : "up"); 1124a4ccabcfSAnthony Liguori 11256db253caSJan Kiszka for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) { 11266db253caSJan Kiszka if (qemu_keycode == modifier_keycode[i]) { 11276db253caSJan Kiszka s->modifier_pressed[i] = (key->type == GDK_KEY_PRESS); 11286db253caSJan Kiszka } 11296db253caSJan Kiszka } 11306db253caSJan Kiszka 1131e3500d1fSGerd Hoffmann qemu_input_event_send_key_number(vc->gfx.dcl.con, qemu_keycode, 1132af98ba92SGerd Hoffmann key->type == GDK_KEY_PRESS); 1133a4ccabcfSAnthony Liguori 1134a4ccabcfSAnthony Liguori return TRUE; 1135a4ccabcfSAnthony Liguori } 1136a4ccabcfSAnthony Liguori 11370d0e044dSTakashi Iwai static gboolean gd_event(GtkWidget *widget, GdkEvent *event, void *opaque) 11380d0e044dSTakashi Iwai { 11390d0e044dSTakashi Iwai if (event->type == GDK_MOTION_NOTIFY) { 11400d0e044dSTakashi Iwai return gd_motion_event(widget, &event->motion, opaque); 11410d0e044dSTakashi Iwai } 11420d0e044dSTakashi Iwai return FALSE; 11430d0e044dSTakashi Iwai } 11440d0e044dSTakashi Iwai 1145a4ccabcfSAnthony Liguori /** Window Menu Actions **/ 1146a4ccabcfSAnthony Liguori 114730e8f22bSJan Kiszka static void gd_menu_pause(GtkMenuItem *item, void *opaque) 114830e8f22bSJan Kiszka { 114930e8f22bSJan Kiszka GtkDisplayState *s = opaque; 115030e8f22bSJan Kiszka 115130e8f22bSJan Kiszka if (s->external_pause_update) { 115230e8f22bSJan Kiszka return; 115330e8f22bSJan Kiszka } 115430e8f22bSJan Kiszka if (runstate_is_running()) { 115530e8f22bSJan Kiszka qmp_stop(NULL); 115630e8f22bSJan Kiszka } else { 115730e8f22bSJan Kiszka qmp_cont(NULL); 115830e8f22bSJan Kiszka } 115930e8f22bSJan Kiszka } 116030e8f22bSJan Kiszka 116130e8f22bSJan Kiszka static void gd_menu_reset(GtkMenuItem *item, void *opaque) 116230e8f22bSJan Kiszka { 116330e8f22bSJan Kiszka qmp_system_reset(NULL); 116430e8f22bSJan Kiszka } 116530e8f22bSJan Kiszka 116630e8f22bSJan Kiszka static void gd_menu_powerdown(GtkMenuItem *item, void *opaque) 116730e8f22bSJan Kiszka { 116830e8f22bSJan Kiszka qmp_system_powerdown(NULL); 116930e8f22bSJan Kiszka } 117030e8f22bSJan Kiszka 1171a4ccabcfSAnthony Liguori static void gd_menu_quit(GtkMenuItem *item, void *opaque) 1172a4ccabcfSAnthony Liguori { 1173a4ccabcfSAnthony Liguori qmp_quit(NULL); 1174a4ccabcfSAnthony Liguori } 1175a4ccabcfSAnthony Liguori 1176a4ccabcfSAnthony Liguori static void gd_menu_switch_vc(GtkMenuItem *item, void *opaque) 1177a4ccabcfSAnthony Liguori { 1178a4ccabcfSAnthony Liguori GtkDisplayState *s = opaque; 1179e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_by_menu(s); 1180e72b59faSJohn Snow GtkNotebook *nb = GTK_NOTEBOOK(s->notebook); 1181832189c9SGerd Hoffmann gint page; 1182a4ccabcfSAnthony Liguori 11836db253caSJan Kiszka gtk_release_modifiers(s); 1184271a25c0SGerd Hoffmann if (vc) { 1185e72b59faSJohn Snow page = gtk_notebook_page_num(nb, vc->tab_item); 1186e72b59faSJohn Snow gtk_notebook_set_current_page(nb, page); 11879d677e1cSJan Kiszka gtk_widget_grab_focus(vc->focus); 1188d861def3SAnthony Liguori } 11891a01716aSJan Kiszka s->ignore_keys = false; 1190d861def3SAnthony Liguori } 1191a4ccabcfSAnthony Liguori 1192277836c8SCole Robinson static void gd_accel_switch_vc(void *opaque) 1193277836c8SCole Robinson { 1194277836c8SCole Robinson VirtualConsole *vc = opaque; 11951a01716aSJan Kiszka 1196277836c8SCole Robinson gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), TRUE); 11971a01716aSJan Kiszka #if !GTK_CHECK_VERSION(3, 0, 0) 11981a01716aSJan Kiszka /* GTK2 sends the accel key to the target console - ignore this until */ 11991a01716aSJan Kiszka vc->s->ignore_keys = true; 12001a01716aSJan Kiszka #endif 1201277836c8SCole Robinson } 1202277836c8SCole Robinson 1203a4ccabcfSAnthony Liguori static void gd_menu_show_tabs(GtkMenuItem *item, void *opaque) 1204a4ccabcfSAnthony Liguori { 1205a4ccabcfSAnthony Liguori GtkDisplayState *s = opaque; 1206fa7a1e52SGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1207a4ccabcfSAnthony Liguori 1208a4ccabcfSAnthony Liguori if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->show_tabs_item))) { 1209a4ccabcfSAnthony Liguori gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), TRUE); 1210a4ccabcfSAnthony Liguori } else { 1211a4ccabcfSAnthony Liguori gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 1212a4ccabcfSAnthony Liguori } 1213fa7a1e52SGerd Hoffmann gd_update_windowsize(vc); 1214a4ccabcfSAnthony Liguori } 1215a4ccabcfSAnthony Liguori 1216cdeb7090SGerd Hoffmann static gboolean gd_tab_window_close(GtkWidget *widget, GdkEvent *event, 1217cdeb7090SGerd Hoffmann void *opaque) 1218cdeb7090SGerd Hoffmann { 1219cdeb7090SGerd Hoffmann VirtualConsole *vc = opaque; 1220cdeb7090SGerd Hoffmann GtkDisplayState *s = vc->s; 1221cdeb7090SGerd Hoffmann 1222cdeb7090SGerd Hoffmann gtk_widget_set_sensitive(vc->menu_item, true); 1223316cb068SGerd Hoffmann gd_widget_reparent(vc->window, s->notebook, vc->tab_item); 1224cdeb7090SGerd Hoffmann gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(s->notebook), 1225cdeb7090SGerd Hoffmann vc->tab_item, vc->label); 1226cdeb7090SGerd Hoffmann gtk_widget_destroy(vc->window); 1227cdeb7090SGerd Hoffmann vc->window = NULL; 1228cdeb7090SGerd Hoffmann return TRUE; 1229cdeb7090SGerd Hoffmann } 1230cdeb7090SGerd Hoffmann 12310c77a37fSGerd Hoffmann static gboolean gd_win_grab(void *opaque) 12320c77a37fSGerd Hoffmann { 12330c77a37fSGerd Hoffmann VirtualConsole *vc = opaque; 12340c77a37fSGerd Hoffmann 12350c77a37fSGerd Hoffmann fprintf(stderr, "%s: %s\n", __func__, vc->label); 12360c77a37fSGerd Hoffmann if (vc->s->ptr_owner) { 12370c77a37fSGerd Hoffmann gd_ungrab_pointer(vc->s); 12380c77a37fSGerd Hoffmann } else { 1239d531deefSGerd Hoffmann gd_grab_pointer(vc, "user-request-detached-tab"); 12400c77a37fSGerd Hoffmann } 12410c77a37fSGerd Hoffmann return TRUE; 12420c77a37fSGerd Hoffmann } 12430c77a37fSGerd Hoffmann 1244cdeb7090SGerd Hoffmann static void gd_menu_untabify(GtkMenuItem *item, void *opaque) 1245cdeb7090SGerd Hoffmann { 1246cdeb7090SGerd Hoffmann GtkDisplayState *s = opaque; 1247cdeb7090SGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1248cdeb7090SGerd Hoffmann 1249f8c223f6SGerd Hoffmann if (vc->type == GD_VC_GFX && 1250f8c223f6SGerd Hoffmann qemu_console_is_graphic(vc->gfx.dcl.con)) { 1251aa0a55d4SGerd Hoffmann gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1252aa0a55d4SGerd Hoffmann FALSE); 1253cdeb7090SGerd Hoffmann } 1254cdeb7090SGerd Hoffmann if (!vc->window) { 1255cdeb7090SGerd Hoffmann gtk_widget_set_sensitive(vc->menu_item, false); 1256cdeb7090SGerd Hoffmann vc->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 1257316cb068SGerd Hoffmann gd_widget_reparent(s->notebook, vc->window, vc->tab_item); 1258cdeb7090SGerd Hoffmann 1259cdeb7090SGerd Hoffmann g_signal_connect(vc->window, "delete-event", 1260cdeb7090SGerd Hoffmann G_CALLBACK(gd_tab_window_close), vc); 1261cdeb7090SGerd Hoffmann gtk_widget_show_all(vc->window); 12624eeaa3a8SGerd Hoffmann 1263f8c223f6SGerd Hoffmann if (qemu_console_is_graphic(vc->gfx.dcl.con)) { 12640c77a37fSGerd Hoffmann GtkAccelGroup *ag = gtk_accel_group_new(); 12650c77a37fSGerd Hoffmann gtk_window_add_accel_group(GTK_WINDOW(vc->window), ag); 12660c77a37fSGerd Hoffmann 1267f8c223f6SGerd Hoffmann GClosure *cb = g_cclosure_new_swap(G_CALLBACK(gd_win_grab), 1268f8c223f6SGerd Hoffmann vc, NULL); 12690c77a37fSGerd Hoffmann gtk_accel_group_connect(ag, GDK_KEY_g, HOTKEY_MODIFIERS, 0, cb); 1270f8c223f6SGerd Hoffmann } 12710c77a37fSGerd Hoffmann 127282fc1809SGerd Hoffmann gd_update_geometry_hints(vc); 12734eeaa3a8SGerd Hoffmann gd_update_caption(s); 1274cdeb7090SGerd Hoffmann } 1275cdeb7090SGerd Hoffmann } 1276cdeb7090SGerd Hoffmann 1277c6158483SAnthony Liguori static void gd_menu_full_screen(GtkMenuItem *item, void *opaque) 1278c6158483SAnthony Liguori { 1279c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1280e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1281c6158483SAnthony Liguori 128210409282SStefan Weil if (!s->full_screen) { 1283c6158483SAnthony Liguori gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 1284b0f31820SCole Robinson gtk_widget_hide(s->menu_bar); 1285e3500d1fSGerd Hoffmann if (vc->type == GD_VC_GFX) { 1286e3500d1fSGerd Hoffmann gtk_widget_set_size_request(vc->gfx.drawing_area, -1, -1); 1287c6158483SAnthony Liguori } 1288e3500d1fSGerd Hoffmann gtk_window_fullscreen(GTK_WINDOW(s->window)); 1289c6158483SAnthony Liguori s->full_screen = TRUE; 1290c6158483SAnthony Liguori } else { 1291c6158483SAnthony Liguori gtk_window_unfullscreen(GTK_WINDOW(s->window)); 1292c6158483SAnthony Liguori gd_menu_show_tabs(GTK_MENU_ITEM(s->show_tabs_item), s); 1293b0f31820SCole Robinson gtk_widget_show(s->menu_bar); 1294c6158483SAnthony Liguori s->full_screen = FALSE; 1295e3500d1fSGerd Hoffmann if (vc->type == GD_VC_GFX) { 1296e3500d1fSGerd Hoffmann vc->gfx.scale_x = 1.0; 1297e3500d1fSGerd Hoffmann vc->gfx.scale_y = 1.0; 129882fc1809SGerd Hoffmann gd_update_windowsize(vc); 1299e3500d1fSGerd Hoffmann } 1300c6158483SAnthony Liguori } 1301c6158483SAnthony Liguori 1302e3500d1fSGerd Hoffmann gd_update_cursor(vc); 1303c6158483SAnthony Liguori } 1304c6158483SAnthony Liguori 130595414914SCole Robinson static void gd_accel_full_screen(void *opaque) 130695414914SCole Robinson { 130795414914SCole Robinson GtkDisplayState *s = opaque; 130895414914SCole Robinson gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item)); 130995414914SCole Robinson } 131095414914SCole Robinson 1311c6158483SAnthony Liguori static void gd_menu_zoom_in(GtkMenuItem *item, void *opaque) 1312c6158483SAnthony Liguori { 1313c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1314e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1315c6158483SAnthony Liguori 1316c6158483SAnthony Liguori gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item), 1317c6158483SAnthony Liguori FALSE); 1318c6158483SAnthony Liguori 131982fc1809SGerd Hoffmann vc->gfx.scale_x += VC_SCALE_STEP; 132082fc1809SGerd Hoffmann vc->gfx.scale_y += VC_SCALE_STEP; 1321c6158483SAnthony Liguori 1322e3500d1fSGerd Hoffmann gd_update_windowsize(vc); 1323c6158483SAnthony Liguori } 1324c6158483SAnthony Liguori 1325c6158483SAnthony Liguori static void gd_menu_zoom_out(GtkMenuItem *item, void *opaque) 1326c6158483SAnthony Liguori { 1327c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1328e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1329c6158483SAnthony Liguori 1330c6158483SAnthony Liguori gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item), 1331c6158483SAnthony Liguori FALSE); 1332c6158483SAnthony Liguori 133382fc1809SGerd Hoffmann vc->gfx.scale_x -= VC_SCALE_STEP; 133482fc1809SGerd Hoffmann vc->gfx.scale_y -= VC_SCALE_STEP; 1335c6158483SAnthony Liguori 133682fc1809SGerd Hoffmann vc->gfx.scale_x = MAX(vc->gfx.scale_x, VC_SCALE_MIN); 133782fc1809SGerd Hoffmann vc->gfx.scale_y = MAX(vc->gfx.scale_y, VC_SCALE_MIN); 1338c6158483SAnthony Liguori 1339e3500d1fSGerd Hoffmann gd_update_windowsize(vc); 1340c6158483SAnthony Liguori } 1341c6158483SAnthony Liguori 1342c6158483SAnthony Liguori static void gd_menu_zoom_fixed(GtkMenuItem *item, void *opaque) 1343c6158483SAnthony Liguori { 1344c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1345e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1346c6158483SAnthony Liguori 1347e3500d1fSGerd Hoffmann vc->gfx.scale_x = 1.0; 1348e3500d1fSGerd Hoffmann vc->gfx.scale_y = 1.0; 1349c6158483SAnthony Liguori 1350e3500d1fSGerd Hoffmann gd_update_windowsize(vc); 1351c6158483SAnthony Liguori } 1352c6158483SAnthony Liguori 1353c6158483SAnthony Liguori static void gd_menu_zoom_fit(GtkMenuItem *item, void *opaque) 1354c6158483SAnthony Liguori { 1355c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1356e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1357c6158483SAnthony Liguori 1358c6158483SAnthony Liguori if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item))) { 1359c6158483SAnthony Liguori s->free_scale = TRUE; 1360c6158483SAnthony Liguori } else { 1361c6158483SAnthony Liguori s->free_scale = FALSE; 1362e3500d1fSGerd Hoffmann vc->gfx.scale_x = 1.0; 1363e3500d1fSGerd Hoffmann vc->gfx.scale_y = 1.0; 1364c6158483SAnthony Liguori } 1365c6158483SAnthony Liguori 136682fc1809SGerd Hoffmann gd_update_windowsize(vc); 1367e3500d1fSGerd Hoffmann gd_update_full_redraw(vc); 1368c6158483SAnthony Liguori } 1369c6158483SAnthony Liguori 1370a69fc693SGerd Hoffmann #if GTK_CHECK_VERSION(3, 20, 0) 1371a69fc693SGerd Hoffmann static void gd_grab_update(VirtualConsole *vc, bool kbd, bool ptr) 1372a69fc693SGerd Hoffmann { 1373a69fc693SGerd Hoffmann GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1374a69fc693SGerd Hoffmann GdkSeat *seat = gdk_display_get_default_seat(display); 1375a69fc693SGerd Hoffmann GdkWindow *window = gtk_widget_get_window(vc->gfx.drawing_area); 1376a69fc693SGerd Hoffmann GdkSeatCapabilities caps = 0; 1377a69fc693SGerd Hoffmann GdkCursor *cursor = NULL; 1378a69fc693SGerd Hoffmann 1379a69fc693SGerd Hoffmann if (kbd) { 1380a69fc693SGerd Hoffmann caps |= GDK_SEAT_CAPABILITY_KEYBOARD; 1381a69fc693SGerd Hoffmann } 1382a69fc693SGerd Hoffmann if (ptr) { 1383a69fc693SGerd Hoffmann caps |= GDK_SEAT_CAPABILITY_ALL_POINTING; 1384a69fc693SGerd Hoffmann cursor = vc->s->null_cursor; 1385a69fc693SGerd Hoffmann } 1386a69fc693SGerd Hoffmann 1387a69fc693SGerd Hoffmann if (caps) { 1388a69fc693SGerd Hoffmann gdk_seat_grab(seat, window, caps, false, cursor, 1389a69fc693SGerd Hoffmann NULL, NULL, NULL); 1390a69fc693SGerd Hoffmann } else { 1391a69fc693SGerd Hoffmann gdk_seat_ungrab(seat); 1392a69fc693SGerd Hoffmann } 1393a69fc693SGerd Hoffmann } 1394a69fc693SGerd Hoffmann #elif GTK_CHECK_VERSION(3, 0, 0) 1395f50def91SGerd Hoffmann static void gd_grab_devices(VirtualConsole *vc, bool grab, 1396f50def91SGerd Hoffmann GdkInputSource source, GdkEventMask mask, 1397f50def91SGerd Hoffmann GdkCursor *cursor) 1398f50def91SGerd Hoffmann { 1399f50def91SGerd Hoffmann GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1400f50def91SGerd Hoffmann GdkDeviceManager *mgr = gdk_display_get_device_manager(display); 1401f50def91SGerd Hoffmann GList *devs = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER); 1402f50def91SGerd Hoffmann GList *tmp = devs; 1403f50def91SGerd Hoffmann 1404f50def91SGerd Hoffmann for (tmp = devs; tmp; tmp = tmp->next) { 1405f50def91SGerd Hoffmann GdkDevice *dev = tmp->data; 1406f50def91SGerd Hoffmann if (gdk_device_get_source(dev) != source) { 1407f50def91SGerd Hoffmann continue; 1408f50def91SGerd Hoffmann } 1409f50def91SGerd Hoffmann if (grab) { 1410f50def91SGerd Hoffmann GdkWindow *win = gtk_widget_get_window(vc->gfx.drawing_area); 1411f50def91SGerd Hoffmann gdk_device_grab(dev, win, GDK_OWNERSHIP_NONE, FALSE, 1412f50def91SGerd Hoffmann mask, cursor, GDK_CURRENT_TIME); 1413f50def91SGerd Hoffmann } else { 1414f50def91SGerd Hoffmann gdk_device_ungrab(dev, GDK_CURRENT_TIME); 1415f50def91SGerd Hoffmann } 1416f50def91SGerd Hoffmann } 1417f50def91SGerd Hoffmann g_list_free(devs); 1418f50def91SGerd Hoffmann } 1419f50def91SGerd Hoffmann #endif 1420f50def91SGerd Hoffmann 1421d531deefSGerd Hoffmann static void gd_grab_keyboard(VirtualConsole *vc, const char *reason) 14225104a1f6SAnthony Liguori { 1423aa4f4058SGerd Hoffmann if (vc->s->kbd_owner) { 1424aa4f4058SGerd Hoffmann if (vc->s->kbd_owner == vc) { 1425aa4f4058SGerd Hoffmann return; 1426aa4f4058SGerd Hoffmann } else { 1427aa4f4058SGerd Hoffmann gd_ungrab_keyboard(vc->s); 1428aa4f4058SGerd Hoffmann } 1429aa4f4058SGerd Hoffmann } 1430aa4f4058SGerd Hoffmann 1431a69fc693SGerd Hoffmann #if GTK_CHECK_VERSION(3, 20, 0) 1432a69fc693SGerd Hoffmann gd_grab_update(vc, true, vc->s->ptr_owner == vc); 1433a69fc693SGerd Hoffmann #elif GTK_CHECK_VERSION(3, 0, 0) 1434f50def91SGerd Hoffmann gd_grab_devices(vc, true, GDK_SOURCE_KEYBOARD, 1435655199daSDaniel P. Berrange GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, 1436f50def91SGerd Hoffmann NULL); 1437655199daSDaniel P. Berrange #else 1438e3500d1fSGerd Hoffmann gdk_keyboard_grab(gtk_widget_get_window(vc->gfx.drawing_area), 14395104a1f6SAnthony Liguori FALSE, 14405104a1f6SAnthony Liguori GDK_CURRENT_TIME); 1441655199daSDaniel P. Berrange #endif 14424c638e2eSGerd Hoffmann vc->s->kbd_owner = vc; 1443695cc59dSGerd Hoffmann gd_update_caption(vc->s); 1444d531deefSGerd Hoffmann trace_gd_grab(vc->label, "kbd", reason); 14455104a1f6SAnthony Liguori } 14465104a1f6SAnthony Liguori 14474c638e2eSGerd Hoffmann static void gd_ungrab_keyboard(GtkDisplayState *s) 14485104a1f6SAnthony Liguori { 14494c638e2eSGerd Hoffmann VirtualConsole *vc = s->kbd_owner; 14504c638e2eSGerd Hoffmann 14514c638e2eSGerd Hoffmann if (vc == NULL) { 14524c638e2eSGerd Hoffmann return; 14534c638e2eSGerd Hoffmann } 14544c638e2eSGerd Hoffmann s->kbd_owner = NULL; 14554c638e2eSGerd Hoffmann 1456a69fc693SGerd Hoffmann #if GTK_CHECK_VERSION(3, 20, 0) 1457a69fc693SGerd Hoffmann gd_grab_update(vc, false, vc->s->ptr_owner == vc); 1458a69fc693SGerd Hoffmann #elif GTK_CHECK_VERSION(3, 0, 0) 1459f50def91SGerd Hoffmann gd_grab_devices(vc, false, GDK_SOURCE_KEYBOARD, 0, NULL); 1460655199daSDaniel P. Berrange #else 14615104a1f6SAnthony Liguori gdk_keyboard_ungrab(GDK_CURRENT_TIME); 1462655199daSDaniel P. Berrange #endif 1463695cc59dSGerd Hoffmann gd_update_caption(s); 1464d531deefSGerd Hoffmann trace_gd_ungrab(vc->label, "kbd"); 14655104a1f6SAnthony Liguori } 14665104a1f6SAnthony Liguori 1467d531deefSGerd Hoffmann static void gd_grab_pointer(VirtualConsole *vc, const char *reason) 14685104a1f6SAnthony Liguori { 1469e3500d1fSGerd Hoffmann GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1470aa4f4058SGerd Hoffmann 1471aa4f4058SGerd Hoffmann if (vc->s->ptr_owner) { 1472aa4f4058SGerd Hoffmann if (vc->s->ptr_owner == vc) { 1473aa4f4058SGerd Hoffmann return; 1474aa4f4058SGerd Hoffmann } else { 1475aa4f4058SGerd Hoffmann gd_ungrab_pointer(vc->s); 1476aa4f4058SGerd Hoffmann } 1477aa4f4058SGerd Hoffmann } 1478aa4f4058SGerd Hoffmann 1479a69fc693SGerd Hoffmann #if GTK_CHECK_VERSION(3, 20, 0) 1480a69fc693SGerd Hoffmann gd_grab_update(vc, vc->s->kbd_owner == vc, true); 1481a69fc693SGerd Hoffmann gdk_device_get_position(gd_get_pointer(display), 1482a69fc693SGerd Hoffmann NULL, &vc->s->grab_x_root, &vc->s->grab_y_root); 1483a69fc693SGerd Hoffmann #elif GTK_CHECK_VERSION(3, 0, 0) 1484f50def91SGerd Hoffmann gd_grab_devices(vc, true, GDK_SOURCE_MOUSE, 14852a05485dSDaniel P. Berrange GDK_POINTER_MOTION_MASK | 14862a05485dSDaniel P. Berrange GDK_BUTTON_PRESS_MASK | 14872a05485dSDaniel P. Berrange GDK_BUTTON_RELEASE_MASK | 14882a05485dSDaniel P. Berrange GDK_BUTTON_MOTION_MASK | 14892a05485dSDaniel P. Berrange GDK_SCROLL_MASK, 1490f50def91SGerd Hoffmann vc->s->null_cursor); 1491bb732ee7SCole Robinson gdk_device_get_position(gd_get_pointer(display), 1492e3500d1fSGerd Hoffmann NULL, &vc->s->grab_x_root, &vc->s->grab_y_root); 14932a05485dSDaniel P. Berrange #else 1494e3500d1fSGerd Hoffmann gdk_pointer_grab(gtk_widget_get_window(vc->gfx.drawing_area), 14955104a1f6SAnthony Liguori FALSE, /* All events to come to our window directly */ 14965104a1f6SAnthony Liguori GDK_POINTER_MOTION_MASK | 14975104a1f6SAnthony Liguori GDK_BUTTON_PRESS_MASK | 14985104a1f6SAnthony Liguori GDK_BUTTON_RELEASE_MASK | 14995104a1f6SAnthony Liguori GDK_BUTTON_MOTION_MASK | 15005104a1f6SAnthony Liguori GDK_SCROLL_MASK, 15015104a1f6SAnthony Liguori NULL, /* Allow cursor to move over entire desktop */ 1502e3500d1fSGerd Hoffmann vc->s->null_cursor, 15035104a1f6SAnthony Liguori GDK_CURRENT_TIME); 1504ecce1929STakashi Iwai gdk_display_get_pointer(display, NULL, 1505e3500d1fSGerd Hoffmann &vc->s->grab_x_root, &vc->s->grab_y_root, NULL); 15062a05485dSDaniel P. Berrange #endif 15074c638e2eSGerd Hoffmann vc->s->ptr_owner = vc; 1508695cc59dSGerd Hoffmann gd_update_caption(vc->s); 1509d531deefSGerd Hoffmann trace_gd_grab(vc->label, "ptr", reason); 15102a05485dSDaniel P. Berrange } 15112a05485dSDaniel P. Berrange 15124c638e2eSGerd Hoffmann static void gd_ungrab_pointer(GtkDisplayState *s) 15132a05485dSDaniel P. Berrange { 15144c638e2eSGerd Hoffmann VirtualConsole *vc = s->ptr_owner; 151541cc5239SGerd Hoffmann GdkDisplay *display; 15164c638e2eSGerd Hoffmann 15174c638e2eSGerd Hoffmann if (vc == NULL) { 15184c638e2eSGerd Hoffmann return; 15194c638e2eSGerd Hoffmann } 15204c638e2eSGerd Hoffmann s->ptr_owner = NULL; 15214c638e2eSGerd Hoffmann 152241cc5239SGerd Hoffmann display = gtk_widget_get_display(vc->gfx.drawing_area); 1523a69fc693SGerd Hoffmann #if GTK_CHECK_VERSION(3, 20, 0) 1524a69fc693SGerd Hoffmann gd_grab_update(vc, vc->s->kbd_owner == vc, false); 1525a69fc693SGerd Hoffmann gdk_device_warp(gd_get_pointer(display), 1526a69fc693SGerd Hoffmann gtk_widget_get_screen(vc->gfx.drawing_area), 1527a69fc693SGerd Hoffmann vc->s->grab_x_root, vc->s->grab_y_root); 1528a69fc693SGerd Hoffmann #elif GTK_CHECK_VERSION(3, 0, 0) 1529f50def91SGerd Hoffmann gd_grab_devices(vc, false, GDK_SOURCE_MOUSE, 0, NULL); 1530bb732ee7SCole Robinson gdk_device_warp(gd_get_pointer(display), 1531e3500d1fSGerd Hoffmann gtk_widget_get_screen(vc->gfx.drawing_area), 1532e3500d1fSGerd Hoffmann vc->s->grab_x_root, vc->s->grab_y_root); 15332a05485dSDaniel P. Berrange #else 15342a05485dSDaniel P. Berrange gdk_pointer_ungrab(GDK_CURRENT_TIME); 1535ecce1929STakashi Iwai gdk_display_warp_pointer(display, 1536e3500d1fSGerd Hoffmann gtk_widget_get_screen(vc->gfx.drawing_area), 1537e3500d1fSGerd Hoffmann vc->s->grab_x_root, vc->s->grab_y_root); 15382a05485dSDaniel P. Berrange #endif 1539695cc59dSGerd Hoffmann gd_update_caption(s); 1540d531deefSGerd Hoffmann trace_gd_ungrab(vc->label, "ptr"); 15412a05485dSDaniel P. Berrange } 15422a05485dSDaniel P. Berrange 15432a05485dSDaniel P. Berrange static void gd_menu_grab_input(GtkMenuItem *item, void *opaque) 15442a05485dSDaniel P. Berrange { 15452a05485dSDaniel P. Berrange GtkDisplayState *s = opaque; 1546e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 15472a05485dSDaniel P. Berrange 15482a05485dSDaniel P. Berrange if (gd_is_grab_active(s)) { 1549d531deefSGerd Hoffmann gd_grab_keyboard(vc, "user-request-main-window"); 1550d531deefSGerd Hoffmann gd_grab_pointer(vc, "user-request-main-window"); 15515104a1f6SAnthony Liguori } else { 15524c638e2eSGerd Hoffmann gd_ungrab_keyboard(s); 15534c638e2eSGerd Hoffmann gd_ungrab_pointer(s); 15545104a1f6SAnthony Liguori } 15555104a1f6SAnthony Liguori 1556e3500d1fSGerd Hoffmann gd_update_cursor(vc); 15575104a1f6SAnthony Liguori } 15585104a1f6SAnthony Liguori 1559a4ccabcfSAnthony Liguori static void gd_change_page(GtkNotebook *nb, gpointer arg1, guint arg2, 1560a4ccabcfSAnthony Liguori gpointer data) 1561a4ccabcfSAnthony Liguori { 1562a4ccabcfSAnthony Liguori GtkDisplayState *s = data; 1563e3500d1fSGerd Hoffmann VirtualConsole *vc; 15645104a1f6SAnthony Liguori gboolean on_vga; 1565a4ccabcfSAnthony Liguori 1566a4ccabcfSAnthony Liguori if (!gtk_widget_get_realized(s->notebook)) { 1567a4ccabcfSAnthony Liguori return; 1568a4ccabcfSAnthony Liguori } 1569a4ccabcfSAnthony Liguori 15706fa27697SGerd Hoffmann #ifdef VTE_RESIZE_HACK 15716fa27697SGerd Hoffmann vc = gd_vc_find_current(s); 15726fa27697SGerd Hoffmann if (vc && vc->type == GD_VC_VTE) { 15736fa27697SGerd Hoffmann gtk_widget_hide(vc->vte.terminal); 15746fa27697SGerd Hoffmann } 15756fa27697SGerd Hoffmann #endif 1576e3500d1fSGerd Hoffmann vc = gd_vc_find_by_page(s, arg2); 1577e3500d1fSGerd Hoffmann if (!vc) { 1578e3500d1fSGerd Hoffmann return; 1579e3500d1fSGerd Hoffmann } 15806fa27697SGerd Hoffmann #ifdef VTE_RESIZE_HACK 15816fa27697SGerd Hoffmann if (vc->type == GD_VC_VTE) { 15826fa27697SGerd Hoffmann gtk_widget_show(vc->vte.terminal); 15836fa27697SGerd Hoffmann } 15846fa27697SGerd Hoffmann #endif 1585e3500d1fSGerd Hoffmann gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), 1586e3500d1fSGerd Hoffmann TRUE); 1587f8c223f6SGerd Hoffmann on_vga = (vc->type == GD_VC_GFX && 1588f8c223f6SGerd Hoffmann qemu_console_is_graphic(vc->gfx.dcl.con)); 15895104a1f6SAnthony Liguori if (!on_vga) { 15905104a1f6SAnthony Liguori gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 15915104a1f6SAnthony Liguori FALSE); 1592c6158483SAnthony Liguori } else if (s->full_screen) { 1593c6158483SAnthony Liguori gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1594c6158483SAnthony Liguori TRUE); 15955104a1f6SAnthony Liguori } 15965104a1f6SAnthony Liguori gtk_widget_set_sensitive(s->grab_item, on_vga); 1597a0815632SStefan Hajnoczi #ifdef CONFIG_VTE 1598a0815632SStefan Hajnoczi gtk_widget_set_sensitive(s->copy_item, vc->type == GD_VC_VTE); 1599a0815632SStefan Hajnoczi #endif 16005104a1f6SAnthony Liguori 160182fc1809SGerd Hoffmann gd_update_windowsize(vc); 1602e3500d1fSGerd Hoffmann gd_update_cursor(vc); 1603a4ccabcfSAnthony Liguori } 1604a4ccabcfSAnthony Liguori 1605e3500d1fSGerd Hoffmann static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing, 1606e3500d1fSGerd Hoffmann gpointer opaque) 16075104a1f6SAnthony Liguori { 1608e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 1609e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 16105104a1f6SAnthony Liguori 16112884cf5bSGerd Hoffmann if (gd_grab_on_hover(s)) { 1612d531deefSGerd Hoffmann gd_grab_keyboard(vc, "grab-on-hover"); 16135104a1f6SAnthony Liguori } 16145104a1f6SAnthony Liguori return TRUE; 16155104a1f6SAnthony Liguori } 16165104a1f6SAnthony Liguori 1617e3500d1fSGerd Hoffmann static gboolean gd_leave_event(GtkWidget *widget, GdkEventCrossing *crossing, 1618e3500d1fSGerd Hoffmann gpointer opaque) 16195104a1f6SAnthony Liguori { 1620e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 1621e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 16225104a1f6SAnthony Liguori 16232884cf5bSGerd Hoffmann if (gd_grab_on_hover(s)) { 16244c638e2eSGerd Hoffmann gd_ungrab_keyboard(s); 16255104a1f6SAnthony Liguori } 16265104a1f6SAnthony Liguori return TRUE; 16275104a1f6SAnthony Liguori } 16285104a1f6SAnthony Liguori 16296db253caSJan Kiszka static gboolean gd_focus_out_event(GtkWidget *widget, 1630e3500d1fSGerd Hoffmann GdkEventCrossing *crossing, gpointer opaque) 16316db253caSJan Kiszka { 1632e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 1633e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 16346db253caSJan Kiszka 16356db253caSJan Kiszka gtk_release_modifiers(s); 16366db253caSJan Kiszka return TRUE; 16376db253caSJan Kiszka } 16386db253caSJan Kiszka 16391301e515SGerd Hoffmann static gboolean gd_configure(GtkWidget *widget, 16401301e515SGerd Hoffmann GdkEventConfigure *cfg, gpointer opaque) 16411301e515SGerd Hoffmann { 16421301e515SGerd Hoffmann VirtualConsole *vc = opaque; 16431301e515SGerd Hoffmann 1644925a0400SGerd Hoffmann gd_set_ui_info(vc, cfg->width, cfg->height); 16451301e515SGerd Hoffmann return FALSE; 16461301e515SGerd Hoffmann } 16471301e515SGerd Hoffmann 1648d861def3SAnthony Liguori /** Virtual Console Callbacks **/ 1649d861def3SAnthony Liguori 1650ed1132e4SGerd Hoffmann static GSList *gd_vc_menu_init(GtkDisplayState *s, VirtualConsole *vc, 1651cdeb7090SGerd Hoffmann int idx, GSList *group, GtkWidget *view_menu) 1652ed1132e4SGerd Hoffmann { 1653cdeb7090SGerd Hoffmann vc->menu_item = gtk_radio_menu_item_new_with_mnemonic(group, vc->label); 1654277836c8SCole Robinson gtk_accel_group_connect(s->accel_group, GDK_KEY_1 + idx, 1655277836c8SCole Robinson HOTKEY_MODIFIERS, 0, 1656277836c8SCole Robinson g_cclosure_new_swap(G_CALLBACK(gd_accel_switch_vc), vc, NULL)); 1657277836c8SCole Robinson #if GTK_CHECK_VERSION(3, 8, 0) 1658277836c8SCole Robinson gtk_accel_label_set_accel( 1659277836c8SCole Robinson GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(vc->menu_item))), 1660277836c8SCole Robinson GDK_KEY_1 + idx, HOTKEY_MODIFIERS); 1661277836c8SCole Robinson #endif 1662ed1132e4SGerd Hoffmann 1663ed1132e4SGerd Hoffmann g_signal_connect(vc->menu_item, "activate", 1664ed1132e4SGerd Hoffmann G_CALLBACK(gd_menu_switch_vc), s); 1665ed1132e4SGerd Hoffmann gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), vc->menu_item); 1666ed1132e4SGerd Hoffmann 1667277836c8SCole Robinson group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(vc->menu_item)); 1668ed1132e4SGerd Hoffmann return group; 1669ed1132e4SGerd Hoffmann } 1670ed1132e4SGerd Hoffmann 1671ee5f31e4SGerd Hoffmann #if defined(CONFIG_VTE) 167244b31e0bSMichael S. Tsirkin static void gd_menu_copy(GtkMenuItem *item, void *opaque) 167344b31e0bSMichael S. Tsirkin { 167444b31e0bSMichael S. Tsirkin GtkDisplayState *s = opaque; 167544b31e0bSMichael S. Tsirkin VirtualConsole *vc = gd_vc_find_current(s); 167644b31e0bSMichael S. Tsirkin 167744b31e0bSMichael S. Tsirkin vte_terminal_copy_clipboard(VTE_TERMINAL(vc->vte.terminal)); 167844b31e0bSMichael S. Tsirkin } 167944b31e0bSMichael S. Tsirkin 16800fb20d1cSCole Robinson static void gd_vc_adjustment_changed(GtkAdjustment *adjustment, void *opaque) 16810fb20d1cSCole Robinson { 16820fb20d1cSCole Robinson VirtualConsole *vc = opaque; 16830fb20d1cSCole Robinson 16840fb20d1cSCole Robinson if (gtk_adjustment_get_upper(adjustment) > 16850fb20d1cSCole Robinson gtk_adjustment_get_page_size(adjustment)) { 1686271a25c0SGerd Hoffmann gtk_widget_show(vc->vte.scrollbar); 16870fb20d1cSCole Robinson } else { 1688271a25c0SGerd Hoffmann gtk_widget_hide(vc->vte.scrollbar); 16890fb20d1cSCole Robinson } 16900fb20d1cSCole Robinson } 16910fb20d1cSCole Robinson 1692*0ec7b3e7SMarc-André Lureau static int gd_vc_chr_write(Chardev *chr, const uint8_t *buf, int len) 1693d861def3SAnthony Liguori { 1694*0ec7b3e7SMarc-André Lureau VCChardev *vcd = (VCChardev *)chr; 169541ac54b2SMarc-André Lureau VirtualConsole *vc = vcd->console; 1696d861def3SAnthony Liguori 1697271a25c0SGerd Hoffmann vte_terminal_feed(VTE_TERMINAL(vc->vte.terminal), (const char *)buf, len); 1698d4370741SCole Robinson return len; 1699d861def3SAnthony Liguori } 1700d861def3SAnthony Liguori 1701*0ec7b3e7SMarc-André Lureau static void gd_vc_chr_set_echo(Chardev *chr, bool echo) 1702fba958c6SPaolo Bonzini { 1703*0ec7b3e7SMarc-André Lureau VCChardev *vcd = (VCChardev *)chr; 170441ac54b2SMarc-André Lureau VirtualConsole *vc = vcd->console; 1705fba958c6SPaolo Bonzini 170641ac54b2SMarc-André Lureau if (vc) { 1707fba958c6SPaolo Bonzini vc->vte.echo = echo; 170841ac54b2SMarc-André Lureau } else { 170941ac54b2SMarc-André Lureau vcd->echo = echo; 171041ac54b2SMarc-André Lureau } 1711fba958c6SPaolo Bonzini } 1712fba958c6SPaolo Bonzini 1713d861def3SAnthony Liguori static int nb_vcs; 1714*0ec7b3e7SMarc-André Lureau static Chardev *vcs[MAX_VCS]; 1715d861def3SAnthony Liguori 1716*0ec7b3e7SMarc-André Lureau static Chardev *gd_vc_handler(ChardevVC *vc, Error **errp) 1717d861def3SAnthony Liguori { 1718b68e956aSMarc-André Lureau static const CharDriver gd_vc_driver = { 1719*0ec7b3e7SMarc-André Lureau .instance_size = sizeof(VCChardev), 1720b68e956aSMarc-André Lureau .kind = CHARDEV_BACKEND_KIND_VC, 1721b68e956aSMarc-André Lureau .chr_write = gd_vc_chr_write, 1722b68e956aSMarc-André Lureau .chr_set_echo = gd_vc_chr_set_echo, 1723b68e956aSMarc-André Lureau }; 1724b68e956aSMarc-André Lureau 1725919e11f3SDaniel P. Berrange ChardevCommon *common = qapi_ChardevVC_base(vc); 1726*0ec7b3e7SMarc-André Lureau Chardev *chr; 1727d861def3SAnthony Liguori 1728c952b715SMarc-André Lureau if (nb_vcs == MAX_VCS) { 1729c952b715SMarc-André Lureau error_setg(errp, "Maximum number of consoles reached"); 1730c952b715SMarc-André Lureau return NULL; 1731c952b715SMarc-André Lureau } 1732c952b715SMarc-André Lureau 1733b68e956aSMarc-André Lureau chr = qemu_chr_alloc(&gd_vc_driver, common, errp); 1734919e11f3SDaniel P. Berrange if (!chr) { 1735919e11f3SDaniel P. Berrange return NULL; 1736919e11f3SDaniel P. Berrange } 1737919e11f3SDaniel P. Berrange 1738d861def3SAnthony Liguori vcs[nb_vcs++] = chr; 1739d861def3SAnthony Liguori 1740d861def3SAnthony Liguori return chr; 1741d861def3SAnthony Liguori } 1742d861def3SAnthony Liguori 1743d4370741SCole Robinson static gboolean gd_vc_in(VteTerminal *terminal, gchar *text, guint size, 1744d4370741SCole Robinson gpointer user_data) 1745d861def3SAnthony Liguori { 1746d4370741SCole Robinson VirtualConsole *vc = user_data; 1747d861def3SAnthony Liguori 1748fba958c6SPaolo Bonzini if (vc->vte.echo) { 1749fba958c6SPaolo Bonzini VteTerminal *term = VTE_TERMINAL(vc->vte.terminal); 1750fba958c6SPaolo Bonzini int i; 1751fba958c6SPaolo Bonzini for (i = 0; i < size; i++) { 1752fba958c6SPaolo Bonzini uint8_t c = text[i]; 1753fba958c6SPaolo Bonzini if (c >= 128 || isprint(c)) { 1754fba958c6SPaolo Bonzini /* 8-bit characters are considered printable. */ 1755fba958c6SPaolo Bonzini vte_terminal_feed(term, &text[i], 1); 1756fba958c6SPaolo Bonzini } else if (c == '\r' || c == '\n') { 1757fba958c6SPaolo Bonzini vte_terminal_feed(term, "\r\n", 2); 1758fba958c6SPaolo Bonzini } else { 1759fba958c6SPaolo Bonzini char ctrl[2] = { '^', 0}; 1760fba958c6SPaolo Bonzini ctrl[1] = text[i] ^ 64; 1761fba958c6SPaolo Bonzini vte_terminal_feed(term, ctrl, 2); 1762fba958c6SPaolo Bonzini } 1763fba958c6SPaolo Bonzini } 1764fba958c6SPaolo Bonzini } 1765fba958c6SPaolo Bonzini 1766271a25c0SGerd Hoffmann qemu_chr_be_write(vc->vte.chr, (uint8_t *)text, (unsigned int)size); 1767d861def3SAnthony Liguori return TRUE; 1768d861def3SAnthony Liguori } 1769d861def3SAnthony Liguori 1770ed1132e4SGerd Hoffmann static GSList *gd_vc_vte_init(GtkDisplayState *s, VirtualConsole *vc, 1771*0ec7b3e7SMarc-André Lureau Chardev *chr, int idx, 1772e3500d1fSGerd Hoffmann GSList *group, GtkWidget *view_menu) 1773d861def3SAnthony Liguori { 1774d861def3SAnthony Liguori char buffer[32]; 17750fb20d1cSCole Robinson GtkWidget *box; 17760fb20d1cSCole Robinson GtkWidget *scrollbar; 17770fb20d1cSCole Robinson GtkAdjustment *vadjustment; 1778*0ec7b3e7SMarc-André Lureau VCChardev *vcd = (VCChardev *)chr; 1779d861def3SAnthony Liguori 1780e3500d1fSGerd Hoffmann vc->s = s; 178141ac54b2SMarc-André Lureau vc->vte.echo = vcd->echo; 1782ed1132e4SGerd Hoffmann vc->vte.chr = chr; 178341ac54b2SMarc-André Lureau vcd->console = vc; 1784d861def3SAnthony Liguori 1785ed1132e4SGerd Hoffmann snprintf(buffer, sizeof(buffer), "vc%d", idx); 1786cdeb7090SGerd Hoffmann vc->label = g_strdup_printf("%s", vc->vte.chr->label 1787cdeb7090SGerd Hoffmann ? vc->vte.chr->label : buffer); 1788cdeb7090SGerd Hoffmann group = gd_vc_menu_init(s, vc, idx, group, view_menu); 1789d861def3SAnthony Liguori 1790271a25c0SGerd Hoffmann vc->vte.terminal = vte_terminal_new(); 1791271a25c0SGerd Hoffmann g_signal_connect(vc->vte.terminal, "commit", G_CALLBACK(gd_vc_in), vc); 1792d861def3SAnthony Liguori 1793fba958c6SPaolo Bonzini /* The documentation says that the default is UTF-8, but actually it is 1794fba958c6SPaolo Bonzini * 7-bit ASCII at least in VTE 0.38. 1795fba958c6SPaolo Bonzini */ 17964d594233SOlaf Hering #if VTE_CHECK_VERSION(0, 38, 0) 1797fba958c6SPaolo Bonzini vte_terminal_set_encoding(VTE_TERMINAL(vc->vte.terminal), "UTF-8", NULL); 1798fba958c6SPaolo Bonzini #else 1799fba958c6SPaolo Bonzini vte_terminal_set_encoding(VTE_TERMINAL(vc->vte.terminal), "UTF-8"); 1800fba958c6SPaolo Bonzini #endif 1801fba958c6SPaolo Bonzini 1802271a25c0SGerd Hoffmann vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->vte.terminal), -1); 180382fc1809SGerd Hoffmann vte_terminal_set_size(VTE_TERMINAL(vc->vte.terminal), 180482fc1809SGerd Hoffmann VC_TERM_X_MIN, VC_TERM_Y_MIN); 1805d861def3SAnthony Liguori 18060fb20d1cSCole Robinson #if VTE_CHECK_VERSION(0, 28, 0) && GTK_CHECK_VERSION(3, 0, 0) 1807271a25c0SGerd Hoffmann vadjustment = gtk_scrollable_get_vadjustment 1808271a25c0SGerd Hoffmann (GTK_SCROLLABLE(vc->vte.terminal)); 18090fb20d1cSCole Robinson #else 1810271a25c0SGerd Hoffmann vadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->vte.terminal)); 18110fb20d1cSCole Robinson #endif 1812d861def3SAnthony Liguori 18130fb20d1cSCole Robinson #if GTK_CHECK_VERSION(3, 0, 0) 18140fb20d1cSCole Robinson box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); 18150fb20d1cSCole Robinson scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, vadjustment); 18160fb20d1cSCole Robinson #else 18170fb20d1cSCole Robinson box = gtk_hbox_new(false, 2); 18180fb20d1cSCole Robinson scrollbar = gtk_vscrollbar_new(vadjustment); 18190fb20d1cSCole Robinson #endif 18200fb20d1cSCole Robinson 1821271a25c0SGerd Hoffmann gtk_box_pack_start(GTK_BOX(box), vc->vte.terminal, TRUE, TRUE, 0); 18220fb20d1cSCole Robinson gtk_box_pack_start(GTK_BOX(box), scrollbar, FALSE, FALSE, 0); 18230fb20d1cSCole Robinson 1824271a25c0SGerd Hoffmann vc->vte.box = box; 1825271a25c0SGerd Hoffmann vc->vte.scrollbar = scrollbar; 18260fb20d1cSCole Robinson 18270fb20d1cSCole Robinson g_signal_connect(vadjustment, "changed", 18280fb20d1cSCole Robinson G_CALLBACK(gd_vc_adjustment_changed), vc); 18290fb20d1cSCole Robinson 1830e3500d1fSGerd Hoffmann vc->type = GD_VC_VTE; 1831271a25c0SGerd Hoffmann vc->tab_item = box; 18329d677e1cSJan Kiszka vc->focus = vc->vte.terminal; 1833271a25c0SGerd Hoffmann gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), vc->tab_item, 1834cdeb7090SGerd Hoffmann gtk_label_new(vc->label)); 1835d861def3SAnthony Liguori 1836271a25c0SGerd Hoffmann qemu_chr_be_generic_open(vc->vte.chr); 1837d861def3SAnthony Liguori 1838d861def3SAnthony Liguori return group; 1839a4ccabcfSAnthony Liguori } 1840a4ccabcfSAnthony Liguori 1841ed1132e4SGerd Hoffmann static void gd_vcs_init(GtkDisplayState *s, GSList *group, 1842ee5f31e4SGerd Hoffmann GtkWidget *view_menu) 1843ee5f31e4SGerd Hoffmann { 1844ee5f31e4SGerd Hoffmann int i; 1845ee5f31e4SGerd Hoffmann 1846ee5f31e4SGerd Hoffmann for (i = 0; i < nb_vcs; i++) { 1847ed1132e4SGerd Hoffmann VirtualConsole *vc = &s->vc[s->nb_vcs]; 1848ed1132e4SGerd Hoffmann group = gd_vc_vte_init(s, vc, vcs[i], s->nb_vcs, group, view_menu); 1849ee5f31e4SGerd Hoffmann s->nb_vcs++; 1850ee5f31e4SGerd Hoffmann } 1851ee5f31e4SGerd Hoffmann } 1852ee5f31e4SGerd Hoffmann #endif /* CONFIG_VTE */ 1853ee5f31e4SGerd Hoffmann 1854a4ccabcfSAnthony Liguori /** Window Creation **/ 1855a4ccabcfSAnthony Liguori 1856e3500d1fSGerd Hoffmann static void gd_connect_vc_gfx_signals(VirtualConsole *vc) 1857e3500d1fSGerd Hoffmann { 1858e3500d1fSGerd Hoffmann #if GTK_CHECK_VERSION(3, 0, 0) 1859e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "draw", 1860e3500d1fSGerd Hoffmann G_CALLBACK(gd_draw_event), vc); 1861925a0400SGerd Hoffmann #if defined(CONFIG_GTK_GL) 1862925a0400SGerd Hoffmann if (display_opengl) { 1863925a0400SGerd Hoffmann /* wire up GtkGlArea events */ 1864925a0400SGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "render", 1865925a0400SGerd Hoffmann G_CALLBACK(gd_render_event), vc); 1866925a0400SGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "resize", 1867925a0400SGerd Hoffmann G_CALLBACK(gd_resize_event), vc); 1868925a0400SGerd Hoffmann } 1869925a0400SGerd Hoffmann #endif 1870e3500d1fSGerd Hoffmann #else 1871e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "expose-event", 1872e3500d1fSGerd Hoffmann G_CALLBACK(gd_expose_event), vc); 1873e3500d1fSGerd Hoffmann #endif 1874f8c223f6SGerd Hoffmann if (qemu_console_is_graphic(vc->gfx.dcl.con)) { 1875e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "event", 1876e3500d1fSGerd Hoffmann G_CALLBACK(gd_event), vc); 1877e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "button-press-event", 1878e3500d1fSGerd Hoffmann G_CALLBACK(gd_button_event), vc); 1879e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "button-release-event", 1880e3500d1fSGerd Hoffmann G_CALLBACK(gd_button_event), vc); 1881e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "scroll-event", 1882e3500d1fSGerd Hoffmann G_CALLBACK(gd_scroll_event), vc); 1883e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "key-press-event", 1884e3500d1fSGerd Hoffmann G_CALLBACK(gd_key_event), vc); 1885e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "key-release-event", 1886e3500d1fSGerd Hoffmann G_CALLBACK(gd_key_event), vc); 1887e3500d1fSGerd Hoffmann 1888e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "enter-notify-event", 1889e3500d1fSGerd Hoffmann G_CALLBACK(gd_enter_event), vc); 1890e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "leave-notify-event", 1891e3500d1fSGerd Hoffmann G_CALLBACK(gd_leave_event), vc); 1892e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "focus-out-event", 1893e3500d1fSGerd Hoffmann G_CALLBACK(gd_focus_out_event), vc); 18941301e515SGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "configure-event", 18951301e515SGerd Hoffmann G_CALLBACK(gd_configure), vc); 1896f8c223f6SGerd Hoffmann } else { 1897f8c223f6SGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "key-press-event", 1898f8c223f6SGerd Hoffmann G_CALLBACK(gd_text_key_down), vc); 1899f8c223f6SGerd Hoffmann } 1900e3500d1fSGerd Hoffmann } 1901e3500d1fSGerd Hoffmann 1902a4ccabcfSAnthony Liguori static void gd_connect_signals(GtkDisplayState *s) 1903a4ccabcfSAnthony Liguori { 1904a4ccabcfSAnthony Liguori g_signal_connect(s->show_tabs_item, "activate", 1905a4ccabcfSAnthony Liguori G_CALLBACK(gd_menu_show_tabs), s); 1906cdeb7090SGerd Hoffmann g_signal_connect(s->untabify_item, "activate", 1907cdeb7090SGerd Hoffmann G_CALLBACK(gd_menu_untabify), s); 1908a4ccabcfSAnthony Liguori 1909a4ccabcfSAnthony Liguori g_signal_connect(s->window, "delete-event", 1910a4ccabcfSAnthony Liguori G_CALLBACK(gd_window_close), s); 1911a4ccabcfSAnthony Liguori 191230e8f22bSJan Kiszka g_signal_connect(s->pause_item, "activate", 191330e8f22bSJan Kiszka G_CALLBACK(gd_menu_pause), s); 191430e8f22bSJan Kiszka g_signal_connect(s->reset_item, "activate", 191530e8f22bSJan Kiszka G_CALLBACK(gd_menu_reset), s); 191630e8f22bSJan Kiszka g_signal_connect(s->powerdown_item, "activate", 191730e8f22bSJan Kiszka G_CALLBACK(gd_menu_powerdown), s); 1918a4ccabcfSAnthony Liguori g_signal_connect(s->quit_item, "activate", 1919a4ccabcfSAnthony Liguori G_CALLBACK(gd_menu_quit), s); 192044b31e0bSMichael S. Tsirkin #if defined(CONFIG_VTE) 192144b31e0bSMichael S. Tsirkin g_signal_connect(s->copy_item, "activate", 192244b31e0bSMichael S. Tsirkin G_CALLBACK(gd_menu_copy), s); 192344b31e0bSMichael S. Tsirkin #endif 1924c6158483SAnthony Liguori g_signal_connect(s->full_screen_item, "activate", 1925c6158483SAnthony Liguori G_CALLBACK(gd_menu_full_screen), s); 1926c6158483SAnthony Liguori g_signal_connect(s->zoom_in_item, "activate", 1927c6158483SAnthony Liguori G_CALLBACK(gd_menu_zoom_in), s); 1928c6158483SAnthony Liguori g_signal_connect(s->zoom_out_item, "activate", 1929c6158483SAnthony Liguori G_CALLBACK(gd_menu_zoom_out), s); 1930c6158483SAnthony Liguori g_signal_connect(s->zoom_fixed_item, "activate", 1931c6158483SAnthony Liguori G_CALLBACK(gd_menu_zoom_fixed), s); 1932c6158483SAnthony Liguori g_signal_connect(s->zoom_fit_item, "activate", 1933c6158483SAnthony Liguori G_CALLBACK(gd_menu_zoom_fit), s); 19345104a1f6SAnthony Liguori g_signal_connect(s->grab_item, "activate", 19355104a1f6SAnthony Liguori G_CALLBACK(gd_menu_grab_input), s); 1936a4ccabcfSAnthony Liguori g_signal_connect(s->notebook, "switch-page", 1937a4ccabcfSAnthony Liguori G_CALLBACK(gd_change_page), s); 1938a4ccabcfSAnthony Liguori } 1939a4ccabcfSAnthony Liguori 1940400519d2SCole Robinson static GtkWidget *gd_create_menu_machine(GtkDisplayState *s) 1941a4ccabcfSAnthony Liguori { 1942bf9b255fSAnthony Liguori GtkWidget *machine_menu; 1943a4ccabcfSAnthony Liguori GtkWidget *separator; 1944a4ccabcfSAnthony Liguori 1945bf9b255fSAnthony Liguori machine_menu = gtk_menu_new(); 1946400519d2SCole Robinson gtk_menu_set_accel_group(GTK_MENU(machine_menu), s->accel_group); 194730e8f22bSJan Kiszka 194830e8f22bSJan Kiszka s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause")); 1949bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->pause_item); 195030e8f22bSJan Kiszka 195130e8f22bSJan Kiszka separator = gtk_separator_menu_item_new(); 1952bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator); 195330e8f22bSJan Kiszka 19549068f20dSCole Robinson s->reset_item = gtk_menu_item_new_with_mnemonic(_("_Reset")); 1955bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->reset_item); 195630e8f22bSJan Kiszka 19579068f20dSCole Robinson s->powerdown_item = gtk_menu_item_new_with_mnemonic(_("Power _Down")); 1958bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->powerdown_item); 195930e8f22bSJan Kiszka 196030e8f22bSJan Kiszka separator = gtk_separator_menu_item_new(); 1961bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator); 1962a4ccabcfSAnthony Liguori 19633d914488SCole Robinson s->quit_item = gtk_menu_item_new_with_mnemonic(_("_Quit")); 1964a4ccabcfSAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item), 196530e8f22bSJan Kiszka "<QEMU>/Machine/Quit"); 19663d914488SCole Robinson gtk_accel_map_add_entry("<QEMU>/Machine/Quit", 1967db1da1f2SCole Robinson GDK_KEY_q, HOTKEY_MODIFIERS); 1968bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->quit_item); 1969a4ccabcfSAnthony Liguori 1970bf9b255fSAnthony Liguori return machine_menu; 1971bf9b255fSAnthony Liguori } 1972bf9b255fSAnthony Liguori 1973e3500d1fSGerd Hoffmann static GSList *gd_vc_gfx_init(GtkDisplayState *s, VirtualConsole *vc, 1974ed1132e4SGerd Hoffmann QemuConsole *con, int idx, 1975e3500d1fSGerd Hoffmann GSList *group, GtkWidget *view_menu) 1976e3500d1fSGerd Hoffmann { 1977779ce88fSGerd Hoffmann vc->label = qemu_console_get_label(con); 1978e3500d1fSGerd Hoffmann vc->s = s; 1979e3500d1fSGerd Hoffmann vc->gfx.scale_x = 1.0; 1980e3500d1fSGerd Hoffmann vc->gfx.scale_y = 1.0; 1981e3500d1fSGerd Hoffmann 1982925a0400SGerd Hoffmann #if defined(CONFIG_OPENGL) 1983925a0400SGerd Hoffmann if (display_opengl) { 1984925a0400SGerd Hoffmann #if defined(CONFIG_GTK_GL) 1985925a0400SGerd Hoffmann vc->gfx.drawing_area = gtk_gl_area_new(); 1986925a0400SGerd Hoffmann vc->gfx.dcl.ops = &dcl_gl_area_ops; 1987925a0400SGerd Hoffmann #else 1988e3500d1fSGerd Hoffmann vc->gfx.drawing_area = gtk_drawing_area_new(); 1989925a0400SGerd Hoffmann /* 1990925a0400SGerd Hoffmann * gtk_widget_set_double_buffered() was deprecated in 3.14. 1991925a0400SGerd Hoffmann * It is required for opengl rendering on X11 though. A 1992925a0400SGerd Hoffmann * proper replacement (native opengl support) is only 1993925a0400SGerd Hoffmann * available in 3.16+. Silence the warning if possible. 1994925a0400SGerd Hoffmann */ 1995925a0400SGerd Hoffmann #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE 1996925a0400SGerd Hoffmann #pragma GCC diagnostic push 1997925a0400SGerd Hoffmann #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 1998925a0400SGerd Hoffmann #endif 1999925a0400SGerd Hoffmann gtk_widget_set_double_buffered(vc->gfx.drawing_area, FALSE); 2000925a0400SGerd Hoffmann #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE 2001925a0400SGerd Hoffmann #pragma GCC diagnostic pop 2002925a0400SGerd Hoffmann #endif 2003925a0400SGerd Hoffmann vc->gfx.dcl.ops = &dcl_egl_ops; 2004925a0400SGerd Hoffmann #endif /* CONFIG_GTK_GL */ 2005925a0400SGerd Hoffmann } else 2006925a0400SGerd Hoffmann #endif 2007925a0400SGerd Hoffmann { 2008925a0400SGerd Hoffmann vc->gfx.drawing_area = gtk_drawing_area_new(); 2009925a0400SGerd Hoffmann vc->gfx.dcl.ops = &dcl_ops; 2010925a0400SGerd Hoffmann } 2011925a0400SGerd Hoffmann 2012925a0400SGerd Hoffmann 2013e3500d1fSGerd Hoffmann gtk_widget_add_events(vc->gfx.drawing_area, 2014e3500d1fSGerd Hoffmann GDK_POINTER_MOTION_MASK | 2015e3500d1fSGerd Hoffmann GDK_BUTTON_PRESS_MASK | 2016e3500d1fSGerd Hoffmann GDK_BUTTON_RELEASE_MASK | 2017e3500d1fSGerd Hoffmann GDK_BUTTON_MOTION_MASK | 2018e3500d1fSGerd Hoffmann GDK_ENTER_NOTIFY_MASK | 2019e3500d1fSGerd Hoffmann GDK_LEAVE_NOTIFY_MASK | 2020e3500d1fSGerd Hoffmann GDK_SCROLL_MASK | 2021e3500d1fSGerd Hoffmann GDK_KEY_PRESS_MASK); 2022e3500d1fSGerd Hoffmann gtk_widget_set_can_focus(vc->gfx.drawing_area, TRUE); 2023e3500d1fSGerd Hoffmann 2024e3500d1fSGerd Hoffmann vc->type = GD_VC_GFX; 2025e3500d1fSGerd Hoffmann vc->tab_item = vc->gfx.drawing_area; 20269d677e1cSJan Kiszka vc->focus = vc->gfx.drawing_area; 2027e3500d1fSGerd Hoffmann gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), 2028cdeb7090SGerd Hoffmann vc->tab_item, gtk_label_new(vc->label)); 2029e3500d1fSGerd Hoffmann 2030e3500d1fSGerd Hoffmann vc->gfx.dcl.con = con; 2031e3500d1fSGerd Hoffmann register_displaychangelistener(&vc->gfx.dcl); 2032e3500d1fSGerd Hoffmann 2033f8c223f6SGerd Hoffmann gd_connect_vc_gfx_signals(vc); 2034f8c223f6SGerd Hoffmann group = gd_vc_menu_init(s, vc, idx, group, view_menu); 2035f8c223f6SGerd Hoffmann 20361301e515SGerd Hoffmann if (dpy_ui_info_supported(vc->gfx.dcl.con)) { 20371301e515SGerd Hoffmann gtk_menu_item_activate(GTK_MENU_ITEM(s->zoom_fit_item)); 20381d73cd78SGerd Hoffmann s->free_scale = true; 20391301e515SGerd Hoffmann } 20401301e515SGerd Hoffmann 2041e3500d1fSGerd Hoffmann return group; 2042e3500d1fSGerd Hoffmann } 2043e3500d1fSGerd Hoffmann 2044400519d2SCole Robinson static GtkWidget *gd_create_menu_view(GtkDisplayState *s) 2045bf9b255fSAnthony Liguori { 2046bf9b255fSAnthony Liguori GSList *group = NULL; 2047bf9b255fSAnthony Liguori GtkWidget *view_menu; 2048bf9b255fSAnthony Liguori GtkWidget *separator; 2049ed1132e4SGerd Hoffmann QemuConsole *con; 2050ed1132e4SGerd Hoffmann int vc; 2051bf9b255fSAnthony Liguori 2052bf9b255fSAnthony Liguori view_menu = gtk_menu_new(); 2053400519d2SCole Robinson gtk_menu_set_accel_group(GTK_MENU(view_menu), s->accel_group); 2054a4ccabcfSAnthony Liguori 20553d914488SCole Robinson s->full_screen_item = gtk_menu_item_new_with_mnemonic(_("_Fullscreen")); 205695414914SCole Robinson 205744b31e0bSMichael S. Tsirkin #if defined(CONFIG_VTE) 205844b31e0bSMichael S. Tsirkin s->copy_item = gtk_menu_item_new_with_mnemonic(_("_Copy")); 205944b31e0bSMichael S. Tsirkin gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->copy_item); 206044b31e0bSMichael S. Tsirkin #endif 206144b31e0bSMichael S. Tsirkin 206295414914SCole Robinson gtk_accel_group_connect(s->accel_group, GDK_KEY_f, HOTKEY_MODIFIERS, 0, 206395414914SCole Robinson g_cclosure_new_swap(G_CALLBACK(gd_accel_full_screen), s, NULL)); 206495414914SCole Robinson #if GTK_CHECK_VERSION(3, 8, 0) 206595414914SCole Robinson gtk_accel_label_set_accel( 206695414914SCole Robinson GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(s->full_screen_item))), 206795414914SCole Robinson GDK_KEY_f, HOTKEY_MODIFIERS); 206895414914SCole Robinson #endif 2069bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->full_screen_item); 2070c6158483SAnthony Liguori 2071c6158483SAnthony Liguori separator = gtk_separator_menu_item_new(); 2072bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 2073c6158483SAnthony Liguori 20743d914488SCole Robinson s->zoom_in_item = gtk_menu_item_new_with_mnemonic(_("Zoom _In")); 2075c6158483SAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_in_item), 2076c6158483SAnthony Liguori "<QEMU>/View/Zoom In"); 2077b1e749c0SJan Kiszka gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus, 2078b1e749c0SJan Kiszka HOTKEY_MODIFIERS); 2079bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_in_item); 2080c6158483SAnthony Liguori 20813d914488SCole Robinson s->zoom_out_item = gtk_menu_item_new_with_mnemonic(_("Zoom _Out")); 2082c6158483SAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_out_item), 2083c6158483SAnthony Liguori "<QEMU>/View/Zoom Out"); 2084b1e749c0SJan Kiszka gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus, 2085b1e749c0SJan Kiszka HOTKEY_MODIFIERS); 2086bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_out_item); 2087c6158483SAnthony Liguori 20883d914488SCole Robinson s->zoom_fixed_item = gtk_menu_item_new_with_mnemonic(_("Best _Fit")); 2089c6158483SAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_fixed_item), 2090c6158483SAnthony Liguori "<QEMU>/View/Zoom Fixed"); 2091b1e749c0SJan Kiszka gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0, 2092b1e749c0SJan Kiszka HOTKEY_MODIFIERS); 2093bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fixed_item); 2094c6158483SAnthony Liguori 2095834574eaSAnthony Liguori s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit")); 2096bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fit_item); 2097c6158483SAnthony Liguori 2098c6158483SAnthony Liguori separator = gtk_separator_menu_item_new(); 2099bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 2100c6158483SAnthony Liguori 2101834574eaSAnthony Liguori s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover")); 2102bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_on_hover_item); 21035104a1f6SAnthony Liguori 2104834574eaSAnthony Liguori s->grab_item = gtk_check_menu_item_new_with_mnemonic(_("_Grab Input")); 21055104a1f6SAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->grab_item), 21065104a1f6SAnthony Liguori "<QEMU>/View/Grab Input"); 2107b1e749c0SJan Kiszka gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g, 2108b1e749c0SJan Kiszka HOTKEY_MODIFIERS); 2109bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_item); 21105104a1f6SAnthony Liguori 2111a4ccabcfSAnthony Liguori separator = gtk_separator_menu_item_new(); 2112bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 2113a4ccabcfSAnthony Liguori 2114e3500d1fSGerd Hoffmann /* gfx */ 2115ed1132e4SGerd Hoffmann for (vc = 0;; vc++) { 2116ed1132e4SGerd Hoffmann con = qemu_console_lookup_by_index(vc); 2117f8c223f6SGerd Hoffmann if (!con) { 2118ed1132e4SGerd Hoffmann break; 2119ed1132e4SGerd Hoffmann } 2120ed1132e4SGerd Hoffmann group = gd_vc_gfx_init(s, &s->vc[vc], con, 2121ed1132e4SGerd Hoffmann vc, group, view_menu); 2122ed1132e4SGerd Hoffmann s->nb_vcs++; 2123ed1132e4SGerd Hoffmann } 2124a4ccabcfSAnthony Liguori 2125ee5f31e4SGerd Hoffmann #if defined(CONFIG_VTE) 2126e3500d1fSGerd Hoffmann /* vte */ 2127ed1132e4SGerd Hoffmann gd_vcs_init(s, group, view_menu); 2128ee5f31e4SGerd Hoffmann #endif 2129d861def3SAnthony Liguori 2130a4ccabcfSAnthony Liguori separator = gtk_separator_menu_item_new(); 2131bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 2132a4ccabcfSAnthony Liguori 2133834574eaSAnthony Liguori s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs")); 2134bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_tabs_item); 2135a4ccabcfSAnthony Liguori 2136cdeb7090SGerd Hoffmann s->untabify_item = gtk_menu_item_new_with_mnemonic(_("Detach Tab")); 2137cdeb7090SGerd Hoffmann gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->untabify_item); 2138cdeb7090SGerd Hoffmann 2139bf9b255fSAnthony Liguori return view_menu; 2140bf9b255fSAnthony Liguori } 2141a4ccabcfSAnthony Liguori 2142bf9b255fSAnthony Liguori static void gd_create_menus(GtkDisplayState *s) 2143bf9b255fSAnthony Liguori { 2144400519d2SCole Robinson s->accel_group = gtk_accel_group_new(); 2145400519d2SCole Robinson s->machine_menu = gd_create_menu_machine(s); 2146400519d2SCole Robinson s->view_menu = gd_create_menu_view(s); 2147bf9b255fSAnthony Liguori 2148bf9b255fSAnthony Liguori s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine")); 214930e8f22bSJan Kiszka gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->machine_menu_item), 215030e8f22bSJan Kiszka s->machine_menu); 215130e8f22bSJan Kiszka gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->machine_menu_item); 2152a4ccabcfSAnthony Liguori 2153bf9b255fSAnthony Liguori s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View")); 2154a4ccabcfSAnthony Liguori gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->view_menu_item), s->view_menu); 2155a4ccabcfSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item); 2156bf9b255fSAnthony Liguori 2157400519d2SCole Robinson g_object_set_data(G_OBJECT(s->window), "accel_group", s->accel_group); 2158400519d2SCole Robinson gtk_window_add_accel_group(GTK_WINDOW(s->window), s->accel_group); 2159a4ccabcfSAnthony Liguori } 2160a4ccabcfSAnthony Liguori 21613158a348SBruce Rogers static void gd_set_keycode_type(GtkDisplayState *s) 21623158a348SBruce Rogers { 21630a337ed0SGerd Hoffmann #ifdef GDK_WINDOWING_X11 21643158a348SBruce Rogers GdkDisplay *display = gtk_widget_get_display(s->window); 21650a337ed0SGerd Hoffmann if (GDK_IS_X11_DISPLAY(display)) { 21663158a348SBruce Rogers Display *x11_display = gdk_x11_display_get_xdisplay(display); 21673158a348SBruce Rogers XkbDescPtr desc = XkbGetKeyboard(x11_display, XkbGBN_AllComponentsMask, 21683158a348SBruce Rogers XkbUseCoreKbd); 21690a337ed0SGerd Hoffmann char *keycodes = NULL; 21703158a348SBruce Rogers 21713158a348SBruce Rogers if (desc && desc->names) { 21723158a348SBruce Rogers keycodes = XGetAtomName(x11_display, desc->names->keycodes); 21733158a348SBruce Rogers } 21743158a348SBruce Rogers if (keycodes == NULL) { 21753158a348SBruce Rogers fprintf(stderr, "could not lookup keycode name\n"); 21763158a348SBruce Rogers } else if (strstart(keycodes, "evdev", NULL)) { 21773158a348SBruce Rogers s->has_evdev = true; 21783158a348SBruce Rogers } else if (!strstart(keycodes, "xfree86", NULL)) { 21793158a348SBruce Rogers fprintf(stderr, "unknown keycodes `%s', please report to " 21803158a348SBruce Rogers "qemu-devel@nongnu.org\n", keycodes); 21813158a348SBruce Rogers } 218284961407SChen Fan 218384961407SChen Fan if (desc) { 218484961407SChen Fan XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True); 218584961407SChen Fan } 218684961407SChen Fan if (keycodes) { 218784961407SChen Fan XFree(keycodes); 218884961407SChen Fan } 21890a337ed0SGerd Hoffmann } 21903158a348SBruce Rogers #endif 21913158a348SBruce Rogers } 21923158a348SBruce Rogers 2193060ab763SGerd Hoffmann static gboolean gtkinit; 2194060ab763SGerd Hoffmann 2195881249c7SJan Kiszka void gtk_display_init(DisplayState *ds, bool full_screen, bool grab_on_hover) 2196a4ccabcfSAnthony Liguori { 21973d4da9d6SHervé Poussineau VirtualConsole *vc; 21983d4da9d6SHervé Poussineau 2199a4ccabcfSAnthony Liguori GtkDisplayState *s = g_malloc0(sizeof(*s)); 2200d819cdccSStefan Weil char *filename; 220163c67b6dSMax Reitz GdkDisplay *window_display; 2202a4ccabcfSAnthony Liguori 2203060ab763SGerd Hoffmann if (!gtkinit) { 2204060ab763SGerd Hoffmann fprintf(stderr, "gtk initialization failed\n"); 2205060ab763SGerd Hoffmann exit(1); 2206060ab763SGerd Hoffmann } 2207060ab763SGerd Hoffmann 2208a4ccabcfSAnthony Liguori s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 220951572ab0SDaniel P. Berrange #if GTK_CHECK_VERSION(3, 2, 0) 221051572ab0SDaniel P. Berrange s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); 221151572ab0SDaniel P. Berrange #else 2212a4ccabcfSAnthony Liguori s->vbox = gtk_vbox_new(FALSE, 0); 221351572ab0SDaniel P. Berrange #endif 2214a4ccabcfSAnthony Liguori s->notebook = gtk_notebook_new(); 2215a4ccabcfSAnthony Liguori s->menu_bar = gtk_menu_bar_new(); 2216a4ccabcfSAnthony Liguori 2217c6158483SAnthony Liguori s->free_scale = FALSE; 2218a4ccabcfSAnthony Liguori 22192cb5d2a4SAlberto Garcia /* LC_MESSAGES only. See early_gtk_display_init() for details */ 22202cb5d2a4SAlberto Garcia setlocale(LC_MESSAGES, ""); 2221834574eaSAnthony Liguori bindtextdomain("qemu", CONFIG_QEMU_LOCALEDIR); 2222834574eaSAnthony Liguori textdomain("qemu"); 2223834574eaSAnthony Liguori 222463c67b6dSMax Reitz window_display = gtk_widget_get_display(s->window); 222563c67b6dSMax Reitz s->null_cursor = gdk_cursor_new_for_display(window_display, 222663c67b6dSMax Reitz GDK_BLANK_CURSOR); 2227a4ccabcfSAnthony Liguori 2228a4ccabcfSAnthony Liguori s->mouse_mode_notifier.notify = gd_mouse_mode_change; 2229a4ccabcfSAnthony Liguori qemu_add_mouse_mode_change_notifier(&s->mouse_mode_notifier); 2230a4ccabcfSAnthony Liguori qemu_add_vm_change_state_handler(gd_change_runstate, s); 2231a4ccabcfSAnthony Liguori 2232f7da9c17SAnthony Liguori filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu_logo_no_text.svg"); 2233d819cdccSStefan Weil if (filename) { 2234d819cdccSStefan Weil GError *error = NULL; 2235d819cdccSStefan Weil GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(filename, &error); 2236d819cdccSStefan Weil if (pixbuf) { 2237d819cdccSStefan Weil gtk_window_set_icon(GTK_WINDOW(s->window), pixbuf); 2238d819cdccSStefan Weil } else { 2239d819cdccSStefan Weil g_error_free(error); 2240d819cdccSStefan Weil } 2241d819cdccSStefan Weil g_free(filename); 2242d819cdccSStefan Weil } 2243d819cdccSStefan Weil 2244a4ccabcfSAnthony Liguori gd_create_menus(s); 2245a4ccabcfSAnthony Liguori 2246a4ccabcfSAnthony Liguori gd_connect_signals(s); 2247a4ccabcfSAnthony Liguori 2248a4ccabcfSAnthony Liguori gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 2249a4ccabcfSAnthony Liguori gtk_notebook_set_show_border(GTK_NOTEBOOK(s->notebook), FALSE); 2250a4ccabcfSAnthony Liguori 2251a4ccabcfSAnthony Liguori gd_update_caption(s); 2252a4ccabcfSAnthony Liguori 2253a4ccabcfSAnthony Liguori gtk_box_pack_start(GTK_BOX(s->vbox), s->menu_bar, FALSE, TRUE, 0); 2254a4ccabcfSAnthony Liguori gtk_box_pack_start(GTK_BOX(s->vbox), s->notebook, TRUE, TRUE, 0); 2255a4ccabcfSAnthony Liguori 2256a4ccabcfSAnthony Liguori gtk_container_add(GTK_CONTAINER(s->window), s->vbox); 2257a4ccabcfSAnthony Liguori 2258a4ccabcfSAnthony Liguori gtk_widget_show_all(s->window); 2259a4ccabcfSAnthony Liguori 22606fa27697SGerd Hoffmann #ifdef VTE_RESIZE_HACK 22616fa27697SGerd Hoffmann { 22626fa27697SGerd Hoffmann VirtualConsole *cur = gd_vc_find_current(s); 2263b310a2a6SFam Zheng if (cur) { 22646fa27697SGerd Hoffmann int i; 22656fa27697SGerd Hoffmann 22666fa27697SGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 22676fa27697SGerd Hoffmann VirtualConsole *vc = &s->vc[i]; 22686fa27697SGerd Hoffmann if (vc && vc->type == GD_VC_VTE && vc != cur) { 22696fa27697SGerd Hoffmann gtk_widget_hide(vc->vte.terminal); 22706fa27697SGerd Hoffmann } 22716fa27697SGerd Hoffmann } 22726fa27697SGerd Hoffmann gd_update_windowsize(cur); 22736fa27697SGerd Hoffmann } 2274b310a2a6SFam Zheng } 22756fa27697SGerd Hoffmann #endif 22766fa27697SGerd Hoffmann 22773d4da9d6SHervé Poussineau vc = gd_vc_find_current(s); 22783d4da9d6SHervé Poussineau gtk_widget_set_sensitive(s->view_menu, vc != NULL); 2279a0815632SStefan Hajnoczi #ifdef CONFIG_VTE 2280a0815632SStefan Hajnoczi gtk_widget_set_sensitive(s->copy_item, 22813d4da9d6SHervé Poussineau vc && vc->type == GD_VC_VTE); 2282a0815632SStefan Hajnoczi #endif 2283a0815632SStefan Hajnoczi 2284787ba4f0SPeter Wu if (full_screen) { 2285787ba4f0SPeter Wu gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item)); 2286787ba4f0SPeter Wu } 2287881249c7SJan Kiszka if (grab_on_hover) { 2288881249c7SJan Kiszka gtk_menu_item_activate(GTK_MENU_ITEM(s->grab_on_hover_item)); 2289881249c7SJan Kiszka } 2290787ba4f0SPeter Wu 22913158a348SBruce Rogers gd_set_keycode_type(s); 2292a4ccabcfSAnthony Liguori } 2293ee5f31e4SGerd Hoffmann 229497edf3bdSGerd Hoffmann void early_gtk_display_init(int opengl) 2295ee5f31e4SGerd Hoffmann { 22962cb5d2a4SAlberto Garcia /* The QEMU code relies on the assumption that it's always run in 22972cb5d2a4SAlberto Garcia * the C locale. Therefore it is not prepared to deal with 22982cb5d2a4SAlberto Garcia * operations that produce different results depending on the 22992cb5d2a4SAlberto Garcia * locale, such as printf's formatting of decimal numbers, and 23002cb5d2a4SAlberto Garcia * possibly others. 23012cb5d2a4SAlberto Garcia * 23022cb5d2a4SAlberto Garcia * Since GTK+ calls setlocale() by default -importing the locale 23032cb5d2a4SAlberto Garcia * settings from the environment- we must prevent it from doing so 23042cb5d2a4SAlberto Garcia * using gtk_disable_setlocale(). 23052cb5d2a4SAlberto Garcia * 23062cb5d2a4SAlberto Garcia * QEMU's GTK+ UI, however, _does_ have translations for some of 23072cb5d2a4SAlberto Garcia * the menu items. As a trade-off between a functionally correct 23082cb5d2a4SAlberto Garcia * QEMU and a fully internationalized UI we support importing 23092cb5d2a4SAlberto Garcia * LC_MESSAGES from the environment (see the setlocale() call 23102cb5d2a4SAlberto Garcia * earlier in this file). This allows us to display translated 23112cb5d2a4SAlberto Garcia * messages leaving everything else untouched. 23122cb5d2a4SAlberto Garcia */ 23132cb5d2a4SAlberto Garcia gtk_disable_setlocale(); 2314060ab763SGerd Hoffmann gtkinit = gtk_init_check(NULL, NULL); 2315060ab763SGerd Hoffmann if (!gtkinit) { 2316060ab763SGerd Hoffmann /* don't exit yet, that'll break -help */ 2317060ab763SGerd Hoffmann return; 2318060ab763SGerd Hoffmann } 231997edf3bdSGerd Hoffmann 232097edf3bdSGerd Hoffmann switch (opengl) { 232197edf3bdSGerd Hoffmann case -1: /* default */ 232297edf3bdSGerd Hoffmann case 0: /* off */ 232397edf3bdSGerd Hoffmann break; 232497edf3bdSGerd Hoffmann case 1: /* on */ 232597edf3bdSGerd Hoffmann #if defined(CONFIG_OPENGL) 2326925a0400SGerd Hoffmann #if defined(CONFIG_GTK_GL) 2327925a0400SGerd Hoffmann gtk_gl_area_init(); 2328925a0400SGerd Hoffmann #else 232997edf3bdSGerd Hoffmann gtk_egl_init(); 233097edf3bdSGerd Hoffmann #endif 2331925a0400SGerd Hoffmann #endif 233297edf3bdSGerd Hoffmann break; 233397edf3bdSGerd Hoffmann default: 233497edf3bdSGerd Hoffmann g_assert_not_reached(); 233597edf3bdSGerd Hoffmann break; 233697edf3bdSGerd Hoffmann } 233797edf3bdSGerd Hoffmann 2338ee5f31e4SGerd Hoffmann #if defined(CONFIG_VTE) 2339ee5f31e4SGerd Hoffmann register_vc_handler(gd_vc_handler); 2340ee5f31e4SGerd Hoffmann #endif 2341ee5f31e4SGerd Hoffmann } 2342