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