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 #include <gtk/gtk.h>
  35 #include <gdk/gdkkeysyms.h>
  36 #include <vte/vte.h>
  37 #include <sys/types.h>
  38 #include <sys/socket.h>
  39 #include <sys/un.h>
  40 #include <sys/wait.h>
  41 #include <pty.h>
  42 #include <math.h>
  43
  44 #include "qemu-common.h"
  45 #include "ui/console.h"
  46 #include "sysemu/sysemu.h"
  47 #include "qmp-commands.h"
  48 #include "x_keymap.h"
  49 #include "keymaps.h"
  50
  51 //#define DEBUG_GTK
  52
  53 #ifdef DEBUG_GTK
  54 #define DPRINTF(fmt, ...) printf(fmt, ## __VA_ARGS__)
  55 #else
  56 #define DPRINTF(fmt, ...) do { } while (0)
  57 #endif
  58
  59 typedef struct VirtualConsole
  60 {
  61     GtkWidget *menu_item;
  62     GtkWidget *terminal;
  63     GtkWidget *scrolled_window;
  64     CharDriverState *chr;
  65     int fd;
  66 } VirtualConsole;
  67
  68 typedef struct GtkDisplayState
  69 {
  70     GtkWidget *window;
  71
  72     GtkWidget *menu_bar;
  73
  74     GtkWidget *file_menu_item;
  75     GtkWidget *file_menu;
  76     GtkWidget *quit_item;
  77
  78     GtkWidget *view_menu_item;
  79     GtkWidget *view_menu;
  80     GtkWidget *vga_item;
  81
  82     GtkWidget *show_tabs_item;
  83
  84     GtkWidget *vbox;
  85     GtkWidget *notebook;
  86     GtkWidget *drawing_area;
  87     cairo_surface_t *surface;
  88     DisplayChangeListener dcl;
  89     DisplayState *ds;
  90     int button_mask;
  91     int last_x;
  92     int last_y;
  93
  94     double scale_x;
  95     double scale_y;
  96
  97     GdkCursor *null_cursor;
  98     Notifier mouse_mode_notifier;
  99 } GtkDisplayState;
 100
 101 static GtkDisplayState *global_state;
 102
 103 /** Utility Functions **/
 104
 105 static void gd_update_cursor(GtkDisplayState *s, gboolean override)
 106 {
 107     GdkWindow *window;
 108     bool on_vga;
 109
 110     window = gtk_widget_get_window(GTK_WIDGET(s->drawing_area));
 111
 112     on_vga = (gtk_notebook_get_current_page(GTK_NOTEBOOK(s->notebook)) == 0);
 113
 114     if ((override || on_vga) && kbd_mouse_is_absolute()) {
 115         gdk_window_set_cursor(window, s->null_cursor);
 116     } else {
 117         gdk_window_set_cursor(window, NULL);
 118     }
 119 }
 120
 121 static void gd_update_caption(GtkDisplayState *s)
 122 {
 123     const char *status = "";
 124     gchar *title;
 125
 126     if (!runstate_is_running()) {
 127         status = " [Stopped]";
 128     }
 129
 130     if (qemu_name) {
 131         title = g_strdup_printf("QEMU (%s)%s", qemu_name, status);
 132     } else {
 133         title = g_strdup_printf("QEMU%s", status);
 134     }
 135
 136     gtk_window_set_title(GTK_WINDOW(s->window), title);
 137
 138     g_free(title);
 139 }
 140
 141 /** DisplayState Callbacks **/
 142
 143 static void gd_update(DisplayState *ds, int x, int y, int w, int h)
 144 {
 145     GtkDisplayState *s = ds->opaque;
 146     int x1, x2, y1, y2;
 147
 148     DPRINTF("update(x=%d, y=%d, w=%d, h=%d)\n", x, y, w, h);
 149
 150     x1 = floor(x * s->scale_x);
 151     y1 = floor(y * s->scale_y);
 152
 153     x2 = ceil(x * s->scale_x + w * s->scale_x);
 154     y2 = ceil(y * s->scale_y + h * s->scale_y);
 155
 156     gtk_widget_queue_draw_area(s->drawing_area, x1, y1, (x2 - x1), (y2 - y1));
 157 }
 158
 159 static void gd_refresh(DisplayState *ds)
 160 {
 161     vga_hw_update();
 162 }
 163
 164 static void gd_resize(DisplayState *ds)
 165 {
 166     GtkDisplayState *s = ds->opaque;
 167     cairo_format_t kind;
 168     int stride;
 169
 170     DPRINTF("resize(width=%d, height=%d)\n",
 171             ds_get_width(ds), ds_get_height(ds));
 172
 173     if (s->surface) {
 174         cairo_surface_destroy(s->surface);
 175     }
 176
 177     switch (ds->surface->pf.bits_per_pixel) {
 178     case 8:
 179         kind = CAIRO_FORMAT_A8;
 180         break;
 181     case 16:
 182         kind = CAIRO_FORMAT_RGB16_565;
 183         break;
 184     case 32:
 185         kind = CAIRO_FORMAT_RGB24;
 186         break;
 187     default:
 188         g_assert_not_reached();
 189         break;
 190     }
 191
 192     stride = cairo_format_stride_for_width(kind, ds_get_width(ds));
 193     g_assert(ds_get_linesize(ds) == stride);
 194
 195     s->surface = cairo_image_surface_create_for_data(ds_get_data(ds),
 196                                                      kind,
 197                                                      ds_get_width(ds),
 198                                                      ds_get_height(ds),
 199                                                      ds_get_linesize(ds));
 200
 201     gtk_widget_set_size_request(s->drawing_area,
 202                                 ds_get_width(ds) * s->scale_x,
 203                                 ds_get_height(ds) * s->scale_y);
 204 }
 205
 206 /** QEMU Events **/
 207
 208 static void gd_change_runstate(void *opaque, int running, RunState state)
 209 {
 210     GtkDisplayState *s = opaque;
 211
 212     gd_update_caption(s);
 213 }
 214
 215 static void gd_mouse_mode_change(Notifier *notify, void *data)
 216 {
 217     gd_update_cursor(container_of(notify, GtkDisplayState, mouse_mode_notifier),
 218                      FALSE);
 219 }
 220
 221 /** GTK Events **/
 222
 223 static gboolean gd_window_close(GtkWidget *widget, GdkEvent *event,
 224                                 void *opaque)
 225 {
 226     GtkDisplayState *s = opaque;
 227
 228     if (!no_quit) {
 229         unregister_displaychangelistener(s->ds, &s->dcl);
 230         qmp_quit(NULL);
 231         return FALSE;
 232     }
 233
 234     return TRUE;
 235 }
 236
 237 static gboolean gd_draw_event(GtkWidget *widget, cairo_t *cr, void *opaque)
 238 {
 239     GtkDisplayState *s = opaque;
 240     int ww, wh;
 241     int fbw, fbh;
 242
 243     fbw = ds_get_width(s->ds);
 244     fbh = ds_get_height(s->ds);
 245
 246     gdk_drawable_get_size(gtk_widget_get_window(widget), &ww, &wh);
 247
 248     cairo_rectangle(cr, 0, 0, ww, wh);
 249
 250     if (ww != fbw || wh != fbh) {
 251         s->scale_x = (double)ww / fbw;
 252         s->scale_y = (double)wh / fbh;
 253         cairo_scale(cr, s->scale_x, s->scale_y);
 254     } else {
 255         s->scale_x = 1.0;
 256         s->scale_y = 1.0;
 257     }
 258
 259     cairo_set_source_surface(cr, s->surface, 0, 0);
 260     cairo_paint(cr);
 261
 262     return TRUE;
 263 }
 264
 265 static gboolean gd_expose_event(GtkWidget *widget, GdkEventExpose *expose,
 266                                 void *opaque)
 267 {
 268     cairo_t *cr;
 269     gboolean ret;
 270
 271     cr = gdk_cairo_create(gtk_widget_get_window(widget));
 272     cairo_rectangle(cr,
 273                     expose->area.x,
 274                     expose->area.y,
 275                     expose->area.width,
 276                     expose->area.height);
 277     cairo_clip(cr);
 278
 279     ret = gd_draw_event(widget, cr, opaque);
 280
 281     cairo_destroy(cr);
 282
 283     return ret;
 284 }
 285
 286 static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion,
 287                                 void *opaque)
 288 {
 289     GtkDisplayState *s = opaque;
 290     int dx, dy;
 291     int x, y;
 292
 293     x = motion->x / s->scale_x;
 294     y = motion->y / s->scale_y;
 295
 296     if (kbd_mouse_is_absolute()) {
 297         dx = x * 0x7FFF / (ds_get_width(s->ds) - 1);
 298         dy = y * 0x7FFF / (ds_get_height(s->ds) - 1);
 299     } else if (s->last_x == -1 || s->last_y == -1) {
 300         dx = 0;
 301         dy = 0;
 302     } else {
 303         dx = x - s->last_x;
 304         dy = y - s->last_y;
 305     }
 306
 307     s->last_x = x;
 308     s->last_y = y;
 309
 310     if (kbd_mouse_is_absolute()) {
 311         kbd_mouse_event(dx, dy, 0, s->button_mask);
 312     }
 313
 314     return TRUE;
 315 }
 316
 317 static gboolean gd_button_event(GtkWidget *widget, GdkEventButton *button,
 318                                 void *opaque)
 319 {
 320     GtkDisplayState *s = opaque;
 321     int dx, dy;
 322     int n;
 323
 324     if (button->button == 1) {
 325         n = 0x01;
 326     } else if (button->button == 2) {
 327         n = 0x04;
 328     } else if (button->button == 3) {
 329         n = 0x02;
 330     } else {
 331         n = 0x00;
 332     }
 333
 334     if (button->type == GDK_BUTTON_PRESS) {
 335         s->button_mask |= n;
 336     } else if (button->type == GDK_BUTTON_RELEASE) {
 337         s->button_mask &= ~n;
 338     }
 339
 340     if (kbd_mouse_is_absolute()) {
 341         dx = s->last_x * 0x7FFF / (ds_get_width(s->ds) - 1);
 342         dy = s->last_y * 0x7FFF / (ds_get_height(s->ds) - 1);
 343     } else {
 344         dx = 0;
 345         dy = 0;
 346     }
 347
 348     kbd_mouse_event(dx, dy, 0, s->button_mask);
 349
 350     return TRUE;
 351 }
 352
 353 static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
 354 {
 355     int gdk_keycode;
 356     int qemu_keycode;
 357
 358     gdk_keycode = key->hardware_keycode;
 359
 360     if (gdk_keycode < 9) {
 361         qemu_keycode = 0;
 362     } else if (gdk_keycode < 97) {
 363         qemu_keycode = gdk_keycode - 8;
 364     } else if (gdk_keycode < 158) {
 365         qemu_keycode = translate_evdev_keycode(gdk_keycode - 97);
 366     } else if (gdk_keycode == 208) { /* Hiragana_Katakana */
 367         qemu_keycode = 0x70;
 368     } else if (gdk_keycode == 211) { /* backslash */
 369         qemu_keycode = 0x73;
 370     } else {
 371         qemu_keycode = 0;
 372     }
 373
 374     DPRINTF("translated GDK keycode %d to QEMU keycode %d (%s)\n",
 375             gdk_keycode, qemu_keycode,
 376             (key->type == GDK_KEY_PRESS) ? "down" : "up");
 377
 378     if (qemu_keycode & SCANCODE_GREY) {
 379         kbd_put_keycode(SCANCODE_EMUL0);
 380     }
 381
 382     if (key->type == GDK_KEY_PRESS) {
 383         kbd_put_keycode(qemu_keycode & SCANCODE_KEYCODEMASK);
 384     } else if (key->type == GDK_KEY_RELEASE) {
 385         kbd_put_keycode(qemu_keycode | SCANCODE_UP);
 386     } else {
 387         g_assert_not_reached();
 388     }
 389
 390     return TRUE;
 391 }
 392
 393 /** Window Menu Actions **/
 394
 395 static void gd_menu_quit(GtkMenuItem *item, void *opaque)
 396 {
 397     qmp_quit(NULL);
 398 }
 399
 400 static void gd_menu_switch_vc(GtkMenuItem *item, void *opaque)
 401 {
 402     GtkDisplayState *s = opaque;
 403
 404     if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->vga_item))) {
 405         gtk_notebook_set_current_page(GTK_NOTEBOOK(s->notebook), 0);
 406     }
 407 }
 408
 409 static void gd_menu_show_tabs(GtkMenuItem *item, void *opaque)
 410 {
 411     GtkDisplayState *s = opaque;
 412
 413     if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->show_tabs_item))) {
 414         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), TRUE);
 415     } else {
 416         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
 417     }
 418 }
 419
 420 static void gd_change_page(GtkNotebook *nb, gpointer arg1, guint arg2,
 421                            gpointer data)
 422 {
 423     GtkDisplayState *s = data;
 424
 425     if (!gtk_widget_get_realized(s->notebook)) {
 426         return;
 427     }
 428
 429     gd_update_cursor(s, TRUE);
 430 }
 431
 432 void early_gtk_display_init(void)
 433 {
 434 }
 435
 436 /** Window Creation **/
 437
 438 static void gd_connect_signals(GtkDisplayState *s)
 439 {
 440     g_signal_connect(s->show_tabs_item, "activate",
 441                      G_CALLBACK(gd_menu_show_tabs), s);
 442
 443     g_signal_connect(s->window, "delete-event",
 444                      G_CALLBACK(gd_window_close), s);
 445
 446     g_signal_connect(s->drawing_area, "expose-event",
 447                      G_CALLBACK(gd_expose_event), s);
 448     g_signal_connect(s->drawing_area, "motion-notify-event",
 449                      G_CALLBACK(gd_motion_event), s);
 450     g_signal_connect(s->drawing_area, "button-press-event",
 451                      G_CALLBACK(gd_button_event), s);
 452     g_signal_connect(s->drawing_area, "button-release-event",
 453                      G_CALLBACK(gd_button_event), s);
 454     g_signal_connect(s->drawing_area, "key-press-event",
 455                      G_CALLBACK(gd_key_event), s);
 456     g_signal_connect(s->drawing_area, "key-release-event",
 457                      G_CALLBACK(gd_key_event), s);
 458
 459     g_signal_connect(s->quit_item, "activate",
 460                      G_CALLBACK(gd_menu_quit), s);
 461     g_signal_connect(s->vga_item, "activate",
 462                      G_CALLBACK(gd_menu_switch_vc), s);
 463     g_signal_connect(s->notebook, "switch-page",
 464                      G_CALLBACK(gd_change_page), s);
 465 }
 466
 467 static void gd_create_menus(GtkDisplayState *s)
 468 {
 469     GtkStockItem item;
 470     GtkAccelGroup *accel_group;
 471     GSList *group = NULL;
 472     GtkWidget *separator;
 473
 474     accel_group = gtk_accel_group_new();
 475     s->file_menu = gtk_menu_new();
 476     gtk_menu_set_accel_group(GTK_MENU(s->file_menu), accel_group);
 477     s->file_menu_item = gtk_menu_item_new_with_mnemonic("_File");
 478
 479     s->quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
 480     gtk_stock_lookup(GTK_STOCK_QUIT, &item);
 481     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item),
 482                                  "<QEMU>/File/Quit");
 483     gtk_accel_map_add_entry("<QEMU>/File/Quit", item.keyval, item.modifier);
 484
 485     s->view_menu = gtk_menu_new();
 486     gtk_menu_set_accel_group(GTK_MENU(s->view_menu), accel_group);
 487     s->view_menu_item = gtk_menu_item_new_with_mnemonic("_View");
 488
 489     separator = gtk_separator_menu_item_new();
 490     gtk_menu_append(GTK_MENU(s->view_menu), separator);
 491
 492     s->vga_item = gtk_radio_menu_item_new_with_mnemonic(group, "_VGA");
 493     group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(s->vga_item));
 494     gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->vga_item),
 495                                  "<QEMU>/View/VGA");
 496     gtk_accel_map_add_entry("<QEMU>/View/VGA", GDK_KEY_1, GDK_CONTROL_MASK | GDK_MOD1_MASK);
 497     gtk_menu_append(GTK_MENU(s->view_menu), s->vga_item);
 498
 499     separator = gtk_separator_menu_item_new();
 500     gtk_menu_append(GTK_MENU(s->view_menu), separator);
 501
 502     s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic("Show _Tabs");
 503     gtk_menu_append(GTK_MENU(s->view_menu), s->show_tabs_item);
 504
 505     g_object_set_data(G_OBJECT(s->window), "accel_group", accel_group);
 506     gtk_window_add_accel_group(GTK_WINDOW(s->window), accel_group);
 507
 508     gtk_menu_append(GTK_MENU(s->file_menu), s->quit_item);
 509     gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->file_menu_item), s->file_menu);
 510     gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->file_menu_item);
 511
 512     gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->view_menu_item), s->view_menu);
 513     gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item);
 514 }
 515
 516 void gtk_display_init(DisplayState *ds)
 517 {
 518     GtkDisplayState *s = g_malloc0(sizeof(*s));
 519
 520     gtk_init(NULL, NULL);
 521
 522     ds->opaque = s;
 523     s->ds = ds;
 524     s->dcl.dpy_gfx_update = gd_update;
 525     s->dcl.dpy_gfx_resize = gd_resize;
 526     s->dcl.dpy_refresh = gd_refresh;
 527
 528     s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 529     s->vbox = gtk_vbox_new(FALSE, 0);
 530     s->notebook = gtk_notebook_new();
 531     s->drawing_area = gtk_drawing_area_new();
 532     s->menu_bar = gtk_menu_bar_new();
 533
 534     s->scale_x = 1.0;
 535     s->scale_y = 1.0;
 536
 537     s->null_cursor = gdk_cursor_new(GDK_BLANK_CURSOR);
 538
 539     s->mouse_mode_notifier.notify = gd_mouse_mode_change;
 540     qemu_add_mouse_mode_change_notifier(&s->mouse_mode_notifier);
 541     qemu_add_vm_change_state_handler(gd_change_runstate, s);
 542
 543     gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), s->drawing_area, gtk_label_new("VGA"));
 544
 545     gd_create_menus(s);
 546
 547     gd_connect_signals(s);
 548
 549     gtk_widget_add_events(s->drawing_area,
 550                           GDK_POINTER_MOTION_MASK |
 551                           GDK_BUTTON_PRESS_MASK |
 552                           GDK_BUTTON_RELEASE_MASK |
 553                           GDK_BUTTON_MOTION_MASK |
 554                           GDK_SCROLL_MASK |
 555                           GDK_KEY_PRESS_MASK);
 556     gtk_widget_set_double_buffered(s->drawing_area, FALSE);
 557     gtk_widget_set_can_focus(s->drawing_area, TRUE);
 558
 559     gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
 560     gtk_notebook_set_show_border(GTK_NOTEBOOK(s->notebook), FALSE);
 561
 562     gtk_window_set_resizable(GTK_WINDOW(s->window), FALSE);
 563
 564     gd_update_caption(s);
 565
 566     gtk_box_pack_start(GTK_BOX(s->vbox), s->menu_bar, FALSE, TRUE, 0);
 567     gtk_box_pack_start(GTK_BOX(s->vbox), s->notebook, TRUE, TRUE, 0);
 568
 569     gtk_container_add(GTK_CONTAINER(s->window), s->vbox);
 570
 571     gtk_widget_show_all(s->window);
 572
 573     register_displaychangelistener(ds, &s->dcl);
 574
 575     global_state = s;
 576 }