ui/gtk.c

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