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