1 /* 2 * GTK UI 3 * 4 * Copyright IBM, Corp. 2012 5 * 6 * Authors: 7 * Anthony Liguori <aliguori@us.ibm.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, see <http://www.gnu.org/licenses/>. 21 * 22 * Portions from gtk-vnc (originally licensed under the LGPL v2+): 23 * 24 * GTK VNC Widget 25 * 26 * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws> 27 * Copyright (C) 2009-2010 Daniel P. Berrange <dan@berrange.com> 28 */ 29 30 #define GETTEXT_PACKAGE "qemu" 31 #define LOCALEDIR "po" 32 33 #include "qemu/osdep.h" 34 #include "qapi/error.h" 35 #include "qapi/qapi-commands-control.h" 36 #include "qapi/qapi-commands-machine.h" 37 #include "qapi/qapi-commands-misc.h" 38 #include "qemu/cutils.h" 39 #include "qemu/error-report.h" 40 #include "qemu/main-loop.h" 41 #include "qemu-main.h" 42 43 #include "ui/console.h" 44 #include "ui/gtk.h" 45 #ifdef G_OS_WIN32 46 #include <gdk/gdkwin32.h> 47 #endif 48 #include "ui/win32-kbd-hook.h" 49 50 #include <glib/gi18n.h> 51 #include <locale.h> 52 #if defined(CONFIG_VTE) 53 #include <vte/vte.h> 54 #endif 55 #include <math.h> 56 57 #include "trace.h" 58 #include "ui/input.h" 59 #include "system/runstate.h" 60 #include "system/system.h" 61 #include "keymaps.h" 62 #include "chardev/char.h" 63 #include "qom/object.h" 64 65 #define VC_WINDOW_X_MIN 320 66 #define VC_WINDOW_Y_MIN 240 67 #define VC_TERM_X_MIN 80 68 #define VC_TERM_Y_MIN 25 69 #define VC_SCALE_MIN 0.25 70 #define VC_SCALE_MAX 4 71 #define VC_SCALE_STEP 0.25 72 73 #ifdef GDK_WINDOWING_X11 74 #include "x_keymap.h" 75 76 /* Gtk2 compat */ 77 #ifndef GDK_IS_X11_DISPLAY 78 #define GDK_IS_X11_DISPLAY(dpy) (dpy != NULL) 79 #endif 80 #endif 81 82 83 #ifdef GDK_WINDOWING_WAYLAND 84 /* Gtk2 compat */ 85 #ifndef GDK_IS_WAYLAND_DISPLAY 86 #define GDK_IS_WAYLAND_DISPLAY(dpy) (dpy != NULL) 87 #endif 88 #endif 89 90 91 #ifdef GDK_WINDOWING_WIN32 92 /* Gtk2 compat */ 93 #ifndef GDK_IS_WIN32_DISPLAY 94 #define GDK_IS_WIN32_DISPLAY(dpy) (dpy != NULL) 95 #endif 96 #endif 97 98 99 #ifdef GDK_WINDOWING_BROADWAY 100 /* Gtk2 compat */ 101 #ifndef GDK_IS_BROADWAY_DISPLAY 102 #define GDK_IS_BROADWAY_DISPLAY(dpy) (dpy != NULL) 103 #endif 104 #endif 105 106 107 #ifdef GDK_WINDOWING_QUARTZ 108 /* Gtk2 compat */ 109 #ifndef GDK_IS_QUARTZ_DISPLAY 110 #define GDK_IS_QUARTZ_DISPLAY(dpy) (dpy != NULL) 111 #endif 112 #endif 113 114 115 #if !defined(CONFIG_VTE) 116 # define VTE_CHECK_VERSION(a, b, c) 0 117 #endif 118 119 #define HOTKEY_MODIFIERS (GDK_CONTROL_MASK | GDK_MOD1_MASK) 120 121 static const guint16 *keycode_map; 122 static size_t keycode_maplen; 123 124 struct VCChardev { 125 Chardev parent; 126 VirtualConsole *console; 127 bool echo; 128 }; 129 typedef struct VCChardev VCChardev; 130 131 #define TYPE_CHARDEV_VC "chardev-vc" 132 DECLARE_INSTANCE_CHECKER(VCChardev, VC_CHARDEV, 133 TYPE_CHARDEV_VC) 134 135 static struct touch_slot touch_slots[INPUT_EVENT_SLOTS_MAX]; 136 137 bool gtk_use_gl_area; 138 139 static void gd_grab_pointer(VirtualConsole *vc, const char *reason); 140 static void gd_ungrab_pointer(GtkDisplayState *s); 141 static void gd_grab_keyboard(VirtualConsole *vc, const char *reason); 142 static void gd_ungrab_keyboard(GtkDisplayState *s); 143 144 /** Utility Functions **/ 145 146 static VirtualConsole *gd_vc_find_by_menu(GtkDisplayState *s) 147 { 148 VirtualConsole *vc; 149 gint i; 150 151 for (i = 0; i < s->nb_vcs; i++) { 152 vc = &s->vc[i]; 153 if (gtk_check_menu_item_get_active 154 (GTK_CHECK_MENU_ITEM(vc->menu_item))) { 155 return vc; 156 } 157 } 158 return NULL; 159 } 160 161 static VirtualConsole *gd_vc_find_by_page(GtkDisplayState *s, gint page) 162 { 163 VirtualConsole *vc; 164 gint i, p; 165 166 for (i = 0; i < s->nb_vcs; i++) { 167 vc = &s->vc[i]; 168 p = gtk_notebook_page_num(GTK_NOTEBOOK(s->notebook), vc->tab_item); 169 if (p == page) { 170 return vc; 171 } 172 } 173 return NULL; 174 } 175 176 static VirtualConsole *gd_vc_find_current(GtkDisplayState *s) 177 { 178 gint page; 179 180 page = gtk_notebook_get_current_page(GTK_NOTEBOOK(s->notebook)); 181 return gd_vc_find_by_page(s, page); 182 } 183 184 static bool gd_is_grab_active(GtkDisplayState *s) 185 { 186 return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_item)); 187 } 188 189 static bool gd_grab_on_hover(GtkDisplayState *s) 190 { 191 return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_on_hover_item)); 192 } 193 194 static void gd_update_cursor(VirtualConsole *vc) 195 { 196 GtkDisplayState *s = vc->s; 197 GdkWindow *window; 198 199 if (vc->type != GD_VC_GFX || 200 !qemu_console_is_graphic(vc->gfx.dcl.con)) { 201 return; 202 } 203 204 if (!gtk_widget_get_realized(vc->gfx.drawing_area)) { 205 return; 206 } 207 208 window = gtk_widget_get_window(GTK_WIDGET(vc->gfx.drawing_area)); 209 if (s->full_screen || qemu_input_is_absolute(vc->gfx.dcl.con) || s->ptr_owner == vc) { 210 gdk_window_set_cursor(window, s->null_cursor); 211 } else { 212 gdk_window_set_cursor(window, NULL); 213 } 214 } 215 216 static void gd_update_caption(GtkDisplayState *s) 217 { 218 const char *status = ""; 219 gchar *prefix; 220 gchar *title; 221 const char *grab = ""; 222 bool is_paused = !runstate_is_running(); 223 int i; 224 225 if (qemu_name) { 226 prefix = g_strdup_printf("QEMU (%s)", qemu_name); 227 } else { 228 prefix = g_strdup_printf("QEMU"); 229 } 230 231 if (s->ptr_owner != NULL && 232 s->ptr_owner->window == NULL) { 233 grab = _(" - Press Ctrl+Alt+G to release grab"); 234 } 235 236 if (is_paused) { 237 status = _(" [Paused]"); 238 } 239 s->external_pause_update = true; 240 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->pause_item), 241 is_paused); 242 s->external_pause_update = false; 243 244 title = g_strdup_printf("%s%s%s", prefix, status, grab); 245 gtk_window_set_title(GTK_WINDOW(s->window), title); 246 g_free(title); 247 248 for (i = 0; i < s->nb_vcs; i++) { 249 VirtualConsole *vc = &s->vc[i]; 250 251 if (!vc->window) { 252 continue; 253 } 254 title = g_strdup_printf("%s: %s%s%s", prefix, vc->label, 255 vc == s->kbd_owner ? " +kbd" : "", 256 vc == s->ptr_owner ? " +ptr" : ""); 257 gtk_window_set_title(GTK_WINDOW(vc->window), title); 258 g_free(title); 259 } 260 261 g_free(prefix); 262 } 263 264 static void gd_update_geometry_hints(VirtualConsole *vc) 265 { 266 GtkDisplayState *s = vc->s; 267 GdkWindowHints mask = 0; 268 GdkGeometry geo = {}; 269 GtkWidget *geo_widget = NULL; 270 GtkWindow *geo_window; 271 272 if (vc->type == GD_VC_GFX) { 273 if (!vc->gfx.ds) { 274 return; 275 } 276 double scale_x = s->free_scale ? VC_SCALE_MIN : vc->gfx.scale_x; 277 double scale_y = s->free_scale ? VC_SCALE_MIN : vc->gfx.scale_y; 278 geo.min_width = surface_width(vc->gfx.ds) * scale_x; 279 geo.min_height = surface_height(vc->gfx.ds) * scale_y; 280 mask |= GDK_HINT_MIN_SIZE; 281 geo_widget = vc->gfx.drawing_area; 282 gtk_widget_set_size_request(geo_widget, geo.min_width, geo.min_height); 283 284 #if defined(CONFIG_VTE) 285 } else if (vc->type == GD_VC_VTE) { 286 VteTerminal *term = VTE_TERMINAL(vc->vte.terminal); 287 GtkBorder padding = { 0 }; 288 289 #if VTE_CHECK_VERSION(0, 37, 0) 290 gtk_style_context_get_padding( 291 gtk_widget_get_style_context(vc->vte.terminal), 292 gtk_widget_get_state_flags(vc->vte.terminal), 293 &padding); 294 #else 295 { 296 GtkBorder *ib = NULL; 297 gtk_widget_style_get(vc->vte.terminal, "inner-border", &ib, NULL); 298 if (ib) { 299 padding = *ib; 300 gtk_border_free(ib); 301 } 302 } 303 #endif 304 305 geo.width_inc = vte_terminal_get_char_width(term); 306 geo.height_inc = vte_terminal_get_char_height(term); 307 mask |= GDK_HINT_RESIZE_INC; 308 geo.base_width = geo.width_inc; 309 geo.base_height = geo.height_inc; 310 mask |= GDK_HINT_BASE_SIZE; 311 geo.min_width = geo.width_inc * VC_TERM_X_MIN; 312 geo.min_height = geo.height_inc * VC_TERM_Y_MIN; 313 mask |= GDK_HINT_MIN_SIZE; 314 315 geo.base_width += padding.left + padding.right; 316 geo.base_height += padding.top + padding.bottom; 317 geo.min_width += padding.left + padding.right; 318 geo.min_height += padding.top + padding.bottom; 319 geo_widget = vc->vte.terminal; 320 #endif 321 } 322 323 geo_window = GTK_WINDOW(vc->window ? vc->window : s->window); 324 gtk_window_set_geometry_hints(geo_window, geo_widget, &geo, mask); 325 } 326 327 void gd_update_windowsize(VirtualConsole *vc) 328 { 329 GtkDisplayState *s = vc->s; 330 331 gd_update_geometry_hints(vc); 332 333 if (vc->type == GD_VC_GFX && !s->full_screen && !s->free_scale) { 334 gtk_window_resize(GTK_WINDOW(vc->window ? vc->window : s->window), 335 VC_WINDOW_X_MIN, VC_WINDOW_Y_MIN); 336 } 337 } 338 339 static void gd_update_full_redraw(VirtualConsole *vc) 340 { 341 GtkWidget *area = vc->gfx.drawing_area; 342 int ww, wh; 343 ww = gdk_window_get_width(gtk_widget_get_window(area)); 344 wh = gdk_window_get_height(gtk_widget_get_window(area)); 345 #if defined(CONFIG_OPENGL) 346 if (vc->gfx.gls && gtk_use_gl_area) { 347 gtk_gl_area_queue_render(GTK_GL_AREA(vc->gfx.drawing_area)); 348 return; 349 } 350 #endif 351 gtk_widget_queue_draw_area(area, 0, 0, ww, wh); 352 } 353 354 static void gtk_release_modifiers(GtkDisplayState *s) 355 { 356 VirtualConsole *vc = gd_vc_find_current(s); 357 358 if (vc->type != GD_VC_GFX || 359 !qemu_console_is_graphic(vc->gfx.dcl.con)) { 360 return; 361 } 362 qkbd_state_lift_all_keys(vc->gfx.kbd); 363 } 364 365 static void gd_widget_reparent(GtkWidget *from, GtkWidget *to, 366 GtkWidget *widget) 367 { 368 g_object_ref(G_OBJECT(widget)); 369 gtk_container_remove(GTK_CONTAINER(from), widget); 370 gtk_container_add(GTK_CONTAINER(to), widget); 371 g_object_unref(G_OBJECT(widget)); 372 } 373 374 static void *gd_win32_get_hwnd(VirtualConsole *vc) 375 { 376 #ifdef G_OS_WIN32 377 return gdk_win32_window_get_impl_hwnd( 378 gtk_widget_get_window(vc->window ? vc->window : vc->s->window)); 379 #else 380 return NULL; 381 #endif 382 } 383 384 /** DisplayState Callbacks **/ 385 386 static void gd_update(DisplayChangeListener *dcl, 387 int fbx, int fby, int fbw, int fbh) 388 { 389 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 390 GdkWindow *win; 391 int wx1, wx2, wy1, wy2; 392 int wx_offset, wy_offset; 393 int ww_surface, wh_surface; 394 int ww_widget, wh_widget; 395 396 trace_gd_update(vc->label, fbx, fby, fbw, fbh); 397 398 if (!gtk_widget_get_realized(vc->gfx.drawing_area)) { 399 return; 400 } 401 402 if (vc->gfx.convert) { 403 pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image, 404 NULL, vc->gfx.convert, 405 fbx, fby, 0, 0, fbx, fby, fbw, fbh); 406 } 407 408 wx1 = floor(fbx * vc->gfx.scale_x); 409 wy1 = floor(fby * vc->gfx.scale_y); 410 411 wx2 = ceil(fbx * vc->gfx.scale_x + fbw * vc->gfx.scale_x); 412 wy2 = ceil(fby * vc->gfx.scale_y + fbh * vc->gfx.scale_y); 413 414 ww_surface = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 415 wh_surface = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 416 417 win = gtk_widget_get_window(vc->gfx.drawing_area); 418 if (!win) { 419 return; 420 } 421 ww_widget = gdk_window_get_width(win); 422 wh_widget = gdk_window_get_height(win); 423 424 wx_offset = wy_offset = 0; 425 if (ww_widget > ww_surface) { 426 wx_offset = (ww_widget - ww_surface) / 2; 427 } 428 if (wh_widget > wh_surface) { 429 wy_offset = (wh_widget - wh_surface) / 2; 430 } 431 432 gtk_widget_queue_draw_area(vc->gfx.drawing_area, 433 wx_offset + wx1, wy_offset + wy1, 434 (wx2 - wx1), (wy2 - wy1)); 435 } 436 437 static void gd_refresh(DisplayChangeListener *dcl) 438 { 439 graphic_hw_update(dcl->con); 440 } 441 442 static GdkDevice *gd_get_pointer(GdkDisplay *dpy) 443 { 444 return gdk_seat_get_pointer(gdk_display_get_default_seat(dpy)); 445 } 446 447 static void gd_mouse_set(DisplayChangeListener *dcl, 448 int x, int y, bool visible) 449 { 450 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 451 GdkDisplay *dpy; 452 gint x_root, y_root; 453 454 if (!gtk_widget_get_realized(vc->gfx.drawing_area) || 455 qemu_input_is_absolute(dcl->con)) { 456 return; 457 } 458 459 dpy = gtk_widget_get_display(vc->gfx.drawing_area); 460 gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area), 461 x, y, &x_root, &y_root); 462 gdk_device_warp(gd_get_pointer(dpy), 463 gtk_widget_get_screen(vc->gfx.drawing_area), 464 x_root, y_root); 465 vc->s->last_x = x; 466 vc->s->last_y = y; 467 } 468 469 static void gd_cursor_define(DisplayChangeListener *dcl, 470 QEMUCursor *c) 471 { 472 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 473 GdkPixbuf *pixbuf; 474 GdkCursor *cursor; 475 476 if (!gtk_widget_get_realized(vc->gfx.drawing_area)) { 477 return; 478 } 479 480 pixbuf = gdk_pixbuf_new_from_data((guchar *)(c->data), 481 GDK_COLORSPACE_RGB, true, 8, 482 c->width, c->height, c->width * 4, 483 NULL, NULL); 484 cursor = gdk_cursor_new_from_pixbuf 485 (gtk_widget_get_display(vc->gfx.drawing_area), 486 pixbuf, c->hot_x, c->hot_y); 487 gdk_window_set_cursor(gtk_widget_get_window(vc->gfx.drawing_area), cursor); 488 g_object_unref(pixbuf); 489 g_object_unref(cursor); 490 } 491 492 static void gd_switch(DisplayChangeListener *dcl, 493 DisplaySurface *surface) 494 { 495 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 496 bool resized = true; 497 498 trace_gd_switch(vc->label, surface_width(surface), surface_height(surface)); 499 500 if (vc->gfx.surface) { 501 cairo_surface_destroy(vc->gfx.surface); 502 vc->gfx.surface = NULL; 503 } 504 if (vc->gfx.convert) { 505 pixman_image_unref(vc->gfx.convert); 506 vc->gfx.convert = NULL; 507 } 508 509 if (vc->gfx.ds && 510 surface_width(vc->gfx.ds) == surface_width(surface) && 511 surface_height(vc->gfx.ds) == surface_height(surface)) { 512 resized = false; 513 } 514 vc->gfx.ds = surface; 515 516 if (surface_format(surface) == PIXMAN_x8r8g8b8) { 517 /* 518 * PIXMAN_x8r8g8b8 == CAIRO_FORMAT_RGB24 519 * 520 * No need to convert, use surface directly. Should be the 521 * common case as this is qemu_default_pixelformat(32) too. 522 */ 523 vc->gfx.surface = cairo_image_surface_create_for_data 524 (surface_data(surface), 525 CAIRO_FORMAT_RGB24, 526 surface_width(surface), 527 surface_height(surface), 528 surface_stride(surface)); 529 } else { 530 /* Must convert surface, use pixman to do it. */ 531 vc->gfx.convert = pixman_image_create_bits(PIXMAN_x8r8g8b8, 532 surface_width(surface), 533 surface_height(surface), 534 NULL, 0); 535 vc->gfx.surface = cairo_image_surface_create_for_data 536 ((void *)pixman_image_get_data(vc->gfx.convert), 537 CAIRO_FORMAT_RGB24, 538 pixman_image_get_width(vc->gfx.convert), 539 pixman_image_get_height(vc->gfx.convert), 540 pixman_image_get_stride(vc->gfx.convert)); 541 pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image, 542 NULL, vc->gfx.convert, 543 0, 0, 0, 0, 0, 0, 544 pixman_image_get_width(vc->gfx.convert), 545 pixman_image_get_height(vc->gfx.convert)); 546 } 547 548 if (resized) { 549 gd_update_windowsize(vc); 550 } else { 551 gd_update_full_redraw(vc); 552 } 553 } 554 555 static const DisplayChangeListenerOps dcl_ops = { 556 .dpy_name = "gtk", 557 .dpy_gfx_update = gd_update, 558 .dpy_gfx_switch = gd_switch, 559 .dpy_gfx_check_format = qemu_pixman_check_format, 560 .dpy_refresh = gd_refresh, 561 .dpy_mouse_set = gd_mouse_set, 562 .dpy_cursor_define = gd_cursor_define, 563 }; 564 565 566 #if defined(CONFIG_OPENGL) 567 568 static bool gd_has_dmabuf(DisplayChangeListener *dcl) 569 { 570 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 571 572 if (gtk_use_gl_area && !gtk_widget_get_realized(vc->gfx.drawing_area)) { 573 /* FIXME: Assume it will work, actual check done after realize */ 574 /* fixing this would require delaying listener registration */ 575 return true; 576 } 577 578 return vc->gfx.has_dmabuf; 579 } 580 581 static void gd_gl_release_dmabuf(DisplayChangeListener *dcl, 582 QemuDmaBuf *dmabuf) 583 { 584 #ifdef CONFIG_GBM 585 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl); 586 587 egl_dmabuf_release_texture(dmabuf); 588 if (vc->gfx.guest_fb.dmabuf == dmabuf) { 589 vc->gfx.guest_fb.dmabuf = NULL; 590 } 591 #endif 592 } 593 594 void gd_hw_gl_flushed(void *vcon) 595 { 596 VirtualConsole *vc = vcon; 597 QemuDmaBuf *dmabuf = vc->gfx.guest_fb.dmabuf; 598 int fence_fd; 599 600 fence_fd = qemu_dmabuf_get_fence_fd(dmabuf); 601 if (fence_fd >= 0) { 602 qemu_set_fd_handler(fence_fd, NULL, NULL, NULL); 603 close(fence_fd); 604 qemu_dmabuf_set_fence_fd(dmabuf, -1); 605 graphic_hw_gl_block(vc->gfx.dcl.con, false); 606 } 607 } 608 609 /** DisplayState Callbacks (opengl version) **/ 610 611 static const DisplayChangeListenerOps dcl_gl_area_ops = { 612 .dpy_name = "gtk-egl", 613 .dpy_gfx_update = gd_gl_area_update, 614 .dpy_gfx_switch = gd_gl_area_switch, 615 .dpy_gfx_check_format = console_gl_check_format, 616 .dpy_refresh = gd_gl_area_refresh, 617 .dpy_mouse_set = gd_mouse_set, 618 .dpy_cursor_define = gd_cursor_define, 619 620 .dpy_gl_scanout_texture = gd_gl_area_scanout_texture, 621 .dpy_gl_scanout_disable = gd_gl_area_scanout_disable, 622 .dpy_gl_update = gd_gl_area_scanout_flush, 623 .dpy_gl_scanout_dmabuf = gd_gl_area_scanout_dmabuf, 624 .dpy_gl_release_dmabuf = gd_gl_release_dmabuf, 625 .dpy_has_dmabuf = gd_has_dmabuf, 626 }; 627 628 static bool 629 gd_gl_area_is_compatible_dcl(DisplayGLCtx *dgc, 630 DisplayChangeListener *dcl) 631 { 632 return dcl->ops == &dcl_gl_area_ops; 633 } 634 635 static const DisplayGLCtxOps gl_area_ctx_ops = { 636 .dpy_gl_ctx_is_compatible_dcl = gd_gl_area_is_compatible_dcl, 637 .dpy_gl_ctx_create = gd_gl_area_create_context, 638 .dpy_gl_ctx_destroy = gd_gl_area_destroy_context, 639 .dpy_gl_ctx_make_current = gd_gl_area_make_current, 640 }; 641 642 #ifdef CONFIG_X11 643 static const DisplayChangeListenerOps dcl_egl_ops = { 644 .dpy_name = "gtk-egl", 645 .dpy_gfx_update = gd_egl_update, 646 .dpy_gfx_switch = gd_egl_switch, 647 .dpy_gfx_check_format = console_gl_check_format, 648 .dpy_refresh = gd_egl_refresh, 649 .dpy_mouse_set = gd_mouse_set, 650 .dpy_cursor_define = gd_cursor_define, 651 652 .dpy_gl_scanout_disable = gd_egl_scanout_disable, 653 .dpy_gl_scanout_texture = gd_egl_scanout_texture, 654 .dpy_gl_scanout_dmabuf = gd_egl_scanout_dmabuf, 655 .dpy_gl_cursor_dmabuf = gd_egl_cursor_dmabuf, 656 .dpy_gl_cursor_position = gd_egl_cursor_position, 657 .dpy_gl_update = gd_egl_flush, 658 .dpy_gl_release_dmabuf = gd_gl_release_dmabuf, 659 .dpy_has_dmabuf = gd_has_dmabuf, 660 }; 661 662 static bool 663 gd_egl_is_compatible_dcl(DisplayGLCtx *dgc, 664 DisplayChangeListener *dcl) 665 { 666 return dcl->ops == &dcl_egl_ops; 667 } 668 669 static const DisplayGLCtxOps egl_ctx_ops = { 670 .dpy_gl_ctx_is_compatible_dcl = gd_egl_is_compatible_dcl, 671 .dpy_gl_ctx_create = gd_egl_create_context, 672 .dpy_gl_ctx_destroy = qemu_egl_destroy_context, 673 .dpy_gl_ctx_make_current = gd_egl_make_current, 674 }; 675 #endif 676 677 #endif /* CONFIG_OPENGL */ 678 679 /** QEMU Events **/ 680 681 static void gd_change_runstate(void *opaque, bool running, RunState state) 682 { 683 GtkDisplayState *s = opaque; 684 685 gd_update_caption(s); 686 } 687 688 static void gd_mouse_mode_change(Notifier *notify, void *data) 689 { 690 GtkDisplayState *s; 691 int i; 692 693 s = container_of(notify, GtkDisplayState, mouse_mode_notifier); 694 /* release the grab at switching to absolute mode */ 695 if (s->ptr_owner && qemu_input_is_absolute(s->ptr_owner->gfx.dcl.con)) { 696 if (!s->ptr_owner->window) { 697 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 698 FALSE); 699 } else { 700 gd_ungrab_pointer(s); 701 } 702 } 703 for (i = 0; i < s->nb_vcs; i++) { 704 VirtualConsole *vc = &s->vc[i]; 705 gd_update_cursor(vc); 706 } 707 } 708 709 /** GTK Events **/ 710 711 static gboolean gd_window_close(GtkWidget *widget, GdkEvent *event, 712 void *opaque) 713 { 714 GtkDisplayState *s = opaque; 715 bool allow_close = true; 716 717 if (s->opts->has_window_close && !s->opts->window_close) { 718 allow_close = false; 719 } 720 721 if (allow_close) { 722 qmp_quit(NULL); 723 } 724 725 return TRUE; 726 } 727 728 static void gd_set_ui_refresh_rate(VirtualConsole *vc, int refresh_rate) 729 { 730 QemuUIInfo info; 731 732 if (!dpy_ui_info_supported(vc->gfx.dcl.con)) { 733 return; 734 } 735 736 info = *dpy_get_ui_info(vc->gfx.dcl.con); 737 info.refresh_rate = refresh_rate; 738 dpy_set_ui_info(vc->gfx.dcl.con, &info, true); 739 } 740 741 static void gd_set_ui_size(VirtualConsole *vc, gint width, gint height) 742 { 743 QemuUIInfo info; 744 745 if (!dpy_ui_info_supported(vc->gfx.dcl.con)) { 746 return; 747 } 748 749 info = *dpy_get_ui_info(vc->gfx.dcl.con); 750 info.width = width; 751 info.height = height; 752 dpy_set_ui_info(vc->gfx.dcl.con, &info, true); 753 } 754 755 #if defined(CONFIG_OPENGL) 756 757 static gboolean gd_render_event(GtkGLArea *area, GdkGLContext *context, 758 void *opaque) 759 { 760 VirtualConsole *vc = opaque; 761 762 if (vc->gfx.gls) { 763 gd_gl_area_draw(vc); 764 } 765 return TRUE; 766 } 767 768 static void gd_resize_event(GtkGLArea *area, 769 gint width, gint height, gpointer *opaque) 770 { 771 VirtualConsole *vc = (void *)opaque; 772 double pw = width, ph = height; 773 double sx = vc->gfx.scale_x, sy = vc->gfx.scale_y; 774 GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(area)); 775 const int gs = gdk_window_get_scale_factor(window); 776 777 if (!vc->s->free_scale && !vc->s->full_screen) { 778 pw /= sx; 779 ph /= sy; 780 } 781 782 /** 783 * width and height here are in pixel coordinate, so we must divide it 784 * by global window scale (gs) 785 */ 786 gd_set_ui_size(vc, pw / gs, ph / gs); 787 } 788 789 #endif 790 791 void gd_update_monitor_refresh_rate(VirtualConsole *vc, GtkWidget *widget) 792 { 793 #ifdef GDK_VERSION_3_22 794 GdkWindow *win = gtk_widget_get_window(widget); 795 int refresh_rate; 796 797 if (win) { 798 GdkDisplay *dpy = gtk_widget_get_display(widget); 799 GdkMonitor *monitor = gdk_display_get_monitor_at_window(dpy, win); 800 refresh_rate = gdk_monitor_get_refresh_rate(monitor); /* [mHz] */ 801 } else { 802 refresh_rate = 0; 803 } 804 805 gd_set_ui_refresh_rate(vc, refresh_rate); 806 807 /* T = 1 / f = 1 [s*Hz] / f = 1000*1000 [ms*mHz] / f */ 808 vc->gfx.dcl.update_interval = refresh_rate ? 809 MIN(1000 * 1000 / refresh_rate, GUI_REFRESH_INTERVAL_DEFAULT) : 810 GUI_REFRESH_INTERVAL_DEFAULT; 811 #endif 812 } 813 814 void gd_update_scale(VirtualConsole *vc, int ww, int wh, int fbw, int fbh) 815 { 816 if (!vc) { 817 return; 818 } 819 820 if (vc->s->full_screen) { 821 vc->gfx.scale_x = (double)ww / fbw; 822 vc->gfx.scale_y = (double)wh / fbh; 823 } else if (vc->s->free_scale) { 824 double sx, sy; 825 826 sx = (double)ww / fbw; 827 sy = (double)wh / fbh; 828 if (vc->s->keep_aspect_ratio) { 829 vc->gfx.scale_x = vc->gfx.scale_y = MIN(sx, sy); 830 } else { 831 vc->gfx.scale_x = sx; 832 vc->gfx.scale_y = sy; 833 } 834 } 835 } 836 /** 837 * DOC: Coordinate handling. 838 * 839 * We are coping with sizes and positions in various coordinates and the 840 * handling of these coordinates is somewhat confusing. It would benefit us 841 * all if we define these coordinates explicitly and clearly. Besides, it's 842 * also helpful to follow the same naming convention for variables 843 * representing values in different coordinates. 844 * 845 * I. Definitions 846 * 847 * - (guest) buffer coordinate: this is the coordinates that the guest will 848 * see. The x/y offsets and width/height specified in commands sent by 849 * guest is basically in buffer coordinate. 850 * 851 * - (host) pixel coordinate: this is the coordinate in pixel level on the 852 * host destop. A window/widget of width 300 in pixel coordinate means it 853 * occupies 300 pixels horizontally. 854 * 855 * - (host) logical window coordinate: the existence of global scaling 856 * factor in desktop level makes this kind of coordinate play a role. It 857 * always holds that (logical window size) * (global scale factor) = 858 * (pixel size). 859 * 860 * - global scale factor: this is specified in desktop level and is 861 * typically invariant during the life cycle of the process. Users with 862 * high-DPI monitors might set this scale, for example, to 2, in order to 863 * make the UI look larger. 864 * 865 * - zooming scale: this can be freely controlled by the QEMU user to zoom 866 * in/out the guest content. 867 * 868 * II. Representation 869 * 870 * We'd like to use consistent representation for variables in different 871 * coordinates: 872 * - buffer coordinate: prefix fb 873 * - pixel coordinate: prefix p 874 * - logical window coordinate: prefix w 875 * 876 * For scales: 877 * - global scale factor: prefix gs 878 * - zooming scale: prefix scale/s 879 * 880 * Example: fbw, pw, ww for width in different coordinates 881 * 882 * III. Equation 883 * 884 * - fbw * gs * scale_x = pw 885 * - pw = gs * ww 886 * 887 * Consequently we have 888 * 889 * - fbw * scale_x = ww 890 * 891 * Example: assuming we are running QEMU on a 3840x2160 screen and have set 892 * global scaling factor to 2, if the guest buffer size is 1920x1080 and the 893 * zooming scale is 0.5, then we have: 894 * - fbw = 1920, fbh = 1080 895 * - pw = 1920, ph = 1080 896 * - ww = 960, wh = 540 897 * A bonus of this configuration is that we can achieve pixel to pixel 898 * presentation of the guest content. 899 */ 900 901 static gboolean gd_draw_event(GtkWidget *widget, cairo_t *cr, void *opaque) 902 { 903 VirtualConsole *vc = opaque; 904 GtkDisplayState *s = vc->s; 905 int wx_offset, wy_offset; 906 int ww_widget, wh_widget, ww_surface, wh_surface; 907 int fbw, fbh; 908 909 #if defined(CONFIG_OPENGL) 910 if (vc->gfx.gls) { 911 if (gtk_use_gl_area) { 912 /* invoke render callback please */ 913 return FALSE; 914 } else { 915 #ifdef CONFIG_X11 916 gd_egl_draw(vc); 917 return TRUE; 918 #else 919 abort(); 920 #endif 921 } 922 } 923 #endif 924 925 if (!gtk_widget_get_realized(widget)) { 926 return FALSE; 927 } 928 if (!vc->gfx.ds) { 929 return FALSE; 930 } 931 if (!vc->gfx.surface) { 932 return FALSE; 933 } 934 935 gd_update_monitor_refresh_rate(vc, vc->window ? vc->window : s->window); 936 937 fbw = surface_width(vc->gfx.ds); 938 fbh = surface_height(vc->gfx.ds); 939 940 ww_widget = gdk_window_get_width(gtk_widget_get_window(widget)); 941 wh_widget = gdk_window_get_height(gtk_widget_get_window(widget)); 942 943 gd_update_scale(vc, ww_widget, wh_widget, fbw, fbh); 944 945 ww_surface = fbw * vc->gfx.scale_x; 946 wh_surface = fbh * vc->gfx.scale_y; 947 948 wx_offset = wy_offset = 0; 949 if (ww_widget > ww_surface) { 950 wx_offset = (ww_widget - ww_surface) / 2; 951 } 952 if (wh_widget > wh_surface) { 953 wy_offset = (wh_widget - wh_surface) / 2; 954 } 955 956 cairo_rectangle(cr, 0, 0, ww_widget, wh_widget); 957 958 /* Optionally cut out the inner area where the pixmap 959 will be drawn. This avoids 'flashing' since we're 960 not double-buffering. Note we're using the undocumented 961 behaviour of drawing the rectangle from right to left 962 to cut out the whole */ 963 cairo_rectangle(cr, wx_offset + ww_surface, wy_offset, 964 -1 * ww_surface, wh_surface); 965 cairo_fill(cr); 966 967 cairo_scale(cr, vc->gfx.scale_x, vc->gfx.scale_y); 968 cairo_set_source_surface(cr, vc->gfx.surface, 969 wx_offset / vc->gfx.scale_x, 970 wy_offset / vc->gfx.scale_y); 971 cairo_paint(cr); 972 973 return TRUE; 974 } 975 976 static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion, 977 void *opaque) 978 { 979 VirtualConsole *vc = opaque; 980 GtkDisplayState *s = vc->s; 981 int fbx, fby; 982 int wx_offset, wy_offset; 983 int wh_surface, ww_surface; 984 int ww_widget, wh_widget; 985 986 if (!vc->gfx.ds) { 987 return TRUE; 988 } 989 990 ww_surface = surface_width(vc->gfx.ds) * vc->gfx.scale_x; 991 wh_surface = surface_height(vc->gfx.ds) * vc->gfx.scale_y; 992 ww_widget = gtk_widget_get_allocated_width(widget); 993 wh_widget = gtk_widget_get_allocated_height(widget); 994 995 /* 996 * `widget` may not have the same size with the frame buffer. 997 * In such cases, some paddings are needed around the `vc`. 998 * To achieve that, `vc` will be displayed at (mx, my) 999 * so that it is displayed at the center of the widget. 1000 */ 1001 wx_offset = wy_offset = 0; 1002 if (ww_widget > ww_surface) { 1003 wx_offset = (ww_widget - ww_surface) / 2; 1004 } 1005 if (wh_widget > wh_surface) { 1006 wy_offset = (wh_widget - wh_surface) / 2; 1007 } 1008 1009 /* 1010 * `motion` is reported in `widget` coordinates 1011 * so translating it to the coordinates in `vc`. 1012 */ 1013 fbx = (motion->x - wx_offset) / vc->gfx.scale_x; 1014 fby = (motion->y - wy_offset) / vc->gfx.scale_y; 1015 1016 trace_gd_motion_event(ww_widget, wh_widget, 1017 gtk_widget_get_scale_factor(widget), fbx, fby); 1018 1019 if (qemu_input_is_absolute(vc->gfx.dcl.con)) { 1020 if (fbx < 0 || fby < 0 || 1021 fbx >= surface_width(vc->gfx.ds) || 1022 fby >= surface_height(vc->gfx.ds)) { 1023 return TRUE; 1024 } 1025 qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_X, fbx, 1026 0, surface_width(vc->gfx.ds)); 1027 qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_Y, fby, 1028 0, surface_height(vc->gfx.ds)); 1029 qemu_input_event_sync(); 1030 } else if (s->last_set && s->ptr_owner == vc) { 1031 qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_X, fbx - s->last_x); 1032 qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_Y, fby - s->last_y); 1033 qemu_input_event_sync(); 1034 } 1035 s->last_x = fbx; 1036 s->last_y = fby; 1037 s->last_set = TRUE; 1038 1039 if (!qemu_input_is_absolute(vc->gfx.dcl.con) && s->ptr_owner == vc) { 1040 GdkScreen *screen = gtk_widget_get_screen(vc->gfx.drawing_area); 1041 GdkDisplay *dpy = gtk_widget_get_display(widget); 1042 GdkWindow *win = gtk_widget_get_window(widget); 1043 GdkMonitor *monitor = gdk_display_get_monitor_at_window(dpy, win); 1044 GdkRectangle geometry; 1045 1046 int xr = (int)motion->x_root; 1047 int yr = (int)motion->y_root; 1048 1049 gdk_monitor_get_geometry(monitor, &geometry); 1050 1051 /* In relative mode check to see if client pointer hit 1052 * one of the monitor edges, and if so move it back to the 1053 * center of the monitor. This is important because the pointer 1054 * in the server doesn't correspond 1-for-1, and so 1055 * may still be only half way across the screen. Without 1056 * this warp, the server pointer would thus appear to hit 1057 * an invisible wall */ 1058 if (xr <= geometry.x || xr - geometry.x >= geometry.width - 1 || 1059 yr <= geometry.y || yr - geometry.y >= geometry.height - 1) { 1060 GdkDevice *dev = gdk_event_get_device((GdkEvent *)motion); 1061 xr = geometry.x + geometry.width / 2; 1062 yr = geometry.y + geometry.height / 2; 1063 1064 gdk_device_warp(dev, screen, xr, yr); 1065 s->last_set = FALSE; 1066 return FALSE; 1067 } 1068 } 1069 return TRUE; 1070 } 1071 1072 static gboolean gd_button_event(GtkWidget *widget, GdkEventButton *button, 1073 void *opaque) 1074 { 1075 VirtualConsole *vc = opaque; 1076 GtkDisplayState *s = vc->s; 1077 InputButton btn; 1078 1079 /* implicitly grab the input at the first click in the relative mode */ 1080 if (button->button == 1 && button->type == GDK_BUTTON_PRESS && 1081 !qemu_input_is_absolute(vc->gfx.dcl.con) && s->ptr_owner != vc) { 1082 if (!vc->window) { 1083 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1084 TRUE); 1085 } else { 1086 gd_grab_pointer(vc, "relative-mode-click"); 1087 } 1088 return TRUE; 1089 } 1090 1091 if (button->button == 1) { 1092 btn = INPUT_BUTTON_LEFT; 1093 } else if (button->button == 2) { 1094 btn = INPUT_BUTTON_MIDDLE; 1095 } else if (button->button == 3) { 1096 btn = INPUT_BUTTON_RIGHT; 1097 } else if (button->button == 8) { 1098 btn = INPUT_BUTTON_SIDE; 1099 } else if (button->button == 9) { 1100 btn = INPUT_BUTTON_EXTRA; 1101 } else { 1102 return TRUE; 1103 } 1104 1105 if (button->type == GDK_2BUTTON_PRESS || button->type == GDK_3BUTTON_PRESS) { 1106 return TRUE; 1107 } 1108 1109 qemu_input_queue_btn(vc->gfx.dcl.con, btn, 1110 button->type == GDK_BUTTON_PRESS); 1111 qemu_input_event_sync(); 1112 return TRUE; 1113 } 1114 1115 static gboolean gd_scroll_event(GtkWidget *widget, GdkEventScroll *scroll, 1116 void *opaque) 1117 { 1118 VirtualConsole *vc = opaque; 1119 InputButton btn_vertical; 1120 InputButton btn_horizontal; 1121 bool has_vertical = false; 1122 bool has_horizontal = false; 1123 1124 if (scroll->direction == GDK_SCROLL_UP) { 1125 btn_vertical = INPUT_BUTTON_WHEEL_UP; 1126 has_vertical = true; 1127 } else if (scroll->direction == GDK_SCROLL_DOWN) { 1128 btn_vertical = INPUT_BUTTON_WHEEL_DOWN; 1129 has_vertical = true; 1130 } else if (scroll->direction == GDK_SCROLL_LEFT) { 1131 btn_horizontal = INPUT_BUTTON_WHEEL_LEFT; 1132 has_horizontal = true; 1133 } else if (scroll->direction == GDK_SCROLL_RIGHT) { 1134 btn_horizontal = INPUT_BUTTON_WHEEL_RIGHT; 1135 has_horizontal = true; 1136 } else if (scroll->direction == GDK_SCROLL_SMOOTH) { 1137 gdouble delta_x, delta_y; 1138 if (!gdk_event_get_scroll_deltas((GdkEvent *)scroll, 1139 &delta_x, &delta_y)) { 1140 return TRUE; 1141 } 1142 1143 if (delta_y > 0) { 1144 btn_vertical = INPUT_BUTTON_WHEEL_DOWN; 1145 has_vertical = true; 1146 } else if (delta_y < 0) { 1147 btn_vertical = INPUT_BUTTON_WHEEL_UP; 1148 has_vertical = true; 1149 } else if (delta_x > 0) { 1150 btn_horizontal = INPUT_BUTTON_WHEEL_RIGHT; 1151 has_horizontal = true; 1152 } else if (delta_x < 0) { 1153 btn_horizontal = INPUT_BUTTON_WHEEL_LEFT; 1154 has_horizontal = true; 1155 } else { 1156 return TRUE; 1157 } 1158 } else { 1159 return TRUE; 1160 } 1161 1162 if (has_vertical) { 1163 qemu_input_queue_btn(vc->gfx.dcl.con, btn_vertical, true); 1164 qemu_input_event_sync(); 1165 qemu_input_queue_btn(vc->gfx.dcl.con, btn_vertical, false); 1166 qemu_input_event_sync(); 1167 } 1168 1169 if (has_horizontal) { 1170 qemu_input_queue_btn(vc->gfx.dcl.con, btn_horizontal, true); 1171 qemu_input_event_sync(); 1172 qemu_input_queue_btn(vc->gfx.dcl.con, btn_horizontal, false); 1173 qemu_input_event_sync(); 1174 } 1175 1176 return TRUE; 1177 } 1178 1179 1180 static gboolean gd_touch_event(GtkWidget *widget, GdkEventTouch *touch, 1181 void *opaque) 1182 { 1183 VirtualConsole *vc = opaque; 1184 uint64_t num_slot = GPOINTER_TO_UINT(touch->sequence); 1185 int type = -1; 1186 1187 switch (touch->type) { 1188 case GDK_TOUCH_BEGIN: 1189 type = INPUT_MULTI_TOUCH_TYPE_BEGIN; 1190 break; 1191 case GDK_TOUCH_UPDATE: 1192 type = INPUT_MULTI_TOUCH_TYPE_UPDATE; 1193 break; 1194 case GDK_TOUCH_END: 1195 case GDK_TOUCH_CANCEL: 1196 type = INPUT_MULTI_TOUCH_TYPE_END; 1197 break; 1198 default: 1199 warn_report("gtk: unexpected touch event type\n"); 1200 return FALSE; 1201 } 1202 1203 console_handle_touch_event(vc->gfx.dcl.con, touch_slots, 1204 num_slot, surface_width(vc->gfx.ds), 1205 surface_height(vc->gfx.ds), touch->x, 1206 touch->y, type, &error_warn); 1207 return TRUE; 1208 } 1209 1210 static const guint16 *gd_get_keymap(size_t *maplen) 1211 { 1212 GdkDisplay *dpy = gdk_display_get_default(); 1213 1214 #ifdef GDK_WINDOWING_X11 1215 if (GDK_IS_X11_DISPLAY(dpy)) { 1216 trace_gd_keymap_windowing("x11"); 1217 return qemu_xkeymap_mapping_table( 1218 gdk_x11_display_get_xdisplay(dpy), maplen); 1219 } 1220 #endif 1221 1222 #ifdef GDK_WINDOWING_WAYLAND 1223 if (GDK_IS_WAYLAND_DISPLAY(dpy)) { 1224 trace_gd_keymap_windowing("wayland"); 1225 *maplen = qemu_input_map_xorgevdev_to_qcode_len; 1226 return qemu_input_map_xorgevdev_to_qcode; 1227 } 1228 #endif 1229 1230 #ifdef GDK_WINDOWING_WIN32 1231 if (GDK_IS_WIN32_DISPLAY(dpy)) { 1232 trace_gd_keymap_windowing("win32"); 1233 *maplen = qemu_input_map_atset1_to_qcode_len; 1234 return qemu_input_map_atset1_to_qcode; 1235 } 1236 #endif 1237 1238 #ifdef GDK_WINDOWING_QUARTZ 1239 if (GDK_IS_QUARTZ_DISPLAY(dpy)) { 1240 trace_gd_keymap_windowing("quartz"); 1241 *maplen = qemu_input_map_osx_to_qcode_len; 1242 return qemu_input_map_osx_to_qcode; 1243 } 1244 #endif 1245 1246 #ifdef GDK_WINDOWING_BROADWAY 1247 if (GDK_IS_BROADWAY_DISPLAY(dpy)) { 1248 trace_gd_keymap_windowing("broadway"); 1249 g_warning("experimental: using broadway, x11 virtual keysym\n" 1250 "mapping - with very limited support. See also\n" 1251 "https://bugzilla.gnome.org/show_bug.cgi?id=700105"); 1252 *maplen = qemu_input_map_x11_to_qcode_len; 1253 return qemu_input_map_x11_to_qcode; 1254 } 1255 #endif 1256 1257 g_warning("Unsupported GDK Windowing platform.\n" 1258 "Disabling extended keycode tables.\n" 1259 "Please report to qemu-devel@nongnu.org\n" 1260 "including the following information:\n" 1261 "\n" 1262 " - Operating system\n" 1263 " - GDK Windowing system build\n"); 1264 return NULL; 1265 } 1266 1267 1268 static int gd_map_keycode(int scancode) 1269 { 1270 if (!keycode_map) { 1271 return 0; 1272 } 1273 if (scancode > keycode_maplen) { 1274 return 0; 1275 } 1276 1277 return keycode_map[scancode]; 1278 } 1279 1280 static int gd_get_keycode(GdkEventKey *key) 1281 { 1282 #ifdef G_OS_WIN32 1283 int scancode = gdk_event_get_scancode((GdkEvent *)key); 1284 1285 /* translate Windows native scancodes to atset1 keycodes */ 1286 switch (scancode & (KF_EXTENDED | 0xff)) { 1287 case 0x145: /* NUMLOCK */ 1288 return scancode & 0xff; 1289 } 1290 1291 return scancode & KF_EXTENDED ? 1292 0xe000 | (scancode & 0xff) : scancode & 0xff; 1293 1294 #else 1295 return key->hardware_keycode; 1296 #endif 1297 } 1298 1299 static gboolean gd_text_key_down(GtkWidget *widget, 1300 GdkEventKey *key, void *opaque) 1301 { 1302 VirtualConsole *vc = opaque; 1303 QemuTextConsole *con = QEMU_TEXT_CONSOLE(vc->gfx.dcl.con); 1304 1305 if (key->keyval == GDK_KEY_Delete) { 1306 qemu_text_console_put_qcode(con, Q_KEY_CODE_DELETE, false); 1307 } else if (key->length) { 1308 qemu_text_console_put_string(con, key->string, key->length); 1309 } else { 1310 int qcode = gd_map_keycode(gd_get_keycode(key)); 1311 qemu_text_console_put_qcode(con, qcode, false); 1312 } 1313 return TRUE; 1314 } 1315 1316 static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque) 1317 { 1318 VirtualConsole *vc = opaque; 1319 int keycode, qcode; 1320 1321 #ifdef G_OS_WIN32 1322 /* on windows, we ought to ignore the reserved key event? */ 1323 if (key->hardware_keycode == 0xff) 1324 return false; 1325 1326 if (!vc->s->kbd_owner) { 1327 if (key->hardware_keycode == VK_LWIN || 1328 key->hardware_keycode == VK_RWIN) { 1329 return FALSE; 1330 } 1331 } 1332 #endif 1333 1334 if (key->keyval == GDK_KEY_Pause 1335 #ifdef G_OS_WIN32 1336 /* for some reason GDK does not fill keyval for VK_PAUSE 1337 * See https://bugzilla.gnome.org/show_bug.cgi?id=769214 1338 */ 1339 || key->hardware_keycode == VK_PAUSE 1340 #endif 1341 ) { 1342 qkbd_state_key_event(vc->gfx.kbd, Q_KEY_CODE_PAUSE, 1343 key->type == GDK_KEY_PRESS); 1344 return TRUE; 1345 } 1346 1347 keycode = gd_get_keycode(key); 1348 qcode = gd_map_keycode(keycode); 1349 1350 trace_gd_key_event(vc->label, keycode, qcode, 1351 (key->type == GDK_KEY_PRESS) ? "down" : "up"); 1352 1353 qkbd_state_key_event(vc->gfx.kbd, qcode, 1354 key->type == GDK_KEY_PRESS); 1355 1356 return TRUE; 1357 } 1358 1359 static gboolean gd_grab_broken_event(GtkWidget *widget, 1360 GdkEventGrabBroken *event, void *opaque) 1361 { 1362 #ifdef CONFIG_WIN32 1363 /* 1364 * On Windows the Ctrl-Alt-Del key combination can't be grabbed. This 1365 * key combination leaves all three keys in a stuck condition. We use 1366 * the grab-broken-event to release all keys. 1367 */ 1368 if (event->keyboard) { 1369 VirtualConsole *vc = opaque; 1370 GtkDisplayState *s = vc->s; 1371 1372 gtk_release_modifiers(s); 1373 } 1374 #endif 1375 return TRUE; 1376 } 1377 1378 static gboolean gd_event(GtkWidget *widget, GdkEvent *event, void *opaque) 1379 { 1380 if (event->type == GDK_MOTION_NOTIFY) { 1381 return gd_motion_event(widget, &event->motion, opaque); 1382 } 1383 return FALSE; 1384 } 1385 1386 /** Window Menu Actions **/ 1387 1388 static void gd_menu_pause(GtkMenuItem *item, void *opaque) 1389 { 1390 GtkDisplayState *s = opaque; 1391 1392 if (s->external_pause_update) { 1393 return; 1394 } 1395 if (runstate_is_running()) { 1396 qmp_stop(NULL); 1397 } else { 1398 qmp_cont(NULL); 1399 } 1400 } 1401 1402 static void gd_menu_reset(GtkMenuItem *item, void *opaque) 1403 { 1404 qmp_system_reset(NULL); 1405 } 1406 1407 static void gd_menu_powerdown(GtkMenuItem *item, void *opaque) 1408 { 1409 qmp_system_powerdown(NULL); 1410 } 1411 1412 static void gd_menu_quit(GtkMenuItem *item, void *opaque) 1413 { 1414 qmp_quit(NULL); 1415 } 1416 1417 static void gd_menu_switch_vc(GtkMenuItem *item, void *opaque) 1418 { 1419 GtkDisplayState *s = opaque; 1420 VirtualConsole *vc = gd_vc_find_by_menu(s); 1421 GtkNotebook *nb = GTK_NOTEBOOK(s->notebook); 1422 gint page; 1423 1424 gtk_release_modifiers(s); 1425 if (vc) { 1426 page = gtk_notebook_page_num(nb, vc->tab_item); 1427 gtk_notebook_set_current_page(nb, page); 1428 gtk_widget_grab_focus(vc->focus); 1429 } 1430 } 1431 1432 static void gd_accel_switch_vc(void *opaque) 1433 { 1434 VirtualConsole *vc = opaque; 1435 1436 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), TRUE); 1437 } 1438 1439 static void gd_menu_show_tabs(GtkMenuItem *item, void *opaque) 1440 { 1441 GtkDisplayState *s = opaque; 1442 VirtualConsole *vc = gd_vc_find_current(s); 1443 1444 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->show_tabs_item))) { 1445 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), TRUE); 1446 } else { 1447 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 1448 } 1449 gd_update_windowsize(vc); 1450 } 1451 1452 static gboolean gd_tab_window_close(GtkWidget *widget, GdkEvent *event, 1453 void *opaque) 1454 { 1455 VirtualConsole *vc = opaque; 1456 GtkDisplayState *s = vc->s; 1457 1458 gtk_widget_set_sensitive(vc->menu_item, true); 1459 gd_widget_reparent(vc->window, s->notebook, vc->tab_item); 1460 gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(s->notebook), 1461 vc->tab_item, vc->label); 1462 gtk_widget_destroy(vc->window); 1463 vc->window = NULL; 1464 #if defined(CONFIG_OPENGL) 1465 if (vc->gfx.esurface) { 1466 eglDestroySurface(qemu_egl_display, vc->gfx.esurface); 1467 vc->gfx.esurface = NULL; 1468 } 1469 if (vc->gfx.ectx) { 1470 eglDestroyContext(qemu_egl_display, vc->gfx.ectx); 1471 vc->gfx.ectx = NULL; 1472 } 1473 #endif 1474 return TRUE; 1475 } 1476 1477 static gboolean gd_win_grab(void *opaque) 1478 { 1479 VirtualConsole *vc = opaque; 1480 1481 fprintf(stderr, "%s: %s\n", __func__, vc->label); 1482 if (vc->s->ptr_owner) { 1483 gd_ungrab_pointer(vc->s); 1484 } else { 1485 gd_grab_pointer(vc, "user-request-detached-tab"); 1486 } 1487 return TRUE; 1488 } 1489 1490 static void gd_menu_untabify(GtkMenuItem *item, void *opaque) 1491 { 1492 GtkDisplayState *s = opaque; 1493 VirtualConsole *vc = gd_vc_find_current(s); 1494 1495 if (vc->type == GD_VC_GFX && 1496 qemu_console_is_graphic(vc->gfx.dcl.con)) { 1497 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1498 FALSE); 1499 } 1500 if (!vc->window) { 1501 gtk_widget_set_sensitive(vc->menu_item, false); 1502 vc->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 1503 #if defined(CONFIG_OPENGL) 1504 if (vc->gfx.esurface) { 1505 eglDestroySurface(qemu_egl_display, vc->gfx.esurface); 1506 vc->gfx.esurface = NULL; 1507 } 1508 if (vc->gfx.ectx) { 1509 eglDestroyContext(qemu_egl_display, vc->gfx.ectx); 1510 vc->gfx.ectx = NULL; 1511 } 1512 #endif 1513 gd_widget_reparent(s->notebook, vc->window, vc->tab_item); 1514 1515 g_signal_connect(vc->window, "delete-event", 1516 G_CALLBACK(gd_tab_window_close), vc); 1517 gtk_widget_show_all(vc->window); 1518 1519 if (qemu_console_is_graphic(vc->gfx.dcl.con)) { 1520 GtkAccelGroup *ag = gtk_accel_group_new(); 1521 gtk_window_add_accel_group(GTK_WINDOW(vc->window), ag); 1522 1523 GClosure *cb = g_cclosure_new_swap(G_CALLBACK(gd_win_grab), 1524 vc, NULL); 1525 gtk_accel_group_connect(ag, GDK_KEY_g, HOTKEY_MODIFIERS, 0, cb); 1526 } 1527 1528 gd_update_geometry_hints(vc); 1529 gd_update_caption(s); 1530 } 1531 } 1532 1533 static void gd_menu_show_menubar(GtkMenuItem *item, void *opaque) 1534 { 1535 GtkDisplayState *s = opaque; 1536 VirtualConsole *vc = gd_vc_find_current(s); 1537 1538 if (s->full_screen) { 1539 return; 1540 } 1541 1542 if (gtk_check_menu_item_get_active( 1543 GTK_CHECK_MENU_ITEM(s->show_menubar_item))) { 1544 gtk_widget_show(s->menu_bar); 1545 } else { 1546 gtk_widget_hide(s->menu_bar); 1547 } 1548 gd_update_windowsize(vc); 1549 } 1550 1551 static void gd_accel_show_menubar(void *opaque) 1552 { 1553 GtkDisplayState *s = opaque; 1554 gtk_menu_item_activate(GTK_MENU_ITEM(s->show_menubar_item)); 1555 } 1556 1557 static void gd_menu_full_screen(GtkMenuItem *item, void *opaque) 1558 { 1559 GtkDisplayState *s = opaque; 1560 VirtualConsole *vc = gd_vc_find_current(s); 1561 1562 if (!s->full_screen) { 1563 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 1564 gtk_widget_hide(s->menu_bar); 1565 if (vc->type == GD_VC_GFX) { 1566 gtk_widget_set_size_request(vc->gfx.drawing_area, -1, -1); 1567 } 1568 gtk_window_fullscreen(GTK_WINDOW(s->window)); 1569 s->full_screen = TRUE; 1570 } else { 1571 gtk_window_unfullscreen(GTK_WINDOW(s->window)); 1572 gd_menu_show_tabs(GTK_MENU_ITEM(s->show_tabs_item), s); 1573 if (gtk_check_menu_item_get_active( 1574 GTK_CHECK_MENU_ITEM(s->show_menubar_item))) { 1575 gtk_widget_show(s->menu_bar); 1576 } 1577 s->full_screen = FALSE; 1578 if (vc->type == GD_VC_GFX) { 1579 vc->gfx.scale_x = vc->gfx.preferred_scale; 1580 vc->gfx.scale_y = vc->gfx.preferred_scale; 1581 gd_update_windowsize(vc); 1582 } 1583 } 1584 1585 gd_update_cursor(vc); 1586 } 1587 1588 static void gd_accel_full_screen(void *opaque) 1589 { 1590 GtkDisplayState *s = opaque; 1591 gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item)); 1592 } 1593 1594 static void gd_menu_zoom_in(GtkMenuItem *item, void *opaque) 1595 { 1596 GtkDisplayState *s = opaque; 1597 VirtualConsole *vc = gd_vc_find_current(s); 1598 1599 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item), 1600 FALSE); 1601 1602 vc->gfx.scale_x += VC_SCALE_STEP; 1603 vc->gfx.scale_y += VC_SCALE_STEP; 1604 1605 gd_update_windowsize(vc); 1606 } 1607 1608 static void gd_accel_zoom_in(void *opaque) 1609 { 1610 GtkDisplayState *s = opaque; 1611 gtk_menu_item_activate(GTK_MENU_ITEM(s->zoom_in_item)); 1612 } 1613 1614 static void gd_menu_zoom_out(GtkMenuItem *item, void *opaque) 1615 { 1616 GtkDisplayState *s = opaque; 1617 VirtualConsole *vc = gd_vc_find_current(s); 1618 1619 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item), 1620 FALSE); 1621 1622 vc->gfx.scale_x -= VC_SCALE_STEP; 1623 vc->gfx.scale_y -= VC_SCALE_STEP; 1624 1625 vc->gfx.scale_x = MAX(vc->gfx.scale_x, VC_SCALE_MIN); 1626 vc->gfx.scale_y = MAX(vc->gfx.scale_y, VC_SCALE_MIN); 1627 1628 gd_update_windowsize(vc); 1629 } 1630 1631 static void gd_menu_zoom_fixed(GtkMenuItem *item, void *opaque) 1632 { 1633 GtkDisplayState *s = opaque; 1634 VirtualConsole *vc = gd_vc_find_current(s); 1635 1636 vc->gfx.scale_x = vc->gfx.preferred_scale; 1637 vc->gfx.scale_y = vc->gfx.preferred_scale; 1638 1639 gd_update_windowsize(vc); 1640 } 1641 1642 static void gd_menu_zoom_fit(GtkMenuItem *item, void *opaque) 1643 { 1644 GtkDisplayState *s = opaque; 1645 VirtualConsole *vc = gd_vc_find_current(s); 1646 1647 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item))) { 1648 s->free_scale = TRUE; 1649 } else { 1650 s->free_scale = FALSE; 1651 vc->gfx.scale_x = vc->gfx.preferred_scale; 1652 vc->gfx.scale_y = vc->gfx.preferred_scale; 1653 } 1654 1655 gd_update_windowsize(vc); 1656 gd_update_full_redraw(vc); 1657 } 1658 1659 static void gd_grab_update(VirtualConsole *vc, bool kbd, bool ptr) 1660 { 1661 GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1662 GdkSeat *seat = gdk_display_get_default_seat(display); 1663 GdkWindow *window = gtk_widget_get_window(vc->gfx.drawing_area); 1664 GdkSeatCapabilities caps = 0; 1665 GdkCursor *cursor = NULL; 1666 1667 if (kbd) { 1668 caps |= GDK_SEAT_CAPABILITY_KEYBOARD; 1669 } 1670 if (ptr) { 1671 caps |= GDK_SEAT_CAPABILITY_ALL_POINTING; 1672 cursor = vc->s->null_cursor; 1673 } 1674 1675 if (caps) { 1676 gdk_seat_grab(seat, window, caps, false, cursor, 1677 NULL, NULL, NULL); 1678 } else { 1679 gdk_seat_ungrab(seat); 1680 } 1681 } 1682 1683 static void gd_grab_keyboard(VirtualConsole *vc, const char *reason) 1684 { 1685 if (vc->s->kbd_owner) { 1686 if (vc->s->kbd_owner == vc) { 1687 return; 1688 } else { 1689 gd_ungrab_keyboard(vc->s); 1690 } 1691 } 1692 1693 win32_kbd_set_grab(true); 1694 gd_grab_update(vc, true, vc->s->ptr_owner == vc); 1695 vc->s->kbd_owner = vc; 1696 gd_update_caption(vc->s); 1697 trace_gd_grab(vc->label, "kbd", reason); 1698 } 1699 1700 static void gd_ungrab_keyboard(GtkDisplayState *s) 1701 { 1702 VirtualConsole *vc = s->kbd_owner; 1703 1704 if (vc == NULL) { 1705 return; 1706 } 1707 s->kbd_owner = NULL; 1708 1709 win32_kbd_set_grab(false); 1710 gd_grab_update(vc, false, vc->s->ptr_owner == vc); 1711 gd_update_caption(s); 1712 trace_gd_ungrab(vc->label, "kbd"); 1713 } 1714 1715 static void gd_grab_pointer(VirtualConsole *vc, const char *reason) 1716 { 1717 GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); 1718 1719 if (vc->s->ptr_owner) { 1720 if (vc->s->ptr_owner == vc) { 1721 return; 1722 } else { 1723 gd_ungrab_pointer(vc->s); 1724 } 1725 } 1726 1727 gd_grab_update(vc, vc->s->kbd_owner == vc, true); 1728 gdk_device_get_position(gd_get_pointer(display), 1729 NULL, &vc->s->grab_x_root, &vc->s->grab_y_root); 1730 vc->s->ptr_owner = vc; 1731 gd_update_caption(vc->s); 1732 trace_gd_grab(vc->label, "ptr", reason); 1733 } 1734 1735 static void gd_ungrab_pointer(GtkDisplayState *s) 1736 { 1737 VirtualConsole *vc = s->ptr_owner; 1738 GdkDisplay *display; 1739 1740 if (vc == NULL) { 1741 return; 1742 } 1743 s->ptr_owner = NULL; 1744 1745 display = gtk_widget_get_display(vc->gfx.drawing_area); 1746 gd_grab_update(vc, vc->s->kbd_owner == vc, false); 1747 gdk_device_warp(gd_get_pointer(display), 1748 gtk_widget_get_screen(vc->gfx.drawing_area), 1749 vc->s->grab_x_root, vc->s->grab_y_root); 1750 gd_update_caption(s); 1751 trace_gd_ungrab(vc->label, "ptr"); 1752 } 1753 1754 static void gd_menu_grab_input(GtkMenuItem *item, void *opaque) 1755 { 1756 GtkDisplayState *s = opaque; 1757 VirtualConsole *vc = gd_vc_find_current(s); 1758 1759 if (gd_is_grab_active(s)) { 1760 gd_grab_keyboard(vc, "user-request-main-window"); 1761 gd_grab_pointer(vc, "user-request-main-window"); 1762 } else { 1763 gd_ungrab_keyboard(s); 1764 gd_ungrab_pointer(s); 1765 } 1766 1767 gd_update_cursor(vc); 1768 } 1769 1770 static void gd_change_page(GtkNotebook *nb, gpointer arg1, guint arg2, 1771 gpointer data) 1772 { 1773 GtkDisplayState *s = data; 1774 VirtualConsole *vc; 1775 gboolean on_vga; 1776 1777 if (!gtk_widget_get_realized(s->notebook)) { 1778 return; 1779 } 1780 1781 vc = gd_vc_find_by_page(s, arg2); 1782 if (!vc) { 1783 return; 1784 } 1785 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), 1786 TRUE); 1787 on_vga = (vc->type == GD_VC_GFX && 1788 qemu_console_is_graphic(vc->gfx.dcl.con)); 1789 if (!on_vga) { 1790 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1791 FALSE); 1792 } else if (s->full_screen) { 1793 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), 1794 TRUE); 1795 } 1796 gtk_widget_set_sensitive(s->grab_item, on_vga); 1797 #ifdef CONFIG_VTE 1798 gtk_widget_set_sensitive(s->copy_item, vc->type == GD_VC_VTE); 1799 #endif 1800 1801 gd_update_windowsize(vc); 1802 gd_update_cursor(vc); 1803 } 1804 1805 static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing, 1806 gpointer opaque) 1807 { 1808 VirtualConsole *vc = opaque; 1809 GtkDisplayState *s = vc->s; 1810 1811 if (gd_grab_on_hover(s)) { 1812 gd_grab_keyboard(vc, "grab-on-hover"); 1813 } 1814 return TRUE; 1815 } 1816 1817 static gboolean gd_leave_event(GtkWidget *widget, GdkEventCrossing *crossing, 1818 gpointer opaque) 1819 { 1820 VirtualConsole *vc = opaque; 1821 GtkDisplayState *s = vc->s; 1822 1823 if (gd_grab_on_hover(s)) { 1824 gd_ungrab_keyboard(s); 1825 } 1826 return TRUE; 1827 } 1828 1829 static gboolean gd_focus_in_event(GtkWidget *widget, 1830 GdkEventFocus *event, gpointer opaque) 1831 { 1832 VirtualConsole *vc = opaque; 1833 1834 win32_kbd_set_window(gd_win32_get_hwnd(vc)); 1835 return TRUE; 1836 } 1837 1838 static gboolean gd_focus_out_event(GtkWidget *widget, 1839 GdkEventFocus *event, gpointer opaque) 1840 { 1841 VirtualConsole *vc = opaque; 1842 GtkDisplayState *s = vc->s; 1843 1844 win32_kbd_set_window(NULL); 1845 gtk_release_modifiers(s); 1846 return TRUE; 1847 } 1848 1849 static gboolean gd_configure(GtkWidget *widget, 1850 GdkEventConfigure *cfg, gpointer opaque) 1851 { 1852 VirtualConsole *vc = opaque; 1853 const double sx = vc->gfx.scale_x, sy = vc->gfx.scale_y; 1854 double width = cfg->width, height = cfg->height; 1855 1856 if (!vc->s->free_scale && !vc->s->full_screen) { 1857 width /= sx; 1858 height /= sy; 1859 } 1860 1861 gd_set_ui_size(vc, width, height); 1862 1863 return FALSE; 1864 } 1865 1866 /** Virtual Console Callbacks **/ 1867 1868 static GSList *gd_vc_menu_init(GtkDisplayState *s, VirtualConsole *vc, 1869 int idx, GSList *group, GtkWidget *view_menu) 1870 { 1871 vc->menu_item = gtk_radio_menu_item_new_with_mnemonic(group, vc->label); 1872 gtk_accel_group_connect(s->accel_group, GDK_KEY_1 + idx, 1873 HOTKEY_MODIFIERS, 0, 1874 g_cclosure_new_swap(G_CALLBACK(gd_accel_switch_vc), vc, NULL)); 1875 gtk_accel_label_set_accel( 1876 GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(vc->menu_item))), 1877 GDK_KEY_1 + idx, HOTKEY_MODIFIERS); 1878 1879 g_signal_connect(vc->menu_item, "activate", 1880 G_CALLBACK(gd_menu_switch_vc), s); 1881 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), vc->menu_item); 1882 1883 return gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(vc->menu_item)); 1884 } 1885 1886 #if defined(CONFIG_VTE) 1887 static void gd_menu_copy(GtkMenuItem *item, void *opaque) 1888 { 1889 GtkDisplayState *s = opaque; 1890 VirtualConsole *vc = gd_vc_find_current(s); 1891 1892 #if VTE_CHECK_VERSION(0, 50, 0) 1893 vte_terminal_copy_clipboard_format(VTE_TERMINAL(vc->vte.terminal), 1894 VTE_FORMAT_TEXT); 1895 #else 1896 vte_terminal_copy_clipboard(VTE_TERMINAL(vc->vte.terminal)); 1897 #endif 1898 } 1899 1900 static void gd_vc_adjustment_changed(GtkAdjustment *adjustment, void *opaque) 1901 { 1902 VirtualConsole *vc = opaque; 1903 1904 if (gtk_adjustment_get_upper(adjustment) > 1905 gtk_adjustment_get_page_size(adjustment)) { 1906 gtk_widget_show(vc->vte.scrollbar); 1907 } else { 1908 gtk_widget_hide(vc->vte.scrollbar); 1909 } 1910 } 1911 1912 static void gd_vc_send_chars(VirtualConsole *vc) 1913 { 1914 uint32_t len, avail; 1915 1916 len = qemu_chr_be_can_write(vc->vte.chr); 1917 avail = fifo8_num_used(&vc->vte.out_fifo); 1918 while (len > 0 && avail > 0) { 1919 const uint8_t *buf; 1920 uint32_t size; 1921 1922 buf = fifo8_pop_bufptr(&vc->vte.out_fifo, MIN(len, avail), &size); 1923 qemu_chr_be_write(vc->vte.chr, buf, size); 1924 len = qemu_chr_be_can_write(vc->vte.chr); 1925 avail -= size; 1926 } 1927 } 1928 1929 static int gd_vc_chr_write(Chardev *chr, const uint8_t *buf, int len) 1930 { 1931 VCChardev *vcd = VC_CHARDEV(chr); 1932 VirtualConsole *vc = vcd->console; 1933 1934 vte_terminal_feed(VTE_TERMINAL(vc->vte.terminal), (const char *)buf, len); 1935 return len; 1936 } 1937 1938 static void gd_vc_chr_accept_input(Chardev *chr) 1939 { 1940 VCChardev *vcd = VC_CHARDEV(chr); 1941 VirtualConsole *vc = vcd->console; 1942 1943 if (vc) { 1944 gd_vc_send_chars(vc); 1945 } 1946 } 1947 1948 static void gd_vc_chr_set_echo(Chardev *chr, bool echo) 1949 { 1950 VCChardev *vcd = VC_CHARDEV(chr); 1951 VirtualConsole *vc = vcd->console; 1952 1953 if (vc) { 1954 vc->vte.echo = echo; 1955 } else { 1956 vcd->echo = echo; 1957 } 1958 } 1959 1960 static int nb_vcs; 1961 static Chardev *vcs[MAX_VCS]; 1962 static void gd_vc_open(Chardev *chr, 1963 ChardevBackend *backend, 1964 bool *be_opened, 1965 Error **errp) 1966 { 1967 if (nb_vcs == MAX_VCS) { 1968 error_setg(errp, "Maximum number of consoles reached"); 1969 return; 1970 } 1971 1972 vcs[nb_vcs++] = chr; 1973 1974 /* console/chardev init sometimes completes elsewhere in a 2nd 1975 * stage, so defer OPENED events until they are fully initialized 1976 */ 1977 *be_opened = false; 1978 } 1979 1980 static void char_gd_vc_class_init(ObjectClass *oc, const void *data) 1981 { 1982 ChardevClass *cc = CHARDEV_CLASS(oc); 1983 1984 cc->open = gd_vc_open; 1985 cc->chr_write = gd_vc_chr_write; 1986 cc->chr_accept_input = gd_vc_chr_accept_input; 1987 cc->chr_set_echo = gd_vc_chr_set_echo; 1988 } 1989 1990 static const TypeInfo char_gd_vc_type_info = { 1991 .name = TYPE_CHARDEV_VC, 1992 .parent = TYPE_CHARDEV, 1993 .instance_size = sizeof(VCChardev), 1994 .class_init = char_gd_vc_class_init, 1995 }; 1996 1997 static gboolean gd_vc_in(VteTerminal *terminal, gchar *text, guint size, 1998 gpointer user_data) 1999 { 2000 VirtualConsole *vc = user_data; 2001 uint32_t free; 2002 2003 if (vc->vte.echo) { 2004 VteTerminal *term = VTE_TERMINAL(vc->vte.terminal); 2005 int i; 2006 for (i = 0; i < size; i++) { 2007 uint8_t c = text[i]; 2008 if (c >= 128 || isprint(c)) { 2009 /* 8-bit characters are considered printable. */ 2010 vte_terminal_feed(term, &text[i], 1); 2011 } else if (c == '\r' || c == '\n') { 2012 vte_terminal_feed(term, "\r\n", 2); 2013 } else { 2014 char ctrl[2] = { '^', 0}; 2015 ctrl[1] = text[i] ^ 64; 2016 vte_terminal_feed(term, ctrl, 2); 2017 } 2018 } 2019 } 2020 2021 free = fifo8_num_free(&vc->vte.out_fifo); 2022 fifo8_push_all(&vc->vte.out_fifo, (uint8_t *)text, MIN(free, size)); 2023 gd_vc_send_chars(vc); 2024 2025 return TRUE; 2026 } 2027 2028 static GSList *gd_vc_vte_init(GtkDisplayState *s, VirtualConsole *vc, 2029 Chardev *chr, int idx, 2030 GSList *group, GtkWidget *view_menu) 2031 { 2032 char buffer[32]; 2033 GtkWidget *box; 2034 GtkWidget *scrollbar; 2035 GtkAdjustment *vadjustment; 2036 VCChardev *vcd = VC_CHARDEV(chr); 2037 2038 vc->s = s; 2039 vc->vte.echo = vcd->echo; 2040 vc->vte.chr = chr; 2041 fifo8_create(&vc->vte.out_fifo, 4096); 2042 vcd->console = vc; 2043 2044 snprintf(buffer, sizeof(buffer), "vc%d", idx); 2045 vc->label = g_strdup(vc->vte.chr->label ? : buffer); 2046 group = gd_vc_menu_init(s, vc, idx, group, view_menu); 2047 2048 vc->vte.terminal = vte_terminal_new(); 2049 g_signal_connect(vc->vte.terminal, "commit", G_CALLBACK(gd_vc_in), vc); 2050 2051 /* The documentation says that the default is UTF-8, but actually it is 2052 * 7-bit ASCII at least in VTE 0.38. The function is deprecated since 2053 * VTE 0.54 (only UTF-8 is supported now). */ 2054 #if !VTE_CHECK_VERSION(0, 54, 0) 2055 #if VTE_CHECK_VERSION(0, 38, 0) 2056 vte_terminal_set_encoding(VTE_TERMINAL(vc->vte.terminal), "UTF-8", NULL); 2057 #else 2058 vte_terminal_set_encoding(VTE_TERMINAL(vc->vte.terminal), "UTF-8"); 2059 #endif 2060 #endif 2061 2062 vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->vte.terminal), -1); 2063 vte_terminal_set_size(VTE_TERMINAL(vc->vte.terminal), 2064 VC_TERM_X_MIN, VC_TERM_Y_MIN); 2065 2066 #if VTE_CHECK_VERSION(0, 28, 0) 2067 vadjustment = gtk_scrollable_get_vadjustment 2068 (GTK_SCROLLABLE(vc->vte.terminal)); 2069 #else 2070 vadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->vte.terminal)); 2071 #endif 2072 2073 box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); 2074 scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, vadjustment); 2075 2076 gtk_box_pack_end(GTK_BOX(box), scrollbar, FALSE, FALSE, 0); 2077 gtk_box_pack_end(GTK_BOX(box), vc->vte.terminal, TRUE, TRUE, 0); 2078 2079 vc->vte.box = box; 2080 vc->vte.scrollbar = scrollbar; 2081 2082 g_signal_connect(vadjustment, "changed", 2083 G_CALLBACK(gd_vc_adjustment_changed), vc); 2084 2085 vc->type = GD_VC_VTE; 2086 vc->tab_item = box; 2087 vc->focus = vc->vte.terminal; 2088 gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), vc->tab_item, 2089 gtk_label_new(vc->label)); 2090 2091 qemu_chr_be_event(vc->vte.chr, CHR_EVENT_OPENED); 2092 2093 return group; 2094 } 2095 2096 static void gd_vcs_init(GtkDisplayState *s, GSList *group, 2097 GtkWidget *view_menu) 2098 { 2099 int i; 2100 2101 for (i = 0; i < nb_vcs; i++) { 2102 VirtualConsole *vc = &s->vc[s->nb_vcs]; 2103 group = gd_vc_vte_init(s, vc, vcs[i], s->nb_vcs, group, view_menu); 2104 s->nb_vcs++; 2105 } 2106 } 2107 #endif /* CONFIG_VTE */ 2108 2109 /** Window Creation **/ 2110 2111 static void gd_connect_vc_gfx_signals(VirtualConsole *vc) 2112 { 2113 g_signal_connect(vc->gfx.drawing_area, "draw", 2114 G_CALLBACK(gd_draw_event), vc); 2115 #if defined(CONFIG_OPENGL) 2116 if (gtk_use_gl_area) { 2117 /* wire up GtkGlArea events */ 2118 g_signal_connect(vc->gfx.drawing_area, "render", 2119 G_CALLBACK(gd_render_event), vc); 2120 g_signal_connect(vc->gfx.drawing_area, "resize", 2121 G_CALLBACK(gd_resize_event), vc); 2122 } 2123 #endif 2124 if (qemu_console_is_graphic(vc->gfx.dcl.con)) { 2125 g_signal_connect(vc->gfx.drawing_area, "event", 2126 G_CALLBACK(gd_event), vc); 2127 g_signal_connect(vc->gfx.drawing_area, "button-press-event", 2128 G_CALLBACK(gd_button_event), vc); 2129 g_signal_connect(vc->gfx.drawing_area, "button-release-event", 2130 G_CALLBACK(gd_button_event), vc); 2131 g_signal_connect(vc->gfx.drawing_area, "scroll-event", 2132 G_CALLBACK(gd_scroll_event), vc); 2133 g_signal_connect(vc->gfx.drawing_area, "key-press-event", 2134 G_CALLBACK(gd_key_event), vc); 2135 g_signal_connect(vc->gfx.drawing_area, "key-release-event", 2136 G_CALLBACK(gd_key_event), vc); 2137 g_signal_connect(vc->gfx.drawing_area, "touch-event", 2138 G_CALLBACK(gd_touch_event), vc); 2139 2140 g_signal_connect(vc->gfx.drawing_area, "enter-notify-event", 2141 G_CALLBACK(gd_enter_event), vc); 2142 g_signal_connect(vc->gfx.drawing_area, "leave-notify-event", 2143 G_CALLBACK(gd_leave_event), vc); 2144 g_signal_connect(vc->gfx.drawing_area, "focus-in-event", 2145 G_CALLBACK(gd_focus_in_event), vc); 2146 g_signal_connect(vc->gfx.drawing_area, "focus-out-event", 2147 G_CALLBACK(gd_focus_out_event), vc); 2148 g_signal_connect(vc->gfx.drawing_area, "configure-event", 2149 G_CALLBACK(gd_configure), vc); 2150 g_signal_connect(vc->gfx.drawing_area, "grab-broken-event", 2151 G_CALLBACK(gd_grab_broken_event), vc); 2152 } else { 2153 g_signal_connect(vc->gfx.drawing_area, "key-press-event", 2154 G_CALLBACK(gd_text_key_down), vc); 2155 } 2156 } 2157 2158 static void gd_connect_signals(GtkDisplayState *s) 2159 { 2160 g_signal_connect(s->show_tabs_item, "activate", 2161 G_CALLBACK(gd_menu_show_tabs), s); 2162 g_signal_connect(s->untabify_item, "activate", 2163 G_CALLBACK(gd_menu_untabify), s); 2164 g_signal_connect(s->show_menubar_item, "activate", 2165 G_CALLBACK(gd_menu_show_menubar), s); 2166 2167 g_signal_connect(s->window, "delete-event", 2168 G_CALLBACK(gd_window_close), s); 2169 2170 g_signal_connect(s->pause_item, "activate", 2171 G_CALLBACK(gd_menu_pause), s); 2172 g_signal_connect(s->reset_item, "activate", 2173 G_CALLBACK(gd_menu_reset), s); 2174 g_signal_connect(s->powerdown_item, "activate", 2175 G_CALLBACK(gd_menu_powerdown), s); 2176 g_signal_connect(s->quit_item, "activate", 2177 G_CALLBACK(gd_menu_quit), s); 2178 #if defined(CONFIG_VTE) 2179 g_signal_connect(s->copy_item, "activate", 2180 G_CALLBACK(gd_menu_copy), s); 2181 #endif 2182 g_signal_connect(s->full_screen_item, "activate", 2183 G_CALLBACK(gd_menu_full_screen), s); 2184 g_signal_connect(s->zoom_in_item, "activate", 2185 G_CALLBACK(gd_menu_zoom_in), s); 2186 g_signal_connect(s->zoom_out_item, "activate", 2187 G_CALLBACK(gd_menu_zoom_out), s); 2188 g_signal_connect(s->zoom_fixed_item, "activate", 2189 G_CALLBACK(gd_menu_zoom_fixed), s); 2190 g_signal_connect(s->zoom_fit_item, "activate", 2191 G_CALLBACK(gd_menu_zoom_fit), s); 2192 g_signal_connect(s->grab_item, "activate", 2193 G_CALLBACK(gd_menu_grab_input), s); 2194 g_signal_connect(s->notebook, "switch-page", 2195 G_CALLBACK(gd_change_page), s); 2196 } 2197 2198 static GtkWidget *gd_create_menu_machine(GtkDisplayState *s) 2199 { 2200 GtkWidget *machine_menu; 2201 GtkWidget *separator; 2202 2203 machine_menu = gtk_menu_new(); 2204 gtk_menu_set_accel_group(GTK_MENU(machine_menu), s->accel_group); 2205 2206 s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause")); 2207 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->pause_item); 2208 2209 separator = gtk_separator_menu_item_new(); 2210 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator); 2211 2212 s->reset_item = gtk_menu_item_new_with_mnemonic(_("_Reset")); 2213 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->reset_item); 2214 2215 s->powerdown_item = gtk_menu_item_new_with_mnemonic(_("Power _Down")); 2216 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->powerdown_item); 2217 2218 separator = gtk_separator_menu_item_new(); 2219 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator); 2220 2221 s->quit_item = gtk_menu_item_new_with_mnemonic(_("_Quit")); 2222 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item), 2223 "<QEMU>/Machine/Quit"); 2224 gtk_accel_map_add_entry("<QEMU>/Machine/Quit", 2225 GDK_KEY_q, HOTKEY_MODIFIERS); 2226 gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->quit_item); 2227 2228 return machine_menu; 2229 } 2230 2231 #if defined(CONFIG_OPENGL) 2232 static void gl_area_realize(GtkGLArea *area, VirtualConsole *vc) 2233 { 2234 gtk_gl_area_make_current(area); 2235 qemu_egl_display = eglGetCurrentDisplay(); 2236 vc->gfx.has_dmabuf = qemu_egl_has_dmabuf(); 2237 if (!vc->gfx.has_dmabuf) { 2238 error_report("GtkGLArea console lacks DMABUF support."); 2239 } 2240 } 2241 #endif 2242 2243 static bool gd_scale_valid(double scale) 2244 { 2245 return scale >= VC_SCALE_MIN && scale <= VC_SCALE_MAX; 2246 } 2247 2248 static GSList *gd_vc_gfx_init(GtkDisplayState *s, VirtualConsole *vc, 2249 QemuConsole *con, int idx, 2250 GSList *group, GtkWidget *view_menu) 2251 { 2252 bool zoom_to_fit = false; 2253 int i; 2254 2255 vc->label = qemu_console_get_label(con); 2256 vc->s = s; 2257 vc->gfx.preferred_scale = 1.0; 2258 if (s->opts->u.gtk.has_scale) { 2259 if (gd_scale_valid(s->opts->u.gtk.scale)) { 2260 vc->gfx.preferred_scale = s->opts->u.gtk.scale; 2261 } else { 2262 error_report("Invalid scale value %lf given, being ignored", 2263 s->opts->u.gtk.scale); 2264 s->opts->u.gtk.has_scale = false; 2265 } 2266 } 2267 vc->gfx.scale_x = vc->gfx.preferred_scale; 2268 vc->gfx.scale_y = vc->gfx.preferred_scale; 2269 2270 #if defined(CONFIG_OPENGL) 2271 if (display_opengl) { 2272 if (gtk_use_gl_area) { 2273 vc->gfx.drawing_area = gtk_gl_area_new(); 2274 g_signal_connect(vc->gfx.drawing_area, "realize", 2275 G_CALLBACK(gl_area_realize), vc); 2276 vc->gfx.dcl.ops = &dcl_gl_area_ops; 2277 vc->gfx.dgc.ops = &gl_area_ctx_ops; 2278 } else { 2279 #ifdef CONFIG_X11 2280 vc->gfx.drawing_area = gtk_drawing_area_new(); 2281 /* 2282 * gtk_widget_set_double_buffered() was deprecated in 3.14. 2283 * It is required for opengl rendering on X11 though. A 2284 * proper replacement (native opengl support) is only 2285 * available in 3.16+. Silence the warning if possible. 2286 */ 2287 #pragma GCC diagnostic push 2288 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 2289 gtk_widget_set_double_buffered(vc->gfx.drawing_area, FALSE); 2290 #pragma GCC diagnostic pop 2291 vc->gfx.dcl.ops = &dcl_egl_ops; 2292 vc->gfx.dgc.ops = &egl_ctx_ops; 2293 vc->gfx.has_dmabuf = qemu_egl_has_dmabuf(); 2294 #else 2295 abort(); 2296 #endif 2297 } 2298 } else 2299 #endif 2300 { 2301 vc->gfx.drawing_area = gtk_drawing_area_new(); 2302 vc->gfx.dcl.ops = &dcl_ops; 2303 } 2304 2305 2306 gtk_widget_add_events(vc->gfx.drawing_area, 2307 GDK_POINTER_MOTION_MASK | 2308 GDK_BUTTON_PRESS_MASK | 2309 GDK_BUTTON_RELEASE_MASK | 2310 GDK_BUTTON_MOTION_MASK | 2311 GDK_TOUCH_MASK | 2312 GDK_ENTER_NOTIFY_MASK | 2313 GDK_LEAVE_NOTIFY_MASK | 2314 GDK_SCROLL_MASK | 2315 GDK_SMOOTH_SCROLL_MASK | 2316 GDK_KEY_PRESS_MASK); 2317 gtk_widget_set_can_focus(vc->gfx.drawing_area, TRUE); 2318 2319 vc->type = GD_VC_GFX; 2320 vc->tab_item = vc->gfx.drawing_area; 2321 vc->focus = vc->gfx.drawing_area; 2322 gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), 2323 vc->tab_item, gtk_label_new(vc->label)); 2324 2325 vc->gfx.kbd = qkbd_state_init(con); 2326 vc->gfx.dcl.con = con; 2327 2328 if (display_opengl) { 2329 qemu_console_set_display_gl_ctx(con, &vc->gfx.dgc); 2330 } 2331 register_displaychangelistener(&vc->gfx.dcl); 2332 2333 gd_connect_vc_gfx_signals(vc); 2334 group = gd_vc_menu_init(s, vc, idx, group, view_menu); 2335 2336 if (dpy_ui_info_supported(vc->gfx.dcl.con)) { 2337 zoom_to_fit = true; 2338 } 2339 if (s->opts->u.gtk.has_zoom_to_fit) { 2340 zoom_to_fit = s->opts->u.gtk.zoom_to_fit; 2341 } 2342 if (zoom_to_fit) { 2343 gtk_menu_item_activate(GTK_MENU_ITEM(s->zoom_fit_item)); 2344 s->free_scale = true; 2345 } 2346 2347 s->keep_aspect_ratio = true; 2348 if (s->opts->u.gtk.has_keep_aspect_ratio) 2349 s->keep_aspect_ratio = s->opts->u.gtk.keep_aspect_ratio; 2350 2351 for (i = 0; i < INPUT_EVENT_SLOTS_MAX; i++) { 2352 struct touch_slot *slot = &touch_slots[i]; 2353 slot->tracking_id = -1; 2354 } 2355 2356 return group; 2357 } 2358 2359 static GtkWidget *gd_create_menu_view(GtkDisplayState *s, DisplayOptions *opts) 2360 { 2361 GSList *group = NULL; 2362 GtkWidget *view_menu; 2363 GtkWidget *separator; 2364 QemuConsole *con; 2365 int vc; 2366 2367 view_menu = gtk_menu_new(); 2368 gtk_menu_set_accel_group(GTK_MENU(view_menu), s->accel_group); 2369 2370 s->full_screen_item = gtk_menu_item_new_with_mnemonic(_("_Fullscreen")); 2371 2372 #if defined(CONFIG_VTE) 2373 s->copy_item = gtk_menu_item_new_with_mnemonic(_("_Copy")); 2374 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->copy_item); 2375 #endif 2376 2377 gtk_accel_group_connect(s->accel_group, GDK_KEY_f, HOTKEY_MODIFIERS, 0, 2378 g_cclosure_new_swap(G_CALLBACK(gd_accel_full_screen), s, NULL)); 2379 gtk_accel_label_set_accel( 2380 GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(s->full_screen_item))), 2381 GDK_KEY_f, HOTKEY_MODIFIERS); 2382 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->full_screen_item); 2383 2384 separator = gtk_separator_menu_item_new(); 2385 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 2386 2387 s->zoom_in_item = gtk_menu_item_new_with_mnemonic(_("Zoom _In")); 2388 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_in_item), 2389 "<QEMU>/View/Zoom In"); 2390 gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus, 2391 HOTKEY_MODIFIERS); 2392 gtk_accel_group_connect(s->accel_group, GDK_KEY_equal, HOTKEY_MODIFIERS, 0, 2393 g_cclosure_new_swap(G_CALLBACK(gd_accel_zoom_in), s, NULL)); 2394 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_in_item); 2395 2396 s->zoom_out_item = gtk_menu_item_new_with_mnemonic(_("Zoom _Out")); 2397 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_out_item), 2398 "<QEMU>/View/Zoom Out"); 2399 gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus, 2400 HOTKEY_MODIFIERS); 2401 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_out_item); 2402 2403 s->zoom_fixed_item = gtk_menu_item_new_with_mnemonic(_("Best _Fit")); 2404 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_fixed_item), 2405 "<QEMU>/View/Zoom Fixed"); 2406 gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0, 2407 HOTKEY_MODIFIERS); 2408 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fixed_item); 2409 2410 s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit")); 2411 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fit_item); 2412 2413 separator = gtk_separator_menu_item_new(); 2414 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 2415 2416 s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover")); 2417 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_on_hover_item); 2418 2419 s->grab_item = gtk_check_menu_item_new_with_mnemonic(_("_Grab Input")); 2420 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->grab_item), 2421 "<QEMU>/View/Grab Input"); 2422 gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g, 2423 HOTKEY_MODIFIERS); 2424 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_item); 2425 2426 separator = gtk_separator_menu_item_new(); 2427 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 2428 2429 /* gfx */ 2430 for (vc = 0;; vc++) { 2431 con = qemu_console_lookup_by_index(vc); 2432 if (!con) { 2433 break; 2434 } 2435 group = gd_vc_gfx_init(s, &s->vc[vc], con, 2436 vc, group, view_menu); 2437 s->nb_vcs++; 2438 } 2439 2440 #if defined(CONFIG_VTE) 2441 /* vte */ 2442 gd_vcs_init(s, group, view_menu); 2443 #endif 2444 2445 separator = gtk_separator_menu_item_new(); 2446 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator); 2447 2448 s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs")); 2449 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_tabs_item); 2450 2451 s->untabify_item = gtk_menu_item_new_with_mnemonic(_("Detach Tab")); 2452 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->untabify_item); 2453 2454 s->show_menubar_item = gtk_check_menu_item_new_with_mnemonic( 2455 _("Show Menubar")); 2456 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->show_menubar_item), 2457 !opts->u.gtk.has_show_menubar || 2458 opts->u.gtk.show_menubar); 2459 gtk_accel_group_connect(s->accel_group, GDK_KEY_m, HOTKEY_MODIFIERS, 0, 2460 g_cclosure_new_swap(G_CALLBACK(gd_accel_show_menubar), s, NULL)); 2461 gtk_accel_label_set_accel( 2462 GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(s->show_menubar_item))), 2463 GDK_KEY_m, HOTKEY_MODIFIERS); 2464 gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_menubar_item); 2465 2466 return view_menu; 2467 } 2468 2469 static void gd_create_menus(GtkDisplayState *s, DisplayOptions *opts) 2470 { 2471 GtkSettings *settings; 2472 2473 s->accel_group = gtk_accel_group_new(); 2474 s->machine_menu = gd_create_menu_machine(s); 2475 s->view_menu = gd_create_menu_view(s, opts); 2476 2477 s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine")); 2478 gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->machine_menu_item), 2479 s->machine_menu); 2480 gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->machine_menu_item); 2481 2482 s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View")); 2483 gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->view_menu_item), s->view_menu); 2484 gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item); 2485 2486 g_object_set_data(G_OBJECT(s->window), "accel_group", s->accel_group); 2487 gtk_window_add_accel_group(GTK_WINDOW(s->window), s->accel_group); 2488 2489 /* Disable the default "F10" menu shortcut. */ 2490 settings = gtk_widget_get_settings(s->window); 2491 g_object_set(G_OBJECT(settings), "gtk-menu-bar-accel", "", NULL); 2492 } 2493 2494 2495 static gboolean gtkinit; 2496 2497 static void gtk_display_init(DisplayState *ds, DisplayOptions *opts) 2498 { 2499 VirtualConsole *vc; 2500 2501 GtkDisplayState *s; 2502 GdkDisplay *window_display; 2503 GtkIconTheme *theme; 2504 char *dir; 2505 int idx; 2506 2507 if (!gtkinit) { 2508 fprintf(stderr, "gtk initialization failed\n"); 2509 exit(1); 2510 } 2511 assert(opts->type == DISPLAY_TYPE_GTK); 2512 s = g_malloc0(sizeof(*s)); 2513 s->opts = opts; 2514 2515 theme = gtk_icon_theme_get_default(); 2516 dir = get_relocated_path(CONFIG_QEMU_ICONDIR); 2517 gtk_icon_theme_prepend_search_path(theme, dir); 2518 g_free(dir); 2519 g_set_prgname("qemu"); 2520 2521 s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 2522 s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); 2523 s->notebook = gtk_notebook_new(); 2524 s->menu_bar = gtk_menu_bar_new(); 2525 2526 s->free_scale = FALSE; 2527 2528 /* Mostly LC_MESSAGES only. See early_gtk_display_init() for details. For 2529 * LC_CTYPE, we need to make sure that non-ASCII characters are considered 2530 * printable, but without changing any of the character classes to make 2531 * sure that we don't accidentally break implicit assumptions. */ 2532 setlocale(LC_MESSAGES, ""); 2533 setlocale(LC_CTYPE, "C.UTF-8"); 2534 dir = get_relocated_path(CONFIG_QEMU_LOCALEDIR); 2535 bindtextdomain("qemu", dir); 2536 g_free(dir); 2537 bind_textdomain_codeset("qemu", "UTF-8"); 2538 textdomain("qemu"); 2539 2540 window_display = gtk_widget_get_display(s->window); 2541 if (s->opts->has_show_cursor && s->opts->show_cursor) { 2542 s->null_cursor = NULL; /* default pointer */ 2543 } else { 2544 s->null_cursor = gdk_cursor_new_for_display(window_display, 2545 GDK_BLANK_CURSOR); 2546 } 2547 2548 s->mouse_mode_notifier.notify = gd_mouse_mode_change; 2549 qemu_add_mouse_mode_change_notifier(&s->mouse_mode_notifier); 2550 qemu_add_vm_change_state_handler(gd_change_runstate, s); 2551 2552 gtk_window_set_icon_name(GTK_WINDOW(s->window), "qemu"); 2553 2554 gd_create_menus(s, opts); 2555 2556 gd_connect_signals(s); 2557 2558 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE); 2559 gtk_notebook_set_show_border(GTK_NOTEBOOK(s->notebook), FALSE); 2560 2561 gd_update_caption(s); 2562 2563 gtk_box_pack_start(GTK_BOX(s->vbox), s->menu_bar, FALSE, TRUE, 0); 2564 gtk_box_pack_start(GTK_BOX(s->vbox), s->notebook, TRUE, TRUE, 0); 2565 2566 gtk_container_add(GTK_CONTAINER(s->window), s->vbox); 2567 2568 gtk_widget_show_all(s->window); 2569 2570 for (idx = 0;; idx++) { 2571 QemuConsole *con = qemu_console_lookup_by_index(idx); 2572 if (!con) { 2573 break; 2574 } 2575 gtk_widget_realize(s->vc[idx].gfx.drawing_area); 2576 } 2577 2578 if (opts->u.gtk.has_show_menubar && 2579 !opts->u.gtk.show_menubar) { 2580 gtk_widget_hide(s->menu_bar); 2581 } 2582 2583 vc = gd_vc_find_current(s); 2584 gtk_widget_set_sensitive(s->view_menu, vc != NULL); 2585 #ifdef CONFIG_VTE 2586 gtk_widget_set_sensitive(s->copy_item, 2587 vc && vc->type == GD_VC_VTE); 2588 #endif 2589 2590 if (opts->has_full_screen && 2591 opts->full_screen) { 2592 gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item)); 2593 } 2594 if (opts->u.gtk.has_grab_on_hover && 2595 opts->u.gtk.grab_on_hover) { 2596 gtk_menu_item_activate(GTK_MENU_ITEM(s->grab_on_hover_item)); 2597 } 2598 if (opts->u.gtk.has_show_tabs && 2599 opts->u.gtk.show_tabs) { 2600 gtk_menu_item_activate(GTK_MENU_ITEM(s->show_tabs_item)); 2601 } 2602 #ifdef CONFIG_GTK_CLIPBOARD 2603 gd_clipboard_init(s); 2604 #endif /* CONFIG_GTK_CLIPBOARD */ 2605 2606 /* GTK's event polling must happen on the main thread. */ 2607 qemu_main = NULL; 2608 } 2609 2610 static void early_gtk_display_init(DisplayOptions *opts) 2611 { 2612 /* The QEMU code relies on the assumption that it's always run in 2613 * the C locale. Therefore it is not prepared to deal with 2614 * operations that produce different results depending on the 2615 * locale, such as printf's formatting of decimal numbers, and 2616 * possibly others. 2617 * 2618 * Since GTK+ calls setlocale() by default -importing the locale 2619 * settings from the environment- we must prevent it from doing so 2620 * using gtk_disable_setlocale(). 2621 * 2622 * QEMU's GTK+ UI, however, _does_ have translations for some of 2623 * the menu items. As a trade-off between a functionally correct 2624 * QEMU and a fully internationalized UI we support importing 2625 * LC_MESSAGES from the environment (see the setlocale() call 2626 * earlier in this file). This allows us to display translated 2627 * messages leaving everything else untouched. 2628 */ 2629 gtk_disable_setlocale(); 2630 gtkinit = gtk_init_check(NULL, NULL); 2631 if (!gtkinit) { 2632 /* don't exit yet, that'll break -help */ 2633 return; 2634 } 2635 2636 assert(opts->type == DISPLAY_TYPE_GTK); 2637 if (opts->has_gl && opts->gl != DISPLAY_GL_MODE_OFF) { 2638 #if defined(CONFIG_OPENGL) 2639 #if defined(GDK_WINDOWING_WAYLAND) 2640 if (GDK_IS_WAYLAND_DISPLAY(gdk_display_get_default())) { 2641 gtk_use_gl_area = true; 2642 gtk_gl_area_init(); 2643 } else 2644 #endif 2645 #if defined(GDK_WINDOWING_WIN32) 2646 if (GDK_IS_WIN32_DISPLAY(gdk_display_get_default())) { 2647 gtk_use_gl_area = true; 2648 gtk_gl_area_init(); 2649 } else 2650 #endif 2651 { 2652 #ifdef CONFIG_X11 2653 DisplayGLMode mode = opts->has_gl ? opts->gl : DISPLAY_GL_MODE_ON; 2654 gtk_egl_init(mode); 2655 #endif 2656 } 2657 #endif 2658 } 2659 2660 keycode_map = gd_get_keymap(&keycode_maplen); 2661 2662 #if defined(CONFIG_VTE) 2663 type_register_static(&char_gd_vc_type_info); 2664 #endif 2665 } 2666 2667 static QemuDisplay qemu_display_gtk = { 2668 .type = DISPLAY_TYPE_GTK, 2669 .early_init = early_gtk_display_init, 2670 .init = gtk_display_init, 2671 .vc = "vc", 2672 }; 2673 2674 static void register_gtk(void) 2675 { 2676 qemu_display_register(&qemu_display_gtk); 2677 } 2678 2679 type_init(register_gtk); 2680 2681 #ifdef CONFIG_OPENGL 2682 module_dep("ui-opengl"); 2683 #endif 2684