ui/gtk.c

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