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 372777ccc5SStefan Weil #ifdef _WIN32 382777ccc5SStefan Weil # define _WIN32_WINNT 0x0601 /* needed to get definition of MAPVK_VK_TO_VSC */ 392777ccc5SStefan Weil #endif 402777ccc5SStefan Weil 41c95e3080SKevin Wolf #include "qemu-common.h" 42c95e3080SKevin Wolf 43c95e3080SKevin Wolf #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE 44c95e3080SKevin Wolf /* Work around an -Wstrict-prototypes warning in GTK headers */ 45e6f53fd5SMarkus Armbruster #pragma GCC diagnostic push 46c95e3080SKevin Wolf #pragma GCC diagnostic ignored "-Wstrict-prototypes" 47c95e3080SKevin Wolf #endif 48a4ccabcfSAnthony Liguori #include <gtk/gtk.h> 49c95e3080SKevin Wolf #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE 50e6f53fd5SMarkus Armbruster #pragma GCC diagnostic pop 51c95e3080SKevin Wolf #endif 52c95e3080SKevin Wolf 53c95e3080SKevin Wolf 54a4ccabcfSAnthony Liguori #include <gdk/gdkkeysyms.h> 55834574eaSAnthony Liguori #include <glib/gi18n.h> 563f58eadeSStefan Weil #include <locale.h> 57bbbf9bfbSStefan Weil #if defined(CONFIG_VTE) 58a4ccabcfSAnthony Liguori #include <vte/vte.h> 59bbbf9bfbSStefan Weil #endif 60a4ccabcfSAnthony Liguori #include <math.h> 61a4ccabcfSAnthony Liguori 62ef0dd982SStefan Weil #include "trace.h" 63a4ccabcfSAnthony Liguori #include "ui/console.h" 64af98ba92SGerd Hoffmann #include "ui/input.h" 65a4ccabcfSAnthony Liguori #include "sysemu/sysemu.h" 66a4ccabcfSAnthony Liguori #include "qmp-commands.h" 67a4ccabcfSAnthony Liguori #include "x_keymap.h" 68a4ccabcfSAnthony Liguori #include "keymaps.h" 69dccfcd0eSPaolo Bonzini #include "sysemu/char.h" 706a24ced5SGerd Hoffmann #include "qom/object.h" 71*3158a348SBruce Rogers #ifndef _WIN32 72*3158a348SBruce Rogers #include <gdk/gdkx.h> 73*3158a348SBruce Rogers #include <X11/XKBlib.h> 74*3158a348SBruce Rogers #endif 75a4ccabcfSAnthony Liguori 76d861def3SAnthony Liguori #define MAX_VCS 10 77d861def3SAnthony Liguori 78bbbf9bfbSStefan Weil #if !defined(CONFIG_VTE) 79bbbf9bfbSStefan Weil # define VTE_CHECK_VERSION(a, b, c) 0 80bbbf9bfbSStefan Weil #endif 81cba68834SDaniel P. Berrange 82cba68834SDaniel P. Berrange /* Compatibility define to let us build on both Gtk2 and Gtk3 */ 83cba68834SDaniel P. Berrange #if GTK_CHECK_VERSION(3, 0, 0) 84cba68834SDaniel P. Berrange static inline void gdk_drawable_get_size(GdkWindow *w, gint *ww, gint *wh) 85cba68834SDaniel P. Berrange { 86cba68834SDaniel P. Berrange *ww = gdk_window_get_width(w); 87cba68834SDaniel P. Berrange *wh = gdk_window_get_height(w); 88cba68834SDaniel P. Berrange } 89cba68834SDaniel P. Berrange #endif 90cba68834SDaniel P. Berrange 91ef6413a2SDaniel P. Berrange #if !GTK_CHECK_VERSION(2, 20, 0) 92ef6413a2SDaniel P. Berrange #define gtk_widget_get_realized(widget) GTK_WIDGET_REALIZED(widget) 93ef6413a2SDaniel P. Berrange #endif 94ef6413a2SDaniel P. Berrange 95bc0477c7SDaniel P. Berrange #ifndef GDK_KEY_0 96bc0477c7SDaniel P. Berrange #define GDK_KEY_0 GDK_0 97bc0477c7SDaniel P. Berrange #define GDK_KEY_1 GDK_1 98bc0477c7SDaniel P. Berrange #define GDK_KEY_2 GDK_2 99bc0477c7SDaniel P. Berrange #define GDK_KEY_f GDK_f 100bc0477c7SDaniel P. Berrange #define GDK_KEY_g GDK_g 101db1da1f2SCole Robinson #define GDK_KEY_q GDK_q 102bc0477c7SDaniel P. Berrange #define GDK_KEY_plus GDK_plus 103bc0477c7SDaniel P. Berrange #define GDK_KEY_minus GDK_minus 104bc0477c7SDaniel P. Berrange #endif 105ef6413a2SDaniel P. Berrange 106b1e749c0SJan Kiszka #define HOTKEY_MODIFIERS (GDK_CONTROL_MASK | GDK_MOD1_MASK) 107b1e749c0SJan Kiszka 1086db253caSJan Kiszka static const int modifier_keycode[] = { 1096db253caSJan Kiszka /* shift, control, alt keys, meta keys, both left & right */ 1106db253caSJan Kiszka 0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8, 0xdb, 0xdd, 1116db253caSJan Kiszka }; 1126db253caSJan Kiszka 113e3500d1fSGerd Hoffmann typedef struct GtkDisplayState GtkDisplayState; 114e3500d1fSGerd Hoffmann 115e3500d1fSGerd Hoffmann typedef struct VirtualGfxConsole { 116e3500d1fSGerd Hoffmann GtkWidget *drawing_area; 117e3500d1fSGerd Hoffmann DisplayChangeListener dcl; 118e3500d1fSGerd Hoffmann DisplaySurface *ds; 119e3500d1fSGerd Hoffmann pixman_image_t *convert; 120e3500d1fSGerd Hoffmann cairo_surface_t *surface; 121e3500d1fSGerd Hoffmann double scale_x; 122e3500d1fSGerd Hoffmann double scale_y; 123e3500d1fSGerd Hoffmann } VirtualGfxConsole; 124e3500d1fSGerd Hoffmann 125bbbf9bfbSStefan Weil #if defined(CONFIG_VTE) 126271a25c0SGerd Hoffmann typedef struct VirtualVteConsole { 1270fb20d1cSCole Robinson GtkWidget *box; 1280fb20d1cSCole Robinson GtkWidget *scrollbar; 129ee5f31e4SGerd Hoffmann GtkWidget *terminal; 130a4ccabcfSAnthony Liguori CharDriverState *chr; 131271a25c0SGerd Hoffmann } VirtualVteConsole; 132bbbf9bfbSStefan Weil #endif 133271a25c0SGerd Hoffmann 134e3500d1fSGerd Hoffmann typedef enum VirtualConsoleType { 135e3500d1fSGerd Hoffmann GD_VC_GFX, 136e3500d1fSGerd Hoffmann GD_VC_VTE, 137e3500d1fSGerd Hoffmann } VirtualConsoleType; 138e3500d1fSGerd Hoffmann 139271a25c0SGerd Hoffmann typedef struct VirtualConsole { 140e3500d1fSGerd Hoffmann GtkDisplayState *s; 141cdeb7090SGerd Hoffmann char *label; 142cdeb7090SGerd Hoffmann GtkWidget *window; 143271a25c0SGerd Hoffmann GtkWidget *menu_item; 144271a25c0SGerd Hoffmann GtkWidget *tab_item; 145e3500d1fSGerd Hoffmann VirtualConsoleType type; 146271a25c0SGerd Hoffmann union { 147e3500d1fSGerd Hoffmann VirtualGfxConsole gfx; 148271a25c0SGerd Hoffmann #if defined(CONFIG_VTE) 149271a25c0SGerd Hoffmann VirtualVteConsole vte; 150271a25c0SGerd Hoffmann #endif 151271a25c0SGerd Hoffmann }; 152a4ccabcfSAnthony Liguori } VirtualConsole; 153a4ccabcfSAnthony Liguori 154e3500d1fSGerd Hoffmann struct GtkDisplayState { 155a4ccabcfSAnthony Liguori GtkWidget *window; 156a4ccabcfSAnthony Liguori 157a4ccabcfSAnthony Liguori GtkWidget *menu_bar; 158a4ccabcfSAnthony Liguori 15973d4dc71SAnthony Liguori GtkAccelGroup *accel_group; 16073d4dc71SAnthony Liguori 16130e8f22bSJan Kiszka GtkWidget *machine_menu_item; 16230e8f22bSJan Kiszka GtkWidget *machine_menu; 16330e8f22bSJan Kiszka GtkWidget *pause_item; 16430e8f22bSJan Kiszka GtkWidget *reset_item; 16530e8f22bSJan Kiszka GtkWidget *powerdown_item; 166a4ccabcfSAnthony Liguori GtkWidget *quit_item; 167a4ccabcfSAnthony Liguori 168a4ccabcfSAnthony Liguori GtkWidget *view_menu_item; 169a4ccabcfSAnthony Liguori GtkWidget *view_menu; 170c6158483SAnthony Liguori GtkWidget *full_screen_item; 171c6158483SAnthony Liguori GtkWidget *zoom_in_item; 172c6158483SAnthony Liguori GtkWidget *zoom_out_item; 173c6158483SAnthony Liguori GtkWidget *zoom_fixed_item; 174c6158483SAnthony Liguori GtkWidget *zoom_fit_item; 1755104a1f6SAnthony Liguori GtkWidget *grab_item; 1765104a1f6SAnthony Liguori GtkWidget *grab_on_hover_item; 177a4ccabcfSAnthony Liguori 178d861def3SAnthony Liguori int nb_vcs; 179d861def3SAnthony Liguori VirtualConsole vc[MAX_VCS]; 180d861def3SAnthony Liguori 181a4ccabcfSAnthony Liguori GtkWidget *show_tabs_item; 182cdeb7090SGerd Hoffmann GtkWidget *untabify_item; 183a4ccabcfSAnthony Liguori 184a4ccabcfSAnthony Liguori GtkWidget *vbox; 185a4ccabcfSAnthony Liguori GtkWidget *notebook; 186a4ccabcfSAnthony Liguori int button_mask; 187e61031cdSTakashi Iwai gboolean last_set; 188a4ccabcfSAnthony Liguori int last_x; 189a4ccabcfSAnthony Liguori int last_y; 190ecce1929STakashi Iwai int grab_x_root; 191ecce1929STakashi Iwai int grab_y_root; 1924c638e2eSGerd Hoffmann VirtualConsole *kbd_owner; 1934c638e2eSGerd Hoffmann VirtualConsole *ptr_owner; 194a4ccabcfSAnthony Liguori 195c6158483SAnthony Liguori gboolean full_screen; 196a4ccabcfSAnthony Liguori 197a4ccabcfSAnthony Liguori GdkCursor *null_cursor; 198a4ccabcfSAnthony Liguori Notifier mouse_mode_notifier; 199c6158483SAnthony Liguori gboolean free_scale; 20030e8f22bSJan Kiszka 20130e8f22bSJan Kiszka bool external_pause_update; 2026db253caSJan Kiszka 2036db253caSJan Kiszka bool modifier_pressed[ARRAY_SIZE(modifier_keycode)]; 204*3158a348SBruce Rogers bool has_evdev; 205e3500d1fSGerd Hoffmann }; 206a4ccabcfSAnthony Liguori 207a4ccabcfSAnthony Liguori static GtkDisplayState *global_state; 208a4ccabcfSAnthony Liguori 2092884cf5bSGerd Hoffmann static void gd_grab_pointer(VirtualConsole *vc); 2102884cf5bSGerd Hoffmann static void gd_ungrab_pointer(GtkDisplayState *s); 2112884cf5bSGerd Hoffmann 212a4ccabcfSAnthony Liguori /** Utility Functions **/ 213a4ccabcfSAnthony Liguori 214271a25c0SGerd Hoffmann static VirtualConsole *gd_vc_find_by_menu(GtkDisplayState *s) 215271a25c0SGerd Hoffmann { 216271a25c0SGerd Hoffmann VirtualConsole *vc; 217271a25c0SGerd Hoffmann gint i; 218271a25c0SGerd Hoffmann 219271a25c0SGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 220271a25c0SGerd Hoffmann vc = &s->vc[i]; 221271a25c0SGerd Hoffmann if (gtk_check_menu_item_get_active 222271a25c0SGerd Hoffmann (GTK_CHECK_MENU_ITEM(vc->menu_item))) { 223271a25c0SGerd Hoffmann return vc; 224271a25c0SGerd Hoffmann } 225271a25c0SGerd Hoffmann } 226271a25c0SGerd Hoffmann return NULL; 227271a25c0SGerd Hoffmann } 228271a25c0SGerd Hoffmann 229271a25c0SGerd Hoffmann static VirtualConsole *gd_vc_find_by_page(GtkDisplayState *s, gint page) 230271a25c0SGerd Hoffmann { 231271a25c0SGerd Hoffmann VirtualConsole *vc; 232271a25c0SGerd Hoffmann gint i, p; 233271a25c0SGerd Hoffmann 234271a25c0SGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 235271a25c0SGerd Hoffmann vc = &s->vc[i]; 236271a25c0SGerd Hoffmann p = gtk_notebook_page_num(GTK_NOTEBOOK(s->notebook), vc->tab_item); 237271a25c0SGerd Hoffmann if (p == page) { 238271a25c0SGerd Hoffmann return vc; 239271a25c0SGerd Hoffmann } 240271a25c0SGerd Hoffmann } 241271a25c0SGerd Hoffmann return NULL; 242271a25c0SGerd Hoffmann } 243271a25c0SGerd Hoffmann 244e3500d1fSGerd Hoffmann static VirtualConsole *gd_vc_find_current(GtkDisplayState *s) 245e3500d1fSGerd Hoffmann { 246e3500d1fSGerd Hoffmann gint page; 247e3500d1fSGerd Hoffmann 248e3500d1fSGerd Hoffmann page = gtk_notebook_get_current_page(GTK_NOTEBOOK(s->notebook)); 249e3500d1fSGerd Hoffmann return gd_vc_find_by_page(s, page); 250e3500d1fSGerd Hoffmann } 251e3500d1fSGerd Hoffmann 2525104a1f6SAnthony Liguori static bool gd_is_grab_active(GtkDisplayState *s) 2535104a1f6SAnthony Liguori { 2545104a1f6SAnthony Liguori return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_item)); 2555104a1f6SAnthony Liguori } 2565104a1f6SAnthony Liguori 2575104a1f6SAnthony Liguori static bool gd_grab_on_hover(GtkDisplayState *s) 2585104a1f6SAnthony Liguori { 2595104a1f6SAnthony Liguori return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_on_hover_item)); 2605104a1f6SAnthony Liguori } 2615104a1f6SAnthony Liguori 262e3500d1fSGerd Hoffmann static void gd_update_cursor(VirtualConsole *vc) 2635104a1f6SAnthony Liguori { 264e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 265e3500d1fSGerd Hoffmann GdkWindow *window; 266832189c9SGerd Hoffmann 267e3500d1fSGerd Hoffmann if (vc->type != GD_VC_GFX) { 268e3500d1fSGerd Hoffmann return; 2695104a1f6SAnthony Liguori } 2705104a1f6SAnthony Liguori 271e3500d1fSGerd Hoffmann window = gtk_widget_get_window(GTK_WIDGET(vc->gfx.drawing_area)); 2722884cf5bSGerd Hoffmann if (s->full_screen || qemu_input_is_absolute() || s->ptr_owner == vc) { 273a4ccabcfSAnthony Liguori gdk_window_set_cursor(window, s->null_cursor); 274a4ccabcfSAnthony Liguori } else { 275a4ccabcfSAnthony Liguori gdk_window_set_cursor(window, NULL); 276a4ccabcfSAnthony Liguori } 277a4ccabcfSAnthony Liguori } 278a4ccabcfSAnthony Liguori 279a4ccabcfSAnthony Liguori static void gd_update_caption(GtkDisplayState *s) 280a4ccabcfSAnthony Liguori { 281a4ccabcfSAnthony Liguori const char *status = ""; 2824eeaa3a8SGerd Hoffmann gchar *prefix; 283a4ccabcfSAnthony Liguori gchar *title; 2845104a1f6SAnthony Liguori const char *grab = ""; 28530e8f22bSJan Kiszka bool is_paused = !runstate_is_running(); 2864eeaa3a8SGerd Hoffmann int i; 2875104a1f6SAnthony Liguori 2884eeaa3a8SGerd Hoffmann if (qemu_name) { 2894eeaa3a8SGerd Hoffmann prefix = g_strdup_printf("QEMU (%s)", qemu_name); 2904eeaa3a8SGerd Hoffmann } else { 2914eeaa3a8SGerd Hoffmann prefix = g_strdup_printf("QEMU"); 2924eeaa3a8SGerd Hoffmann } 2934eeaa3a8SGerd Hoffmann 2944eeaa3a8SGerd Hoffmann if (s->ptr_owner != NULL && 2954eeaa3a8SGerd Hoffmann s->ptr_owner->window == NULL) { 296d8da9ee8SAurelien Jarno grab = _(" - Press Ctrl+Alt+G to release grab"); 2975104a1f6SAnthony Liguori } 298a4ccabcfSAnthony Liguori 29930e8f22bSJan Kiszka if (is_paused) { 300d8da9ee8SAurelien Jarno status = _(" [Paused]"); 301a4ccabcfSAnthony Liguori } 30230e8f22bSJan Kiszka s->external_pause_update = true; 30330e8f22bSJan Kiszka gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->pause_item), 30430e8f22bSJan Kiszka is_paused); 30530e8f22bSJan Kiszka s->external_pause_update = false; 306a4ccabcfSAnthony Liguori 3074eeaa3a8SGerd Hoffmann title = g_strdup_printf("%s%s%s", prefix, status, grab); 3084eeaa3a8SGerd Hoffmann gtk_window_set_title(GTK_WINDOW(s->window), title); 3094eeaa3a8SGerd Hoffmann g_free(title); 3104eeaa3a8SGerd Hoffmann 3114eeaa3a8SGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 3124eeaa3a8SGerd Hoffmann VirtualConsole *vc = &s->vc[i]; 3134eeaa3a8SGerd Hoffmann 3144eeaa3a8SGerd Hoffmann if (!vc->window) { 3154eeaa3a8SGerd Hoffmann continue; 3164eeaa3a8SGerd Hoffmann } 3174eeaa3a8SGerd Hoffmann title = g_strdup_printf("%s: %s%s%s", prefix, vc->label, 3184eeaa3a8SGerd Hoffmann vc == s->kbd_owner ? " +kbd" : "", 3194eeaa3a8SGerd Hoffmann vc == s->ptr_owner ? " +ptr" : ""); 3204eeaa3a8SGerd Hoffmann gtk_window_set_title(GTK_WINDOW(vc->window), title); 3214eeaa3a8SGerd Hoffmann g_free(title); 322a4ccabcfSAnthony Liguori } 323a4ccabcfSAnthony Liguori 3244eeaa3a8SGerd Hoffmann g_free(prefix); 325a4ccabcfSAnthony Liguori } 326a4ccabcfSAnthony Liguori 327e3500d1fSGerd Hoffmann static void gd_update_windowsize(VirtualConsole *vc) 328a4ccabcfSAnthony Liguori { 329e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 330c6158483SAnthony Liguori double sx, sy; 331c6158483SAnthony Liguori 332d3ef5750SGerd Hoffmann if (vc->type != GD_VC_GFX || s->full_screen) { 333d3ef5750SGerd Hoffmann return; 334d3ef5750SGerd Hoffmann } 335c6158483SAnthony Liguori 336d3ef5750SGerd Hoffmann if (s->free_scale) { 337c6158483SAnthony Liguori sx = 1.0; 338c6158483SAnthony Liguori sy = 1.0; 339d3ef5750SGerd Hoffmann } else { 340d3ef5750SGerd Hoffmann sx = vc->gfx.scale_x; 341d3ef5750SGerd Hoffmann sy = vc->gfx.scale_y; 342c6158483SAnthony Liguori } 343d3ef5750SGerd Hoffmann gtk_widget_set_size_request(vc->gfx.drawing_area, 344d3ef5750SGerd Hoffmann surface_width(vc->gfx.ds) * sx, 345d3ef5750SGerd Hoffmann surface_height(vc->gfx.ds) * sy); 346aa0a55d4SGerd Hoffmann if (vc->window) { 347aa0a55d4SGerd Hoffmann gtk_window_resize(GTK_WINDOW(vc->window), 320, 240); 348aa0a55d4SGerd Hoffmann } else { 349d3ef5750SGerd Hoffmann gtk_window_resize(GTK_WINDOW(s->window), 320, 240); 350a4ccabcfSAnthony Liguori } 351aa0a55d4SGerd Hoffmann } 352a4ccabcfSAnthony Liguori 353e3500d1fSGerd Hoffmann static void gd_update_full_redraw(VirtualConsole *vc) 3549d9801cfSGerd Hoffmann { 355e3500d1fSGerd Hoffmann GtkWidget *area = vc->gfx.drawing_area; 3569d9801cfSGerd Hoffmann int ww, wh; 357e3500d1fSGerd Hoffmann gdk_drawable_get_size(gtk_widget_get_window(area), &ww, &wh); 358e3500d1fSGerd Hoffmann gtk_widget_queue_draw_area(area, 0, 0, ww, wh); 3599d9801cfSGerd Hoffmann } 3609d9801cfSGerd Hoffmann 3616db253caSJan Kiszka static void gtk_release_modifiers(GtkDisplayState *s) 3626db253caSJan Kiszka { 363e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 3646db253caSJan Kiszka int i, keycode; 3656db253caSJan Kiszka 366e3500d1fSGerd Hoffmann if (vc->type != GD_VC_GFX) { 3676db253caSJan Kiszka return; 3686db253caSJan Kiszka } 3696db253caSJan Kiszka for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) { 3706db253caSJan Kiszka keycode = modifier_keycode[i]; 3716db253caSJan Kiszka if (!s->modifier_pressed[i]) { 3726db253caSJan Kiszka continue; 3736db253caSJan Kiszka } 374e3500d1fSGerd Hoffmann qemu_input_event_send_key_number(vc->gfx.dcl.con, keycode, false); 3756db253caSJan Kiszka s->modifier_pressed[i] = false; 3766db253caSJan Kiszka } 3776db253caSJan Kiszka } 3786db253caSJan Kiszka 3799d9801cfSGerd Hoffmann /** DisplayState Callbacks **/ 3809d9801cfSGerd Hoffmann 3819d9801cfSGerd Hoffmann static void gd_update(DisplayChangeListener *dcl, 382bc2ed970SGerd Hoffmann int x, int y, int w, int h) 3839d9801cfSGerd Hoffmann { 384e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 3859d9801cfSGerd Hoffmann int x1, x2, y1, y2; 3869d9801cfSGerd Hoffmann int mx, my; 3879d9801cfSGerd Hoffmann int fbw, fbh; 3889d9801cfSGerd Hoffmann int ww, wh; 3899d9801cfSGerd Hoffmann 39074444bc1SGerd Hoffmann trace_gd_update(vc->label, x, y, w, h); 3919d9801cfSGerd Hoffmann 392e3500d1fSGerd Hoffmann if (vc->gfx.convert) { 393e3500d1fSGerd Hoffmann pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image, 394e3500d1fSGerd Hoffmann NULL, vc->gfx.convert, 395f0875536SGerd Hoffmann x, y, 0, 0, x, y, w, h); 396f0875536SGerd Hoffmann } 397f0875536SGerd Hoffmann 398e3500d1fSGerd Hoffmann x1 = floor(x * vc->gfx.scale_x); 399e3500d1fSGerd Hoffmann y1 = floor(y * vc->gfx.scale_y); 4009d9801cfSGerd Hoffmann 401e3500d1fSGerd Hoffmann x2 = ceil(x * vc->gfx.scale_x + w * vc->gfx.scale_x); 402e3500d1fSGerd Hoffmann y2 = ceil(y * vc->gfx.scale_y + h * vc->gfx.scale_y); 4039d9801cfSGerd Hoffmann 404e3500d1fSGerd Hoffmann fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 405e3500d1fSGerd Hoffmann fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 4069d9801cfSGerd Hoffmann 407e3500d1fSGerd Hoffmann gdk_drawable_get_size(gtk_widget_get_window(vc->gfx.drawing_area), 408e3500d1fSGerd Hoffmann &ww, &wh); 4099d9801cfSGerd Hoffmann 4109d9801cfSGerd Hoffmann mx = my = 0; 4119d9801cfSGerd Hoffmann if (ww > fbw) { 4129d9801cfSGerd Hoffmann mx = (ww - fbw) / 2; 4139d9801cfSGerd Hoffmann } 4149d9801cfSGerd Hoffmann if (wh > fbh) { 4159d9801cfSGerd Hoffmann my = (wh - fbh) / 2; 4169d9801cfSGerd Hoffmann } 4179d9801cfSGerd Hoffmann 418e3500d1fSGerd Hoffmann gtk_widget_queue_draw_area(vc->gfx.drawing_area, 419e3500d1fSGerd Hoffmann mx + x1, my + y1, (x2 - x1), (y2 - y1)); 4209d9801cfSGerd Hoffmann } 4219d9801cfSGerd Hoffmann 422bc2ed970SGerd Hoffmann static void gd_refresh(DisplayChangeListener *dcl) 4239d9801cfSGerd Hoffmann { 424284d1c6bSGerd Hoffmann graphic_hw_update(dcl->con); 4259d9801cfSGerd Hoffmann } 4269d9801cfSGerd Hoffmann 427b087143bSIgor Mitsyanko #if GTK_CHECK_VERSION(3, 0, 0) 428b087143bSIgor Mitsyanko static void gd_mouse_set(DisplayChangeListener *dcl, 429b087143bSIgor Mitsyanko int x, int y, int visible) 430b087143bSIgor Mitsyanko { 431e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 432b087143bSIgor Mitsyanko GdkDisplay *dpy; 433b087143bSIgor Mitsyanko GdkDeviceManager *mgr; 434b087143bSIgor Mitsyanko gint x_root, y_root; 435b087143bSIgor Mitsyanko 4362bda6602SCole Robinson if (qemu_input_is_absolute()) { 4372bda6602SCole Robinson return; 4382bda6602SCole Robinson } 4392bda6602SCole Robinson 440e3500d1fSGerd Hoffmann dpy = gtk_widget_get_display(vc->gfx.drawing_area); 441b087143bSIgor Mitsyanko mgr = gdk_display_get_device_manager(dpy); 442e3500d1fSGerd Hoffmann gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area), 443b087143bSIgor Mitsyanko x, y, &x_root, &y_root); 444b087143bSIgor Mitsyanko gdk_device_warp(gdk_device_manager_get_client_pointer(mgr), 445e3500d1fSGerd Hoffmann gtk_widget_get_screen(vc->gfx.drawing_area), 446298526feSCole Robinson x_root, y_root); 447b087143bSIgor Mitsyanko } 448b087143bSIgor Mitsyanko #else 4499697f5d2SGerd Hoffmann static void gd_mouse_set(DisplayChangeListener *dcl, 4509697f5d2SGerd Hoffmann int x, int y, int visible) 4519697f5d2SGerd Hoffmann { 452e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 4539697f5d2SGerd Hoffmann gint x_root, y_root; 4549697f5d2SGerd Hoffmann 4552bda6602SCole Robinson if (qemu_input_is_absolute()) { 4562bda6602SCole Robinson return; 4572bda6602SCole Robinson } 4582bda6602SCole Robinson 459e3500d1fSGerd Hoffmann gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area), 4609697f5d2SGerd Hoffmann x, y, &x_root, &y_root); 461e3500d1fSGerd Hoffmann gdk_display_warp_pointer(gtk_widget_get_display(vc->gfx.drawing_area), 462e3500d1fSGerd Hoffmann gtk_widget_get_screen(vc->gfx.drawing_area), 4639697f5d2SGerd Hoffmann x_root, y_root); 4649697f5d2SGerd Hoffmann } 465b087143bSIgor Mitsyanko #endif 4669697f5d2SGerd Hoffmann 4679697f5d2SGerd Hoffmann static void gd_cursor_define(DisplayChangeListener *dcl, 4689697f5d2SGerd Hoffmann QEMUCursor *c) 4699697f5d2SGerd Hoffmann { 470e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 4719697f5d2SGerd Hoffmann GdkPixbuf *pixbuf; 4729697f5d2SGerd Hoffmann GdkCursor *cursor; 4739697f5d2SGerd Hoffmann 4749697f5d2SGerd Hoffmann pixbuf = gdk_pixbuf_new_from_data((guchar *)(c->data), 4759697f5d2SGerd Hoffmann GDK_COLORSPACE_RGB, true, 8, 4769697f5d2SGerd Hoffmann c->width, c->height, c->width * 4, 4779697f5d2SGerd Hoffmann NULL, NULL); 478e3500d1fSGerd Hoffmann cursor = gdk_cursor_new_from_pixbuf 479e3500d1fSGerd Hoffmann (gtk_widget_get_display(vc->gfx.drawing_area), 4809697f5d2SGerd Hoffmann pixbuf, c->hot_x, c->hot_y); 481e3500d1fSGerd Hoffmann gdk_window_set_cursor(gtk_widget_get_window(vc->gfx.drawing_area), cursor); 4829697f5d2SGerd Hoffmann g_object_unref(pixbuf); 483030b4b7dSStefan Weil #if !GTK_CHECK_VERSION(3, 0, 0) 48417139240SAnthony Liguori gdk_cursor_unref(cursor); 485030b4b7dSStefan Weil #else 486030b4b7dSStefan Weil g_object_unref(cursor); 487030b4b7dSStefan Weil #endif 4889697f5d2SGerd Hoffmann } 4899697f5d2SGerd Hoffmann 4909d9801cfSGerd Hoffmann static void gd_switch(DisplayChangeListener *dcl, 4919d9801cfSGerd Hoffmann DisplaySurface *surface) 4929d9801cfSGerd Hoffmann { 493e3500d1fSGerd Hoffmann VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 4949d9801cfSGerd Hoffmann bool resized = true; 4959d9801cfSGerd Hoffmann 49674444bc1SGerd Hoffmann trace_gd_switch(vc->label, surface_width(surface), surface_height(surface)); 4979d9801cfSGerd Hoffmann 498e3500d1fSGerd Hoffmann if (vc->gfx.surface) { 499e3500d1fSGerd Hoffmann cairo_surface_destroy(vc->gfx.surface); 5009d9801cfSGerd Hoffmann } 5019d9801cfSGerd Hoffmann 502e3500d1fSGerd Hoffmann if (vc->gfx.ds && 503e3500d1fSGerd Hoffmann surface_width(vc->gfx.ds) == surface_width(surface) && 504e3500d1fSGerd Hoffmann surface_height(vc->gfx.ds) == surface_height(surface)) { 5059d9801cfSGerd Hoffmann resized = false; 5069d9801cfSGerd Hoffmann } 507e3500d1fSGerd Hoffmann vc->gfx.ds = surface; 508f0875536SGerd Hoffmann 509e3500d1fSGerd Hoffmann if (vc->gfx.convert) { 510e3500d1fSGerd Hoffmann pixman_image_unref(vc->gfx.convert); 511e3500d1fSGerd Hoffmann vc->gfx.convert = NULL; 5129d9801cfSGerd Hoffmann } 5139d9801cfSGerd Hoffmann 514f0875536SGerd Hoffmann if (surface->format == PIXMAN_x8r8g8b8) { 515f0875536SGerd Hoffmann /* 516f0875536SGerd Hoffmann * PIXMAN_x8r8g8b8 == CAIRO_FORMAT_RGB24 517f0875536SGerd Hoffmann * 518f0875536SGerd Hoffmann * No need to convert, use surface directly. Should be the 519f0875536SGerd Hoffmann * common case as this is qemu_default_pixelformat(32) too. 520f0875536SGerd Hoffmann */ 521e3500d1fSGerd Hoffmann vc->gfx.surface = cairo_image_surface_create_for_data 522f0875536SGerd Hoffmann (surface_data(surface), 523f0875536SGerd Hoffmann CAIRO_FORMAT_RGB24, 5249d9801cfSGerd Hoffmann surface_width(surface), 5259d9801cfSGerd Hoffmann surface_height(surface), 5269d9801cfSGerd Hoffmann surface_stride(surface)); 527f0875536SGerd Hoffmann } else { 528f0875536SGerd Hoffmann /* Must convert surface, use pixman to do it. */ 529e3500d1fSGerd Hoffmann vc->gfx.convert = pixman_image_create_bits(PIXMAN_x8r8g8b8, 530f0875536SGerd Hoffmann surface_width(surface), 531f0875536SGerd Hoffmann surface_height(surface), 532f0875536SGerd Hoffmann NULL, 0); 533e3500d1fSGerd Hoffmann vc->gfx.surface = cairo_image_surface_create_for_data 534e3500d1fSGerd Hoffmann ((void *)pixman_image_get_data(vc->gfx.convert), 535f0875536SGerd Hoffmann CAIRO_FORMAT_RGB24, 536e3500d1fSGerd Hoffmann pixman_image_get_width(vc->gfx.convert), 537e3500d1fSGerd Hoffmann pixman_image_get_height(vc->gfx.convert), 538e3500d1fSGerd Hoffmann pixman_image_get_stride(vc->gfx.convert)); 539e3500d1fSGerd Hoffmann pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image, 540e3500d1fSGerd Hoffmann NULL, vc->gfx.convert, 541f0875536SGerd Hoffmann 0, 0, 0, 0, 0, 0, 542e3500d1fSGerd Hoffmann pixman_image_get_width(vc->gfx.convert), 543e3500d1fSGerd Hoffmann pixman_image_get_height(vc->gfx.convert)); 544f0875536SGerd Hoffmann } 5459d9801cfSGerd Hoffmann 5469d9801cfSGerd Hoffmann if (resized) { 547e3500d1fSGerd Hoffmann gd_update_windowsize(vc); 5489d9801cfSGerd Hoffmann } else { 549e3500d1fSGerd Hoffmann gd_update_full_redraw(vc); 5509d9801cfSGerd Hoffmann } 5519d9801cfSGerd Hoffmann } 5529d9801cfSGerd Hoffmann 553a4ccabcfSAnthony Liguori /** QEMU Events **/ 554a4ccabcfSAnthony Liguori 555a4ccabcfSAnthony Liguori static void gd_change_runstate(void *opaque, int running, RunState state) 556a4ccabcfSAnthony Liguori { 557a4ccabcfSAnthony Liguori GtkDisplayState *s = opaque; 558a4ccabcfSAnthony Liguori 559a4ccabcfSAnthony Liguori gd_update_caption(s); 560a4ccabcfSAnthony Liguori } 561a4ccabcfSAnthony Liguori 562a4ccabcfSAnthony Liguori static void gd_mouse_mode_change(Notifier *notify, void *data) 563a4ccabcfSAnthony Liguori { 564800b0e81STakashi Iwai GtkDisplayState *s; 56599623c90SGerd Hoffmann int i; 566800b0e81STakashi Iwai 567800b0e81STakashi Iwai s = container_of(notify, GtkDisplayState, mouse_mode_notifier); 568800b0e81STakashi Iwai /* release the grab at switching to absolute mode */ 569800b0e81STakashi Iwai if (qemu_input_is_absolute() && gd_is_grab_active(s)) { 570800b0e81STakashi Iwai gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 571a4ccabcfSAnthony Liguori FALSE); 572a4ccabcfSAnthony Liguori } 57399623c90SGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 57499623c90SGerd Hoffmann VirtualConsole *vc = &s->vc[i]; 57599623c90SGerd Hoffmann gd_update_cursor(vc); 57699623c90SGerd Hoffmann } 577800b0e81STakashi Iwai } 578a4ccabcfSAnthony Liguori 579a4ccabcfSAnthony Liguori /** GTK Events **/ 580a4ccabcfSAnthony Liguori 581a4ccabcfSAnthony Liguori static gboolean gd_window_close(GtkWidget *widget, GdkEvent *event, 582a4ccabcfSAnthony Liguori void *opaque) 583a4ccabcfSAnthony Liguori { 584a4ccabcfSAnthony Liguori GtkDisplayState *s = opaque; 585e3500d1fSGerd Hoffmann int i; 586a4ccabcfSAnthony Liguori 587a4ccabcfSAnthony Liguori if (!no_quit) { 588e3500d1fSGerd Hoffmann for (i = 0; i < s->nb_vcs; i++) { 589e3500d1fSGerd Hoffmann if (s->vc[i].type != GD_VC_GFX) { 590e3500d1fSGerd Hoffmann continue; 591e3500d1fSGerd Hoffmann } 592e3500d1fSGerd Hoffmann unregister_displaychangelistener(&s->vc[i].gfx.dcl); 593e3500d1fSGerd Hoffmann } 594a4ccabcfSAnthony Liguori qmp_quit(NULL); 595a4ccabcfSAnthony Liguori return FALSE; 596a4ccabcfSAnthony Liguori } 597a4ccabcfSAnthony Liguori 598a4ccabcfSAnthony Liguori return TRUE; 599a4ccabcfSAnthony Liguori } 600a4ccabcfSAnthony Liguori 601a4ccabcfSAnthony Liguori static gboolean gd_draw_event(GtkWidget *widget, cairo_t *cr, void *opaque) 602a4ccabcfSAnthony Liguori { 603e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 604e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 605c6158483SAnthony Liguori int mx, my; 606a4ccabcfSAnthony Liguori int ww, wh; 607a4ccabcfSAnthony Liguori int fbw, fbh; 608a4ccabcfSAnthony Liguori 609c6158483SAnthony Liguori if (!gtk_widget_get_realized(widget)) { 610c6158483SAnthony Liguori return FALSE; 611c6158483SAnthony Liguori } 612c6158483SAnthony Liguori 613e3500d1fSGerd Hoffmann fbw = surface_width(vc->gfx.ds); 614e3500d1fSGerd Hoffmann fbh = surface_height(vc->gfx.ds); 615a4ccabcfSAnthony Liguori 616a4ccabcfSAnthony Liguori gdk_drawable_get_size(gtk_widget_get_window(widget), &ww, &wh); 617a4ccabcfSAnthony Liguori 618c6158483SAnthony Liguori if (s->full_screen) { 619e3500d1fSGerd Hoffmann vc->gfx.scale_x = (double)ww / fbw; 620e3500d1fSGerd Hoffmann vc->gfx.scale_y = (double)wh / fbh; 621c6158483SAnthony Liguori } else if (s->free_scale) { 622c6158483SAnthony Liguori double sx, sy; 623c6158483SAnthony Liguori 624c6158483SAnthony Liguori sx = (double)ww / fbw; 625c6158483SAnthony Liguori sy = (double)wh / fbh; 626c6158483SAnthony Liguori 627e3500d1fSGerd Hoffmann vc->gfx.scale_x = vc->gfx.scale_y = MIN(sx, sy); 628a4ccabcfSAnthony Liguori } 629a4ccabcfSAnthony Liguori 630e3500d1fSGerd Hoffmann fbw *= vc->gfx.scale_x; 631e3500d1fSGerd Hoffmann fbh *= vc->gfx.scale_y; 6325104a1f6SAnthony Liguori 633c6158483SAnthony Liguori mx = my = 0; 634c6158483SAnthony Liguori if (ww > fbw) { 635c6158483SAnthony Liguori mx = (ww - fbw) / 2; 636c6158483SAnthony Liguori } 637c6158483SAnthony Liguori if (wh > fbh) { 638c6158483SAnthony Liguori my = (wh - fbh) / 2; 639c6158483SAnthony Liguori } 640c6158483SAnthony Liguori 641c6158483SAnthony Liguori cairo_rectangle(cr, 0, 0, ww, wh); 642c6158483SAnthony Liguori 643c6158483SAnthony Liguori /* Optionally cut out the inner area where the pixmap 644c6158483SAnthony Liguori will be drawn. This avoids 'flashing' since we're 645c6158483SAnthony Liguori not double-buffering. Note we're using the undocumented 646c6158483SAnthony Liguori behaviour of drawing the rectangle from right to left 647c6158483SAnthony Liguori to cut out the whole */ 648c6158483SAnthony Liguori cairo_rectangle(cr, mx + fbw, my, 649c6158483SAnthony Liguori -1 * fbw, fbh); 650c6158483SAnthony Liguori cairo_fill(cr); 651c6158483SAnthony Liguori 652e3500d1fSGerd Hoffmann cairo_scale(cr, vc->gfx.scale_x, vc->gfx.scale_y); 653e3500d1fSGerd Hoffmann cairo_set_source_surface(cr, vc->gfx.surface, 654e3500d1fSGerd Hoffmann mx / vc->gfx.scale_x, my / vc->gfx.scale_y); 655a4ccabcfSAnthony Liguori cairo_paint(cr); 656a4ccabcfSAnthony Liguori 657a4ccabcfSAnthony Liguori return TRUE; 658a4ccabcfSAnthony Liguori } 659a4ccabcfSAnthony Liguori 660fe43bca8SDaniel P. Berrange #if !GTK_CHECK_VERSION(3, 0, 0) 661a4ccabcfSAnthony Liguori static gboolean gd_expose_event(GtkWidget *widget, GdkEventExpose *expose, 662a4ccabcfSAnthony Liguori void *opaque) 663a4ccabcfSAnthony Liguori { 664a4ccabcfSAnthony Liguori cairo_t *cr; 665a4ccabcfSAnthony Liguori gboolean ret; 666a4ccabcfSAnthony Liguori 667a4ccabcfSAnthony Liguori cr = gdk_cairo_create(gtk_widget_get_window(widget)); 668a4ccabcfSAnthony Liguori cairo_rectangle(cr, 669a4ccabcfSAnthony Liguori expose->area.x, 670a4ccabcfSAnthony Liguori expose->area.y, 671a4ccabcfSAnthony Liguori expose->area.width, 672a4ccabcfSAnthony Liguori expose->area.height); 673a4ccabcfSAnthony Liguori cairo_clip(cr); 674a4ccabcfSAnthony Liguori 675a4ccabcfSAnthony Liguori ret = gd_draw_event(widget, cr, opaque); 676a4ccabcfSAnthony Liguori 677a4ccabcfSAnthony Liguori cairo_destroy(cr); 678a4ccabcfSAnthony Liguori 679a4ccabcfSAnthony Liguori return ret; 680a4ccabcfSAnthony Liguori } 681fe43bca8SDaniel P. Berrange #endif 682a4ccabcfSAnthony Liguori 683a4ccabcfSAnthony Liguori static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion, 684a4ccabcfSAnthony Liguori void *opaque) 685a4ccabcfSAnthony Liguori { 686e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 687e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 688a4ccabcfSAnthony Liguori int x, y; 689c6158483SAnthony Liguori int mx, my; 690c6158483SAnthony Liguori int fbh, fbw; 691c6158483SAnthony Liguori int ww, wh; 692a4ccabcfSAnthony Liguori 693e3500d1fSGerd Hoffmann fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 694e3500d1fSGerd Hoffmann fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 695c6158483SAnthony Liguori 696e3500d1fSGerd Hoffmann gdk_drawable_get_size(gtk_widget_get_window(vc->gfx.drawing_area), 697e3500d1fSGerd Hoffmann &ww, &wh); 698c6158483SAnthony Liguori 699c6158483SAnthony Liguori mx = my = 0; 700c6158483SAnthony Liguori if (ww > fbw) { 701c6158483SAnthony Liguori mx = (ww - fbw) / 2; 702c6158483SAnthony Liguori } 703c6158483SAnthony Liguori if (wh > fbh) { 704c6158483SAnthony Liguori my = (wh - fbh) / 2; 705c6158483SAnthony Liguori } 706c6158483SAnthony Liguori 707e3500d1fSGerd Hoffmann x = (motion->x - mx) / vc->gfx.scale_x; 708e3500d1fSGerd Hoffmann y = (motion->y - my) / vc->gfx.scale_y; 709c6158483SAnthony Liguori 710e61031cdSTakashi Iwai if (qemu_input_is_absolute()) { 711c6158483SAnthony Liguori if (x < 0 || y < 0 || 712e3500d1fSGerd Hoffmann x >= surface_width(vc->gfx.ds) || 713e3500d1fSGerd Hoffmann y >= surface_height(vc->gfx.ds)) { 714c6158483SAnthony Liguori return TRUE; 715c6158483SAnthony Liguori } 716e3500d1fSGerd Hoffmann qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_X, x, 717e3500d1fSGerd Hoffmann surface_width(vc->gfx.ds)); 718e3500d1fSGerd Hoffmann qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_Y, y, 719e3500d1fSGerd Hoffmann surface_height(vc->gfx.ds)); 720192f81bfSGerd Hoffmann qemu_input_event_sync(); 7212884cf5bSGerd Hoffmann } else if (s->last_set && s->ptr_owner == vc) { 722e3500d1fSGerd Hoffmann qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_X, x - s->last_x); 723e3500d1fSGerd Hoffmann qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_Y, y - s->last_y); 724192f81bfSGerd Hoffmann qemu_input_event_sync(); 725a4ccabcfSAnthony Liguori } 726a4ccabcfSAnthony Liguori s->last_x = x; 727a4ccabcfSAnthony Liguori s->last_y = y; 728e61031cdSTakashi Iwai s->last_set = TRUE; 729a4ccabcfSAnthony Liguori 7302884cf5bSGerd Hoffmann if (!qemu_input_is_absolute() && s->ptr_owner == vc) { 731e3500d1fSGerd Hoffmann GdkScreen *screen = gtk_widget_get_screen(vc->gfx.drawing_area); 7325104a1f6SAnthony Liguori int x = (int)motion->x_root; 7335104a1f6SAnthony Liguori int y = (int)motion->y_root; 7345104a1f6SAnthony Liguori 7355104a1f6SAnthony Liguori /* In relative mode check to see if client pointer hit 7365104a1f6SAnthony Liguori * one of the screen edges, and if so move it back by 7375104a1f6SAnthony Liguori * 200 pixels. This is important because the pointer 7385104a1f6SAnthony Liguori * in the server doesn't correspond 1-for-1, and so 7395104a1f6SAnthony Liguori * may still be only half way across the screen. Without 7405104a1f6SAnthony Liguori * this warp, the server pointer would thus appear to hit 7415104a1f6SAnthony Liguori * an invisible wall */ 7425104a1f6SAnthony Liguori if (x == 0) { 7435104a1f6SAnthony Liguori x += 200; 7445104a1f6SAnthony Liguori } 7455104a1f6SAnthony Liguori if (y == 0) { 7465104a1f6SAnthony Liguori y += 200; 7475104a1f6SAnthony Liguori } 7485104a1f6SAnthony Liguori if (x == (gdk_screen_get_width(screen) - 1)) { 7495104a1f6SAnthony Liguori x -= 200; 7505104a1f6SAnthony Liguori } 7515104a1f6SAnthony Liguori if (y == (gdk_screen_get_height(screen) - 1)) { 7525104a1f6SAnthony Liguori y -= 200; 7535104a1f6SAnthony Liguori } 7545104a1f6SAnthony Liguori 7555104a1f6SAnthony Liguori if (x != (int)motion->x_root || y != (int)motion->y_root) { 7568906de76SDaniel P. Berrange #if GTK_CHECK_VERSION(3, 0, 0) 7578906de76SDaniel P. Berrange GdkDevice *dev = gdk_event_get_device((GdkEvent *)motion); 7588906de76SDaniel P. Berrange gdk_device_warp(dev, screen, x, y); 7598906de76SDaniel P. Berrange #else 7608906de76SDaniel P. Berrange GdkDisplay *display = gtk_widget_get_display(widget); 7615104a1f6SAnthony Liguori gdk_display_warp_pointer(display, screen, x, y); 7628906de76SDaniel P. Berrange #endif 763e61031cdSTakashi Iwai s->last_set = FALSE; 7645104a1f6SAnthony Liguori return FALSE; 7655104a1f6SAnthony Liguori } 7665104a1f6SAnthony Liguori } 767a4ccabcfSAnthony Liguori return TRUE; 768a4ccabcfSAnthony Liguori } 769a4ccabcfSAnthony Liguori 770a4ccabcfSAnthony Liguori static gboolean gd_button_event(GtkWidget *widget, GdkEventButton *button, 771a4ccabcfSAnthony Liguori void *opaque) 772a4ccabcfSAnthony Liguori { 773e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 774e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 775192f81bfSGerd Hoffmann InputButton btn; 776a4ccabcfSAnthony Liguori 777800b0e81STakashi Iwai /* implicitly grab the input at the first click in the relative mode */ 778800b0e81STakashi Iwai if (button->button == 1 && button->type == GDK_BUTTON_PRESS && 7792884cf5bSGerd Hoffmann !qemu_input_is_absolute() && s->ptr_owner != vc) { 7802884cf5bSGerd Hoffmann gd_ungrab_pointer(s); 7812884cf5bSGerd Hoffmann if (!vc->window) { 782800b0e81STakashi Iwai gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 783800b0e81STakashi Iwai TRUE); 7842884cf5bSGerd Hoffmann } else { 7852884cf5bSGerd Hoffmann gd_grab_pointer(vc); 7862884cf5bSGerd Hoffmann gd_update_caption(s); 7872884cf5bSGerd Hoffmann } 788800b0e81STakashi Iwai return TRUE; 789800b0e81STakashi Iwai } 790800b0e81STakashi Iwai 791a4ccabcfSAnthony Liguori if (button->button == 1) { 792192f81bfSGerd Hoffmann btn = INPUT_BUTTON_LEFT; 793a4ccabcfSAnthony Liguori } else if (button->button == 2) { 794192f81bfSGerd Hoffmann btn = INPUT_BUTTON_MIDDLE; 795a4ccabcfSAnthony Liguori } else if (button->button == 3) { 796192f81bfSGerd Hoffmann btn = INPUT_BUTTON_RIGHT; 797a4ccabcfSAnthony Liguori } else { 798192f81bfSGerd Hoffmann return TRUE; 799a4ccabcfSAnthony Liguori } 800a4ccabcfSAnthony Liguori 801e3500d1fSGerd Hoffmann qemu_input_queue_btn(vc->gfx.dcl.con, btn, 802e3500d1fSGerd Hoffmann button->type == GDK_BUTTON_PRESS); 803192f81bfSGerd Hoffmann qemu_input_event_sync(); 804a4ccabcfSAnthony Liguori return TRUE; 805a4ccabcfSAnthony Liguori } 806a4ccabcfSAnthony Liguori 807d58b9122SJan Kiszka static gboolean gd_scroll_event(GtkWidget *widget, GdkEventScroll *scroll, 808d58b9122SJan Kiszka void *opaque) 809d58b9122SJan Kiszka { 810e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 811d58b9122SJan Kiszka InputButton btn; 812d58b9122SJan Kiszka 813d58b9122SJan Kiszka if (scroll->direction == GDK_SCROLL_UP) { 814d58b9122SJan Kiszka btn = INPUT_BUTTON_WHEEL_UP; 815d58b9122SJan Kiszka } else if (scroll->direction == GDK_SCROLL_DOWN) { 816d58b9122SJan Kiszka btn = INPUT_BUTTON_WHEEL_DOWN; 817d58b9122SJan Kiszka } else { 818d58b9122SJan Kiszka return TRUE; 819d58b9122SJan Kiszka } 820d58b9122SJan Kiszka 821e3500d1fSGerd Hoffmann qemu_input_queue_btn(vc->gfx.dcl.con, btn, true); 822d58b9122SJan Kiszka qemu_input_event_sync(); 823e3500d1fSGerd Hoffmann qemu_input_queue_btn(vc->gfx.dcl.con, btn, false); 824d58b9122SJan Kiszka qemu_input_event_sync(); 825d58b9122SJan Kiszka return TRUE; 826d58b9122SJan Kiszka } 827d58b9122SJan Kiszka 828a4ccabcfSAnthony Liguori static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque) 829a4ccabcfSAnthony Liguori { 830e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 831e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 8322777ccc5SStefan Weil int gdk_keycode = key->hardware_keycode; 8336db253caSJan Kiszka int i; 834a4ccabcfSAnthony Liguori 8352777ccc5SStefan Weil #ifdef _WIN32 8362777ccc5SStefan Weil UINT qemu_keycode = MapVirtualKey(gdk_keycode, MAPVK_VK_TO_VSC); 8372777ccc5SStefan Weil switch (qemu_keycode) { 8382777ccc5SStefan Weil case 103: /* alt gr */ 8392777ccc5SStefan Weil qemu_keycode = 56 | SCANCODE_GREY; 8402777ccc5SStefan Weil break; 8412777ccc5SStefan Weil } 8422777ccc5SStefan Weil #else 8432777ccc5SStefan Weil int qemu_keycode; 844a4ccabcfSAnthony Liguori 845a4ccabcfSAnthony Liguori if (gdk_keycode < 9) { 846a4ccabcfSAnthony Liguori qemu_keycode = 0; 847a4ccabcfSAnthony Liguori } else if (gdk_keycode < 97) { 848a4ccabcfSAnthony Liguori qemu_keycode = gdk_keycode - 8; 849a4ccabcfSAnthony Liguori } else if (gdk_keycode < 158) { 850*3158a348SBruce Rogers if (s->has_evdev) { 851a4ccabcfSAnthony Liguori qemu_keycode = translate_evdev_keycode(gdk_keycode - 97); 852*3158a348SBruce Rogers } else { 853*3158a348SBruce Rogers qemu_keycode = translate_xfree86_keycode(gdk_keycode - 97); 854*3158a348SBruce Rogers } 855a4ccabcfSAnthony Liguori } else if (gdk_keycode == 208) { /* Hiragana_Katakana */ 856a4ccabcfSAnthony Liguori qemu_keycode = 0x70; 857a4ccabcfSAnthony Liguori } else if (gdk_keycode == 211) { /* backslash */ 858a4ccabcfSAnthony Liguori qemu_keycode = 0x73; 859a4ccabcfSAnthony Liguori } else { 860a4ccabcfSAnthony Liguori qemu_keycode = 0; 861a4ccabcfSAnthony Liguori } 8622777ccc5SStefan Weil #endif 863a4ccabcfSAnthony Liguori 86474444bc1SGerd Hoffmann trace_gd_key_event(vc->label, gdk_keycode, qemu_keycode, 865a4ccabcfSAnthony Liguori (key->type == GDK_KEY_PRESS) ? "down" : "up"); 866a4ccabcfSAnthony Liguori 8676db253caSJan Kiszka for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) { 8686db253caSJan Kiszka if (qemu_keycode == modifier_keycode[i]) { 8696db253caSJan Kiszka s->modifier_pressed[i] = (key->type == GDK_KEY_PRESS); 8706db253caSJan Kiszka } 8716db253caSJan Kiszka } 8726db253caSJan Kiszka 873e3500d1fSGerd Hoffmann qemu_input_event_send_key_number(vc->gfx.dcl.con, qemu_keycode, 874af98ba92SGerd Hoffmann key->type == GDK_KEY_PRESS); 875a4ccabcfSAnthony Liguori 876a4ccabcfSAnthony Liguori return TRUE; 877a4ccabcfSAnthony Liguori } 878a4ccabcfSAnthony Liguori 8790d0e044dSTakashi Iwai static gboolean gd_event(GtkWidget *widget, GdkEvent *event, void *opaque) 8800d0e044dSTakashi Iwai { 8810d0e044dSTakashi Iwai if (event->type == GDK_MOTION_NOTIFY) { 8820d0e044dSTakashi Iwai return gd_motion_event(widget, &event->motion, opaque); 8830d0e044dSTakashi Iwai } 8840d0e044dSTakashi Iwai return FALSE; 8850d0e044dSTakashi Iwai } 8860d0e044dSTakashi Iwai 887a4ccabcfSAnthony Liguori /** Window Menu Actions **/ 888a4ccabcfSAnthony Liguori 88930e8f22bSJan Kiszka static void gd_menu_pause(GtkMenuItem *item, void *opaque) 89030e8f22bSJan Kiszka { 89130e8f22bSJan Kiszka GtkDisplayState *s = opaque; 89230e8f22bSJan Kiszka 89330e8f22bSJan Kiszka if (s->external_pause_update) { 89430e8f22bSJan Kiszka return; 89530e8f22bSJan Kiszka } 89630e8f22bSJan Kiszka if (runstate_is_running()) { 89730e8f22bSJan Kiszka qmp_stop(NULL); 89830e8f22bSJan Kiszka } else { 89930e8f22bSJan Kiszka qmp_cont(NULL); 90030e8f22bSJan Kiszka } 90130e8f22bSJan Kiszka } 90230e8f22bSJan Kiszka 90330e8f22bSJan Kiszka static void gd_menu_reset(GtkMenuItem *item, void *opaque) 90430e8f22bSJan Kiszka { 90530e8f22bSJan Kiszka qmp_system_reset(NULL); 90630e8f22bSJan Kiszka } 90730e8f22bSJan Kiszka 90830e8f22bSJan Kiszka static void gd_menu_powerdown(GtkMenuItem *item, void *opaque) 90930e8f22bSJan Kiszka { 91030e8f22bSJan Kiszka qmp_system_powerdown(NULL); 91130e8f22bSJan Kiszka } 91230e8f22bSJan Kiszka 913a4ccabcfSAnthony Liguori static void gd_menu_quit(GtkMenuItem *item, void *opaque) 914a4ccabcfSAnthony Liguori { 915a4ccabcfSAnthony Liguori qmp_quit(NULL); 916a4ccabcfSAnthony Liguori } 917a4ccabcfSAnthony Liguori 918a4ccabcfSAnthony Liguori static void gd_menu_switch_vc(GtkMenuItem *item, void *opaque) 919a4ccabcfSAnthony Liguori { 920a4ccabcfSAnthony Liguori GtkDisplayState *s = opaque; 921e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_by_menu(s); 922832189c9SGerd Hoffmann gint page; 923a4ccabcfSAnthony Liguori 9246db253caSJan Kiszka gtk_release_modifiers(s); 925271a25c0SGerd Hoffmann if (vc) { 926832189c9SGerd Hoffmann page = gtk_notebook_page_num(GTK_NOTEBOOK(s->notebook), 927271a25c0SGerd Hoffmann vc->tab_item); 928832189c9SGerd Hoffmann gtk_notebook_set_current_page(GTK_NOTEBOOK(s->notebook), page); 929d861def3SAnthony Liguori } 930d861def3SAnthony Liguori } 931a4ccabcfSAnthony Liguori 932a4ccabcfSAnthony Liguori static void gd_menu_show_tabs(GtkMenuItem *item, void *opaque) 933a4ccabcfSAnthony Liguori { 934a4ccabcfSAnthony Liguori GtkDisplayState *s = opaque; 935a4ccabcfSAnthony Liguori 936a4ccabcfSAnthony Liguori if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->show_tabs_item))) { 937a4ccabcfSAnthony Liguori gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), TRUE); 938a4ccabcfSAnthony Liguori } else { 939a4ccabcfSAnthony Liguori gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 940a4ccabcfSAnthony Liguori } 941a4ccabcfSAnthony Liguori } 942a4ccabcfSAnthony Liguori 943cdeb7090SGerd Hoffmann static gboolean gd_tab_window_close(GtkWidget *widget, GdkEvent *event, 944cdeb7090SGerd Hoffmann void *opaque) 945cdeb7090SGerd Hoffmann { 946cdeb7090SGerd Hoffmann VirtualConsole *vc = opaque; 947cdeb7090SGerd Hoffmann GtkDisplayState *s = vc->s; 948cdeb7090SGerd Hoffmann 949cdeb7090SGerd Hoffmann gtk_widget_set_sensitive(vc->menu_item, true); 950cdeb7090SGerd Hoffmann gtk_widget_reparent(vc->tab_item, s->notebook); 951cdeb7090SGerd Hoffmann gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(s->notebook), 952cdeb7090SGerd Hoffmann vc->tab_item, vc->label); 953cdeb7090SGerd Hoffmann gtk_widget_destroy(vc->window); 954cdeb7090SGerd Hoffmann vc->window = NULL; 955cdeb7090SGerd Hoffmann return TRUE; 956cdeb7090SGerd Hoffmann } 957cdeb7090SGerd Hoffmann 9580c77a37fSGerd Hoffmann static gboolean gd_win_grab(void *opaque) 9590c77a37fSGerd Hoffmann { 9600c77a37fSGerd Hoffmann VirtualConsole *vc = opaque; 9610c77a37fSGerd Hoffmann 9620c77a37fSGerd Hoffmann fprintf(stderr, "%s: %s\n", __func__, vc->label); 9630c77a37fSGerd Hoffmann if (vc->s->ptr_owner) { 9640c77a37fSGerd Hoffmann gd_ungrab_pointer(vc->s); 9650c77a37fSGerd Hoffmann } else { 9660c77a37fSGerd Hoffmann gd_grab_pointer(vc); 9670c77a37fSGerd Hoffmann } 9680c77a37fSGerd Hoffmann gd_update_caption(vc->s); 9690c77a37fSGerd Hoffmann return TRUE; 9700c77a37fSGerd Hoffmann } 9710c77a37fSGerd Hoffmann 972cdeb7090SGerd Hoffmann static void gd_menu_untabify(GtkMenuItem *item, void *opaque) 973cdeb7090SGerd Hoffmann { 974cdeb7090SGerd Hoffmann GtkDisplayState *s = opaque; 975cdeb7090SGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 976cdeb7090SGerd Hoffmann 977cdeb7090SGerd Hoffmann if (vc->type == GD_VC_GFX) { 978aa0a55d4SGerd Hoffmann gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 979aa0a55d4SGerd Hoffmann FALSE); 980cdeb7090SGerd Hoffmann } 981cdeb7090SGerd Hoffmann if (!vc->window) { 982cdeb7090SGerd Hoffmann gtk_widget_set_sensitive(vc->menu_item, false); 983cdeb7090SGerd Hoffmann vc->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 984cdeb7090SGerd Hoffmann gtk_widget_reparent(vc->tab_item, vc->window); 985cdeb7090SGerd Hoffmann 986cdeb7090SGerd Hoffmann g_signal_connect(vc->window, "delete-event", 987cdeb7090SGerd Hoffmann G_CALLBACK(gd_tab_window_close), vc); 988cdeb7090SGerd Hoffmann gtk_widget_show_all(vc->window); 9894eeaa3a8SGerd Hoffmann 9900c77a37fSGerd Hoffmann GtkAccelGroup *ag = gtk_accel_group_new(); 9910c77a37fSGerd Hoffmann gtk_window_add_accel_group(GTK_WINDOW(vc->window), ag); 9920c77a37fSGerd Hoffmann 9930c77a37fSGerd Hoffmann GClosure *cb = g_cclosure_new_swap(G_CALLBACK(gd_win_grab), vc, NULL); 9940c77a37fSGerd Hoffmann gtk_accel_group_connect(ag, GDK_KEY_g, HOTKEY_MODIFIERS, 0, cb); 9950c77a37fSGerd Hoffmann 9960c77a37fSGerd Hoffmann fprintf(stderr, "%s: %p\n", __func__, vc); 9974eeaa3a8SGerd Hoffmann gd_update_caption(s); 998cdeb7090SGerd Hoffmann } 999cdeb7090SGerd Hoffmann } 1000cdeb7090SGerd Hoffmann 1001c6158483SAnthony Liguori static void gd_menu_full_screen(GtkMenuItem *item, void *opaque) 1002c6158483SAnthony Liguori { 1003c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1004e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1005c6158483SAnthony Liguori 100610409282SStefan Weil if (!s->full_screen) { 1007c6158483SAnthony Liguori gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 1008c6158483SAnthony Liguori gtk_widget_set_size_request(s->menu_bar, 0, 0); 1009e3500d1fSGerd Hoffmann if (vc->type == GD_VC_GFX) { 1010e3500d1fSGerd Hoffmann gtk_widget_set_size_request(vc->gfx.drawing_area, -1, -1); 1011e3500d1fSGerd Hoffmann gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1012e3500d1fSGerd Hoffmann TRUE); 1013c6158483SAnthony Liguori } 1014e3500d1fSGerd Hoffmann gtk_window_fullscreen(GTK_WINDOW(s->window)); 1015c6158483SAnthony Liguori s->full_screen = TRUE; 1016c6158483SAnthony Liguori } else { 1017c6158483SAnthony Liguori gtk_window_unfullscreen(GTK_WINDOW(s->window)); 1018c6158483SAnthony Liguori gd_menu_show_tabs(GTK_MENU_ITEM(s->show_tabs_item), s); 1019c6158483SAnthony Liguori gtk_widget_set_size_request(s->menu_bar, -1, -1); 1020c6158483SAnthony Liguori s->full_screen = FALSE; 1021e3500d1fSGerd Hoffmann if (vc->type == GD_VC_GFX) { 1022e3500d1fSGerd Hoffmann vc->gfx.scale_x = 1.0; 1023e3500d1fSGerd Hoffmann vc->gfx.scale_y = 1.0; 1024e3500d1fSGerd Hoffmann gtk_widget_set_size_request(vc->gfx.drawing_area, 1025e3500d1fSGerd Hoffmann surface_width(vc->gfx.ds), 1026e3500d1fSGerd Hoffmann surface_height(vc->gfx.ds)); 1027e3500d1fSGerd Hoffmann gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1028e3500d1fSGerd Hoffmann FALSE); 1029e3500d1fSGerd Hoffmann } 1030c6158483SAnthony Liguori } 1031c6158483SAnthony Liguori 1032e3500d1fSGerd Hoffmann gd_update_cursor(vc); 1033c6158483SAnthony Liguori } 1034c6158483SAnthony Liguori 1035c6158483SAnthony Liguori static void gd_menu_zoom_in(GtkMenuItem *item, void *opaque) 1036c6158483SAnthony Liguori { 1037c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1038e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1039c6158483SAnthony Liguori 1040c6158483SAnthony Liguori gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item), 1041c6158483SAnthony Liguori FALSE); 1042c6158483SAnthony Liguori 1043e3500d1fSGerd Hoffmann vc->gfx.scale_x += .25; 1044e3500d1fSGerd Hoffmann vc->gfx.scale_y += .25; 1045c6158483SAnthony Liguori 1046e3500d1fSGerd Hoffmann gd_update_windowsize(vc); 1047c6158483SAnthony Liguori } 1048c6158483SAnthony Liguori 1049c6158483SAnthony Liguori static void gd_menu_zoom_out(GtkMenuItem *item, void *opaque) 1050c6158483SAnthony Liguori { 1051c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1052e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1053c6158483SAnthony Liguori 1054c6158483SAnthony Liguori gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item), 1055c6158483SAnthony Liguori FALSE); 1056c6158483SAnthony Liguori 1057e3500d1fSGerd Hoffmann vc->gfx.scale_x -= .25; 1058e3500d1fSGerd Hoffmann vc->gfx.scale_y -= .25; 1059c6158483SAnthony Liguori 1060e3500d1fSGerd Hoffmann vc->gfx.scale_x = MAX(vc->gfx.scale_x, .25); 1061e3500d1fSGerd Hoffmann vc->gfx.scale_y = MAX(vc->gfx.scale_y, .25); 1062c6158483SAnthony Liguori 1063e3500d1fSGerd Hoffmann gd_update_windowsize(vc); 1064c6158483SAnthony Liguori } 1065c6158483SAnthony Liguori 1066c6158483SAnthony Liguori static void gd_menu_zoom_fixed(GtkMenuItem *item, void *opaque) 1067c6158483SAnthony Liguori { 1068c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1069e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1070c6158483SAnthony Liguori 1071e3500d1fSGerd Hoffmann vc->gfx.scale_x = 1.0; 1072e3500d1fSGerd Hoffmann vc->gfx.scale_y = 1.0; 1073c6158483SAnthony Liguori 1074e3500d1fSGerd Hoffmann gd_update_windowsize(vc); 1075c6158483SAnthony Liguori } 1076c6158483SAnthony Liguori 1077c6158483SAnthony Liguori static void gd_menu_zoom_fit(GtkMenuItem *item, void *opaque) 1078c6158483SAnthony Liguori { 1079c6158483SAnthony Liguori GtkDisplayState *s = opaque; 1080e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 1081c6158483SAnthony Liguori 1082c6158483SAnthony Liguori if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item))) { 1083c6158483SAnthony Liguori s->free_scale = TRUE; 1084c6158483SAnthony Liguori } else { 1085c6158483SAnthony Liguori s->free_scale = FALSE; 1086e3500d1fSGerd Hoffmann vc->gfx.scale_x = 1.0; 1087e3500d1fSGerd Hoffmann vc->gfx.scale_y = 1.0; 1088e3500d1fSGerd Hoffmann gd_update_windowsize(vc); 1089c6158483SAnthony Liguori } 1090c6158483SAnthony Liguori 1091e3500d1fSGerd Hoffmann gd_update_full_redraw(vc); 1092c6158483SAnthony Liguori } 1093c6158483SAnthony Liguori 1094e3500d1fSGerd Hoffmann static void gd_grab_keyboard(VirtualConsole *vc) 10955104a1f6SAnthony Liguori { 1096655199daSDaniel P. Berrange #if GTK_CHECK_VERSION(3, 0, 0) 1097e3500d1fSGerd Hoffmann GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1098655199daSDaniel P. Berrange GdkDeviceManager *mgr = gdk_display_get_device_manager(display); 1099655199daSDaniel P. Berrange GList *devices = gdk_device_manager_list_devices(mgr, 1100655199daSDaniel P. Berrange GDK_DEVICE_TYPE_MASTER); 1101655199daSDaniel P. Berrange GList *tmp = devices; 1102655199daSDaniel P. Berrange while (tmp) { 1103655199daSDaniel P. Berrange GdkDevice *dev = tmp->data; 1104655199daSDaniel P. Berrange if (gdk_device_get_source(dev) == GDK_SOURCE_KEYBOARD) { 1105655199daSDaniel P. Berrange gdk_device_grab(dev, 1106e3500d1fSGerd Hoffmann gtk_widget_get_window(vc->gfx.drawing_area), 1107655199daSDaniel P. Berrange GDK_OWNERSHIP_NONE, 1108655199daSDaniel P. Berrange FALSE, 1109655199daSDaniel P. Berrange GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, 1110655199daSDaniel P. Berrange NULL, 1111655199daSDaniel P. Berrange GDK_CURRENT_TIME); 1112655199daSDaniel P. Berrange } 1113655199daSDaniel P. Berrange tmp = tmp->next; 1114655199daSDaniel P. Berrange } 1115655199daSDaniel P. Berrange g_list_free(devices); 1116655199daSDaniel P. Berrange #else 1117e3500d1fSGerd Hoffmann gdk_keyboard_grab(gtk_widget_get_window(vc->gfx.drawing_area), 11185104a1f6SAnthony Liguori FALSE, 11195104a1f6SAnthony Liguori GDK_CURRENT_TIME); 1120655199daSDaniel P. Berrange #endif 11214c638e2eSGerd Hoffmann vc->s->kbd_owner = vc; 11221c856da5SGerd Hoffmann trace_gd_grab(vc->label, "kbd", true); 11235104a1f6SAnthony Liguori } 11245104a1f6SAnthony Liguori 11254c638e2eSGerd Hoffmann static void gd_ungrab_keyboard(GtkDisplayState *s) 11265104a1f6SAnthony Liguori { 11274c638e2eSGerd Hoffmann VirtualConsole *vc = s->kbd_owner; 11284c638e2eSGerd Hoffmann 11294c638e2eSGerd Hoffmann if (vc == NULL) { 11304c638e2eSGerd Hoffmann return; 11314c638e2eSGerd Hoffmann } 11324c638e2eSGerd Hoffmann s->kbd_owner = NULL; 11334c638e2eSGerd Hoffmann 1134655199daSDaniel P. Berrange #if GTK_CHECK_VERSION(3, 0, 0) 1135e3500d1fSGerd Hoffmann GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1136655199daSDaniel P. Berrange GdkDeviceManager *mgr = gdk_display_get_device_manager(display); 1137655199daSDaniel P. Berrange GList *devices = gdk_device_manager_list_devices(mgr, 1138655199daSDaniel P. Berrange GDK_DEVICE_TYPE_MASTER); 1139655199daSDaniel P. Berrange GList *tmp = devices; 1140655199daSDaniel P. Berrange while (tmp) { 1141655199daSDaniel P. Berrange GdkDevice *dev = tmp->data; 1142655199daSDaniel P. Berrange if (gdk_device_get_source(dev) == GDK_SOURCE_KEYBOARD) { 1143655199daSDaniel P. Berrange gdk_device_ungrab(dev, 1144655199daSDaniel P. Berrange GDK_CURRENT_TIME); 1145655199daSDaniel P. Berrange } 1146655199daSDaniel P. Berrange tmp = tmp->next; 1147655199daSDaniel P. Berrange } 1148655199daSDaniel P. Berrange g_list_free(devices); 1149655199daSDaniel P. Berrange #else 11505104a1f6SAnthony Liguori gdk_keyboard_ungrab(GDK_CURRENT_TIME); 1151655199daSDaniel P. Berrange #endif 11521c856da5SGerd Hoffmann trace_gd_grab(vc->label, "kbd", false); 11535104a1f6SAnthony Liguori } 11545104a1f6SAnthony Liguori 1155e3500d1fSGerd Hoffmann static void gd_grab_pointer(VirtualConsole *vc) 11565104a1f6SAnthony Liguori { 1157e3500d1fSGerd Hoffmann GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1158ecce1929STakashi Iwai #if GTK_CHECK_VERSION(3, 0, 0) 11592a05485dSDaniel P. Berrange GdkDeviceManager *mgr = gdk_display_get_device_manager(display); 11602a05485dSDaniel P. Berrange GList *devices = gdk_device_manager_list_devices(mgr, 11612a05485dSDaniel P. Berrange GDK_DEVICE_TYPE_MASTER); 11622a05485dSDaniel P. Berrange GList *tmp = devices; 11632a05485dSDaniel P. Berrange while (tmp) { 11642a05485dSDaniel P. Berrange GdkDevice *dev = tmp->data; 11652a05485dSDaniel P. Berrange if (gdk_device_get_source(dev) == GDK_SOURCE_MOUSE) { 11662a05485dSDaniel P. Berrange gdk_device_grab(dev, 1167e3500d1fSGerd Hoffmann gtk_widget_get_window(vc->gfx.drawing_area), 11682a05485dSDaniel P. Berrange GDK_OWNERSHIP_NONE, 11692a05485dSDaniel P. Berrange FALSE, /* All events to come to our 11702a05485dSDaniel P. Berrange window directly */ 11712a05485dSDaniel P. Berrange GDK_POINTER_MOTION_MASK | 11722a05485dSDaniel P. Berrange GDK_BUTTON_PRESS_MASK | 11732a05485dSDaniel P. Berrange GDK_BUTTON_RELEASE_MASK | 11742a05485dSDaniel P. Berrange GDK_BUTTON_MOTION_MASK | 11752a05485dSDaniel P. Berrange GDK_SCROLL_MASK, 1176e3500d1fSGerd Hoffmann vc->s->null_cursor, 11772a05485dSDaniel P. Berrange GDK_CURRENT_TIME); 11782a05485dSDaniel P. Berrange } 11792a05485dSDaniel P. Berrange tmp = tmp->next; 11802a05485dSDaniel P. Berrange } 11812a05485dSDaniel P. Berrange g_list_free(devices); 1182ecce1929STakashi Iwai gdk_device_get_position(gdk_device_manager_get_client_pointer(mgr), 1183e3500d1fSGerd Hoffmann NULL, &vc->s->grab_x_root, &vc->s->grab_y_root); 11842a05485dSDaniel P. Berrange #else 1185e3500d1fSGerd Hoffmann gdk_pointer_grab(gtk_widget_get_window(vc->gfx.drawing_area), 11865104a1f6SAnthony Liguori FALSE, /* All events to come to our window directly */ 11875104a1f6SAnthony Liguori GDK_POINTER_MOTION_MASK | 11885104a1f6SAnthony Liguori GDK_BUTTON_PRESS_MASK | 11895104a1f6SAnthony Liguori GDK_BUTTON_RELEASE_MASK | 11905104a1f6SAnthony Liguori GDK_BUTTON_MOTION_MASK | 11915104a1f6SAnthony Liguori GDK_SCROLL_MASK, 11925104a1f6SAnthony Liguori NULL, /* Allow cursor to move over entire desktop */ 1193e3500d1fSGerd Hoffmann vc->s->null_cursor, 11945104a1f6SAnthony Liguori GDK_CURRENT_TIME); 1195ecce1929STakashi Iwai gdk_display_get_pointer(display, NULL, 1196e3500d1fSGerd Hoffmann &vc->s->grab_x_root, &vc->s->grab_y_root, NULL); 11972a05485dSDaniel P. Berrange #endif 11984c638e2eSGerd Hoffmann vc->s->ptr_owner = vc; 11991c856da5SGerd Hoffmann trace_gd_grab(vc->label, "ptr", true); 12002a05485dSDaniel P. Berrange } 12012a05485dSDaniel P. Berrange 12024c638e2eSGerd Hoffmann static void gd_ungrab_pointer(GtkDisplayState *s) 12032a05485dSDaniel P. Berrange { 12044c638e2eSGerd Hoffmann VirtualConsole *vc = s->ptr_owner; 12054c638e2eSGerd Hoffmann 12064c638e2eSGerd Hoffmann if (vc == NULL) { 12074c638e2eSGerd Hoffmann return; 12084c638e2eSGerd Hoffmann } 12094c638e2eSGerd Hoffmann s->ptr_owner = NULL; 12104c638e2eSGerd Hoffmann 1211e3500d1fSGerd Hoffmann GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1212ecce1929STakashi Iwai #if GTK_CHECK_VERSION(3, 0, 0) 12132a05485dSDaniel P. Berrange GdkDeviceManager *mgr = gdk_display_get_device_manager(display); 12142a05485dSDaniel P. Berrange GList *devices = gdk_device_manager_list_devices(mgr, 12152a05485dSDaniel P. Berrange GDK_DEVICE_TYPE_MASTER); 12162a05485dSDaniel P. Berrange GList *tmp = devices; 12172a05485dSDaniel P. Berrange while (tmp) { 12182a05485dSDaniel P. Berrange GdkDevice *dev = tmp->data; 12192a05485dSDaniel P. Berrange if (gdk_device_get_source(dev) == GDK_SOURCE_MOUSE) { 12202a05485dSDaniel P. Berrange gdk_device_ungrab(dev, 12212a05485dSDaniel P. Berrange GDK_CURRENT_TIME); 12222a05485dSDaniel P. Berrange } 12232a05485dSDaniel P. Berrange tmp = tmp->next; 12242a05485dSDaniel P. Berrange } 12252a05485dSDaniel P. Berrange g_list_free(devices); 1226ecce1929STakashi Iwai gdk_device_warp(gdk_device_manager_get_client_pointer(mgr), 1227e3500d1fSGerd Hoffmann gtk_widget_get_screen(vc->gfx.drawing_area), 1228e3500d1fSGerd Hoffmann vc->s->grab_x_root, vc->s->grab_y_root); 12292a05485dSDaniel P. Berrange #else 12302a05485dSDaniel P. Berrange gdk_pointer_ungrab(GDK_CURRENT_TIME); 1231ecce1929STakashi Iwai gdk_display_warp_pointer(display, 1232e3500d1fSGerd Hoffmann gtk_widget_get_screen(vc->gfx.drawing_area), 1233e3500d1fSGerd Hoffmann vc->s->grab_x_root, vc->s->grab_y_root); 12342a05485dSDaniel P. Berrange #endif 12351c856da5SGerd Hoffmann trace_gd_grab(vc->label, "ptr", false); 12362a05485dSDaniel P. Berrange } 12372a05485dSDaniel P. Berrange 12382a05485dSDaniel P. Berrange static void gd_menu_grab_input(GtkMenuItem *item, void *opaque) 12392a05485dSDaniel P. Berrange { 12402a05485dSDaniel P. Berrange GtkDisplayState *s = opaque; 1241e3500d1fSGerd Hoffmann VirtualConsole *vc = gd_vc_find_current(s); 12422a05485dSDaniel P. Berrange 12432a05485dSDaniel P. Berrange if (gd_is_grab_active(s)) { 1244746b8670SGerd Hoffmann if (!gd_grab_on_hover(s)) { 1245e3500d1fSGerd Hoffmann gd_grab_keyboard(vc); 1246746b8670SGerd Hoffmann } 1247e3500d1fSGerd Hoffmann gd_grab_pointer(vc); 12485104a1f6SAnthony Liguori } else { 12494c638e2eSGerd Hoffmann gd_ungrab_keyboard(s); 12504c638e2eSGerd Hoffmann gd_ungrab_pointer(s); 12515104a1f6SAnthony Liguori } 12525104a1f6SAnthony Liguori 12535104a1f6SAnthony Liguori gd_update_caption(s); 1254e3500d1fSGerd Hoffmann gd_update_cursor(vc); 12555104a1f6SAnthony Liguori } 12565104a1f6SAnthony Liguori 1257a4ccabcfSAnthony Liguori static void gd_change_page(GtkNotebook *nb, gpointer arg1, guint arg2, 1258a4ccabcfSAnthony Liguori gpointer data) 1259a4ccabcfSAnthony Liguori { 1260a4ccabcfSAnthony Liguori GtkDisplayState *s = data; 1261e3500d1fSGerd Hoffmann VirtualConsole *vc; 12625104a1f6SAnthony Liguori gboolean on_vga; 1263a4ccabcfSAnthony Liguori 1264a4ccabcfSAnthony Liguori if (!gtk_widget_get_realized(s->notebook)) { 1265a4ccabcfSAnthony Liguori return; 1266a4ccabcfSAnthony Liguori } 1267a4ccabcfSAnthony Liguori 1268e3500d1fSGerd Hoffmann vc = gd_vc_find_by_page(s, arg2); 1269e3500d1fSGerd Hoffmann if (!vc) { 1270e3500d1fSGerd Hoffmann return; 1271e3500d1fSGerd Hoffmann } 1272e3500d1fSGerd Hoffmann gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), 1273e3500d1fSGerd Hoffmann TRUE); 1274e3500d1fSGerd Hoffmann on_vga = (vc->type == GD_VC_GFX); 12755104a1f6SAnthony Liguori if (!on_vga) { 12765104a1f6SAnthony Liguori gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 12775104a1f6SAnthony Liguori FALSE); 1278c6158483SAnthony Liguori } else if (s->full_screen) { 1279c6158483SAnthony Liguori gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1280c6158483SAnthony Liguori TRUE); 12815104a1f6SAnthony Liguori } 12825104a1f6SAnthony Liguori gtk_widget_set_sensitive(s->grab_item, on_vga); 12835104a1f6SAnthony Liguori 1284e3500d1fSGerd Hoffmann gd_update_cursor(vc); 1285a4ccabcfSAnthony Liguori } 1286a4ccabcfSAnthony Liguori 1287e3500d1fSGerd Hoffmann static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing, 1288e3500d1fSGerd Hoffmann gpointer opaque) 12895104a1f6SAnthony Liguori { 1290e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 1291e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 12925104a1f6SAnthony Liguori 12932884cf5bSGerd Hoffmann if (gd_grab_on_hover(s)) { 12942884cf5bSGerd Hoffmann gd_ungrab_keyboard(s); 1295e3500d1fSGerd Hoffmann gd_grab_keyboard(vc); 12962884cf5bSGerd Hoffmann gd_update_caption(s); 12975104a1f6SAnthony Liguori } 12985104a1f6SAnthony Liguori return TRUE; 12995104a1f6SAnthony Liguori } 13005104a1f6SAnthony Liguori 1301e3500d1fSGerd Hoffmann static gboolean gd_leave_event(GtkWidget *widget, GdkEventCrossing *crossing, 1302e3500d1fSGerd Hoffmann gpointer opaque) 13035104a1f6SAnthony Liguori { 1304e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 1305e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 13065104a1f6SAnthony Liguori 13072884cf5bSGerd Hoffmann if (gd_grab_on_hover(s)) { 13084c638e2eSGerd Hoffmann gd_ungrab_keyboard(s); 13092884cf5bSGerd Hoffmann gd_update_caption(s); 13105104a1f6SAnthony Liguori } 13115104a1f6SAnthony Liguori return TRUE; 13125104a1f6SAnthony Liguori } 13135104a1f6SAnthony Liguori 13146db253caSJan Kiszka static gboolean gd_focus_out_event(GtkWidget *widget, 1315e3500d1fSGerd Hoffmann GdkEventCrossing *crossing, gpointer opaque) 13166db253caSJan Kiszka { 1317e3500d1fSGerd Hoffmann VirtualConsole *vc = opaque; 1318e3500d1fSGerd Hoffmann GtkDisplayState *s = vc->s; 13196db253caSJan Kiszka 13206db253caSJan Kiszka gtk_release_modifiers(s); 13216db253caSJan Kiszka return TRUE; 13226db253caSJan Kiszka } 13236db253caSJan Kiszka 1324d861def3SAnthony Liguori /** Virtual Console Callbacks **/ 1325d861def3SAnthony Liguori 1326ed1132e4SGerd Hoffmann static GSList *gd_vc_menu_init(GtkDisplayState *s, VirtualConsole *vc, 1327cdeb7090SGerd Hoffmann int idx, GSList *group, GtkWidget *view_menu) 1328ed1132e4SGerd Hoffmann { 1329ed1132e4SGerd Hoffmann char path[32]; 1330ed1132e4SGerd Hoffmann 1331ed1132e4SGerd Hoffmann snprintf(path, sizeof(path), "<QEMU>/View/VC%d", idx); 1332ed1132e4SGerd Hoffmann 1333cdeb7090SGerd Hoffmann vc->menu_item = gtk_radio_menu_item_new_with_mnemonic(group, vc->label); 1334ed1132e4SGerd Hoffmann group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(vc->menu_item)); 1335ed1132e4SGerd Hoffmann gtk_menu_item_set_accel_path(GTK_MENU_ITEM(vc->menu_item), path); 1336ed1132e4SGerd Hoffmann gtk_accel_map_add_entry(path, GDK_KEY_1 + idx, HOTKEY_MODIFIERS); 1337ed1132e4SGerd Hoffmann 1338ed1132e4SGerd Hoffmann g_signal_connect(vc->menu_item, "activate", 1339ed1132e4SGerd Hoffmann G_CALLBACK(gd_menu_switch_vc), s); 1340ed1132e4SGerd Hoffmann gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), vc->menu_item); 1341ed1132e4SGerd Hoffmann 1342ed1132e4SGerd Hoffmann return group; 1343ed1132e4SGerd Hoffmann } 1344ed1132e4SGerd Hoffmann 1345ee5f31e4SGerd Hoffmann #if defined(CONFIG_VTE) 13460fb20d1cSCole Robinson static void gd_vc_adjustment_changed(GtkAdjustment *adjustment, void *opaque) 13470fb20d1cSCole Robinson { 13480fb20d1cSCole Robinson VirtualConsole *vc = opaque; 13490fb20d1cSCole Robinson 13500fb20d1cSCole Robinson if (gtk_adjustment_get_upper(adjustment) > 13510fb20d1cSCole Robinson gtk_adjustment_get_page_size(adjustment)) { 1352271a25c0SGerd Hoffmann gtk_widget_show(vc->vte.scrollbar); 13530fb20d1cSCole Robinson } else { 1354271a25c0SGerd Hoffmann gtk_widget_hide(vc->vte.scrollbar); 13550fb20d1cSCole Robinson } 13560fb20d1cSCole Robinson } 13570fb20d1cSCole Robinson 1358d861def3SAnthony Liguori static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len) 1359d861def3SAnthony Liguori { 1360d861def3SAnthony Liguori VirtualConsole *vc = chr->opaque; 1361d861def3SAnthony Liguori 1362271a25c0SGerd Hoffmann vte_terminal_feed(VTE_TERMINAL(vc->vte.terminal), (const char *)buf, len); 1363d4370741SCole Robinson return len; 1364d861def3SAnthony Liguori } 1365d861def3SAnthony Liguori 1366d861def3SAnthony Liguori static int nb_vcs; 1367d861def3SAnthony Liguori static CharDriverState *vcs[MAX_VCS]; 1368d861def3SAnthony Liguori 1369702ec69cSGerd Hoffmann static CharDriverState *gd_vc_handler(ChardevVC *unused) 1370d861def3SAnthony Liguori { 1371d861def3SAnthony Liguori CharDriverState *chr; 1372d861def3SAnthony Liguori 1373d861def3SAnthony Liguori chr = g_malloc0(sizeof(*chr)); 1374d861def3SAnthony Liguori chr->chr_write = gd_vc_chr_write; 1375bd5c51eeSMichael Roth /* defer OPENED events until our vc is fully initialized */ 1376bd5c51eeSMichael Roth chr->explicit_be_open = true; 1377d861def3SAnthony Liguori 1378d861def3SAnthony Liguori vcs[nb_vcs++] = chr; 1379d861def3SAnthony Liguori 1380d861def3SAnthony Liguori return chr; 1381d861def3SAnthony Liguori } 1382d861def3SAnthony Liguori 1383d4370741SCole Robinson static gboolean gd_vc_in(VteTerminal *terminal, gchar *text, guint size, 1384d4370741SCole Robinson gpointer user_data) 1385d861def3SAnthony Liguori { 1386d4370741SCole Robinson VirtualConsole *vc = user_data; 1387d861def3SAnthony Liguori 1388271a25c0SGerd Hoffmann qemu_chr_be_write(vc->vte.chr, (uint8_t *)text, (unsigned int)size); 1389d861def3SAnthony Liguori return TRUE; 1390d861def3SAnthony Liguori } 1391d861def3SAnthony Liguori 1392ed1132e4SGerd Hoffmann static GSList *gd_vc_vte_init(GtkDisplayState *s, VirtualConsole *vc, 1393ed1132e4SGerd Hoffmann CharDriverState *chr, int idx, 1394e3500d1fSGerd Hoffmann GSList *group, GtkWidget *view_menu) 1395d861def3SAnthony Liguori { 1396d861def3SAnthony Liguori char buffer[32]; 13970fb20d1cSCole Robinson GtkWidget *box; 13980fb20d1cSCole Robinson GtkWidget *scrollbar; 13990fb20d1cSCole Robinson GtkAdjustment *vadjustment; 1400d861def3SAnthony Liguori 1401e3500d1fSGerd Hoffmann vc->s = s; 1402ed1132e4SGerd Hoffmann vc->vte.chr = chr; 1403d861def3SAnthony Liguori 1404ed1132e4SGerd Hoffmann snprintf(buffer, sizeof(buffer), "vc%d", idx); 1405cdeb7090SGerd Hoffmann vc->label = g_strdup_printf("%s", vc->vte.chr->label 1406cdeb7090SGerd Hoffmann ? vc->vte.chr->label : buffer); 1407cdeb7090SGerd Hoffmann group = gd_vc_menu_init(s, vc, idx, group, view_menu); 1408d861def3SAnthony Liguori 1409271a25c0SGerd Hoffmann vc->vte.terminal = vte_terminal_new(); 1410271a25c0SGerd Hoffmann g_signal_connect(vc->vte.terminal, "commit", G_CALLBACK(gd_vc_in), vc); 1411d861def3SAnthony Liguori 1412271a25c0SGerd Hoffmann vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->vte.terminal), -1); 1413271a25c0SGerd Hoffmann vte_terminal_set_size(VTE_TERMINAL(vc->vte.terminal), 80, 25); 1414d861def3SAnthony Liguori 14150fb20d1cSCole Robinson #if VTE_CHECK_VERSION(0, 28, 0) && GTK_CHECK_VERSION(3, 0, 0) 1416271a25c0SGerd Hoffmann vadjustment = gtk_scrollable_get_vadjustment 1417271a25c0SGerd Hoffmann (GTK_SCROLLABLE(vc->vte.terminal)); 14180fb20d1cSCole Robinson #else 1419271a25c0SGerd Hoffmann vadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->vte.terminal)); 14200fb20d1cSCole Robinson #endif 1421d861def3SAnthony Liguori 14220fb20d1cSCole Robinson #if GTK_CHECK_VERSION(3, 0, 0) 14230fb20d1cSCole Robinson box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); 14240fb20d1cSCole Robinson scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, vadjustment); 14250fb20d1cSCole Robinson #else 14260fb20d1cSCole Robinson box = gtk_hbox_new(false, 2); 14270fb20d1cSCole Robinson scrollbar = gtk_vscrollbar_new(vadjustment); 14280fb20d1cSCole Robinson #endif 14290fb20d1cSCole Robinson 1430271a25c0SGerd Hoffmann gtk_box_pack_start(GTK_BOX(box), vc->vte.terminal, TRUE, TRUE, 0); 14310fb20d1cSCole Robinson gtk_box_pack_start(GTK_BOX(box), scrollbar, FALSE, FALSE, 0); 14320fb20d1cSCole Robinson 1433271a25c0SGerd Hoffmann vc->vte.chr->opaque = vc; 1434271a25c0SGerd Hoffmann vc->vte.box = box; 1435271a25c0SGerd Hoffmann vc->vte.scrollbar = scrollbar; 14360fb20d1cSCole Robinson 14370fb20d1cSCole Robinson g_signal_connect(vadjustment, "changed", 14380fb20d1cSCole Robinson G_CALLBACK(gd_vc_adjustment_changed), vc); 14390fb20d1cSCole Robinson 1440e3500d1fSGerd Hoffmann vc->type = GD_VC_VTE; 1441271a25c0SGerd Hoffmann vc->tab_item = box; 1442271a25c0SGerd Hoffmann gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), vc->tab_item, 1443cdeb7090SGerd Hoffmann gtk_label_new(vc->label)); 1444d861def3SAnthony Liguori 1445271a25c0SGerd Hoffmann qemu_chr_be_generic_open(vc->vte.chr); 1446271a25c0SGerd Hoffmann if (vc->vte.chr->init) { 1447271a25c0SGerd Hoffmann vc->vte.chr->init(vc->vte.chr); 1448d861def3SAnthony Liguori } 1449d861def3SAnthony Liguori 1450d861def3SAnthony Liguori return group; 1451a4ccabcfSAnthony Liguori } 1452a4ccabcfSAnthony Liguori 1453ed1132e4SGerd Hoffmann static void gd_vcs_init(GtkDisplayState *s, GSList *group, 1454ee5f31e4SGerd Hoffmann GtkWidget *view_menu) 1455ee5f31e4SGerd Hoffmann { 1456ee5f31e4SGerd Hoffmann int i; 1457ee5f31e4SGerd Hoffmann 1458ee5f31e4SGerd Hoffmann for (i = 0; i < nb_vcs; i++) { 1459ed1132e4SGerd Hoffmann VirtualConsole *vc = &s->vc[s->nb_vcs]; 1460ed1132e4SGerd Hoffmann group = gd_vc_vte_init(s, vc, vcs[i], s->nb_vcs, group, view_menu); 1461ee5f31e4SGerd Hoffmann s->nb_vcs++; 1462ee5f31e4SGerd Hoffmann } 1463ee5f31e4SGerd Hoffmann } 1464ee5f31e4SGerd Hoffmann #endif /* CONFIG_VTE */ 1465ee5f31e4SGerd Hoffmann 1466a4ccabcfSAnthony Liguori /** Window Creation **/ 1467a4ccabcfSAnthony Liguori 1468e3500d1fSGerd Hoffmann static void gd_connect_vc_gfx_signals(VirtualConsole *vc) 1469e3500d1fSGerd Hoffmann { 1470e3500d1fSGerd Hoffmann #if GTK_CHECK_VERSION(3, 0, 0) 1471e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "draw", 1472e3500d1fSGerd Hoffmann G_CALLBACK(gd_draw_event), vc); 1473e3500d1fSGerd Hoffmann #else 1474e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "expose-event", 1475e3500d1fSGerd Hoffmann G_CALLBACK(gd_expose_event), vc); 1476e3500d1fSGerd Hoffmann #endif 1477e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "event", 1478e3500d1fSGerd Hoffmann G_CALLBACK(gd_event), vc); 1479e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "button-press-event", 1480e3500d1fSGerd Hoffmann G_CALLBACK(gd_button_event), vc); 1481e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "button-release-event", 1482e3500d1fSGerd Hoffmann G_CALLBACK(gd_button_event), vc); 1483e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "scroll-event", 1484e3500d1fSGerd Hoffmann G_CALLBACK(gd_scroll_event), vc); 1485e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "key-press-event", 1486e3500d1fSGerd Hoffmann G_CALLBACK(gd_key_event), vc); 1487e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "key-release-event", 1488e3500d1fSGerd Hoffmann G_CALLBACK(gd_key_event), vc); 1489e3500d1fSGerd Hoffmann 1490e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "enter-notify-event", 1491e3500d1fSGerd Hoffmann G_CALLBACK(gd_enter_event), vc); 1492e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "leave-notify-event", 1493e3500d1fSGerd Hoffmann G_CALLBACK(gd_leave_event), vc); 1494e3500d1fSGerd Hoffmann g_signal_connect(vc->gfx.drawing_area, "focus-out-event", 1495e3500d1fSGerd Hoffmann G_CALLBACK(gd_focus_out_event), vc); 1496e3500d1fSGerd Hoffmann } 1497e3500d1fSGerd Hoffmann 1498a4ccabcfSAnthony Liguori static void gd_connect_signals(GtkDisplayState *s) 1499a4ccabcfSAnthony Liguori { 1500a4ccabcfSAnthony Liguori g_signal_connect(s->show_tabs_item, "activate", 1501a4ccabcfSAnthony Liguori G_CALLBACK(gd_menu_show_tabs), s); 1502cdeb7090SGerd Hoffmann g_signal_connect(s->untabify_item, "activate", 1503cdeb7090SGerd Hoffmann G_CALLBACK(gd_menu_untabify), s); 1504a4ccabcfSAnthony Liguori 1505a4ccabcfSAnthony Liguori g_signal_connect(s->window, "delete-event", 1506a4ccabcfSAnthony Liguori G_CALLBACK(gd_window_close), s); 1507a4ccabcfSAnthony Liguori 150830e8f22bSJan Kiszka g_signal_connect(s->pause_item, "activate", 150930e8f22bSJan Kiszka G_CALLBACK(gd_menu_pause), s); 151030e8f22bSJan Kiszka g_signal_connect(s->reset_item, "activate", 151130e8f22bSJan Kiszka G_CALLBACK(gd_menu_reset), s); 151230e8f22bSJan Kiszka g_signal_connect(s->powerdown_item, "activate", 151330e8f22bSJan Kiszka G_CALLBACK(gd_menu_powerdown), s); 1514a4ccabcfSAnthony Liguori g_signal_connect(s->quit_item, "activate", 1515a4ccabcfSAnthony Liguori G_CALLBACK(gd_menu_quit), s); 1516c6158483SAnthony Liguori g_signal_connect(s->full_screen_item, "activate", 1517c6158483SAnthony Liguori G_CALLBACK(gd_menu_full_screen), s); 1518c6158483SAnthony Liguori g_signal_connect(s->zoom_in_item, "activate", 1519c6158483SAnthony Liguori G_CALLBACK(gd_menu_zoom_in), s); 1520c6158483SAnthony Liguori g_signal_connect(s->zoom_out_item, "activate", 1521c6158483SAnthony Liguori G_CALLBACK(gd_menu_zoom_out), s); 1522c6158483SAnthony Liguori g_signal_connect(s->zoom_fixed_item, "activate", 1523c6158483SAnthony Liguori G_CALLBACK(gd_menu_zoom_fixed), s); 1524c6158483SAnthony Liguori g_signal_connect(s->zoom_fit_item, "activate", 1525c6158483SAnthony Liguori G_CALLBACK(gd_menu_zoom_fit), s); 15265104a1f6SAnthony Liguori g_signal_connect(s->grab_item, "activate", 15275104a1f6SAnthony Liguori G_CALLBACK(gd_menu_grab_input), s); 1528a4ccabcfSAnthony Liguori g_signal_connect(s->notebook, "switch-page", 1529a4ccabcfSAnthony Liguori G_CALLBACK(gd_change_page), s); 1530a4ccabcfSAnthony Liguori } 1531a4ccabcfSAnthony Liguori 1532bf9b255fSAnthony Liguori static GtkWidget *gd_create_menu_machine(GtkDisplayState *s, GtkAccelGroup *accel_group) 1533a4ccabcfSAnthony Liguori { 1534bf9b255fSAnthony Liguori GtkWidget *machine_menu; 1535a4ccabcfSAnthony Liguori GtkWidget *separator; 1536a4ccabcfSAnthony Liguori 1537bf9b255fSAnthony Liguori machine_menu = gtk_menu_new(); 1538bf9b255fSAnthony Liguori gtk_menu_set_accel_group(GTK_MENU(machine_menu), accel_group); 153930e8f22bSJan Kiszka 154030e8f22bSJan Kiszka s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause")); 1541bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->pause_item); 154230e8f22bSJan Kiszka 154330e8f22bSJan Kiszka separator = gtk_separator_menu_item_new(); 1544bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator); 154530e8f22bSJan Kiszka 15469068f20dSCole Robinson s->reset_item = gtk_menu_item_new_with_mnemonic(_("_Reset")); 1547bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->reset_item); 154830e8f22bSJan Kiszka 15499068f20dSCole Robinson s->powerdown_item = gtk_menu_item_new_with_mnemonic(_("Power _Down")); 1550bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->powerdown_item); 155130e8f22bSJan Kiszka 155230e8f22bSJan Kiszka separator = gtk_separator_menu_item_new(); 1553bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator); 1554a4ccabcfSAnthony Liguori 15553d914488SCole Robinson s->quit_item = gtk_menu_item_new_with_mnemonic(_("_Quit")); 1556a4ccabcfSAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item), 155730e8f22bSJan Kiszka "<QEMU>/Machine/Quit"); 15583d914488SCole Robinson gtk_accel_map_add_entry("<QEMU>/Machine/Quit", 1559db1da1f2SCole Robinson GDK_KEY_q, HOTKEY_MODIFIERS); 1560bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->quit_item); 1561a4ccabcfSAnthony Liguori 1562bf9b255fSAnthony Liguori return machine_menu; 1563bf9b255fSAnthony Liguori } 1564bf9b255fSAnthony Liguori 1565e3500d1fSGerd Hoffmann static const DisplayChangeListenerOps dcl_ops = { 1566e3500d1fSGerd Hoffmann .dpy_name = "gtk", 1567e3500d1fSGerd Hoffmann .dpy_gfx_update = gd_update, 1568e3500d1fSGerd Hoffmann .dpy_gfx_switch = gd_switch, 1569e3500d1fSGerd Hoffmann .dpy_refresh = gd_refresh, 1570e3500d1fSGerd Hoffmann .dpy_mouse_set = gd_mouse_set, 1571e3500d1fSGerd Hoffmann .dpy_cursor_define = gd_cursor_define, 1572e3500d1fSGerd Hoffmann }; 1573e3500d1fSGerd Hoffmann 1574e3500d1fSGerd Hoffmann static GSList *gd_vc_gfx_init(GtkDisplayState *s, VirtualConsole *vc, 1575ed1132e4SGerd Hoffmann QemuConsole *con, int idx, 1576e3500d1fSGerd Hoffmann GSList *group, GtkWidget *view_menu) 1577e3500d1fSGerd Hoffmann { 15786a24ced5SGerd Hoffmann Error *local_err = NULL; 15796a24ced5SGerd Hoffmann Object *obj; 15806a24ced5SGerd Hoffmann 15816a24ced5SGerd Hoffmann obj = object_property_get_link(OBJECT(con), "device", &local_err); 15826a24ced5SGerd Hoffmann if (obj) { 1583cdeb7090SGerd Hoffmann vc->label = g_strdup_printf("%s", object_get_typename(obj)); 1584cdeb7090SGerd Hoffmann } else { 1585cdeb7090SGerd Hoffmann vc->label = g_strdup_printf("VGA"); 15866a24ced5SGerd Hoffmann } 15876a24ced5SGerd Hoffmann 1588e3500d1fSGerd Hoffmann vc->s = s; 1589e3500d1fSGerd Hoffmann vc->gfx.scale_x = 1.0; 1590e3500d1fSGerd Hoffmann vc->gfx.scale_y = 1.0; 1591e3500d1fSGerd Hoffmann 1592e3500d1fSGerd Hoffmann vc->gfx.drawing_area = gtk_drawing_area_new(); 1593e3500d1fSGerd Hoffmann gtk_widget_add_events(vc->gfx.drawing_area, 1594e3500d1fSGerd Hoffmann GDK_POINTER_MOTION_MASK | 1595e3500d1fSGerd Hoffmann GDK_BUTTON_PRESS_MASK | 1596e3500d1fSGerd Hoffmann GDK_BUTTON_RELEASE_MASK | 1597e3500d1fSGerd Hoffmann GDK_BUTTON_MOTION_MASK | 1598e3500d1fSGerd Hoffmann GDK_ENTER_NOTIFY_MASK | 1599e3500d1fSGerd Hoffmann GDK_LEAVE_NOTIFY_MASK | 1600e3500d1fSGerd Hoffmann GDK_SCROLL_MASK | 1601e3500d1fSGerd Hoffmann GDK_KEY_PRESS_MASK); 1602e3500d1fSGerd Hoffmann gtk_widget_set_double_buffered(vc->gfx.drawing_area, FALSE); 1603e3500d1fSGerd Hoffmann gtk_widget_set_can_focus(vc->gfx.drawing_area, TRUE); 1604e3500d1fSGerd Hoffmann 1605e3500d1fSGerd Hoffmann vc->type = GD_VC_GFX; 1606e3500d1fSGerd Hoffmann vc->tab_item = vc->gfx.drawing_area; 1607e3500d1fSGerd Hoffmann gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), 1608cdeb7090SGerd Hoffmann vc->tab_item, gtk_label_new(vc->label)); 1609e3500d1fSGerd Hoffmann gd_connect_vc_gfx_signals(vc); 1610e3500d1fSGerd Hoffmann 1611cdeb7090SGerd Hoffmann group = gd_vc_menu_init(s, vc, idx, group, view_menu); 1612e3500d1fSGerd Hoffmann 1613e3500d1fSGerd Hoffmann vc->gfx.dcl.ops = &dcl_ops; 1614e3500d1fSGerd Hoffmann vc->gfx.dcl.con = con; 1615e3500d1fSGerd Hoffmann register_displaychangelistener(&vc->gfx.dcl); 1616e3500d1fSGerd Hoffmann 1617e3500d1fSGerd Hoffmann return group; 1618e3500d1fSGerd Hoffmann } 1619e3500d1fSGerd Hoffmann 1620bf9b255fSAnthony Liguori static GtkWidget *gd_create_menu_view(GtkDisplayState *s, GtkAccelGroup *accel_group) 1621bf9b255fSAnthony Liguori { 1622bf9b255fSAnthony Liguori GSList *group = NULL; 1623bf9b255fSAnthony Liguori GtkWidget *view_menu; 1624bf9b255fSAnthony Liguori GtkWidget *separator; 1625ed1132e4SGerd Hoffmann QemuConsole *con; 1626ed1132e4SGerd Hoffmann int vc; 1627bf9b255fSAnthony Liguori 1628bf9b255fSAnthony Liguori view_menu = gtk_menu_new(); 1629bf9b255fSAnthony Liguori gtk_menu_set_accel_group(GTK_MENU(view_menu), accel_group); 1630a4ccabcfSAnthony Liguori 16313d914488SCole Robinson s->full_screen_item = gtk_menu_item_new_with_mnemonic(_("_Fullscreen")); 1632c6158483SAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->full_screen_item), 1633c6158483SAnthony Liguori "<QEMU>/View/Full Screen"); 1634b1e749c0SJan Kiszka gtk_accel_map_add_entry("<QEMU>/View/Full Screen", GDK_KEY_f, 1635b1e749c0SJan Kiszka HOTKEY_MODIFIERS); 1636bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->full_screen_item); 1637c6158483SAnthony Liguori 1638c6158483SAnthony Liguori separator = gtk_separator_menu_item_new(); 1639bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 1640c6158483SAnthony Liguori 16413d914488SCole Robinson s->zoom_in_item = gtk_menu_item_new_with_mnemonic(_("Zoom _In")); 1642c6158483SAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_in_item), 1643c6158483SAnthony Liguori "<QEMU>/View/Zoom In"); 1644b1e749c0SJan Kiszka gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus, 1645b1e749c0SJan Kiszka HOTKEY_MODIFIERS); 1646bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_in_item); 1647c6158483SAnthony Liguori 16483d914488SCole Robinson s->zoom_out_item = gtk_menu_item_new_with_mnemonic(_("Zoom _Out")); 1649c6158483SAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_out_item), 1650c6158483SAnthony Liguori "<QEMU>/View/Zoom Out"); 1651b1e749c0SJan Kiszka gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus, 1652b1e749c0SJan Kiszka HOTKEY_MODIFIERS); 1653bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_out_item); 1654c6158483SAnthony Liguori 16553d914488SCole Robinson s->zoom_fixed_item = gtk_menu_item_new_with_mnemonic(_("Best _Fit")); 1656c6158483SAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_fixed_item), 1657c6158483SAnthony Liguori "<QEMU>/View/Zoom Fixed"); 1658b1e749c0SJan Kiszka gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0, 1659b1e749c0SJan Kiszka HOTKEY_MODIFIERS); 1660bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fixed_item); 1661c6158483SAnthony Liguori 1662834574eaSAnthony Liguori s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit")); 1663bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fit_item); 1664c6158483SAnthony Liguori 1665c6158483SAnthony Liguori separator = gtk_separator_menu_item_new(); 1666bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 1667c6158483SAnthony Liguori 1668834574eaSAnthony Liguori s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover")); 1669bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_on_hover_item); 16705104a1f6SAnthony Liguori 1671834574eaSAnthony Liguori s->grab_item = gtk_check_menu_item_new_with_mnemonic(_("_Grab Input")); 16725104a1f6SAnthony Liguori gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->grab_item), 16735104a1f6SAnthony Liguori "<QEMU>/View/Grab Input"); 1674b1e749c0SJan Kiszka gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g, 1675b1e749c0SJan Kiszka HOTKEY_MODIFIERS); 1676bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_item); 16775104a1f6SAnthony Liguori 1678a4ccabcfSAnthony Liguori separator = gtk_separator_menu_item_new(); 1679bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 1680a4ccabcfSAnthony Liguori 1681e3500d1fSGerd Hoffmann /* gfx */ 1682ed1132e4SGerd Hoffmann for (vc = 0;; vc++) { 1683ed1132e4SGerd Hoffmann con = qemu_console_lookup_by_index(vc); 1684ed1132e4SGerd Hoffmann if (!con || !qemu_console_is_graphic(con)) { 1685ed1132e4SGerd Hoffmann break; 1686ed1132e4SGerd Hoffmann } 1687ed1132e4SGerd Hoffmann group = gd_vc_gfx_init(s, &s->vc[vc], con, 1688ed1132e4SGerd Hoffmann vc, group, view_menu); 1689ed1132e4SGerd Hoffmann s->nb_vcs++; 1690ed1132e4SGerd Hoffmann } 1691a4ccabcfSAnthony Liguori 1692ee5f31e4SGerd Hoffmann #if defined(CONFIG_VTE) 1693e3500d1fSGerd Hoffmann /* vte */ 1694ed1132e4SGerd Hoffmann gd_vcs_init(s, group, view_menu); 1695ee5f31e4SGerd Hoffmann #endif 1696d861def3SAnthony Liguori 1697a4ccabcfSAnthony Liguori separator = gtk_separator_menu_item_new(); 1698bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 1699a4ccabcfSAnthony Liguori 1700834574eaSAnthony Liguori s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs")); 1701bf9b255fSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_tabs_item); 1702a4ccabcfSAnthony Liguori 1703cdeb7090SGerd Hoffmann s->untabify_item = gtk_menu_item_new_with_mnemonic(_("Detach Tab")); 1704cdeb7090SGerd Hoffmann gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->untabify_item); 1705cdeb7090SGerd Hoffmann 1706bf9b255fSAnthony Liguori return view_menu; 1707bf9b255fSAnthony Liguori } 1708a4ccabcfSAnthony Liguori 1709bf9b255fSAnthony Liguori static void gd_create_menus(GtkDisplayState *s) 1710bf9b255fSAnthony Liguori { 1711bf9b255fSAnthony Liguori GtkAccelGroup *accel_group; 1712bf9b255fSAnthony Liguori 1713bf9b255fSAnthony Liguori accel_group = gtk_accel_group_new(); 1714bf9b255fSAnthony Liguori s->machine_menu = gd_create_menu_machine(s, accel_group); 1715bf9b255fSAnthony Liguori s->view_menu = gd_create_menu_view(s, accel_group); 1716bf9b255fSAnthony Liguori 1717bf9b255fSAnthony Liguori s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine")); 171830e8f22bSJan Kiszka gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->machine_menu_item), 171930e8f22bSJan Kiszka s->machine_menu); 172030e8f22bSJan Kiszka gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->machine_menu_item); 1721a4ccabcfSAnthony Liguori 1722bf9b255fSAnthony Liguori s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View")); 1723a4ccabcfSAnthony Liguori gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->view_menu_item), s->view_menu); 1724a4ccabcfSAnthony Liguori gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item); 1725bf9b255fSAnthony Liguori 1726bf9b255fSAnthony Liguori g_object_set_data(G_OBJECT(s->window), "accel_group", accel_group); 1727bf9b255fSAnthony Liguori gtk_window_add_accel_group(GTK_WINDOW(s->window), accel_group); 1728bf9b255fSAnthony Liguori s->accel_group = accel_group; 1729a4ccabcfSAnthony Liguori } 1730a4ccabcfSAnthony Liguori 1731*3158a348SBruce Rogers static void gd_set_keycode_type(GtkDisplayState *s) 1732*3158a348SBruce Rogers { 1733*3158a348SBruce Rogers #ifndef _WIN32 1734*3158a348SBruce Rogers char *keycodes = NULL; 1735*3158a348SBruce Rogers GdkDisplay *display = gtk_widget_get_display(s->window); 1736*3158a348SBruce Rogers Display *x11_display = gdk_x11_display_get_xdisplay(display); 1737*3158a348SBruce Rogers XkbDescPtr desc = XkbGetKeyboard(x11_display, XkbGBN_AllComponentsMask, 1738*3158a348SBruce Rogers XkbUseCoreKbd); 1739*3158a348SBruce Rogers 1740*3158a348SBruce Rogers if (desc && desc->names) { 1741*3158a348SBruce Rogers keycodes = XGetAtomName(x11_display, desc->names->keycodes); 1742*3158a348SBruce Rogers } 1743*3158a348SBruce Rogers if (keycodes == NULL) { 1744*3158a348SBruce Rogers fprintf(stderr, "could not lookup keycode name\n"); 1745*3158a348SBruce Rogers } else if (strstart(keycodes, "evdev", NULL)) { 1746*3158a348SBruce Rogers s->has_evdev = true; 1747*3158a348SBruce Rogers } else if (!strstart(keycodes, "xfree86", NULL)) { 1748*3158a348SBruce Rogers fprintf(stderr, "unknown keycodes `%s', please report to " 1749*3158a348SBruce Rogers "qemu-devel@nongnu.org\n", keycodes); 1750*3158a348SBruce Rogers } 1751*3158a348SBruce Rogers #endif 1752*3158a348SBruce Rogers } 1753*3158a348SBruce Rogers 1754881249c7SJan Kiszka void gtk_display_init(DisplayState *ds, bool full_screen, bool grab_on_hover) 1755a4ccabcfSAnthony Liguori { 1756a4ccabcfSAnthony Liguori GtkDisplayState *s = g_malloc0(sizeof(*s)); 1757d819cdccSStefan Weil char *filename; 1758a4ccabcfSAnthony Liguori 1759a4ccabcfSAnthony Liguori gtk_init(NULL, NULL); 1760a4ccabcfSAnthony Liguori 1761a4ccabcfSAnthony Liguori s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 176251572ab0SDaniel P. Berrange #if GTK_CHECK_VERSION(3, 2, 0) 176351572ab0SDaniel P. Berrange s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); 176451572ab0SDaniel P. Berrange #else 1765a4ccabcfSAnthony Liguori s->vbox = gtk_vbox_new(FALSE, 0); 176651572ab0SDaniel P. Berrange #endif 1767a4ccabcfSAnthony Liguori s->notebook = gtk_notebook_new(); 1768a4ccabcfSAnthony Liguori s->menu_bar = gtk_menu_bar_new(); 1769a4ccabcfSAnthony Liguori 1770c6158483SAnthony Liguori s->free_scale = FALSE; 1771a4ccabcfSAnthony Liguori 1772834574eaSAnthony Liguori setlocale(LC_ALL, ""); 1773834574eaSAnthony Liguori bindtextdomain("qemu", CONFIG_QEMU_LOCALEDIR); 1774834574eaSAnthony Liguori textdomain("qemu"); 1775834574eaSAnthony Liguori 1776a4ccabcfSAnthony Liguori s->null_cursor = gdk_cursor_new(GDK_BLANK_CURSOR); 1777a4ccabcfSAnthony Liguori 1778a4ccabcfSAnthony Liguori s->mouse_mode_notifier.notify = gd_mouse_mode_change; 1779a4ccabcfSAnthony Liguori qemu_add_mouse_mode_change_notifier(&s->mouse_mode_notifier); 1780a4ccabcfSAnthony Liguori qemu_add_vm_change_state_handler(gd_change_runstate, s); 1781a4ccabcfSAnthony Liguori 1782f7da9c17SAnthony Liguori filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu_logo_no_text.svg"); 1783d819cdccSStefan Weil if (filename) { 1784d819cdccSStefan Weil GError *error = NULL; 1785d819cdccSStefan Weil GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(filename, &error); 1786d819cdccSStefan Weil if (pixbuf) { 1787d819cdccSStefan Weil gtk_window_set_icon(GTK_WINDOW(s->window), pixbuf); 1788d819cdccSStefan Weil } else { 1789d819cdccSStefan Weil g_error_free(error); 1790d819cdccSStefan Weil } 1791d819cdccSStefan Weil g_free(filename); 1792d819cdccSStefan Weil } 1793d819cdccSStefan Weil 1794a4ccabcfSAnthony Liguori gd_create_menus(s); 1795a4ccabcfSAnthony Liguori 1796a4ccabcfSAnthony Liguori gd_connect_signals(s); 1797a4ccabcfSAnthony Liguori 1798a4ccabcfSAnthony Liguori gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 1799a4ccabcfSAnthony Liguori gtk_notebook_set_show_border(GTK_NOTEBOOK(s->notebook), FALSE); 1800a4ccabcfSAnthony Liguori 1801a4ccabcfSAnthony Liguori gd_update_caption(s); 1802a4ccabcfSAnthony Liguori 1803a4ccabcfSAnthony Liguori gtk_box_pack_start(GTK_BOX(s->vbox), s->menu_bar, FALSE, TRUE, 0); 1804a4ccabcfSAnthony Liguori gtk_box_pack_start(GTK_BOX(s->vbox), s->notebook, TRUE, TRUE, 0); 1805a4ccabcfSAnthony Liguori 1806a4ccabcfSAnthony Liguori gtk_container_add(GTK_CONTAINER(s->window), s->vbox); 1807a4ccabcfSAnthony Liguori 1808a4ccabcfSAnthony Liguori gtk_widget_show_all(s->window); 1809a4ccabcfSAnthony Liguori 1810787ba4f0SPeter Wu if (full_screen) { 1811787ba4f0SPeter Wu gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item)); 1812787ba4f0SPeter Wu } 1813881249c7SJan Kiszka if (grab_on_hover) { 1814881249c7SJan Kiszka gtk_menu_item_activate(GTK_MENU_ITEM(s->grab_on_hover_item)); 1815881249c7SJan Kiszka } 1816787ba4f0SPeter Wu 1817*3158a348SBruce Rogers gd_set_keycode_type(s); 1818*3158a348SBruce Rogers 1819a4ccabcfSAnthony Liguori global_state = s; 1820a4ccabcfSAnthony Liguori } 1821ee5f31e4SGerd Hoffmann 1822ee5f31e4SGerd Hoffmann void early_gtk_display_init(void) 1823ee5f31e4SGerd Hoffmann { 1824ee5f31e4SGerd Hoffmann #if defined(CONFIG_VTE) 1825ee5f31e4SGerd Hoffmann register_vc_handler(gd_vc_handler); 1826ee5f31e4SGerd Hoffmann #endif 1827ee5f31e4SGerd Hoffmann } 1828