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 #include "ui/console.h" 40 #include "ui/gtk.h" 41 42 #include <glib/gi18n.h> 43 #include <locale.h> 44 #if defined(CONFIG_VTE) 45 #include <vte/vte.h> 46 #endif 47 #include <math.h> 48 49 #include "trace.h" 50 #include "ui/input.h" 51 #include "sysemu/sysemu.h" 52 #include "qmp-commands.h" 53 #include "x_keymap.h" 54 #include "keymaps.h" 55 #include "sysemu/char.h" 56 #include "qom/object.h" 57 58 #define MAX_VCS 10 59 #define VC_WINDOW_X_MIN 320 60 #define VC_WINDOW_Y_MIN 240 61 #define VC_TERM_X_MIN 80 62 #define VC_TERM_Y_MIN 25 63 #define VC_SCALE_MIN 0.25 64 #define VC_SCALE_STEP 0.25 65 66 #if !defined(CONFIG_VTE) 67 # define VTE_CHECK_VERSION(a, b, c) 0 68 #endif 69 70 #if defined(CONFIG_VTE) && !GTK_CHECK_VERSION(3, 0, 0) 71 /* 72 * The gtk2 vte terminal widget seriously messes up the window resize 73 * for some reason. You basically can't make the qemu window smaller 74 * any more because the toplevel window geoemtry hints are overridden. 75 * 76 * Workaround that by hiding all vte widgets, except the one in the 77 * current tab. 78 * 79 * Luckily everything works smooth in gtk3. 80 */ 81 # define VTE_RESIZE_HACK 1 82 #endif 83 84 #if !GTK_CHECK_VERSION(2, 20, 0) 85 #define gtk_widget_get_realized(widget) GTK_WIDGET_REALIZED(widget) 86 #endif 87 88 #ifndef GDK_IS_X11_DISPLAY 89 #define GDK_IS_X11_DISPLAY(dpy) (dpy == dpy) 90 #endif 91 #ifndef GDK_IS_WIN32_DISPLAY 92 #define GDK_IS_WIN32_DISPLAY(dpy) (dpy == dpy) 93 #endif 94 95 #ifndef GDK_KEY_0 96 #define GDK_KEY_0 GDK_0 97 #define GDK_KEY_1 GDK_1 98 #define GDK_KEY_2 GDK_2 99 #define GDK_KEY_f GDK_f 100 #define GDK_KEY_g GDK_g 101 #define GDK_KEY_q GDK_q 102 #define GDK_KEY_plus GDK_plus 103 #define GDK_KEY_minus GDK_minus 104 #define GDK_KEY_Pause GDK_Pause 105 #endif 106 107 #define HOTKEY_MODIFIERS (GDK_CONTROL_MASK | GDK_MOD1_MASK) 108 109 static const int modifier_keycode[] = { 110 /* shift, control, alt keys, meta keys, both left & right */ 111 0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8, 0xdb, 0xdd, 112 }; 113 114 struct GtkDisplayState { 115 GtkWidget *window; 116 117 GtkWidget *menu_bar; 118 119 GtkAccelGroup *accel_group; 120 121 GtkWidget *machine_menu_item; 122 GtkWidget *machine_menu; 123 GtkWidget *pause_item; 124 GtkWidget *reset_item; 125 GtkWidget *powerdown_item; 126 GtkWidget *quit_item; 127 128 GtkWidget *view_menu_item; 129 GtkWidget *view_menu; 130 GtkWidget *full_screen_item; 131 GtkWidget *zoom_in_item; 132 GtkWidget *zoom_out_item; 133 GtkWidget *zoom_fixed_item; 134 GtkWidget *zoom_fit_item; 135 GtkWidget *grab_item; 136 GtkWidget *grab_on_hover_item; 137 138 int nb_vcs; 139 VirtualConsole vc[MAX_VCS]; 140 141 GtkWidget *show_tabs_item; 142 GtkWidget *untabify_item; 143 144 GtkWidget *vbox; 145 GtkWidget *notebook; 146 int button_mask; 147 gboolean last_set; 148 int last_x; 149 int last_y; 150 int grab_x_root; 151 int grab_y_root; 152 VirtualConsole *kbd_owner; 153 VirtualConsole *ptr_owner; 154 155 gboolean full_screen; 156 157 GdkCursor *null_cursor; 158 Notifier mouse_mode_notifier; 159 gboolean free_scale; 160 161 bool external_pause_update; 162 163 bool modifier_pressed[ARRAY_SIZE(modifier_keycode)]; 164 bool has_evdev; 165 bool ignore_keys; 166 }; 167 168 static void gd_grab_pointer(VirtualConsole *vc, const char *reason); 169 static void gd_ungrab_pointer(GtkDisplayState *s); 170 static void gd_grab_keyboard(VirtualConsole *vc, const char *reason); 171 static void gd_ungrab_keyboard(GtkDisplayState *s); 172 173 /** Utility Functions **/ 174 175 static VirtualConsole *gd_vc_find_by_menu(GtkDisplayState *s) 176 { 177 VirtualConsole *vc; 178 gint i; 179 180 for (i = 0; i < s->nb_vcs; i++) { 181 vc = &s->vc[i]; 182 if (gtk_check_menu_item_get_active 183 (GTK_CHECK_MENU_ITEM(vc->menu_item))) { 184 return vc; 185 } 186 } 187 return NULL; 188 } 189 190 static VirtualConsole *gd_vc_find_by_page(GtkDisplayState *s, gint page) 191 { 192 VirtualConsole *vc; 193 gint i, p; 194 195 for (i = 0; i < s->nb_vcs; i++) { 196 vc = &s->vc[i]; 197 p = gtk_notebook_page_num(GTK_NOTEBOOK(s->notebook), vc->tab_item); 198 if (p == page) { 199 return vc; 200 } 201 } 202 return NULL; 203 } 204 205 static VirtualConsole *gd_vc_find_current(GtkDisplayState *s) 206 { 207 gint page; 208 209 page = gtk_notebook_get_current_page(GTK_NOTEBOOK(s->notebook)); 210 return gd_vc_find_by_page(s, page); 211 } 212 213 static bool gd_is_grab_active(GtkDisplayState *s) 214 { 215 return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_item)); 216 } 217 218 static bool gd_grab_on_hover(GtkDisplayState *s) 219 { 220 return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_on_hover_item)); 221 } 222 223 static void gd_update_cursor(VirtualConsole *vc) 224 { 225 GtkDisplayState *s = vc->s; 226 GdkWindow *window; 227 228 if (vc->type != GD_VC_GFX || 229 !qemu_console_is_graphic(vc->gfx.dcl.con)) { 230 return; 231 } 232 233 if (!gtk_widget_get_realized(vc->gfx.drawing_area)) { 234 return; 235 } 236 237 window = gtk_widget_get_window(GTK_WIDGET(vc->gfx.drawing_area)); 238 if (s->full_screen || qemu_input_is_absolute() || s->ptr_owner == vc) { 239 gdk_window_set_cursor(window, s->null_cursor); 240 } else { 241 gdk_window_set_cursor(window, NULL); 242 } 243 } 244 245 static void gd_update_caption(GtkDisplayState *s) 246 { 247 const char *status = ""; 248 gchar *prefix; 249 gchar *title; 250 const char *grab = ""; 251 bool is_paused = !runstate_is_running(); 252 int i; 253 254 if (qemu_name) { 255 prefix = g_strdup_printf("QEMU (%s)", qemu_name); 256 } else { 257 prefix = g_strdup_printf("QEMU"); 258 } 259 260 if (s->ptr_owner != NULL && 261 s->ptr_owner->window == NULL) { 262 grab = _(" - Press Ctrl+Alt+G to release grab"); 263 } 264 265 if (is_paused) { 266 status = _(" [Paused]"); 267 } 268 s->external_pause_update = true; 269 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->pause_item), 270 is_paused); 271 s->external_pause_update = false; 272 273 title = g_strdup_printf("%s%s%s", prefix, status, grab); 274 gtk_window_set_title(GTK_WINDOW(s->window), title); 275 g_free(title); 276 277 for (i = 0; i < s->nb_vcs; i++) { 278 VirtualConsole *vc = &s->vc[i]; 279 280 if (!vc->window) { 281 continue; 282 } 283 title = g_strdup_printf("%s: %s%s%s", prefix, vc->label, 284 vc == s->kbd_owner ? " +kbd" : "", 285 vc == s->ptr_owner ? " +ptr" : ""); 286 gtk_window_set_title(GTK_WINDOW(vc->window), title); 287 g_free(title); 288 } 289 290 g_free(prefix); 291 } 292 293 static void gd_update_geometry_hints(VirtualConsole *vc) 294 { 295 GtkDisplayState *s = vc->s; 296 GdkWindowHints mask = 0; 297 GdkGeometry geo = {}; 298 GtkWidget *geo_widget = NULL; 299 GtkWindow *geo_window; 300 301 if (vc->type == GD_VC_GFX) { 302 if (!vc->gfx.ds) { 303 return; 304 } 305 if (s->free_scale) { 306 geo.min_width = surface_width(vc->gfx.ds) * VC_SCALE_MIN; 307 geo.min_height = surface_height(vc->gfx.ds) * VC_SCALE_MIN; 308 mask |= GDK_HINT_MIN_SIZE; 309 } else { 310 geo.min_width = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 311 geo.min_height = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 312 mask |= GDK_HINT_MIN_SIZE; 313 } 314 geo_widget = vc->gfx.drawing_area; 315 gtk_widget_set_size_request(geo_widget, geo.min_width, geo.min_height); 316 317 #if defined(CONFIG_VTE) 318 } else if (vc->type == GD_VC_VTE) { 319 VteTerminal *term = VTE_TERMINAL(vc->vte.terminal); 320 GtkBorder *ib; 321 322 geo.width_inc = vte_terminal_get_char_width(term); 323 geo.height_inc = vte_terminal_get_char_height(term); 324 mask |= GDK_HINT_RESIZE_INC; 325 geo.base_width = geo.width_inc; 326 geo.base_height = geo.height_inc; 327 mask |= GDK_HINT_BASE_SIZE; 328 geo.min_width = geo.width_inc * VC_TERM_X_MIN; 329 geo.min_height = geo.height_inc * VC_TERM_Y_MIN; 330 mask |= GDK_HINT_MIN_SIZE; 331 gtk_widget_style_get(vc->vte.terminal, "inner-border", &ib, NULL); 332 geo.base_width += ib->left + ib->right; 333 geo.base_height += ib->top + ib->bottom; 334 geo.min_width += ib->left + ib->right; 335 geo.min_height += ib->top + ib->bottom; 336 geo_widget = vc->vte.terminal; 337 #endif 338 } 339 340 geo_window = GTK_WINDOW(vc->window ? vc->window : s->window); 341 gtk_window_set_geometry_hints(geo_window, geo_widget, &geo, mask); 342 } 343 344 void gd_update_windowsize(VirtualConsole *vc) 345 { 346 GtkDisplayState *s = vc->s; 347 348 gd_update_geometry_hints(vc); 349 350 if (vc->type == GD_VC_GFX && !s->full_screen && !s->free_scale) { 351 gtk_window_resize(GTK_WINDOW(vc->window ? vc->window : s->window), 352 VC_WINDOW_X_MIN, VC_WINDOW_Y_MIN); 353 } 354 } 355 356 static void gd_update_full_redraw(VirtualConsole *vc) 357 { 358 GtkWidget *area = vc->gfx.drawing_area; 359 int ww, wh; 360 gdk_drawable_get_size(gtk_widget_get_window(area), &ww, &wh); 361 gtk_widget_queue_draw_area(area, 0, 0, ww, wh); 362 } 363 364 static void gtk_release_modifiers(GtkDisplayState *s) 365 { 366 VirtualConsole *vc = gd_vc_find_current(s); 367 int i, keycode; 368 369 if (vc->type != GD_VC_GFX || 370 !qemu_console_is_graphic(vc->gfx.dcl.con)) { 371 return; 372 } 373 for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) { 374 keycode = modifier_keycode[i]; 375 if (!s->modifier_pressed[i]) { 376 continue; 377 } 378 qemu_input_event_send_key_number(vc->gfx.dcl.con, keycode, false); 379 s->modifier_pressed[i] = false; 380 } 381 } 382 383 static void gd_widget_reparent(GtkWidget *from, GtkWidget *to, 384 GtkWidget *widget) 385 { 386 g_object_ref(G_OBJECT(widget)); 387 gtk_container_remove(GTK_CONTAINER(from), widget); 388 gtk_container_add(GTK_CONTAINER(to), widget); 389 g_object_unref(G_OBJECT(widget)); 390 } 391 392 /** DisplayState Callbacks **/ 393 394 static void gd_update(DisplayChangeListener *dcl, 395 int x, int y, int w, int h) 396 { 397 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 398 GdkWindow *win; 399 int x1, x2, y1, y2; 400 int mx, my; 401 int fbw, fbh; 402 int ww, wh; 403 404 trace_gd_update(vc->label, x, y, w, h); 405 406 if (!gtk_widget_get_realized(vc->gfx.drawing_area)) { 407 return; 408 } 409 410 if (vc->gfx.convert) { 411 pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image, 412 NULL, vc->gfx.convert, 413 x, y, 0, 0, x, y, w, h); 414 } 415 416 x1 = floor(x * vc->gfx.scale_x); 417 y1 = floor(y * vc->gfx.scale_y); 418 419 x2 = ceil(x * vc->gfx.scale_x + w * vc->gfx.scale_x); 420 y2 = ceil(y * vc->gfx.scale_y + h * vc->gfx.scale_y); 421 422 fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 423 fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 424 425 win = gtk_widget_get_window(vc->gfx.drawing_area); 426 if (!win) { 427 return; 428 } 429 gdk_drawable_get_size(win, &ww, &wh); 430 431 mx = my = 0; 432 if (ww > fbw) { 433 mx = (ww - fbw) / 2; 434 } 435 if (wh > fbh) { 436 my = (wh - fbh) / 2; 437 } 438 439 gtk_widget_queue_draw_area(vc->gfx.drawing_area, 440 mx + x1, my + y1, (x2 - x1), (y2 - y1)); 441 } 442 443 static void gd_refresh(DisplayChangeListener *dcl) 444 { 445 graphic_hw_update(dcl->con); 446 } 447 448 #if GTK_CHECK_VERSION(3, 0, 0) 449 static void gd_mouse_set(DisplayChangeListener *dcl, 450 int x, int y, int visible) 451 { 452 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 453 GdkDisplay *dpy; 454 GdkDeviceManager *mgr; 455 gint x_root, y_root; 456 457 if (qemu_input_is_absolute()) { 458 return; 459 } 460 461 dpy = gtk_widget_get_display(vc->gfx.drawing_area); 462 mgr = gdk_display_get_device_manager(dpy); 463 gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area), 464 x, y, &x_root, &y_root); 465 gdk_device_warp(gdk_device_manager_get_client_pointer(mgr), 466 gtk_widget_get_screen(vc->gfx.drawing_area), 467 x_root, y_root); 468 vc->s->last_x = x; 469 vc->s->last_y = y; 470 } 471 #else 472 static void gd_mouse_set(DisplayChangeListener *dcl, 473 int x, int y, int visible) 474 { 475 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 476 gint x_root, y_root; 477 478 if (qemu_input_is_absolute()) { 479 return; 480 } 481 482 gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area), 483 x, y, &x_root, &y_root); 484 gdk_display_warp_pointer(gtk_widget_get_display(vc->gfx.drawing_area), 485 gtk_widget_get_screen(vc->gfx.drawing_area), 486 x_root, y_root); 487 } 488 #endif 489 490 static void gd_cursor_define(DisplayChangeListener *dcl, 491 QEMUCursor *c) 492 { 493 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 494 GdkPixbuf *pixbuf; 495 GdkCursor *cursor; 496 497 if (!gtk_widget_get_realized(vc->gfx.drawing_area)) { 498 return; 499 } 500 501 pixbuf = gdk_pixbuf_new_from_data((guchar *)(c->data), 502 GDK_COLORSPACE_RGB, true, 8, 503 c->width, c->height, c->width * 4, 504 NULL, NULL); 505 cursor = gdk_cursor_new_from_pixbuf 506 (gtk_widget_get_display(vc->gfx.drawing_area), 507 pixbuf, c->hot_x, c->hot_y); 508 gdk_window_set_cursor(gtk_widget_get_window(vc->gfx.drawing_area), cursor); 509 g_object_unref(pixbuf); 510 #if !GTK_CHECK_VERSION(3, 0, 0) 511 gdk_cursor_unref(cursor); 512 #else 513 g_object_unref(cursor); 514 #endif 515 } 516 517 static void gd_switch(DisplayChangeListener *dcl, 518 DisplaySurface *surface) 519 { 520 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 521 bool resized = true; 522 523 trace_gd_switch(vc->label, 524 surface ? surface_width(surface) : 0, 525 surface ? surface_height(surface) : 0); 526 527 if (vc->gfx.surface) { 528 cairo_surface_destroy(vc->gfx.surface); 529 vc->gfx.surface = NULL; 530 } 531 if (vc->gfx.convert) { 532 pixman_image_unref(vc->gfx.convert); 533 vc->gfx.convert = NULL; 534 } 535 536 if (vc->gfx.ds && surface && 537 surface_width(vc->gfx.ds) == surface_width(surface) && 538 surface_height(vc->gfx.ds) == surface_height(surface)) { 539 resized = false; 540 } 541 vc->gfx.ds = surface; 542 543 if (!surface) { 544 return; 545 } 546 547 if (surface->format == PIXMAN_x8r8g8b8) { 548 /* 549 * PIXMAN_x8r8g8b8 == CAIRO_FORMAT_RGB24 550 * 551 * No need to convert, use surface directly. Should be the 552 * common case as this is qemu_default_pixelformat(32) too. 553 */ 554 vc->gfx.surface = cairo_image_surface_create_for_data 555 (surface_data(surface), 556 CAIRO_FORMAT_RGB24, 557 surface_width(surface), 558 surface_height(surface), 559 surface_stride(surface)); 560 } else { 561 /* Must convert surface, use pixman to do it. */ 562 vc->gfx.convert = pixman_image_create_bits(PIXMAN_x8r8g8b8, 563 surface_width(surface), 564 surface_height(surface), 565 NULL, 0); 566 vc->gfx.surface = cairo_image_surface_create_for_data 567 ((void *)pixman_image_get_data(vc->gfx.convert), 568 CAIRO_FORMAT_RGB24, 569 pixman_image_get_width(vc->gfx.convert), 570 pixman_image_get_height(vc->gfx.convert), 571 pixman_image_get_stride(vc->gfx.convert)); 572 pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image, 573 NULL, vc->gfx.convert, 574 0, 0, 0, 0, 0, 0, 575 pixman_image_get_width(vc->gfx.convert), 576 pixman_image_get_height(vc->gfx.convert)); 577 } 578 579 if (resized) { 580 gd_update_windowsize(vc); 581 } else { 582 gd_update_full_redraw(vc); 583 } 584 } 585 586 static const DisplayChangeListenerOps dcl_ops = { 587 .dpy_name = "gtk", 588 .dpy_gfx_update = gd_update, 589 .dpy_gfx_switch = gd_switch, 590 .dpy_gfx_check_format = qemu_pixman_check_format, 591 .dpy_refresh = gd_refresh, 592 .dpy_mouse_set = gd_mouse_set, 593 .dpy_cursor_define = gd_cursor_define, 594 }; 595 596 597 #if defined(CONFIG_OPENGL) 598 599 /** DisplayState Callbacks (opengl version) **/ 600 601 static const DisplayChangeListenerOps dcl_egl_ops = { 602 .dpy_name = "gtk-egl", 603 .dpy_gfx_update = gd_egl_update, 604 .dpy_gfx_switch = gd_egl_switch, 605 .dpy_gfx_check_format = console_gl_check_format, 606 .dpy_refresh = gd_egl_refresh, 607 .dpy_mouse_set = gd_mouse_set, 608 .dpy_cursor_define = gd_cursor_define, 609 }; 610 611 #endif 612 613 /** QEMU Events **/ 614 615 static void gd_change_runstate(void *opaque, int running, RunState state) 616 { 617 GtkDisplayState *s = opaque; 618 619 gd_update_caption(s); 620 } 621 622 static void gd_mouse_mode_change(Notifier *notify, void *data) 623 { 624 GtkDisplayState *s; 625 int i; 626 627 s = container_of(notify, GtkDisplayState, mouse_mode_notifier); 628 /* release the grab at switching to absolute mode */ 629 if (qemu_input_is_absolute() && gd_is_grab_active(s)) { 630 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 631 FALSE); 632 } 633 for (i = 0; i < s->nb_vcs; i++) { 634 VirtualConsole *vc = &s->vc[i]; 635 gd_update_cursor(vc); 636 } 637 } 638 639 /** GTK Events **/ 640 641 static gboolean gd_window_close(GtkWidget *widget, GdkEvent *event, 642 void *opaque) 643 { 644 GtkDisplayState *s = opaque; 645 int i; 646 647 if (!no_quit) { 648 for (i = 0; i < s->nb_vcs; i++) { 649 if (s->vc[i].type != GD_VC_GFX) { 650 continue; 651 } 652 unregister_displaychangelistener(&s->vc[i].gfx.dcl); 653 } 654 qmp_quit(NULL); 655 return FALSE; 656 } 657 658 return TRUE; 659 } 660 661 static gboolean gd_draw_event(GtkWidget *widget, cairo_t *cr, void *opaque) 662 { 663 VirtualConsole *vc = opaque; 664 GtkDisplayState *s = vc->s; 665 int mx, my; 666 int ww, wh; 667 int fbw, fbh; 668 669 #if defined(CONFIG_OPENGL) 670 if (vc->gfx.gls) { 671 gd_egl_draw(vc); 672 return TRUE; 673 } 674 #endif 675 676 if (!gtk_widget_get_realized(widget)) { 677 return FALSE; 678 } 679 if (!vc->gfx.ds) { 680 return FALSE; 681 } 682 683 fbw = surface_width(vc->gfx.ds); 684 fbh = surface_height(vc->gfx.ds); 685 686 gdk_drawable_get_size(gtk_widget_get_window(widget), &ww, &wh); 687 688 if (s->full_screen) { 689 vc->gfx.scale_x = (double)ww / fbw; 690 vc->gfx.scale_y = (double)wh / fbh; 691 } else if (s->free_scale) { 692 double sx, sy; 693 694 sx = (double)ww / fbw; 695 sy = (double)wh / fbh; 696 697 vc->gfx.scale_x = vc->gfx.scale_y = MIN(sx, sy); 698 } 699 700 fbw *= vc->gfx.scale_x; 701 fbh *= vc->gfx.scale_y; 702 703 mx = my = 0; 704 if (ww > fbw) { 705 mx = (ww - fbw) / 2; 706 } 707 if (wh > fbh) { 708 my = (wh - fbh) / 2; 709 } 710 711 cairo_rectangle(cr, 0, 0, ww, wh); 712 713 /* Optionally cut out the inner area where the pixmap 714 will be drawn. This avoids 'flashing' since we're 715 not double-buffering. Note we're using the undocumented 716 behaviour of drawing the rectangle from right to left 717 to cut out the whole */ 718 cairo_rectangle(cr, mx + fbw, my, 719 -1 * fbw, fbh); 720 cairo_fill(cr); 721 722 cairo_scale(cr, vc->gfx.scale_x, vc->gfx.scale_y); 723 cairo_set_source_surface(cr, vc->gfx.surface, 724 mx / vc->gfx.scale_x, my / vc->gfx.scale_y); 725 cairo_paint(cr); 726 727 return TRUE; 728 } 729 730 #if !GTK_CHECK_VERSION(3, 0, 0) 731 static gboolean gd_expose_event(GtkWidget *widget, GdkEventExpose *expose, 732 void *opaque) 733 { 734 cairo_t *cr; 735 gboolean ret; 736 737 cr = gdk_cairo_create(gtk_widget_get_window(widget)); 738 cairo_rectangle(cr, 739 expose->area.x, 740 expose->area.y, 741 expose->area.width, 742 expose->area.height); 743 cairo_clip(cr); 744 745 ret = gd_draw_event(widget, cr, opaque); 746 747 cairo_destroy(cr); 748 749 return ret; 750 } 751 #endif 752 753 static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion, 754 void *opaque) 755 { 756 VirtualConsole *vc = opaque; 757 GtkDisplayState *s = vc->s; 758 int x, y; 759 int mx, my; 760 int fbh, fbw; 761 int ww, wh; 762 763 if (!vc->gfx.ds) { 764 return TRUE; 765 } 766 767 fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 768 fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 769 770 gdk_drawable_get_size(gtk_widget_get_window(vc->gfx.drawing_area), 771 &ww, &wh); 772 773 mx = my = 0; 774 if (ww > fbw) { 775 mx = (ww - fbw) / 2; 776 } 777 if (wh > fbh) { 778 my = (wh - fbh) / 2; 779 } 780 781 x = (motion->x - mx) / vc->gfx.scale_x; 782 y = (motion->y - my) / vc->gfx.scale_y; 783 784 if (qemu_input_is_absolute()) { 785 if (x < 0 || y < 0 || 786 x >= surface_width(vc->gfx.ds) || 787 y >= surface_height(vc->gfx.ds)) { 788 return TRUE; 789 } 790 qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_X, x, 791 surface_width(vc->gfx.ds)); 792 qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_Y, y, 793 surface_height(vc->gfx.ds)); 794 qemu_input_event_sync(); 795 } else if (s->last_set && s->ptr_owner == vc) { 796 qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_X, x - s->last_x); 797 qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_Y, y - s->last_y); 798 qemu_input_event_sync(); 799 } 800 s->last_x = x; 801 s->last_y = y; 802 s->last_set = TRUE; 803 804 if (!qemu_input_is_absolute() && s->ptr_owner == vc) { 805 GdkScreen *screen = gtk_widget_get_screen(vc->gfx.drawing_area); 806 int x = (int)motion->x_root; 807 int y = (int)motion->y_root; 808 809 /* In relative mode check to see if client pointer hit 810 * one of the screen edges, and if so move it back by 811 * 200 pixels. This is important because the pointer 812 * in the server doesn't correspond 1-for-1, and so 813 * may still be only half way across the screen. Without 814 * this warp, the server pointer would thus appear to hit 815 * an invisible wall */ 816 if (x == 0) { 817 x += 200; 818 } 819 if (y == 0) { 820 y += 200; 821 } 822 if (x == (gdk_screen_get_width(screen) - 1)) { 823 x -= 200; 824 } 825 if (y == (gdk_screen_get_height(screen) - 1)) { 826 y -= 200; 827 } 828 829 if (x != (int)motion->x_root || y != (int)motion->y_root) { 830 #if GTK_CHECK_VERSION(3, 0, 0) 831 GdkDevice *dev = gdk_event_get_device((GdkEvent *)motion); 832 gdk_device_warp(dev, screen, x, y); 833 #else 834 GdkDisplay *display = gtk_widget_get_display(widget); 835 gdk_display_warp_pointer(display, screen, x, y); 836 #endif 837 s->last_set = FALSE; 838 return FALSE; 839 } 840 } 841 return TRUE; 842 } 843 844 static gboolean gd_button_event(GtkWidget *widget, GdkEventButton *button, 845 void *opaque) 846 { 847 VirtualConsole *vc = opaque; 848 GtkDisplayState *s = vc->s; 849 InputButton btn; 850 851 /* implicitly grab the input at the first click in the relative mode */ 852 if (button->button == 1 && button->type == GDK_BUTTON_PRESS && 853 !qemu_input_is_absolute() && s->ptr_owner != vc) { 854 if (!vc->window) { 855 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 856 TRUE); 857 } else { 858 gd_grab_pointer(vc, "relative-mode-click"); 859 } 860 return TRUE; 861 } 862 863 if (button->button == 1) { 864 btn = INPUT_BUTTON_LEFT; 865 } else if (button->button == 2) { 866 btn = INPUT_BUTTON_MIDDLE; 867 } else if (button->button == 3) { 868 btn = INPUT_BUTTON_RIGHT; 869 } else { 870 return TRUE; 871 } 872 873 qemu_input_queue_btn(vc->gfx.dcl.con, btn, 874 button->type == GDK_BUTTON_PRESS); 875 qemu_input_event_sync(); 876 return TRUE; 877 } 878 879 static gboolean gd_scroll_event(GtkWidget *widget, GdkEventScroll *scroll, 880 void *opaque) 881 { 882 VirtualConsole *vc = opaque; 883 InputButton btn; 884 885 if (scroll->direction == GDK_SCROLL_UP) { 886 btn = INPUT_BUTTON_WHEEL_UP; 887 } else if (scroll->direction == GDK_SCROLL_DOWN) { 888 btn = INPUT_BUTTON_WHEEL_DOWN; 889 } else { 890 return TRUE; 891 } 892 893 qemu_input_queue_btn(vc->gfx.dcl.con, btn, true); 894 qemu_input_event_sync(); 895 qemu_input_queue_btn(vc->gfx.dcl.con, btn, false); 896 qemu_input_event_sync(); 897 return TRUE; 898 } 899 900 static int gd_map_keycode(GtkDisplayState *s, GdkDisplay *dpy, int gdk_keycode) 901 { 902 int qemu_keycode; 903 904 #ifdef GDK_WINDOWING_WIN32 905 if (GDK_IS_WIN32_DISPLAY(dpy)) { 906 qemu_keycode = MapVirtualKey(gdk_keycode, MAPVK_VK_TO_VSC); 907 switch (qemu_keycode) { 908 case 103: /* alt gr */ 909 qemu_keycode = 56 | SCANCODE_GREY; 910 break; 911 } 912 return qemu_keycode; 913 } 914 #endif 915 916 if (gdk_keycode < 9) { 917 qemu_keycode = 0; 918 } else if (gdk_keycode < 97) { 919 qemu_keycode = gdk_keycode - 8; 920 #ifdef GDK_WINDOWING_X11 921 } else if (GDK_IS_X11_DISPLAY(dpy) && gdk_keycode < 158) { 922 if (s->has_evdev) { 923 qemu_keycode = translate_evdev_keycode(gdk_keycode - 97); 924 } else { 925 qemu_keycode = translate_xfree86_keycode(gdk_keycode - 97); 926 } 927 #endif 928 } else if (gdk_keycode == 208) { /* Hiragana_Katakana */ 929 qemu_keycode = 0x70; 930 } else if (gdk_keycode == 211) { /* backslash */ 931 qemu_keycode = 0x73; 932 } else { 933 qemu_keycode = 0; 934 } 935 936 return qemu_keycode; 937 } 938 939 static gboolean gd_text_key_down(GtkWidget *widget, 940 GdkEventKey *key, void *opaque) 941 { 942 VirtualConsole *vc = opaque; 943 QemuConsole *con = vc->gfx.dcl.con; 944 945 if (key->length) { 946 kbd_put_string_console(con, key->string, key->length); 947 } else { 948 int num = gd_map_keycode(vc->s, gtk_widget_get_display(widget), 949 key->hardware_keycode); 950 int qcode = qemu_input_key_number_to_qcode(num); 951 kbd_put_qcode_console(con, qcode); 952 } 953 return TRUE; 954 } 955 956 static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque) 957 { 958 VirtualConsole *vc = opaque; 959 GtkDisplayState *s = vc->s; 960 int gdk_keycode = key->hardware_keycode; 961 int qemu_keycode; 962 int i; 963 964 if (s->ignore_keys) { 965 s->ignore_keys = (key->type == GDK_KEY_PRESS); 966 return TRUE; 967 } 968 969 if (key->keyval == GDK_KEY_Pause) { 970 qemu_input_event_send_key_qcode(vc->gfx.dcl.con, Q_KEY_CODE_PAUSE, 971 key->type == GDK_KEY_PRESS); 972 return TRUE; 973 } 974 975 qemu_keycode = gd_map_keycode(s, gtk_widget_get_display(widget), 976 gdk_keycode); 977 978 trace_gd_key_event(vc->label, gdk_keycode, qemu_keycode, 979 (key->type == GDK_KEY_PRESS) ? "down" : "up"); 980 981 for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) { 982 if (qemu_keycode == modifier_keycode[i]) { 983 s->modifier_pressed[i] = (key->type == GDK_KEY_PRESS); 984 } 985 } 986 987 qemu_input_event_send_key_number(vc->gfx.dcl.con, qemu_keycode, 988 key->type == GDK_KEY_PRESS); 989 990 return TRUE; 991 } 992 993 static gboolean gd_event(GtkWidget *widget, GdkEvent *event, void *opaque) 994 { 995 if (event->type == GDK_MOTION_NOTIFY) { 996 return gd_motion_event(widget, &event->motion, opaque); 997 } 998 return FALSE; 999 } 1000 1001 /** Window Menu Actions **/ 1002 1003 static void gd_menu_pause(GtkMenuItem *item, void *opaque) 1004 { 1005 GtkDisplayState *s = opaque; 1006 1007 if (s->external_pause_update) { 1008 return; 1009 } 1010 if (runstate_is_running()) { 1011 qmp_stop(NULL); 1012 } else { 1013 qmp_cont(NULL); 1014 } 1015 } 1016 1017 static void gd_menu_reset(GtkMenuItem *item, void *opaque) 1018 { 1019 qmp_system_reset(NULL); 1020 } 1021 1022 static void gd_menu_powerdown(GtkMenuItem *item, void *opaque) 1023 { 1024 qmp_system_powerdown(NULL); 1025 } 1026 1027 static void gd_menu_quit(GtkMenuItem *item, void *opaque) 1028 { 1029 qmp_quit(NULL); 1030 } 1031 1032 static void gd_menu_switch_vc(GtkMenuItem *item, void *opaque) 1033 { 1034 GtkDisplayState *s = opaque; 1035 VirtualConsole *vc = gd_vc_find_by_menu(s); 1036 GtkNotebook *nb = GTK_NOTEBOOK(s->notebook); 1037 gint page; 1038 1039 gtk_release_modifiers(s); 1040 if (vc) { 1041 page = gtk_notebook_page_num(nb, vc->tab_item); 1042 gtk_notebook_set_current_page(nb, page); 1043 gtk_widget_grab_focus(vc->focus); 1044 } 1045 s->ignore_keys = false; 1046 } 1047 1048 static void gd_accel_switch_vc(void *opaque) 1049 { 1050 VirtualConsole *vc = opaque; 1051 1052 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), TRUE); 1053 #if !GTK_CHECK_VERSION(3, 0, 0) 1054 /* GTK2 sends the accel key to the target console - ignore this until */ 1055 vc->s->ignore_keys = true; 1056 #endif 1057 } 1058 1059 static void gd_menu_show_tabs(GtkMenuItem *item, void *opaque) 1060 { 1061 GtkDisplayState *s = opaque; 1062 VirtualConsole *vc = gd_vc_find_current(s); 1063 1064 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->show_tabs_item))) { 1065 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), TRUE); 1066 } else { 1067 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 1068 } 1069 gd_update_windowsize(vc); 1070 } 1071 1072 static gboolean gd_tab_window_close(GtkWidget *widget, GdkEvent *event, 1073 void *opaque) 1074 { 1075 VirtualConsole *vc = opaque; 1076 GtkDisplayState *s = vc->s; 1077 1078 gtk_widget_set_sensitive(vc->menu_item, true); 1079 gd_widget_reparent(vc->window, s->notebook, vc->tab_item); 1080 gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(s->notebook), 1081 vc->tab_item, vc->label); 1082 gtk_widget_destroy(vc->window); 1083 vc->window = NULL; 1084 return TRUE; 1085 } 1086 1087 static gboolean gd_win_grab(void *opaque) 1088 { 1089 VirtualConsole *vc = opaque; 1090 1091 fprintf(stderr, "%s: %s\n", __func__, vc->label); 1092 if (vc->s->ptr_owner) { 1093 gd_ungrab_pointer(vc->s); 1094 } else { 1095 gd_grab_pointer(vc, "user-request-detached-tab"); 1096 } 1097 return TRUE; 1098 } 1099 1100 static void gd_menu_untabify(GtkMenuItem *item, void *opaque) 1101 { 1102 GtkDisplayState *s = opaque; 1103 VirtualConsole *vc = gd_vc_find_current(s); 1104 1105 if (vc->type == GD_VC_GFX && 1106 qemu_console_is_graphic(vc->gfx.dcl.con)) { 1107 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1108 FALSE); 1109 } 1110 if (!vc->window) { 1111 gtk_widget_set_sensitive(vc->menu_item, false); 1112 vc->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 1113 gd_widget_reparent(s->notebook, vc->window, vc->tab_item); 1114 1115 g_signal_connect(vc->window, "delete-event", 1116 G_CALLBACK(gd_tab_window_close), vc); 1117 gtk_widget_show_all(vc->window); 1118 1119 if (qemu_console_is_graphic(vc->gfx.dcl.con)) { 1120 GtkAccelGroup *ag = gtk_accel_group_new(); 1121 gtk_window_add_accel_group(GTK_WINDOW(vc->window), ag); 1122 1123 GClosure *cb = g_cclosure_new_swap(G_CALLBACK(gd_win_grab), 1124 vc, NULL); 1125 gtk_accel_group_connect(ag, GDK_KEY_g, HOTKEY_MODIFIERS, 0, cb); 1126 } 1127 1128 gd_update_geometry_hints(vc); 1129 gd_update_caption(s); 1130 } 1131 } 1132 1133 static void gd_menu_full_screen(GtkMenuItem *item, void *opaque) 1134 { 1135 GtkDisplayState *s = opaque; 1136 VirtualConsole *vc = gd_vc_find_current(s); 1137 1138 if (!s->full_screen) { 1139 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 1140 gtk_widget_hide(s->menu_bar); 1141 if (vc->type == GD_VC_GFX) { 1142 gtk_widget_set_size_request(vc->gfx.drawing_area, -1, -1); 1143 } 1144 gtk_window_fullscreen(GTK_WINDOW(s->window)); 1145 s->full_screen = TRUE; 1146 } else { 1147 gtk_window_unfullscreen(GTK_WINDOW(s->window)); 1148 gd_menu_show_tabs(GTK_MENU_ITEM(s->show_tabs_item), s); 1149 gtk_widget_show(s->menu_bar); 1150 s->full_screen = FALSE; 1151 if (vc->type == GD_VC_GFX) { 1152 vc->gfx.scale_x = 1.0; 1153 vc->gfx.scale_y = 1.0; 1154 gd_update_windowsize(vc); 1155 } 1156 } 1157 1158 gd_update_cursor(vc); 1159 } 1160 1161 static void gd_accel_full_screen(void *opaque) 1162 { 1163 GtkDisplayState *s = opaque; 1164 gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item)); 1165 } 1166 1167 static void gd_menu_zoom_in(GtkMenuItem *item, void *opaque) 1168 { 1169 GtkDisplayState *s = opaque; 1170 VirtualConsole *vc = gd_vc_find_current(s); 1171 1172 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item), 1173 FALSE); 1174 1175 vc->gfx.scale_x += VC_SCALE_STEP; 1176 vc->gfx.scale_y += VC_SCALE_STEP; 1177 1178 gd_update_windowsize(vc); 1179 } 1180 1181 static void gd_menu_zoom_out(GtkMenuItem *item, void *opaque) 1182 { 1183 GtkDisplayState *s = opaque; 1184 VirtualConsole *vc = gd_vc_find_current(s); 1185 1186 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item), 1187 FALSE); 1188 1189 vc->gfx.scale_x -= VC_SCALE_STEP; 1190 vc->gfx.scale_y -= VC_SCALE_STEP; 1191 1192 vc->gfx.scale_x = MAX(vc->gfx.scale_x, VC_SCALE_MIN); 1193 vc->gfx.scale_y = MAX(vc->gfx.scale_y, VC_SCALE_MIN); 1194 1195 gd_update_windowsize(vc); 1196 } 1197 1198 static void gd_menu_zoom_fixed(GtkMenuItem *item, void *opaque) 1199 { 1200 GtkDisplayState *s = opaque; 1201 VirtualConsole *vc = gd_vc_find_current(s); 1202 1203 vc->gfx.scale_x = 1.0; 1204 vc->gfx.scale_y = 1.0; 1205 1206 gd_update_windowsize(vc); 1207 } 1208 1209 static void gd_menu_zoom_fit(GtkMenuItem *item, void *opaque) 1210 { 1211 GtkDisplayState *s = opaque; 1212 VirtualConsole *vc = gd_vc_find_current(s); 1213 1214 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item))) { 1215 s->free_scale = TRUE; 1216 } else { 1217 s->free_scale = FALSE; 1218 vc->gfx.scale_x = 1.0; 1219 vc->gfx.scale_y = 1.0; 1220 } 1221 1222 gd_update_windowsize(vc); 1223 gd_update_full_redraw(vc); 1224 } 1225 1226 #if GTK_CHECK_VERSION(3, 0, 0) 1227 static void gd_grab_devices(VirtualConsole *vc, bool grab, 1228 GdkInputSource source, GdkEventMask mask, 1229 GdkCursor *cursor) 1230 { 1231 GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1232 GdkDeviceManager *mgr = gdk_display_get_device_manager(display); 1233 GList *devs = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER); 1234 GList *tmp = devs; 1235 1236 for (tmp = devs; tmp; tmp = tmp->next) { 1237 GdkDevice *dev = tmp->data; 1238 if (gdk_device_get_source(dev) != source) { 1239 continue; 1240 } 1241 if (grab) { 1242 GdkWindow *win = gtk_widget_get_window(vc->gfx.drawing_area); 1243 gdk_device_grab(dev, win, GDK_OWNERSHIP_NONE, FALSE, 1244 mask, cursor, GDK_CURRENT_TIME); 1245 } else { 1246 gdk_device_ungrab(dev, GDK_CURRENT_TIME); 1247 } 1248 } 1249 g_list_free(devs); 1250 } 1251 #endif 1252 1253 static void gd_grab_keyboard(VirtualConsole *vc, const char *reason) 1254 { 1255 if (vc->s->kbd_owner) { 1256 if (vc->s->kbd_owner == vc) { 1257 return; 1258 } else { 1259 gd_ungrab_keyboard(vc->s); 1260 } 1261 } 1262 1263 #if GTK_CHECK_VERSION(3, 0, 0) 1264 gd_grab_devices(vc, true, GDK_SOURCE_KEYBOARD, 1265 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, 1266 NULL); 1267 #else 1268 gdk_keyboard_grab(gtk_widget_get_window(vc->gfx.drawing_area), 1269 FALSE, 1270 GDK_CURRENT_TIME); 1271 #endif 1272 vc->s->kbd_owner = vc; 1273 gd_update_caption(vc->s); 1274 trace_gd_grab(vc->label, "kbd", reason); 1275 } 1276 1277 static void gd_ungrab_keyboard(GtkDisplayState *s) 1278 { 1279 VirtualConsole *vc = s->kbd_owner; 1280 1281 if (vc == NULL) { 1282 return; 1283 } 1284 s->kbd_owner = NULL; 1285 1286 #if GTK_CHECK_VERSION(3, 0, 0) 1287 gd_grab_devices(vc, false, GDK_SOURCE_KEYBOARD, 0, NULL); 1288 #else 1289 gdk_keyboard_ungrab(GDK_CURRENT_TIME); 1290 #endif 1291 gd_update_caption(s); 1292 trace_gd_ungrab(vc->label, "kbd"); 1293 } 1294 1295 static void gd_grab_pointer(VirtualConsole *vc, const char *reason) 1296 { 1297 GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1298 1299 if (vc->s->ptr_owner) { 1300 if (vc->s->ptr_owner == vc) { 1301 return; 1302 } else { 1303 gd_ungrab_pointer(vc->s); 1304 } 1305 } 1306 1307 #if GTK_CHECK_VERSION(3, 0, 0) 1308 GdkDeviceManager *mgr = gdk_display_get_device_manager(display); 1309 gd_grab_devices(vc, true, GDK_SOURCE_MOUSE, 1310 GDK_POINTER_MOTION_MASK | 1311 GDK_BUTTON_PRESS_MASK | 1312 GDK_BUTTON_RELEASE_MASK | 1313 GDK_BUTTON_MOTION_MASK | 1314 GDK_SCROLL_MASK, 1315 vc->s->null_cursor); 1316 gdk_device_get_position(gdk_device_manager_get_client_pointer(mgr), 1317 NULL, &vc->s->grab_x_root, &vc->s->grab_y_root); 1318 #else 1319 gdk_pointer_grab(gtk_widget_get_window(vc->gfx.drawing_area), 1320 FALSE, /* All events to come to our window directly */ 1321 GDK_POINTER_MOTION_MASK | 1322 GDK_BUTTON_PRESS_MASK | 1323 GDK_BUTTON_RELEASE_MASK | 1324 GDK_BUTTON_MOTION_MASK | 1325 GDK_SCROLL_MASK, 1326 NULL, /* Allow cursor to move over entire desktop */ 1327 vc->s->null_cursor, 1328 GDK_CURRENT_TIME); 1329 gdk_display_get_pointer(display, NULL, 1330 &vc->s->grab_x_root, &vc->s->grab_y_root, NULL); 1331 #endif 1332 vc->s->ptr_owner = vc; 1333 gd_update_caption(vc->s); 1334 trace_gd_grab(vc->label, "ptr", reason); 1335 } 1336 1337 static void gd_ungrab_pointer(GtkDisplayState *s) 1338 { 1339 VirtualConsole *vc = s->ptr_owner; 1340 1341 if (vc == NULL) { 1342 return; 1343 } 1344 s->ptr_owner = NULL; 1345 1346 GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1347 #if GTK_CHECK_VERSION(3, 0, 0) 1348 GdkDeviceManager *mgr = gdk_display_get_device_manager(display); 1349 gd_grab_devices(vc, false, GDK_SOURCE_MOUSE, 0, NULL); 1350 gdk_device_warp(gdk_device_manager_get_client_pointer(mgr), 1351 gtk_widget_get_screen(vc->gfx.drawing_area), 1352 vc->s->grab_x_root, vc->s->grab_y_root); 1353 #else 1354 gdk_pointer_ungrab(GDK_CURRENT_TIME); 1355 gdk_display_warp_pointer(display, 1356 gtk_widget_get_screen(vc->gfx.drawing_area), 1357 vc->s->grab_x_root, vc->s->grab_y_root); 1358 #endif 1359 gd_update_caption(s); 1360 trace_gd_ungrab(vc->label, "ptr"); 1361 } 1362 1363 static void gd_menu_grab_input(GtkMenuItem *item, void *opaque) 1364 { 1365 GtkDisplayState *s = opaque; 1366 VirtualConsole *vc = gd_vc_find_current(s); 1367 1368 if (gd_is_grab_active(s)) { 1369 gd_grab_keyboard(vc, "user-request-main-window"); 1370 gd_grab_pointer(vc, "user-request-main-window"); 1371 } else { 1372 gd_ungrab_keyboard(s); 1373 gd_ungrab_pointer(s); 1374 } 1375 1376 gd_update_cursor(vc); 1377 } 1378 1379 static void gd_change_page(GtkNotebook *nb, gpointer arg1, guint arg2, 1380 gpointer data) 1381 { 1382 GtkDisplayState *s = data; 1383 VirtualConsole *vc; 1384 gboolean on_vga; 1385 1386 if (!gtk_widget_get_realized(s->notebook)) { 1387 return; 1388 } 1389 1390 #ifdef VTE_RESIZE_HACK 1391 vc = gd_vc_find_current(s); 1392 if (vc && vc->type == GD_VC_VTE) { 1393 gtk_widget_hide(vc->vte.terminal); 1394 } 1395 #endif 1396 vc = gd_vc_find_by_page(s, arg2); 1397 if (!vc) { 1398 return; 1399 } 1400 #ifdef VTE_RESIZE_HACK 1401 if (vc->type == GD_VC_VTE) { 1402 gtk_widget_show(vc->vte.terminal); 1403 } 1404 #endif 1405 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), 1406 TRUE); 1407 on_vga = (vc->type == GD_VC_GFX && 1408 qemu_console_is_graphic(vc->gfx.dcl.con)); 1409 if (!on_vga) { 1410 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1411 FALSE); 1412 } else if (s->full_screen) { 1413 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1414 TRUE); 1415 } 1416 gtk_widget_set_sensitive(s->grab_item, on_vga); 1417 1418 gd_update_windowsize(vc); 1419 gd_update_cursor(vc); 1420 } 1421 1422 static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing, 1423 gpointer opaque) 1424 { 1425 VirtualConsole *vc = opaque; 1426 GtkDisplayState *s = vc->s; 1427 1428 if (gd_grab_on_hover(s)) { 1429 gd_grab_keyboard(vc, "grab-on-hover"); 1430 } 1431 return TRUE; 1432 } 1433 1434 static gboolean gd_leave_event(GtkWidget *widget, GdkEventCrossing *crossing, 1435 gpointer opaque) 1436 { 1437 VirtualConsole *vc = opaque; 1438 GtkDisplayState *s = vc->s; 1439 1440 if (gd_grab_on_hover(s)) { 1441 gd_ungrab_keyboard(s); 1442 } 1443 return TRUE; 1444 } 1445 1446 static gboolean gd_focus_out_event(GtkWidget *widget, 1447 GdkEventCrossing *crossing, gpointer opaque) 1448 { 1449 VirtualConsole *vc = opaque; 1450 GtkDisplayState *s = vc->s; 1451 1452 gtk_release_modifiers(s); 1453 return TRUE; 1454 } 1455 1456 static gboolean gd_configure(GtkWidget *widget, 1457 GdkEventConfigure *cfg, gpointer opaque) 1458 { 1459 VirtualConsole *vc = opaque; 1460 QemuUIInfo info; 1461 1462 memset(&info, 0, sizeof(info)); 1463 info.width = cfg->width; 1464 info.height = cfg->height; 1465 dpy_set_ui_info(vc->gfx.dcl.con, &info); 1466 return FALSE; 1467 } 1468 1469 /** Virtual Console Callbacks **/ 1470 1471 static GSList *gd_vc_menu_init(GtkDisplayState *s, VirtualConsole *vc, 1472 int idx, GSList *group, GtkWidget *view_menu) 1473 { 1474 vc->menu_item = gtk_radio_menu_item_new_with_mnemonic(group, vc->label); 1475 gtk_accel_group_connect(s->accel_group, GDK_KEY_1 + idx, 1476 HOTKEY_MODIFIERS, 0, 1477 g_cclosure_new_swap(G_CALLBACK(gd_accel_switch_vc), vc, NULL)); 1478 #if GTK_CHECK_VERSION(3, 8, 0) 1479 gtk_accel_label_set_accel( 1480 GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(vc->menu_item))), 1481 GDK_KEY_1 + idx, HOTKEY_MODIFIERS); 1482 #endif 1483 1484 g_signal_connect(vc->menu_item, "activate", 1485 G_CALLBACK(gd_menu_switch_vc), s); 1486 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), vc->menu_item); 1487 1488 group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(vc->menu_item)); 1489 return group; 1490 } 1491 1492 #if defined(CONFIG_VTE) 1493 static void gd_vc_adjustment_changed(GtkAdjustment *adjustment, void *opaque) 1494 { 1495 VirtualConsole *vc = opaque; 1496 1497 if (gtk_adjustment_get_upper(adjustment) > 1498 gtk_adjustment_get_page_size(adjustment)) { 1499 gtk_widget_show(vc->vte.scrollbar); 1500 } else { 1501 gtk_widget_hide(vc->vte.scrollbar); 1502 } 1503 } 1504 1505 static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len) 1506 { 1507 VirtualConsole *vc = chr->opaque; 1508 1509 vte_terminal_feed(VTE_TERMINAL(vc->vte.terminal), (const char *)buf, len); 1510 return len; 1511 } 1512 1513 static int nb_vcs; 1514 static CharDriverState *vcs[MAX_VCS]; 1515 1516 static CharDriverState *gd_vc_handler(ChardevVC *unused) 1517 { 1518 CharDriverState *chr; 1519 1520 chr = g_malloc0(sizeof(*chr)); 1521 chr->chr_write = gd_vc_chr_write; 1522 /* defer OPENED events until our vc is fully initialized */ 1523 chr->explicit_be_open = true; 1524 1525 vcs[nb_vcs++] = chr; 1526 1527 return chr; 1528 } 1529 1530 static gboolean gd_vc_in(VteTerminal *terminal, gchar *text, guint size, 1531 gpointer user_data) 1532 { 1533 VirtualConsole *vc = user_data; 1534 1535 qemu_chr_be_write(vc->vte.chr, (uint8_t *)text, (unsigned int)size); 1536 return TRUE; 1537 } 1538 1539 static GSList *gd_vc_vte_init(GtkDisplayState *s, VirtualConsole *vc, 1540 CharDriverState *chr, int idx, 1541 GSList *group, GtkWidget *view_menu) 1542 { 1543 char buffer[32]; 1544 GtkWidget *box; 1545 GtkWidget *scrollbar; 1546 GtkAdjustment *vadjustment; 1547 1548 vc->s = s; 1549 vc->vte.chr = chr; 1550 1551 snprintf(buffer, sizeof(buffer), "vc%d", idx); 1552 vc->label = g_strdup_printf("%s", vc->vte.chr->label 1553 ? vc->vte.chr->label : buffer); 1554 group = gd_vc_menu_init(s, vc, idx, group, view_menu); 1555 1556 vc->vte.terminal = vte_terminal_new(); 1557 g_signal_connect(vc->vte.terminal, "commit", G_CALLBACK(gd_vc_in), vc); 1558 1559 vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->vte.terminal), -1); 1560 vte_terminal_set_size(VTE_TERMINAL(vc->vte.terminal), 1561 VC_TERM_X_MIN, VC_TERM_Y_MIN); 1562 1563 #if VTE_CHECK_VERSION(0, 28, 0) && GTK_CHECK_VERSION(3, 0, 0) 1564 vadjustment = gtk_scrollable_get_vadjustment 1565 (GTK_SCROLLABLE(vc->vte.terminal)); 1566 #else 1567 vadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->vte.terminal)); 1568 #endif 1569 1570 #if GTK_CHECK_VERSION(3, 0, 0) 1571 box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); 1572 scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, vadjustment); 1573 #else 1574 box = gtk_hbox_new(false, 2); 1575 scrollbar = gtk_vscrollbar_new(vadjustment); 1576 #endif 1577 1578 gtk_box_pack_start(GTK_BOX(box), vc->vte.terminal, TRUE, TRUE, 0); 1579 gtk_box_pack_start(GTK_BOX(box), scrollbar, FALSE, FALSE, 0); 1580 1581 vc->vte.chr->opaque = vc; 1582 vc->vte.box = box; 1583 vc->vte.scrollbar = scrollbar; 1584 1585 g_signal_connect(vadjustment, "changed", 1586 G_CALLBACK(gd_vc_adjustment_changed), vc); 1587 1588 vc->type = GD_VC_VTE; 1589 vc->tab_item = box; 1590 vc->focus = vc->vte.terminal; 1591 gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), vc->tab_item, 1592 gtk_label_new(vc->label)); 1593 1594 qemu_chr_be_generic_open(vc->vte.chr); 1595 if (vc->vte.chr->init) { 1596 vc->vte.chr->init(vc->vte.chr); 1597 } 1598 1599 return group; 1600 } 1601 1602 static void gd_vcs_init(GtkDisplayState *s, GSList *group, 1603 GtkWidget *view_menu) 1604 { 1605 int i; 1606 1607 for (i = 0; i < nb_vcs; i++) { 1608 VirtualConsole *vc = &s->vc[s->nb_vcs]; 1609 group = gd_vc_vte_init(s, vc, vcs[i], s->nb_vcs, group, view_menu); 1610 s->nb_vcs++; 1611 } 1612 } 1613 #endif /* CONFIG_VTE */ 1614 1615 /** Window Creation **/ 1616 1617 static void gd_connect_vc_gfx_signals(VirtualConsole *vc) 1618 { 1619 #if GTK_CHECK_VERSION(3, 0, 0) 1620 g_signal_connect(vc->gfx.drawing_area, "draw", 1621 G_CALLBACK(gd_draw_event), vc); 1622 #else 1623 g_signal_connect(vc->gfx.drawing_area, "expose-event", 1624 G_CALLBACK(gd_expose_event), vc); 1625 #endif 1626 if (qemu_console_is_graphic(vc->gfx.dcl.con)) { 1627 g_signal_connect(vc->gfx.drawing_area, "event", 1628 G_CALLBACK(gd_event), vc); 1629 g_signal_connect(vc->gfx.drawing_area, "button-press-event", 1630 G_CALLBACK(gd_button_event), vc); 1631 g_signal_connect(vc->gfx.drawing_area, "button-release-event", 1632 G_CALLBACK(gd_button_event), vc); 1633 g_signal_connect(vc->gfx.drawing_area, "scroll-event", 1634 G_CALLBACK(gd_scroll_event), vc); 1635 g_signal_connect(vc->gfx.drawing_area, "key-press-event", 1636 G_CALLBACK(gd_key_event), vc); 1637 g_signal_connect(vc->gfx.drawing_area, "key-release-event", 1638 G_CALLBACK(gd_key_event), vc); 1639 1640 g_signal_connect(vc->gfx.drawing_area, "enter-notify-event", 1641 G_CALLBACK(gd_enter_event), vc); 1642 g_signal_connect(vc->gfx.drawing_area, "leave-notify-event", 1643 G_CALLBACK(gd_leave_event), vc); 1644 g_signal_connect(vc->gfx.drawing_area, "focus-out-event", 1645 G_CALLBACK(gd_focus_out_event), vc); 1646 g_signal_connect(vc->gfx.drawing_area, "configure-event", 1647 G_CALLBACK(gd_configure), vc); 1648 } else { 1649 g_signal_connect(vc->gfx.drawing_area, "key-press-event", 1650 G_CALLBACK(gd_text_key_down), vc); 1651 } 1652 } 1653 1654 static void gd_connect_signals(GtkDisplayState *s) 1655 { 1656 g_signal_connect(s->show_tabs_item, "activate", 1657 G_CALLBACK(gd_menu_show_tabs), s); 1658 g_signal_connect(s->untabify_item, "activate", 1659 G_CALLBACK(gd_menu_untabify), s); 1660 1661 g_signal_connect(s->window, "delete-event", 1662 G_CALLBACK(gd_window_close), s); 1663 1664 g_signal_connect(s->pause_item, "activate", 1665 G_CALLBACK(gd_menu_pause), s); 1666 g_signal_connect(s->reset_item, "activate", 1667 G_CALLBACK(gd_menu_reset), s); 1668 g_signal_connect(s->powerdown_item, "activate", 1669 G_CALLBACK(gd_menu_powerdown), s); 1670 g_signal_connect(s->quit_item, "activate", 1671 G_CALLBACK(gd_menu_quit), s); 1672 g_signal_connect(s->full_screen_item, "activate", 1673 G_CALLBACK(gd_menu_full_screen), s); 1674 g_signal_connect(s->zoom_in_item, "activate", 1675 G_CALLBACK(gd_menu_zoom_in), s); 1676 g_signal_connect(s->zoom_out_item, "activate", 1677 G_CALLBACK(gd_menu_zoom_out), s); 1678 g_signal_connect(s->zoom_fixed_item, "activate", 1679 G_CALLBACK(gd_menu_zoom_fixed), s); 1680 g_signal_connect(s->zoom_fit_item, "activate", 1681 G_CALLBACK(gd_menu_zoom_fit), s); 1682 g_signal_connect(s->grab_item, "activate", 1683 G_CALLBACK(gd_menu_grab_input), s); 1684 g_signal_connect(s->notebook, "switch-page", 1685 G_CALLBACK(gd_change_page), s); 1686 } 1687 1688 static GtkWidget *gd_create_menu_machine(GtkDisplayState *s) 1689 { 1690 GtkWidget *machine_menu; 1691 GtkWidget *separator; 1692 1693 machine_menu = gtk_menu_new(); 1694 gtk_menu_set_accel_group(GTK_MENU(machine_menu), s->accel_group); 1695 1696 s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause")); 1697 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->pause_item); 1698 1699 separator = gtk_separator_menu_item_new(); 1700 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator); 1701 1702 s->reset_item = gtk_menu_item_new_with_mnemonic(_("_Reset")); 1703 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->reset_item); 1704 1705 s->powerdown_item = gtk_menu_item_new_with_mnemonic(_("Power _Down")); 1706 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->powerdown_item); 1707 1708 separator = gtk_separator_menu_item_new(); 1709 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator); 1710 1711 s->quit_item = gtk_menu_item_new_with_mnemonic(_("_Quit")); 1712 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item), 1713 "<QEMU>/Machine/Quit"); 1714 gtk_accel_map_add_entry("<QEMU>/Machine/Quit", 1715 GDK_KEY_q, HOTKEY_MODIFIERS); 1716 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->quit_item); 1717 1718 return machine_menu; 1719 } 1720 1721 static GSList *gd_vc_gfx_init(GtkDisplayState *s, VirtualConsole *vc, 1722 QemuConsole *con, int idx, 1723 GSList *group, GtkWidget *view_menu) 1724 { 1725 vc->label = qemu_console_get_label(con); 1726 vc->s = s; 1727 vc->gfx.scale_x = 1.0; 1728 vc->gfx.scale_y = 1.0; 1729 1730 vc->gfx.drawing_area = gtk_drawing_area_new(); 1731 gtk_widget_add_events(vc->gfx.drawing_area, 1732 GDK_POINTER_MOTION_MASK | 1733 GDK_BUTTON_PRESS_MASK | 1734 GDK_BUTTON_RELEASE_MASK | 1735 GDK_BUTTON_MOTION_MASK | 1736 GDK_ENTER_NOTIFY_MASK | 1737 GDK_LEAVE_NOTIFY_MASK | 1738 GDK_SCROLL_MASK | 1739 GDK_KEY_PRESS_MASK); 1740 gtk_widget_set_can_focus(vc->gfx.drawing_area, TRUE); 1741 1742 vc->type = GD_VC_GFX; 1743 vc->tab_item = vc->gfx.drawing_area; 1744 vc->focus = vc->gfx.drawing_area; 1745 gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), 1746 vc->tab_item, gtk_label_new(vc->label)); 1747 1748 #if defined(CONFIG_OPENGL) 1749 if (display_opengl) { 1750 /* 1751 * gtk_widget_set_double_buffered() was deprecated in 3.14. 1752 * It is required for opengl rendering on X11 though. A 1753 * proper replacement (native opengl support) is only 1754 * available in 3.16+. Silence the warning if possible. 1755 */ 1756 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE 1757 #pragma GCC diagnostic push 1758 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 1759 #endif 1760 gtk_widget_set_double_buffered(vc->gfx.drawing_area, FALSE); 1761 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE 1762 #pragma GCC diagnostic pop 1763 #endif 1764 vc->gfx.dcl.ops = &dcl_egl_ops; 1765 } else 1766 #endif 1767 { 1768 vc->gfx.dcl.ops = &dcl_ops; 1769 } 1770 1771 vc->gfx.dcl.con = con; 1772 register_displaychangelistener(&vc->gfx.dcl); 1773 1774 gd_connect_vc_gfx_signals(vc); 1775 group = gd_vc_menu_init(s, vc, idx, group, view_menu); 1776 1777 if (dpy_ui_info_supported(vc->gfx.dcl.con)) { 1778 gtk_menu_item_activate(GTK_MENU_ITEM(s->zoom_fit_item)); 1779 s->free_scale = true; 1780 } 1781 1782 return group; 1783 } 1784 1785 static GtkWidget *gd_create_menu_view(GtkDisplayState *s) 1786 { 1787 GSList *group = NULL; 1788 GtkWidget *view_menu; 1789 GtkWidget *separator; 1790 QemuConsole *con; 1791 int vc; 1792 1793 view_menu = gtk_menu_new(); 1794 gtk_menu_set_accel_group(GTK_MENU(view_menu), s->accel_group); 1795 1796 s->full_screen_item = gtk_menu_item_new_with_mnemonic(_("_Fullscreen")); 1797 1798 gtk_accel_group_connect(s->accel_group, GDK_KEY_f, HOTKEY_MODIFIERS, 0, 1799 g_cclosure_new_swap(G_CALLBACK(gd_accel_full_screen), s, NULL)); 1800 #if GTK_CHECK_VERSION(3, 8, 0) 1801 gtk_accel_label_set_accel( 1802 GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(s->full_screen_item))), 1803 GDK_KEY_f, HOTKEY_MODIFIERS); 1804 #endif 1805 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->full_screen_item); 1806 1807 separator = gtk_separator_menu_item_new(); 1808 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 1809 1810 s->zoom_in_item = gtk_menu_item_new_with_mnemonic(_("Zoom _In")); 1811 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_in_item), 1812 "<QEMU>/View/Zoom In"); 1813 gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus, 1814 HOTKEY_MODIFIERS); 1815 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_in_item); 1816 1817 s->zoom_out_item = gtk_menu_item_new_with_mnemonic(_("Zoom _Out")); 1818 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_out_item), 1819 "<QEMU>/View/Zoom Out"); 1820 gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus, 1821 HOTKEY_MODIFIERS); 1822 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_out_item); 1823 1824 s->zoom_fixed_item = gtk_menu_item_new_with_mnemonic(_("Best _Fit")); 1825 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_fixed_item), 1826 "<QEMU>/View/Zoom Fixed"); 1827 gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0, 1828 HOTKEY_MODIFIERS); 1829 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fixed_item); 1830 1831 s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit")); 1832 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fit_item); 1833 1834 separator = gtk_separator_menu_item_new(); 1835 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 1836 1837 s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover")); 1838 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_on_hover_item); 1839 1840 s->grab_item = gtk_check_menu_item_new_with_mnemonic(_("_Grab Input")); 1841 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->grab_item), 1842 "<QEMU>/View/Grab Input"); 1843 gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g, 1844 HOTKEY_MODIFIERS); 1845 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_item); 1846 1847 separator = gtk_separator_menu_item_new(); 1848 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 1849 1850 /* gfx */ 1851 for (vc = 0;; vc++) { 1852 con = qemu_console_lookup_by_index(vc); 1853 if (!con) { 1854 break; 1855 } 1856 group = gd_vc_gfx_init(s, &s->vc[vc], con, 1857 vc, group, view_menu); 1858 s->nb_vcs++; 1859 } 1860 1861 #if defined(CONFIG_VTE) 1862 /* vte */ 1863 gd_vcs_init(s, group, view_menu); 1864 #endif 1865 1866 separator = gtk_separator_menu_item_new(); 1867 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 1868 1869 s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs")); 1870 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_tabs_item); 1871 1872 s->untabify_item = gtk_menu_item_new_with_mnemonic(_("Detach Tab")); 1873 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->untabify_item); 1874 1875 return view_menu; 1876 } 1877 1878 static void gd_create_menus(GtkDisplayState *s) 1879 { 1880 s->accel_group = gtk_accel_group_new(); 1881 s->machine_menu = gd_create_menu_machine(s); 1882 s->view_menu = gd_create_menu_view(s); 1883 1884 s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine")); 1885 gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->machine_menu_item), 1886 s->machine_menu); 1887 gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->machine_menu_item); 1888 1889 s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View")); 1890 gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->view_menu_item), s->view_menu); 1891 gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item); 1892 1893 g_object_set_data(G_OBJECT(s->window), "accel_group", s->accel_group); 1894 gtk_window_add_accel_group(GTK_WINDOW(s->window), s->accel_group); 1895 } 1896 1897 static void gd_set_keycode_type(GtkDisplayState *s) 1898 { 1899 #ifdef GDK_WINDOWING_X11 1900 GdkDisplay *display = gtk_widget_get_display(s->window); 1901 if (GDK_IS_X11_DISPLAY(display)) { 1902 Display *x11_display = gdk_x11_display_get_xdisplay(display); 1903 XkbDescPtr desc = XkbGetKeyboard(x11_display, XkbGBN_AllComponentsMask, 1904 XkbUseCoreKbd); 1905 char *keycodes = NULL; 1906 1907 if (desc && desc->names) { 1908 keycodes = XGetAtomName(x11_display, desc->names->keycodes); 1909 } 1910 if (keycodes == NULL) { 1911 fprintf(stderr, "could not lookup keycode name\n"); 1912 } else if (strstart(keycodes, "evdev", NULL)) { 1913 s->has_evdev = true; 1914 } else if (!strstart(keycodes, "xfree86", NULL)) { 1915 fprintf(stderr, "unknown keycodes `%s', please report to " 1916 "qemu-devel@nongnu.org\n", keycodes); 1917 } 1918 1919 if (desc) { 1920 XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True); 1921 } 1922 if (keycodes) { 1923 XFree(keycodes); 1924 } 1925 } 1926 #endif 1927 } 1928 1929 static gboolean gtkinit; 1930 1931 void gtk_display_init(DisplayState *ds, bool full_screen, bool grab_on_hover) 1932 { 1933 GtkDisplayState *s = g_malloc0(sizeof(*s)); 1934 char *filename; 1935 GdkDisplay *window_display; 1936 1937 if (!gtkinit) { 1938 fprintf(stderr, "gtk initialization failed\n"); 1939 exit(1); 1940 } 1941 1942 s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 1943 #if GTK_CHECK_VERSION(3, 2, 0) 1944 s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); 1945 #else 1946 s->vbox = gtk_vbox_new(FALSE, 0); 1947 #endif 1948 s->notebook = gtk_notebook_new(); 1949 s->menu_bar = gtk_menu_bar_new(); 1950 1951 s->free_scale = FALSE; 1952 1953 /* LC_MESSAGES only. See early_gtk_display_init() for details */ 1954 setlocale(LC_MESSAGES, ""); 1955 bindtextdomain("qemu", CONFIG_QEMU_LOCALEDIR); 1956 textdomain("qemu"); 1957 1958 window_display = gtk_widget_get_display(s->window); 1959 s->null_cursor = gdk_cursor_new_for_display(window_display, 1960 GDK_BLANK_CURSOR); 1961 1962 s->mouse_mode_notifier.notify = gd_mouse_mode_change; 1963 qemu_add_mouse_mode_change_notifier(&s->mouse_mode_notifier); 1964 qemu_add_vm_change_state_handler(gd_change_runstate, s); 1965 1966 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu_logo_no_text.svg"); 1967 if (filename) { 1968 GError *error = NULL; 1969 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(filename, &error); 1970 if (pixbuf) { 1971 gtk_window_set_icon(GTK_WINDOW(s->window), pixbuf); 1972 } else { 1973 g_error_free(error); 1974 } 1975 g_free(filename); 1976 } 1977 1978 gd_create_menus(s); 1979 1980 gd_connect_signals(s); 1981 1982 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 1983 gtk_notebook_set_show_border(GTK_NOTEBOOK(s->notebook), FALSE); 1984 1985 gd_update_caption(s); 1986 1987 gtk_box_pack_start(GTK_BOX(s->vbox), s->menu_bar, FALSE, TRUE, 0); 1988 gtk_box_pack_start(GTK_BOX(s->vbox), s->notebook, TRUE, TRUE, 0); 1989 1990 gtk_container_add(GTK_CONTAINER(s->window), s->vbox); 1991 1992 gtk_widget_show_all(s->window); 1993 1994 #ifdef VTE_RESIZE_HACK 1995 { 1996 VirtualConsole *cur = gd_vc_find_current(s); 1997 if (cur) { 1998 int i; 1999 2000 for (i = 0; i < s->nb_vcs; i++) { 2001 VirtualConsole *vc = &s->vc[i]; 2002 if (vc && vc->type == GD_VC_VTE && vc != cur) { 2003 gtk_widget_hide(vc->vte.terminal); 2004 } 2005 } 2006 gd_update_windowsize(cur); 2007 } 2008 } 2009 #endif 2010 2011 if (full_screen) { 2012 gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item)); 2013 } 2014 if (grab_on_hover) { 2015 gtk_menu_item_activate(GTK_MENU_ITEM(s->grab_on_hover_item)); 2016 } 2017 2018 gd_set_keycode_type(s); 2019 } 2020 2021 void early_gtk_display_init(int opengl) 2022 { 2023 /* The QEMU code relies on the assumption that it's always run in 2024 * the C locale. Therefore it is not prepared to deal with 2025 * operations that produce different results depending on the 2026 * locale, such as printf's formatting of decimal numbers, and 2027 * possibly others. 2028 * 2029 * Since GTK+ calls setlocale() by default -importing the locale 2030 * settings from the environment- we must prevent it from doing so 2031 * using gtk_disable_setlocale(). 2032 * 2033 * QEMU's GTK+ UI, however, _does_ have translations for some of 2034 * the menu items. As a trade-off between a functionally correct 2035 * QEMU and a fully internationalized UI we support importing 2036 * LC_MESSAGES from the environment (see the setlocale() call 2037 * earlier in this file). This allows us to display translated 2038 * messages leaving everything else untouched. 2039 */ 2040 gtk_disable_setlocale(); 2041 gtkinit = gtk_init_check(NULL, NULL); 2042 if (!gtkinit) { 2043 /* don't exit yet, that'll break -help */ 2044 return; 2045 } 2046 2047 switch (opengl) { 2048 case -1: /* default */ 2049 case 0: /* off */ 2050 break; 2051 case 1: /* on */ 2052 #if defined(CONFIG_OPENGL) 2053 gtk_egl_init(); 2054 #endif 2055 break; 2056 default: 2057 g_assert_not_reached(); 2058 break; 2059 } 2060 2061 #if defined(CONFIG_VTE) 2062 register_vc_handler(gd_vc_handler); 2063 #endif 2064 } 2065