ui/gtk.c

   1 /*
   2  * GTK UI
   3  *
   4  * Copyright IBM, Corp. 2012
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <[email protected]>
   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 <[email protected]>
  17  * Copyright (C) 2009-2010 Daniel P. Berrange <[email protected]>
  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 #ifdef _WIN32
  38 # define _WIN32_WINNT 0x0601 /* needed to get definition of MAPVK_VK_TO_VSC */
  39 #endif
  40
  41 #include "qemu-common.h"
  42
  43 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
  44 /* Work around an -Wstrict-prototypes warning in GTK headers */
  45 #pragma GCC diagnostic push
  46 #pragma GCC diagnostic ignored "-Wstrict-prototypes"
  47 #endif
  48 #include <gtk/gtk.h>
  49 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
  50 #pragma GCC diagnostic pop
  51 #endif
  52
  53
  54 #include <gdk/gdkkeysyms.h>
  55 #include <glib/gi18n.h>
  56 #include <locale.h>
  57 #if defined(CONFIG_VTE)
  58 #include <vte/vte.h>
  59 #endif
  60 #include <math.h>
  61
  62 #include "trace.h"
  63 #include "ui/console.h"
  64 #include "ui/input.h"
  65 #include "sysemu/sysemu.h"
  66 #include "qmp-commands.h"
  67 #include "x_keymap.h"
  68 #include "keymaps.h"
  69 #include "sysemu/char.h"
  70
  71 #define MAX_VCS 10
  72
  73 #if !defined(CONFIG_VTE)
  74 # define VTE_CHECK_VERSION(a, b, c) 0
  75 #endif
  76
  77 /* Compatibility define to let us build on both Gtk2 and Gtk3 */
  78 #if GTK_CHECK_VERSION(3, 0, 0)
  79 static inline void gdk_drawable_get_size(GdkWindow *w, gint *ww, gint *wh)
  80 {
  81     *ww = gdk_window_get_width(w);
  82     *wh = gdk_window_get_height(w);
  83 }
  84 #endif
  85
  86 #if !GTK_CHECK_VERSION(2, 20, 0)
  87 #define gtk_widget_get_realized(widget) GTK_WIDGET_REALIZED(widget)
  88 #endif
  89
  90 #ifndef GDK_KEY_0
  91 #define GDK_KEY_0 GDK_0
  92 #define GDK_KEY_1 GDK_1
  93 #define GDK_KEY_2 GDK_2
  94 #define GDK_KEY_f GDK_f
  95 #define GDK_KEY_g GDK_g
  96 #define GDK_KEY_plus GDK_plus
  97 #define GDK_KEY_minus GDK_minus
  98 #endif
  99
 100 #define HOTKEY_MODIFIERS        (GDK_CONTROL_MASK | GDK_MOD1_MASK)
 101 #define IGNORE_MODIFIER_MASK \
 102     (GDK_MODIFIER_MASK & ~(GDK_LOCK_MASK | GDK_MOD2_MASK))
 103
 104 static const int modifier_keycode[] = {
 105     /* shift, control, alt keys, meta keys, both left & right */
 106     0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8, 0xdb, 0xdd,
 107 };
 108
 109 typedef struct VirtualConsole
 110 {
 111     GtkWidget *menu_item;
 112     GtkWidget *terminal;
 113 #if defined(CONFIG_VTE)
 114     GtkWidget *scrolled_window;
 115     CharDriverState *chr;
 116 #endif
 117     int fd;
 118 } VirtualConsole;
 119
 120 typedef struct GtkDisplayState
 121 {
 122     GtkWidget *window;
 123
 124     GtkWidget *menu_bar;
 125
 126     GtkAccelGroup *accel_group;
 127
 128     GtkWidget *machine_menu_item;
 129     GtkWidget *machine_menu;
 130     GtkWidget *pause_item;
 131     GtkWidget *reset_item;
 132     GtkWidget *powerdown_item;
 133     GtkWidget *quit_item;
 134
 135     GtkWidget *view_menu_item;
 136     GtkWidget *view_menu;
 137     GtkWidget *full_screen_item;
 138     GtkWidget *zoom_in_item;
 139     GtkWidget *zoom_out_item;
 140     GtkWidget *zoom_fixed_item;
 141     GtkWidget *zoom_fit_item;
 142     GtkWidget *grab_item;
 143     GtkWidget *grab_on_hover_item;
 144     GtkWidget *vga_item;
 145
 146     int nb_vcs;
 147     VirtualConsole vc[MAX_VCS];
 148
 149     GtkWidget *show_tabs_item;
 150
 151     GtkWidget *vbox;
 152     GtkWidget *notebook;
 153     GtkWidget *drawing_area;
 154     cairo_surface_t *surface;
 155     pixman_image_t *convert;
 156     DisplayChangeListener dcl;
 157     DisplaySurface *ds;
 158     int button_mask;
 159     int last_x;
 160     int last_y;
 161
 162     double scale_x;
 163     double scale_y;
 164     gboolean full_screen;
 165
 166     GdkCursor *null_cursor;
 167     Notifier mouse_mode_notifier;
 168     gboolean free_scale;
 169
 170     bool external_pause_update;
 171
 172     bool modifier_pressed[ARRAY_SIZE(modifier_keycode)];
 173 } GtkDisplayState;
 174
 175 static GtkDisplayState *global_state;
 176
 177 /** Utility Functions **/
 178
 179 static bool gd_is_grab_active(GtkDisplayState *s)
 180 {
 181     return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_item));
 182 }
 183
 184 static bool gd_grab_on_hover(GtkDisplayState *s)
 185 {
 186     return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_on_hover_item));
 187 }
 188
 189 static bool gd_on_vga(GtkDisplayState *s)
 190 {
 191     return gtk_notebook_get_current_page(GTK_NOTEBOOK(s->notebook)) == 0;
 192 }
 193
 194 static void gd_update_cursor(GtkDisplayState *s, gboolean override)
 195 {
 196     GdkWindow *window;
 197     bool on_vga;
 198
 199     window = gtk_widget_get_window(GTK_WIDGET(s->drawing_area));
 200
 201     on_vga = gd_on_vga(s);
 202
 203     if ((override || on_vga) &&
 204         (s->full_screen || qemu_input_is_absolute() || gd_is_grab_active(s))) {
 205         gdk_window_set_cursor(window, s->null_cursor);
 206     } else {
 207         gdk_window_set_cursor(window, NULL);
 208     }
 209 }
 210
 211 static void gd_update_caption(GtkDisplayState *s)
 212 {
 213     const char *status = "";
 214     gchar *title;
 215     const char *grab = "";
 216     bool is_paused = !runstate_is_running();
 217
 218     if (gd_is_grab_active(s)) {
 219         grab = _(" - Press Ctrl+Alt+G to release grab");
 220     }
 221
 222     if (is_paused) {
 223         status = _(" [Paused]");
 224     }
 225     s->external_pause_update = true;
 226     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->pause_item),
 227                                    is_paused);
 228     s->external_pause_update = false;
 229
 230     if (qemu_name) {
 231         title = g_strdup_printf("QEMU (%s)%s%s", qemu_name, status, grab);
 232     } else {
 233         title = g_strdup_printf("QEMU%s%s", status, grab);
 234     }
 235
 236     gtk_window_set_title(GTK_WINDOW(s->window), title);
 237
 238     g_free(title);
 239 }
 240
 241 static void gd_update_windowsize(GtkDisplayState *s)
 242 {
 243     if (!s->full_screen) {
 244         GtkRequisition req;
 245         double sx, sy;
 246
 247         if (s->free_scale) {
 248             sx = s->scale_x;
 249             sy = s->scale_y;
 250
 251             s->scale_y = 1.0;
 252             s->scale_x = 1.0;
 253         } else {
 254             sx = 1.0;
 255             sy = 1.0;
 256         }
 257
 258         gtk_widget_set_size_request(s->drawing_area,
 259                                     surface_width(s->ds) * s->scale_x,
 260                                     surface_height(s->ds) * s->scale_y);
 261 #if GTK_CHECK_VERSION(3, 0, 0)
 262         gtk_widget_get_preferred_size(s->vbox, NULL, &req);
 263 #else
 264         gtk_widget_size_request(s->vbox, &req);
 265 #endif
 266
 267         gtk_window_resize(GTK_WINDOW(s->window),
 268                           req.width * sx, req.height * sy);
 269     }
 270 }
 271
 272 static void gd_update_full_redraw(GtkDisplayState *s)
 273 {
 274     int ww, wh;
 275     gdk_drawable_get_size(gtk_widget_get_window(s->drawing_area), &ww, &wh);
 276     gtk_widget_queue_draw_area(s->drawing_area, 0, 0, ww, wh);
 277 }
 278
 279 static void gtk_release_modifiers(GtkDisplayState *s)
 280 {
 281     int i, keycode;
 282
 283     if (!gd_on_vga(s)) {
 284         return;
 285     }
 286     for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) {
 287         keycode = modifier_keycode[i];
 288         if (!s->modifier_pressed[i]) {
 289             continue;
 290         }
 291         qemu_input_event_send_key_number(s->dcl.con, keycode, false);
 292         s->modifier_pressed[i] = false;
 293     }
 294 }
 295
 296 /** DisplayState Callbacks **/
 297
 298 static void gd_update(DisplayChangeListener *dcl,
 299                       int x, int y, int w, int h)
 300 {
 301     GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
 302     int x1, x2, y1, y2;
 303     int mx, my;
 304     int fbw, fbh;
 305     int ww, wh;
 306
 307     trace_gd_update(x, y, w, h);
 308
 309     if (s->convert) {
 310         pixman_image_composite(PIXMAN_OP_SRC, s->ds->image, NULL, s->convert,
 311                                x, y, 0, 0, x, y, w, h);
 312     }
 313
 314     x1 = floor(x * s->scale_x);
 315     y1 = floor(y * s->scale_y);
 316
 317     x2 = ceil(x * s->scale_x + w * s->scale_x);
 318     y2 = ceil(y * s->scale_y + h * s->scale_y);
 319
 320     fbw = surface_width(s->ds) * s->scale_x;
 321     fbh = surface_height(s->ds) * s->scale_y;
 322
 323     gdk_drawable_get_size(gtk_widget_get_window(s->drawing_area), &ww, &wh);
 324
 325     mx = my = 0;
 326     if (ww > fbw) {
 327         mx = (ww - fbw) / 2;
 328     }
 329     if (wh > fbh) {
 330         my = (wh - fbh) / 2;
 331     }
 332
 333     gtk_widget_queue_draw_area(s->drawing_area, mx + x1, my + y1, (x2 - x1), (y2 - y1));
 334 }
 335
 336 static void gd_refresh(DisplayChangeListener *dcl)
 337 {
 338     graphic_hw_update(dcl->con);
 339 }
 340
 341 #if GTK_CHECK_VERSION(3, 0, 0)
 342 static void gd_mouse_set(DisplayChangeListener *dcl,
 343                          int x, int y, int visible)
 344 {
 345     GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
 346     GdkDisplay *dpy;
 347     GdkDeviceManager *mgr;
 348     gint x_root, y_root;
 349
 350     if (qemu_input_is_absolute()) {
 351         return;
 352     }
 353
 354     dpy = gtk_widget_get_display(s->drawing_area);
 355     mgr = gdk_display_get_device_manager(dpy);
 356     gdk_window_get_root_coords(gtk_widget_get_window(s->drawing_area),
 357                                x, y, &x_root, &y_root);
 358     gdk_device_warp(gdk_device_manager_get_client_pointer(mgr),
 359                     gtk_widget_get_screen(s->drawing_area),
 360                     x_root, y_root);
 361 }
 362 #else
 363 static void gd_mouse_set(DisplayChangeListener *dcl,
 364                          int x, int y, int visible)
 365 {
 366     GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
 367     gint x_root, y_root;
 368
 369     if (qemu_input_is_absolute()) {
 370         return;
 371     }
 372
 373     gdk_window_get_root_coords(gtk_widget_get_window(s->drawing_area),
 374                                x, y, &x_root, &y_root);
 375     gdk_display_warp_pointer(gtk_widget_get_display(s->drawing_area),
 376                              gtk_widget_get_screen(s->drawing_area),
 377                              x_root, y_root);
 378 }
 379 #endif
 380
 381 static void gd_cursor_define(DisplayChangeListener *dcl,
 382                              QEMUCursor *c)
 383 {
 384     GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
 385     GdkPixbuf *pixbuf;
 386     GdkCursor *cursor;
 387
 388     pixbuf = gdk_pixbuf_new_from_data((guchar *)(c->data),
 389                                       GDK_COLORSPACE_RGB, true, 8,
 390                                       c->width, c->height, c->width * 4,
 391                                       NULL, NULL);
 392     cursor = gdk_cursor_new_from_pixbuf(gtk_widget_get_display(s->drawing_area),
 393                                         pixbuf, c->hot_x, c->hot_y);
 394     gdk_window_set_cursor(gtk_widget_get_window(s->drawing_area), cursor);
 395     g_object_unref(pixbuf);
 396 #if !GTK_CHECK_VERSION(3, 0, 0)
 397     gdk_cursor_unref(cursor);
 398 #else
 399     g_object_unref(cursor);
 400 #endif
 401 }
 402
 403 static void gd_switch(DisplayChangeListener *dcl,
 404                       DisplaySurface *surface)
 405 {
 406     GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
 407     bool resized = true;
 408
 409     trace_gd_switch(surface_width(surface), surface_height(surface));
 410
 411     if (s->surface) {
 412         cairo_surface_destroy(s->surface);
 413     }
 414
 415     if (s->ds &&
 416         surface_width(s->ds) == surface_width(surface) &&
 417         surface_height(s->ds) == surface_height(surface)) {
 418         resized = false;
 419     }
 420     s->ds = surface;
 421
 422     if (s->convert) {
 423         pixman_image_unref(s->convert);
 424         s->convert = NULL;
 425     }
 426
 427     if (surface->format == PIXMAN_x8r8g8b8) {
 428         /*
 429          * PIXMAN_x8r8g8b8 == CAIRO_FORMAT_RGB24
 430          *
 431          * No need to convert, use surface directly.  Should be the
 432          * common case as this is qemu_default_pixelformat(32) too.
 433          */
 434         s->surface = cairo_image_surface_create_for_data
 435             (surface_data(surface),
 436              CAIRO_FORMAT_RGB24,
 437              surface_width(surface),
 438              surface_height(surface),
 439              surface_stride(surface));
 440     } else {
 441         /* Must convert surface, use pixman to do it. */
 442         s->convert = pixman_image_create_bits(PIXMAN_x8r8g8b8,
 443                                               surface_width(surface),
 444                                               surface_height(surface),
 445                                               NULL, 0);
 446         s->surface = cairo_image_surface_create_for_data
 447             ((void *)pixman_image_get_data(s->convert),
 448              CAIRO_FORMAT_RGB24,
 449              pixman_image_get_width(s->convert),
 450              pixman_image_get_height(s->convert),
 451              pixman_image_get_stride(s->convert));
 452         pixman_image_composite(PIXMAN_OP_SRC, s->ds->image, NULL, s->convert,
 453                                0, 0, 0, 0, 0, 0,
 454                                pixman_image_get_width(s->convert),
 455                                pixman_image_get_height(s->convert));
 456     }
 457
 458     if (resized) {
 459         gd_update_windowsize(s);
 460     } else {
 461         gd_update_full_redraw(s);
 462     }
 463 }
 464
 465 /** QEMU Events **/
 466
 467 static void gd_change_runstate(void *opaque, int running, RunState state)
 468 {
 469     GtkDisplayState *s = opaque;
 470
 471     gd_update_caption(s);
 472 }
 473
 474 static void gd_mouse_mode_change(Notifier *notify, void *data)
 475 {
 476     gd_update_cursor(container_of(notify, GtkDisplayState, mouse_mode_notifier),
 477                      FALSE);
 478 }
 479
 480 /** GTK Events **/
 481
 482 static gboolean gd_window_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
 483 {
 484     GtkDisplayState *s = opaque;
 485     gboolean handled = FALSE;
 486
 487     if (!gd_is_grab_active(s) ||
 488         (key->state & IGNORE_MODIFIER_MASK) == HOTKEY_MODIFIERS) {
 489         handled = gtk_window_activate_key(GTK_WINDOW(widget), key);
 490     }
 491     if (handled) {
 492         gtk_release_modifiers(s);
 493     } else {
 494         handled = gtk_window_propagate_key_event(GTK_WINDOW(widget), key);
 495     }
 496
 497     return handled;
 498 }
 499
 500 static gboolean gd_window_close(GtkWidget *widget, GdkEvent *event,
 501                                 void *opaque)
 502 {
 503     GtkDisplayState *s = opaque;
 504
 505     if (!no_quit) {
 506         unregister_displaychangelistener(&s->dcl);
 507         qmp_quit(NULL);
 508         return FALSE;
 509     }
 510
 511     return TRUE;
 512 }
 513
 514 static gboolean gd_draw_event(GtkWidget *widget, cairo_t *cr, void *opaque)
 515 {
 516     GtkDisplayState *s = opaque;
 517     int mx, my;
 518     int ww, wh;
 519     int fbw, fbh;
 520
 521     if (!gtk_widget_get_realized(widget)) {
 522         return FALSE;
 523     }
 524
 525     fbw = surface_width(s->ds);
 526     fbh = surface_height(s->ds);
 527
 528     gdk_drawable_get_size(gtk_widget_get_window(widget), &ww, &wh);
 529
 530     if (s->full_screen) {
 531         s->scale_x = (double)ww / fbw;
 532         s->scale_y = (double)wh / fbh;
 533     } else if (s->free_scale) {
 534         double sx, sy;
 535
 536         sx = (double)ww / fbw;
 537         sy = (double)wh / fbh;
 538
 539         s->scale_x = s->scale_y = MIN(sx, sy);
 540     }
 541
 542     fbw *= s->scale_x;
 543     fbh *= s->scale_y;
 544
 545     mx = my = 0;
 546     if (ww > fbw) {
 547         mx = (ww - fbw) / 2;
 548     }
 549     if (wh > fbh) {
 550         my = (wh - fbh) / 2;
 551     }
 552
 553     cairo_rectangle(cr, 0, 0, ww, wh);
 554
 555     /* Optionally cut out the inner area where the pixmap
 556        will be drawn. This avoids 'flashing' since we're
 557        not double-buffering. Note we're using the undocumented
 558        behaviour of drawing the rectangle from right to left
 559        to cut out the whole */
 560     cairo_rectangle(cr, mx + fbw, my,
 561                     -1 * fbw, fbh);
 562     cairo_fill(cr);
 563
 564     cairo_scale(cr, s->scale_x, s->scale_y);
 565     cairo_set_source_surface(cr, s->surface, mx / s->scale_x, my / s->scale_y);
 566     cairo_paint(cr);
 567
 568     return TRUE;
 569 }
 570
 571 #if !GTK_CHECK_VERSION(3, 0, 0)
 572 static gboolean gd_expose_event(GtkWidget *widget, GdkEventExpose *expose,
 573                                 void *opaque)
 574 {
 575     cairo_t *cr;
 576     gboolean ret;
 577
 578     cr = gdk_cairo_create(gtk_widget_get_window(widget));
 579     cairo_rectangle(cr,
 580                     expose->area.x,
 581                     expose->area.y,
 582                     expose->area.width,
 583                     expose->area.height);
 584     cairo_clip(cr);
 585
 586     ret = gd_draw_event(widget, cr, opaque);
 587
 588     cairo_destroy(cr);
 589
 590     return ret;
 591 }
 592 #endif
 593
 594 static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion,
 595                                 void *opaque)
 596 {
 597     GtkDisplayState *s = opaque;
 598     int x, y;
 599     int mx, my;
 600     int fbh, fbw;
 601     int ww, wh;
 602
 603     fbw = surface_width(s->ds) * s->scale_x;
 604     fbh = surface_height(s->ds) * s->scale_y;
 605
 606     gdk_drawable_get_size(gtk_widget_get_window(s->drawing_area), &ww, &wh);
 607
 608     mx = my = 0;
 609     if (ww > fbw) {
 610         mx = (ww - fbw) / 2;
 611     }
 612     if (wh > fbh) {
 613         my = (wh - fbh) / 2;
 614     }
 615
 616     x = (motion->x - mx) / s->scale_x;
 617     y = (motion->y - my) / s->scale_y;
 618
 619     if (x < 0 || y < 0 ||
 620         x >= surface_width(s->ds) ||
 621         y >= surface_height(s->ds)) {
 622         return TRUE;
 623     }
 624
 625     if (qemu_input_is_absolute()) {
 626         qemu_input_queue_abs(s->dcl.con, INPUT_AXIS_X, x,
 627                              surface_width(s->ds));
 628         qemu_input_queue_abs(s->dcl.con, INPUT_AXIS_Y, y,
 629                              surface_height(s->ds));
 630         qemu_input_event_sync();
 631     } else if (s->last_x != -1 && s->last_y != -1 && gd_is_grab_active(s)) {
 632         qemu_input_queue_rel(s->dcl.con, INPUT_AXIS_X, x - s->last_x);
 633         qemu_input_queue_rel(s->dcl.con, INPUT_AXIS_Y, y - s->last_y);
 634         qemu_input_event_sync();
 635     }
 636     s->last_x = x;
 637     s->last_y = y;
 638
 639     if (!qemu_input_is_absolute() && gd_is_grab_active(s)) {
 640         GdkScreen *screen = gtk_widget_get_screen(s->drawing_area);
 641         int x = (int)motion->x_root;
 642         int y = (int)motion->y_root;
 643
 644         /* In relative mode check to see if client pointer hit
 645          * one of the screen edges, and if so move it back by
 646          * 200 pixels. This is important because the pointer
 647          * in the server doesn't correspond 1-for-1, and so
 648          * may still be only half way across the screen. Without
 649          * this warp, the server pointer would thus appear to hit
 650          * an invisible wall */
 651         if (x == 0) {
 652             x += 200;
 653         }
 654         if (y == 0) {
 655             y += 200;
 656         }
 657         if (x == (gdk_screen_get_width(screen) - 1)) {
 658             x -= 200;
 659         }
 660         if (y == (gdk_screen_get_height(screen) - 1)) {
 661             y -= 200;
 662         }
 663
 664         if (x != (int)motion->x_root || y != (int)motion->y_root) {
 665 #if GTK_CHECK_VERSION(3, 0, 0)
 666             GdkDevice *dev = gdk_event_get_device((GdkEvent *)motion);
 667             gdk_device_warp(dev, screen, x, y);
 668 #else
 669             GdkDisplay *display = gtk_widget_get_display(widget);
 670             gdk_display_warp_pointer(display, screen, x, y);
 671 #endif
 672             s->last_x = -1;
 673             s->last_y = -1;
 674             return FALSE;
 675         }
 676     }
 677     return TRUE;
 678 }
 679
 680 static gboolean gd_button_event(GtkWidget *widget, GdkEventButton *button,
 681                                 void *opaque)
 682 {
 683     GtkDisplayState *s = opaque;
 684     InputButton btn;
 685
 686     if (button->button == 1) {
 687         btn = INPUT_BUTTON_LEFT;
 688     } else if (button->button == 2) {
 689         btn = INPUT_BUTTON_MIDDLE;
 690     } else if (button->button == 3) {
 691         btn = INPUT_BUTTON_RIGHT;
 692     } else {
 693         return TRUE;
 694     }
 695
 696     qemu_input_queue_btn(s->dcl.con, btn, button->type == GDK_BUTTON_PRESS);
 697     qemu_input_event_sync();
 698     return TRUE;
 699 }
 700
 701 static gboolean gd_scroll_event(GtkWidget *widget, GdkEventScroll *scroll,
 702                                 void *opaque)
 703 {
 704     GtkDisplayState *s = opaque;
 705     InputButton btn;
 706
 707     if (scroll->direction == GDK_SCROLL_UP) {
 708         btn = INPUT_BUTTON_WHEEL_UP;
 709     } else if (scroll->direction == GDK_SCROLL_DOWN) {
 710         btn = INPUT_BUTTON_WHEEL_DOWN;
 711     } else {
 712         return TRUE;
 713     }
 714
 715     qemu_input_queue_btn(s->dcl.con, btn, true);
 716     qemu_input_event_sync();
 717     qemu_input_queue_btn(s->dcl.con, btn, false);
 718     qemu_input_event_sync();
 719     return TRUE;
 720 }
 721
 722 static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
 723 {
 724     GtkDisplayState *s = opaque;
 725     int gdk_keycode = key->hardware_keycode;
 726     int i;
 727
 728 #ifdef _WIN32
 729     UINT qemu_keycode = MapVirtualKey(gdk_keycode, MAPVK_VK_TO_VSC);
 730     switch (qemu_keycode) {
 731     case 103:   /* alt gr */
 732         qemu_keycode = 56 | SCANCODE_GREY;
 733         break;
 734     }
 735 #else
 736     int qemu_keycode;
 737
 738     if (gdk_keycode < 9) {
 739         qemu_keycode = 0;
 740     } else if (gdk_keycode < 97) {
 741         qemu_keycode = gdk_keycode - 8;
 742     } else if (gdk_keycode < 158) {
 743         qemu_keycode = translate_evdev_keycode(gdk_keycode - 97);
 744     } else if (gdk_keycode == 208) { /* Hiragana_Katakana */
 745         qemu_keycode = 0x70;
 746     } else if (gdk_keycode == 211) { /* backslash */
 747         qemu_keycode = 0x73;
 748     } else {
 749         qemu_keycode = 0;
 750     }
 751 #endif
 752
 753     trace_gd_key_event(gdk_keycode, qemu_keycode,
 754                        (key->type == GDK_KEY_PRESS) ? "down" : "up");
 755
 756     for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) {
 757         if (qemu_keycode == modifier_keycode[i]) {
 758             s->modifier_pressed[i] = (key->type == GDK_KEY_PRESS);
 759         }
 760     }
 761
 762     qemu_input_event_send_key_number(s->dcl.con, qemu_keycode,
 763                                      key->type == GDK_KEY_PRESS);
 764
 765     return TRUE;
 766 }
 767
 768 /** Window Menu Actions **/
 769
 770 static void gd_menu_pause(GtkMenuItem *item, void *opaque)
 771 {
 772     GtkDisplayState *s = opaque;
 773
 774     if (s->external_pause_update) {
 775         return;
 776     }
 777     if (runstate_is_running()) {
 778         qmp_stop(NULL);
 779     } else {
 780         qmp_cont(NULL);
 781     }
 782 }
 783
 784 static void gd_menu_reset(GtkMenuItem *item, void *opaque)
 785 {
 786     qmp_system_reset(NULL);
 787 }
 788
 789 static void gd_menu_powerdown(GtkMenuItem *item, void *opaque)
 790 {
 791     qmp_system_powerdown(NULL);
 792 }
 793
 794 static void gd_menu_quit(GtkMenuItem *item, void *opaque)
 795 {
 796     qmp_quit(NULL);
 797 }
 798
 799 static void gd_menu_switch_vc(GtkMenuItem *item, void *opaque)
 800 {
 801     GtkDisplayState *s = opaque;
 802
 803     if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->vga_item))) {
 804         gtk_notebook_set_current_page(GTK_NOTEBOOK(s->notebook), 0);
 805     } else {
 806         int i;
 807
 808         gtk_release_modifiers(s);
 809         for (i = 0; i < s->nb_vcs; i++) {
 810             if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->vc[i].menu_item))) {
 811                 gtk_notebook_set_current_page(GTK_NOTEBOOK(s->notebook), i + 1);
 812                 break;
 813             }
 814         }
 815     }
 816 }
 817
 818 static void gd_menu_show_tabs(GtkMenuItem *item, void *opaque)
 819 {
 820     GtkDisplayState *s = opaque;
 821
 822     if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->show_tabs_item))) {
 823         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), TRUE);
 824     } else {
 825         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
 826     }
 827 }
 828
 829 static void gd_menu_full_screen(GtkMenuItem *item, void *opaque)
 830 {
 831     GtkDisplayState *s = opaque;
 832
 833     if (!s->full_screen) {
 834         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
 835         gtk_widget_set_size_request(s->menu_bar, 0, 0);
 836         gtk_widget_set_size_request(s->drawing_area, -1, -1);
 837         gtk_window_fullscreen(GTK_WINDOW(s->window));
 838         if (gd_on_vga(s)) {
 839             gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), TRUE);
 840         }
 841         s->full_screen = TRUE;
 842     } else {
 843         gtk_window_unfullscreen(GTK_WINDOW(s->window));
 844         gd_menu_show_tabs(GTK_MENU_ITEM(s->show_tabs_item), s);
 845         gtk_widget_set_size_request(s->menu_bar, -1, -1);
 846         gtk_widget_set_size_request(s->drawing_area,
 847                                     surface_width(s->ds),
 848                                     surface_height(s->ds));
 849         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), FALSE);
 850         s->full_screen = FALSE;
 851         s->scale_x = 1.0;
 852         s->scale_y = 1.0;
 853     }
 854
 855     gd_update_cursor(s, FALSE);
 856 }
 857
 858 static void gd_menu_zoom_in(GtkMenuItem *item, void *opaque)
 859 {
 860     GtkDisplayState *s = opaque;
 861
 862     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item),
 863                                    FALSE);
 864
 865     s->scale_x += .25;
 866     s->scale_y += .25;
 867
 868     gd_update_windowsize(s);
 869 }
 870
 871 static void gd_menu_zoom_out(GtkMenuItem *item, void *opaque)
 872 {
 873     GtkDisplayState *s = opaque;
 874
 875     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item),
 876                                    FALSE);
 877
 878     s->scale_x -= .25;
 879     s->scale_y -= .25;
 880
 881     s->scale_x = MAX(s->scale_x, .25);
 882     s->scale_y = MAX(s->scale_y, .25);
 883
 884     gd_update_windowsize(s);
 885 }
 886
 887 static void gd_menu_zoom_fixed(GtkMenuItem *item, void *opaque)
 888 {
 889     GtkDisplayState *s = opaque;
 890
 891     s->scale_x = 1.0;
 892     s->scale_y = 1.0;
 893
 894     gd_update_windowsize(s);
 895 }
 896
 897 static void gd_menu_zoom_fit(GtkMenuItem *item, void *opaque)
 898 {
 899     GtkDisplayState *s = opaque;
 900
 901     if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item))) {
 902         s->free_scale = TRUE;
 903     } else {
 904         s->free_scale = FALSE;
 905         s->scale_x = 1.0;
 906         s->scale_y = 1.0;
 907         gd_update_windowsize(s);
 908     }
 909
 910     gd_update_full_redraw(s);
 911 }
 912
 913 static void gd_grab_keyboard(GtkDisplayState *s)
 914 {
 915 #if GTK_CHECK_VERSION(3, 0, 0)
 916     GdkDisplay *display = gtk_widget_get_display(s->drawing_area);
 917     GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
 918     GList *devices = gdk_device_manager_list_devices(mgr,
 919                                                      GDK_DEVICE_TYPE_MASTER);
 920     GList *tmp = devices;
 921     while (tmp) {
 922         GdkDevice *dev = tmp->data;
 923         if (gdk_device_get_source(dev) == GDK_SOURCE_KEYBOARD) {
 924             gdk_device_grab(dev,
 925                             gtk_widget_get_window(s->drawing_area),
 926                             GDK_OWNERSHIP_NONE,
 927                             FALSE,
 928                             GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
 929                             NULL,
 930                             GDK_CURRENT_TIME);
 931         }
 932         tmp = tmp->next;
 933     }
 934     g_list_free(devices);
 935 #else
 936     gdk_keyboard_grab(gtk_widget_get_window(s->drawing_area),
 937                       FALSE,
 938                       GDK_CURRENT_TIME);
 939 #endif
 940 }
 941
 942 static void gd_ungrab_keyboard(GtkDisplayState *s)
 943 {
 944 #if GTK_CHECK_VERSION(3, 0, 0)
 945     GdkDisplay *display = gtk_widget_get_display(s->drawing_area);
 946     GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
 947     GList *devices = gdk_device_manager_list_devices(mgr,
 948                                                      GDK_DEVICE_TYPE_MASTER);
 949     GList *tmp = devices;
 950     while (tmp) {
 951         GdkDevice *dev = tmp->data;
 952         if (gdk_device_get_source(dev) == GDK_SOURCE_KEYBOARD) {
 953             gdk_device_ungrab(dev,
 954                               GDK_CURRENT_TIME);
 955         }
 956         tmp = tmp->next;
 957     }
 958     g_list_free(devices);
 959 #else
 960     gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 961 #endif
 962 }
 963
 964 static void gd_grab_pointer(GtkDisplayState *s)
 965 {
 966 #if GTK_CHECK_VERSION(3, 0, 0)
 967     GdkDisplay *display = gtk_widget_get_display(s->drawing_area);
 968     GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
 969     GList *devices = gdk_device_manager_list_devices(mgr,
 970                                                      GDK_DEVICE_TYPE_MASTER);
 971     GList *tmp = devices;
 972     while (tmp) {
 973         GdkDevice *dev = tmp->data;
 974         if (gdk_device_get_source(dev) == GDK_SOURCE_MOUSE) {
 975             gdk_device_grab(dev,
 976                             gtk_widget_get_window(s->drawing_area),
 977                             GDK_OWNERSHIP_NONE,
 978                             FALSE, /* All events to come to our
 979                                       window directly */
 980                             GDK_POINTER_MOTION_MASK |
 981                             GDK_BUTTON_PRESS_MASK |
 982                             GDK_BUTTON_RELEASE_MASK |
 983                             GDK_BUTTON_MOTION_MASK |
 984                             GDK_SCROLL_MASK,
 985                             s->null_cursor,
 986                             GDK_CURRENT_TIME);
 987         }
 988         tmp = tmp->next;
 989     }
 990     g_list_free(devices);
 991 #else
 992     gdk_pointer_grab(gtk_widget_get_window(s->drawing_area),
 993                      FALSE, /* All events to come to our window directly */
 994                      GDK_POINTER_MOTION_MASK |
 995                      GDK_BUTTON_PRESS_MASK |
 996                      GDK_BUTTON_RELEASE_MASK |
 997                      GDK_BUTTON_MOTION_MASK |
 998                      GDK_SCROLL_MASK,
 999                      NULL, /* Allow cursor to move over entire desktop */
1000                      s->null_cursor,
1001                      GDK_CURRENT_TIME);
1002 #endif
1003 }
1004
1005 static void gd_ungrab_pointer(GtkDisplayState *s)
1006 {
1007 #if GTK_CHECK_VERSION(3, 0, 0)
1008     GdkDisplay *display = gtk_widget_get_display(s->drawing_area);
1009     GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
1010     GList *devices = gdk_device_manager_list_devices(mgr,
1011                                                      GDK_DEVICE_TYPE_MASTER);
1012     GList *tmp = devices;
1013     while (tmp) {
1014         GdkDevice *dev = tmp->data;
1015         if (gdk_device_get_source(dev) == GDK_SOURCE_MOUSE) {
1016             gdk_device_ungrab(dev,
1017                               GDK_CURRENT_TIME);
1018         }
1019         tmp = tmp->next;
1020     }
1021     g_list_free(devices);
1022 #else
1023     gdk_pointer_ungrab(GDK_CURRENT_TIME);
1024 #endif
1025 }
1026
1027 static void gd_menu_grab_input(GtkMenuItem *item, void *opaque)
1028 {
1029     GtkDisplayState *s = opaque;
1030
1031     if (gd_is_grab_active(s)) {
1032         gd_grab_keyboard(s);
1033         gd_grab_pointer(s);
1034     } else {
1035         gd_ungrab_keyboard(s);
1036         gd_ungrab_pointer(s);
1037     }
1038
1039     gd_update_caption(s);
1040     gd_update_cursor(s, FALSE);
1041 }
1042
1043 static void gd_change_page(GtkNotebook *nb, gpointer arg1, guint arg2,
1044                            gpointer data)
1045 {
1046     GtkDisplayState *s = data;
1047     guint last_page;
1048     gboolean on_vga;
1049
1050     if (!gtk_widget_get_realized(s->notebook)) {
1051         return;
1052     }
1053
1054     last_page = gtk_notebook_get_current_page(nb);
1055
1056     if (last_page) {
1057         gtk_widget_set_size_request(s->vc[last_page - 1].terminal, -1, -1);
1058     }
1059
1060     on_vga = arg2 == 0;
1061
1062     if (!on_vga) {
1063         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
1064                                        FALSE);
1065     } else if (s->full_screen) {
1066         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
1067                                        TRUE);
1068     }
1069
1070     if (arg2 == 0) {
1071         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->vga_item), TRUE);
1072     } else {
1073 #if defined(CONFIG_VTE)
1074         VirtualConsole *vc = &s->vc[arg2 - 1];
1075         VteTerminal *term = VTE_TERMINAL(vc->terminal);
1076         int width, height;
1077
1078         width = 80 * vte_terminal_get_char_width(term);
1079         height = 25 * vte_terminal_get_char_height(term);
1080
1081         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), TRUE);
1082         gtk_widget_set_size_request(vc->terminal, width, height);
1083 #else
1084         g_assert_not_reached();
1085 #endif
1086     }
1087
1088     gtk_widget_set_sensitive(s->grab_item, on_vga);
1089
1090     gd_update_cursor(s, TRUE);
1091 }
1092
1093 static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing, gpointer data)
1094 {
1095     GtkDisplayState *s = data;
1096
1097     if (!gd_is_grab_active(s) && gd_grab_on_hover(s)) {
1098         gd_grab_keyboard(s);
1099     }
1100
1101     return TRUE;
1102 }
1103
1104 static gboolean gd_leave_event(GtkWidget *widget, GdkEventCrossing *crossing, gpointer data)
1105 {
1106     GtkDisplayState *s = data;
1107
1108     if (!gd_is_grab_active(s) && gd_grab_on_hover(s)) {
1109         gd_ungrab_keyboard(s);
1110     }
1111
1112     return TRUE;
1113 }
1114
1115 static gboolean gd_focus_out_event(GtkWidget *widget,
1116                                    GdkEventCrossing *crossing, gpointer data)
1117 {
1118     GtkDisplayState *s = data;
1119
1120     gtk_release_modifiers(s);
1121
1122     return TRUE;
1123 }
1124
1125 /** Virtual Console Callbacks **/
1126
1127 static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1128 {
1129     VirtualConsole *vc = chr->opaque;
1130
1131     return vc ? write(vc->fd, buf, len) : len;
1132 }
1133
1134 static int nb_vcs;
1135 static CharDriverState *vcs[MAX_VCS];
1136
1137 static CharDriverState *gd_vc_handler(ChardevVC *unused)
1138 {
1139     CharDriverState *chr;
1140
1141     chr = g_malloc0(sizeof(*chr));
1142     chr->chr_write = gd_vc_chr_write;
1143     /* defer OPENED events until our vc is fully initialized */
1144     chr->explicit_be_open = true;
1145
1146     vcs[nb_vcs++] = chr;
1147
1148     return chr;
1149 }
1150
1151 void early_gtk_display_init(void)
1152 {
1153     register_vc_handler(gd_vc_handler);
1154 }
1155
1156 #if defined(CONFIG_VTE)
1157 static gboolean gd_vc_in(GIOChannel *chan, GIOCondition cond, void *opaque)
1158 {
1159     VirtualConsole *vc = opaque;
1160     uint8_t buffer[1024];
1161     ssize_t len;
1162
1163     len = read(vc->fd, buffer, sizeof(buffer));
1164     if (len <= 0) {
1165         return FALSE;
1166     }
1167
1168     qemu_chr_be_write(vc->chr, buffer, len);
1169
1170     return TRUE;
1171 }
1172 #endif
1173
1174 static GSList *gd_vc_init(GtkDisplayState *s, VirtualConsole *vc, int index, GSList *group,
1175                           GtkWidget *view_menu)
1176 {
1177 #if defined(CONFIG_VTE)
1178     const char *label;
1179     char buffer[32];
1180     char path[32];
1181 #if VTE_CHECK_VERSION(0, 26, 0)
1182     VtePty *pty;
1183 #endif
1184     GIOChannel *chan;
1185     GtkWidget *scrolled_window;
1186     GtkAdjustment *vadjustment;
1187     int master_fd, slave_fd;
1188
1189     snprintf(buffer, sizeof(buffer), "vc%d", index);
1190     snprintf(path, sizeof(path), "<QEMU>/View/VC%d", index);
1191
1192     vc->chr = vcs[index];
1193
1194     if (vc->chr->label) {
1195         label = vc->chr->label;
1196     } else {
1197         label = buffer;
1198     }
1199
1200     vc->menu_item = gtk_radio_menu_item_new_with_mnemonic(group, label);
1201     group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(vc->menu_item));
1202     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(vc->menu_item), path);
1203     gtk_accel_map_add_entry(path, GDK_KEY_2 + index, HOTKEY_MODIFIERS);
1204
1205     vc->terminal = vte_terminal_new();
1206
1207     master_fd = qemu_openpty_raw(&slave_fd, NULL);
1208     g_assert(master_fd != -1);
1209
1210 #if VTE_CHECK_VERSION(0, 26, 0)
1211     pty = vte_pty_new_foreign(master_fd, NULL);
1212     vte_terminal_set_pty_object(VTE_TERMINAL(vc->terminal), pty);
1213 #else
1214     vte_terminal_set_pty(VTE_TERMINAL(vc->terminal), master_fd);
1215 #endif
1216
1217     vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->terminal), -1);
1218
1219     vadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->terminal));
1220
1221     scrolled_window = gtk_scrolled_window_new(NULL, vadjustment);
1222     gtk_container_add(GTK_CONTAINER(scrolled_window), vc->terminal);
1223
1224     vte_terminal_set_size(VTE_TERMINAL(vc->terminal), 80, 25);
1225
1226     vc->fd = slave_fd;
1227     vc->chr->opaque = vc;
1228     vc->scrolled_window = scrolled_window;
1229
1230     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vc->scrolled_window),
1231                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1232
1233     gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), scrolled_window, gtk_label_new(label));
1234     g_signal_connect(vc->menu_item, "activate",
1235                      G_CALLBACK(gd_menu_switch_vc), s);
1236
1237     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), vc->menu_item);
1238
1239     qemu_chr_be_generic_open(vc->chr);
1240     if (vc->chr->init) {
1241         vc->chr->init(vc->chr);
1242     }
1243
1244     chan = g_io_channel_unix_new(vc->fd);
1245     g_io_add_watch(chan, G_IO_IN, gd_vc_in, vc);
1246
1247 #endif /* CONFIG_VTE */
1248     return group;
1249 }
1250
1251 /** Window Creation **/
1252
1253 static void gd_connect_signals(GtkDisplayState *s)
1254 {
1255     g_signal_connect(s->show_tabs_item, "activate",
1256                      G_CALLBACK(gd_menu_show_tabs), s);
1257
1258     g_signal_connect(s->window, "key-press-event",
1259                      G_CALLBACK(gd_window_key_event), s);
1260     g_signal_connect(s->window, "delete-event",
1261                      G_CALLBACK(gd_window_close), s);
1262
1263 #if GTK_CHECK_VERSION(3, 0, 0)
1264     g_signal_connect(s->drawing_area, "draw",
1265                      G_CALLBACK(gd_draw_event), s);
1266 #else
1267     g_signal_connect(s->drawing_area, "expose-event",
1268                      G_CALLBACK(gd_expose_event), s);
1269 #endif
1270     g_signal_connect(s->drawing_area, "motion-notify-event",
1271                      G_CALLBACK(gd_motion_event), s);
1272     g_signal_connect(s->drawing_area, "button-press-event",
1273                      G_CALLBACK(gd_button_event), s);
1274     g_signal_connect(s->drawing_area, "button-release-event",
1275                      G_CALLBACK(gd_button_event), s);
1276     g_signal_connect(s->drawing_area, "scroll-event",
1277                      G_CALLBACK(gd_scroll_event), s);
1278     g_signal_connect(s->drawing_area, "key-press-event",
1279                      G_CALLBACK(gd_key_event), s);
1280     g_signal_connect(s->drawing_area, "key-release-event",
1281                      G_CALLBACK(gd_key_event), s);
1282
1283     g_signal_connect(s->pause_item, "activate",
1284                      G_CALLBACK(gd_menu_pause), s);
1285     g_signal_connect(s->reset_item, "activate",
1286                      G_CALLBACK(gd_menu_reset), s);
1287     g_signal_connect(s->powerdown_item, "activate",
1288                      G_CALLBACK(gd_menu_powerdown), s);
1289     g_signal_connect(s->quit_item, "activate",
1290                      G_CALLBACK(gd_menu_quit), s);
1291     g_signal_connect(s->full_screen_item, "activate",
1292                      G_CALLBACK(gd_menu_full_screen), s);
1293     g_signal_connect(s->zoom_in_item, "activate",
1294                      G_CALLBACK(gd_menu_zoom_in), s);
1295     g_signal_connect(s->zoom_out_item, "activate",
1296                      G_CALLBACK(gd_menu_zoom_out), s);
1297     g_signal_connect(s->zoom_fixed_item, "activate",
1298                      G_CALLBACK(gd_menu_zoom_fixed), s);
1299     g_signal_connect(s->zoom_fit_item, "activate",
1300                      G_CALLBACK(gd_menu_zoom_fit), s);
1301     g_signal_connect(s->vga_item, "activate",
1302                      G_CALLBACK(gd_menu_switch_vc), s);
1303     g_signal_connect(s->grab_item, "activate",
1304                      G_CALLBACK(gd_menu_grab_input), s);
1305     g_signal_connect(s->notebook, "switch-page",
1306                      G_CALLBACK(gd_change_page), s);
1307     g_signal_connect(s->drawing_area, "enter-notify-event",
1308                      G_CALLBACK(gd_enter_event), s);
1309     g_signal_connect(s->drawing_area, "leave-notify-event",
1310                      G_CALLBACK(gd_leave_event), s);
1311     g_signal_connect(s->drawing_area, "focus-out-event",
1312                      G_CALLBACK(gd_focus_out_event), s);
1313 }
1314
1315 static GtkWidget *gd_create_menu_machine(GtkDisplayState *s, GtkAccelGroup *accel_group)
1316 {
1317     GtkWidget *machine_menu;
1318     GtkWidget *separator;
1319     GtkStockItem item;
1320
1321     machine_menu = gtk_menu_new();
1322     gtk_menu_set_accel_group(GTK_MENU(machine_menu), accel_group);
1323
1324     s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause"));
1325     gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->pause_item);
1326
1327     separator = gtk_separator_menu_item_new();
1328     gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
1329
1330     s->reset_item = gtk_image_menu_item_new_with_mnemonic(_("_Reset"));
1331     gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->reset_item);
1332
1333     s->powerdown_item = gtk_image_menu_item_new_with_mnemonic(_("Power _Down"));
1334     gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->powerdown_item);
1335
1336     separator = gtk_separator_menu_item_new();
1337     gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
1338
1339     s->quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
1340     gtk_stock_lookup(GTK_STOCK_QUIT, &item);
1341     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item),
1342                                  "<QEMU>/Machine/Quit");
1343     gtk_accel_map_add_entry("<QEMU>/Machine/Quit", item.keyval, item.modifier);
1344     gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->quit_item);
1345
1346     return machine_menu;
1347 }
1348
1349 static GtkWidget *gd_create_menu_view(GtkDisplayState *s, GtkAccelGroup *accel_group)
1350 {
1351     GSList *group = NULL;
1352     GtkWidget *view_menu;
1353     GtkWidget *separator;
1354     int i;
1355
1356     view_menu = gtk_menu_new();
1357     gtk_menu_set_accel_group(GTK_MENU(view_menu), accel_group);
1358
1359     s->full_screen_item =
1360         gtk_image_menu_item_new_from_stock(GTK_STOCK_FULLSCREEN, NULL);
1361     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->full_screen_item),
1362                                  "<QEMU>/View/Full Screen");
1363     gtk_accel_map_add_entry("<QEMU>/View/Full Screen", GDK_KEY_f,
1364                             HOTKEY_MODIFIERS);
1365     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->full_screen_item);
1366
1367     separator = gtk_separator_menu_item_new();
1368     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1369
1370     s->zoom_in_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
1371     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_in_item),
1372                                  "<QEMU>/View/Zoom In");
1373     gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus,
1374                             HOTKEY_MODIFIERS);
1375     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_in_item);
1376
1377     s->zoom_out_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
1378     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_out_item),
1379                                  "<QEMU>/View/Zoom Out");
1380     gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus,
1381                             HOTKEY_MODIFIERS);
1382     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_out_item);
1383
1384     s->zoom_fixed_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
1385     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_fixed_item),
1386                                  "<QEMU>/View/Zoom Fixed");
1387     gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0,
1388                             HOTKEY_MODIFIERS);
1389     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fixed_item);
1390
1391     s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit"));
1392     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fit_item);
1393
1394     separator = gtk_separator_menu_item_new();
1395     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1396
1397     s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover"));
1398     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_on_hover_item);
1399
1400     s->grab_item = gtk_check_menu_item_new_with_mnemonic(_("_Grab Input"));
1401     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->grab_item),
1402                                  "<QEMU>/View/Grab Input");
1403     gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g,
1404                             HOTKEY_MODIFIERS);
1405     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_item);
1406
1407     separator = gtk_separator_menu_item_new();
1408     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1409
1410     s->vga_item = gtk_radio_menu_item_new_with_mnemonic(group, "_VGA");
1411     group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(s->vga_item));
1412     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->vga_item),
1413                                  "<QEMU>/View/VGA");
1414     gtk_accel_map_add_entry("<QEMU>/View/VGA", GDK_KEY_1, HOTKEY_MODIFIERS);
1415     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->vga_item);
1416
1417     for (i = 0; i < nb_vcs; i++) {
1418         VirtualConsole *vc = &s->vc[i];
1419
1420         group = gd_vc_init(s, vc, i, group, view_menu);
1421         s->nb_vcs++;
1422     }
1423
1424     separator = gtk_separator_menu_item_new();
1425     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1426
1427     s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs"));
1428     gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_tabs_item);
1429
1430     return view_menu;
1431 }
1432
1433 static void gd_create_menus(GtkDisplayState *s)
1434 {
1435     GtkAccelGroup *accel_group;
1436
1437     accel_group = gtk_accel_group_new();
1438     s->machine_menu = gd_create_menu_machine(s, accel_group);
1439     s->view_menu = gd_create_menu_view(s, accel_group);
1440
1441     s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine"));
1442     gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->machine_menu_item),
1443                               s->machine_menu);
1444     gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->machine_menu_item);
1445
1446     s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View"));
1447     gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->view_menu_item), s->view_menu);
1448     gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item);
1449
1450     g_object_set_data(G_OBJECT(s->window), "accel_group", accel_group);
1451     gtk_window_add_accel_group(GTK_WINDOW(s->window), accel_group);
1452     s->accel_group = accel_group;
1453 }
1454
1455 static const DisplayChangeListenerOps dcl_ops = {
1456     .dpy_name          = "gtk",
1457     .dpy_gfx_update    = gd_update,
1458     .dpy_gfx_switch    = gd_switch,
1459     .dpy_refresh       = gd_refresh,
1460     .dpy_mouse_set     = gd_mouse_set,
1461     .dpy_cursor_define = gd_cursor_define,
1462 };
1463
1464 void gtk_display_init(DisplayState *ds, bool full_screen, bool grab_on_hover)
1465 {
1466     GtkDisplayState *s = g_malloc0(sizeof(*s));
1467     char *filename;
1468
1469     gtk_init(NULL, NULL);
1470
1471     s->dcl.ops = &dcl_ops;
1472     s->dcl.con = qemu_console_lookup_by_index(0);
1473
1474     s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1475 #if GTK_CHECK_VERSION(3, 2, 0)
1476     s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
1477 #else
1478     s->vbox = gtk_vbox_new(FALSE, 0);
1479 #endif
1480     s->notebook = gtk_notebook_new();
1481     s->drawing_area = gtk_drawing_area_new();
1482     s->menu_bar = gtk_menu_bar_new();
1483
1484     s->scale_x = 1.0;
1485     s->scale_y = 1.0;
1486     s->free_scale = FALSE;
1487
1488     setlocale(LC_ALL, "");
1489     bindtextdomain("qemu", CONFIG_QEMU_LOCALEDIR);
1490     textdomain("qemu");
1491
1492     s->null_cursor = gdk_cursor_new(GDK_BLANK_CURSOR);
1493
1494     s->mouse_mode_notifier.notify = gd_mouse_mode_change;
1495     qemu_add_mouse_mode_change_notifier(&s->mouse_mode_notifier);
1496     qemu_add_vm_change_state_handler(gd_change_runstate, s);
1497
1498     gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), s->drawing_area, gtk_label_new("VGA"));
1499
1500     filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu_logo_no_text.svg");
1501     if (filename) {
1502         GError *error = NULL;
1503         GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(filename, &error);
1504         if (pixbuf) {
1505             gtk_window_set_icon(GTK_WINDOW(s->window), pixbuf);
1506         } else {
1507             g_error_free(error);
1508         }
1509         g_free(filename);
1510     }
1511
1512     gd_create_menus(s);
1513
1514     gd_connect_signals(s);
1515
1516     gtk_widget_add_events(s->drawing_area,
1517                           GDK_POINTER_MOTION_MASK |
1518                           GDK_BUTTON_PRESS_MASK |
1519                           GDK_BUTTON_RELEASE_MASK |
1520                           GDK_BUTTON_MOTION_MASK |
1521                           GDK_ENTER_NOTIFY_MASK |
1522                           GDK_LEAVE_NOTIFY_MASK |
1523                           GDK_SCROLL_MASK |
1524                           GDK_KEY_PRESS_MASK);
1525     gtk_widget_set_double_buffered(s->drawing_area, FALSE);
1526     gtk_widget_set_can_focus(s->drawing_area, TRUE);
1527
1528     gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
1529     gtk_notebook_set_show_border(GTK_NOTEBOOK(s->notebook), FALSE);
1530
1531     gd_update_caption(s);
1532
1533     gtk_box_pack_start(GTK_BOX(s->vbox), s->menu_bar, FALSE, TRUE, 0);
1534     gtk_box_pack_start(GTK_BOX(s->vbox), s->notebook, TRUE, TRUE, 0);
1535
1536     gtk_container_add(GTK_CONTAINER(s->window), s->vbox);
1537
1538     gtk_widget_show_all(s->window);
1539
1540     if (full_screen) {
1541         gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item));
1542     }
1543     if (grab_on_hover) {
1544         gtk_menu_item_activate(GTK_MENU_ITEM(s->grab_on_hover_item));
1545     }
1546
1547     register_displaychangelistener(&s->dcl);
1548
1549     global_state = s;
1550 }