gtk.c 58.0 KB
Newer Older
A
Anthony Liguori 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
/*
 * GTK UI
 *
 * Copyright IBM, Corp. 2012
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 *
 * Portions from gtk-vnc:
 *
 * GTK VNC Widget
 *
 * Copyright (C) 2006  Anthony Liguori <anthony@codemonkey.ws>
 * Copyright (C) 2009-2010 Daniel P. Berrange <dan@berrange.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.0 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

34 35 36
#define GETTEXT_PACKAGE "qemu"
#define LOCALEDIR "po"

37 38 39 40
#ifdef _WIN32
# define _WIN32_WINNT 0x0601 /* needed to get definition of MAPVK_VK_TO_VSC */
#endif

K
Kevin Wolf 已提交
41 42 43 44
#include "qemu-common.h"

#ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
/* Work around an -Wstrict-prototypes warning in GTK headers */
45
#pragma GCC diagnostic push
K
Kevin Wolf 已提交
46 47
#pragma GCC diagnostic ignored "-Wstrict-prototypes"
#endif
A
Anthony Liguori 已提交
48
#include <gtk/gtk.h>
K
Kevin Wolf 已提交
49
#ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
50
#pragma GCC diagnostic pop
K
Kevin Wolf 已提交
51 52 53
#endif


A
Anthony Liguori 已提交
54
#include <gdk/gdkkeysyms.h>
55
#include <glib/gi18n.h>
56
#include <locale.h>
S
Stefan Weil 已提交
57
#if defined(CONFIG_VTE)
A
Anthony Liguori 已提交
58
#include <vte/vte.h>
S
Stefan Weil 已提交
59
#endif
A
Anthony Liguori 已提交
60 61
#include <math.h>

62
#include "trace.h"
A
Anthony Liguori 已提交
63
#include "ui/console.h"
64
#include "ui/input.h"
A
Anthony Liguori 已提交
65 66 67 68
#include "sysemu/sysemu.h"
#include "qmp-commands.h"
#include "x_keymap.h"
#include "keymaps.h"
69
#include "sysemu/char.h"
G
Gerd Hoffmann 已提交
70
#include "qom/object.h"
71
#ifdef GDK_WINDOWING_X11
72 73 74
#include <gdk/gdkx.h>
#include <X11/XKBlib.h>
#endif
A
Anthony Liguori 已提交
75

76
#define MAX_VCS 10
G
Gerd Hoffmann 已提交
77 78 79 80 81 82
#define VC_WINDOW_X_MIN  320
#define VC_WINDOW_Y_MIN  240
#define VC_TERM_X_MIN     80
#define VC_TERM_Y_MIN     25
#define VC_SCALE_MIN    0.25
#define VC_SCALE_STEP   0.25
83

S
Stefan Weil 已提交
84 85 86
#if !defined(CONFIG_VTE)
# define VTE_CHECK_VERSION(a, b, c) 0
#endif
87

88 89 90 91 92 93 94 95 96 97 98 99 100 101
#if defined(CONFIG_VTE) && !GTK_CHECK_VERSION(3, 0, 0)
/*
 * The gtk2 vte terminal widget seriously messes up the window resize
 * for some reason.  You basically can't make the qemu window smaller
 * any more because the toplevel window geoemtry hints are overridden.
 *
 * Workaround that by hiding all vte widgets, except the one in the
 * current tab.
 *
 * Luckily everything works smooth in gtk3.
 */
# define VTE_RESIZE_HACK 1
#endif

102 103 104 105 106 107 108 109 110
/* Compatibility define to let us build on both Gtk2 and Gtk3 */
#if GTK_CHECK_VERSION(3, 0, 0)
static inline void gdk_drawable_get_size(GdkWindow *w, gint *ww, gint *wh)
{
    *ww = gdk_window_get_width(w);
    *wh = gdk_window_get_height(w);
}
#endif

111 112 113 114
#if !GTK_CHECK_VERSION(2, 20, 0)
#define gtk_widget_get_realized(widget) GTK_WIDGET_REALIZED(widget)
#endif

115 116 117 118 119 120 121
#ifndef GDK_IS_X11_DISPLAY
#define GDK_IS_X11_DISPLAY(dpy) (dpy == dpy)
#endif
#ifndef GDK_IS_WIN32_DISPLAY
#define GDK_IS_WIN32_DISPLAY(dpy) (dpy == dpy)
#endif

122 123 124 125 126 127
#ifndef GDK_KEY_0
#define GDK_KEY_0 GDK_0
#define GDK_KEY_1 GDK_1
#define GDK_KEY_2 GDK_2
#define GDK_KEY_f GDK_f
#define GDK_KEY_g GDK_g
128
#define GDK_KEY_q GDK_q
129 130
#define GDK_KEY_plus GDK_plus
#define GDK_KEY_minus GDK_minus
G
Gerd Hoffmann 已提交
131
#define GDK_KEY_Pause GDK_Pause
132
#endif
133

J
Jan Kiszka 已提交
134 135
#define HOTKEY_MODIFIERS        (GDK_CONTROL_MASK | GDK_MOD1_MASK)

136 137 138 139 140
static const int modifier_keycode[] = {
    /* shift, control, alt keys, meta keys, both left & right */
    0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8, 0xdb, 0xdd,
};

141 142 143 144 145 146 147 148 149 150 151 152
typedef struct GtkDisplayState GtkDisplayState;

typedef struct VirtualGfxConsole {
    GtkWidget *drawing_area;
    DisplayChangeListener dcl;
    DisplaySurface *ds;
    pixman_image_t *convert;
    cairo_surface_t *surface;
    double scale_x;
    double scale_y;
} VirtualGfxConsole;

S
Stefan Weil 已提交
153
#if defined(CONFIG_VTE)
G
Gerd Hoffmann 已提交
154
typedef struct VirtualVteConsole {
155 156
    GtkWidget *box;
    GtkWidget *scrollbar;
157
    GtkWidget *terminal;
A
Anthony Liguori 已提交
158
    CharDriverState *chr;
G
Gerd Hoffmann 已提交
159 160 161
} VirtualVteConsole;
#endif

162 163 164 165 166
typedef enum VirtualConsoleType {
    GD_VC_GFX,
    GD_VC_VTE,
} VirtualConsoleType;

G
Gerd Hoffmann 已提交
167
typedef struct VirtualConsole {
168
    GtkDisplayState *s;
169 170
    char *label;
    GtkWidget *window;
G
Gerd Hoffmann 已提交
171 172
    GtkWidget *menu_item;
    GtkWidget *tab_item;
173
    VirtualConsoleType type;
G
Gerd Hoffmann 已提交
174
    union {
175
        VirtualGfxConsole gfx;
G
Gerd Hoffmann 已提交
176 177
#if defined(CONFIG_VTE)
        VirtualVteConsole vte;
S
Stefan Weil 已提交
178
#endif
G
Gerd Hoffmann 已提交
179
    };
A
Anthony Liguori 已提交
180 181
} VirtualConsole;

182
struct GtkDisplayState {
A
Anthony Liguori 已提交
183 184 185 186
    GtkWidget *window;

    GtkWidget *menu_bar;

187 188
    GtkAccelGroup *accel_group;

189 190 191 192 193
    GtkWidget *machine_menu_item;
    GtkWidget *machine_menu;
    GtkWidget *pause_item;
    GtkWidget *reset_item;
    GtkWidget *powerdown_item;
A
Anthony Liguori 已提交
194 195 196 197
    GtkWidget *quit_item;

    GtkWidget *view_menu_item;
    GtkWidget *view_menu;
198 199 200 201 202
    GtkWidget *full_screen_item;
    GtkWidget *zoom_in_item;
    GtkWidget *zoom_out_item;
    GtkWidget *zoom_fixed_item;
    GtkWidget *zoom_fit_item;
203 204
    GtkWidget *grab_item;
    GtkWidget *grab_on_hover_item;
A
Anthony Liguori 已提交
205

206 207 208
    int nb_vcs;
    VirtualConsole vc[MAX_VCS];

A
Anthony Liguori 已提交
209
    GtkWidget *show_tabs_item;
210
    GtkWidget *untabify_item;
A
Anthony Liguori 已提交
211 212 213 214

    GtkWidget *vbox;
    GtkWidget *notebook;
    int button_mask;
215
    gboolean last_set;
A
Anthony Liguori 已提交
216 217
    int last_x;
    int last_y;
218 219
    int grab_x_root;
    int grab_y_root;
G
Gerd Hoffmann 已提交
220 221
    VirtualConsole *kbd_owner;
    VirtualConsole *ptr_owner;
A
Anthony Liguori 已提交
222

223
    gboolean full_screen;
A
Anthony Liguori 已提交
224 225 226

    GdkCursor *null_cursor;
    Notifier mouse_mode_notifier;
227
    gboolean free_scale;
228 229

    bool external_pause_update;
230 231

    bool modifier_pressed[ARRAY_SIZE(modifier_keycode)];
232
    bool has_evdev;
233
};
A
Anthony Liguori 已提交
234

G
Gerd Hoffmann 已提交
235 236 237
static void gd_grab_pointer(VirtualConsole *vc);
static void gd_ungrab_pointer(GtkDisplayState *s);

A
Anthony Liguori 已提交
238 239
/** Utility Functions **/

G
Gerd Hoffmann 已提交
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
static VirtualConsole *gd_vc_find_by_menu(GtkDisplayState *s)
{
    VirtualConsole *vc;
    gint i;

    for (i = 0; i < s->nb_vcs; i++) {
        vc = &s->vc[i];
        if (gtk_check_menu_item_get_active
            (GTK_CHECK_MENU_ITEM(vc->menu_item))) {
            return vc;
        }
    }
    return NULL;
}

static VirtualConsole *gd_vc_find_by_page(GtkDisplayState *s, gint page)
{
    VirtualConsole *vc;
    gint i, p;

    for (i = 0; i < s->nb_vcs; i++) {
        vc = &s->vc[i];
        p = gtk_notebook_page_num(GTK_NOTEBOOK(s->notebook), vc->tab_item);
        if (p == page) {
            return vc;
        }
    }
    return NULL;
}

270 271 272 273 274 275 276 277
static VirtualConsole *gd_vc_find_current(GtkDisplayState *s)
{
    gint page;

    page = gtk_notebook_get_current_page(GTK_NOTEBOOK(s->notebook));
    return gd_vc_find_by_page(s, page);
}

278 279 280 281 282 283 284 285 286 287
static bool gd_is_grab_active(GtkDisplayState *s)
{
    return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_item));
}

static bool gd_grab_on_hover(GtkDisplayState *s)
{
    return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->grab_on_hover_item));
}

288
static void gd_update_cursor(VirtualConsole *vc)
A
Anthony Liguori 已提交
289
{
290
    GtkDisplayState *s = vc->s;
A
Anthony Liguori 已提交
291 292
    GdkWindow *window;

293 294 295
    if (vc->type != GD_VC_GFX) {
        return;
    }
A
Anthony Liguori 已提交
296

297 298 299 300
    if (!gtk_widget_get_realized(vc->gfx.drawing_area)) {
        return;
    }

301
    window = gtk_widget_get_window(GTK_WIDGET(vc->gfx.drawing_area));
G
Gerd Hoffmann 已提交
302
    if (s->full_screen || qemu_input_is_absolute() || s->ptr_owner == vc) {
A
Anthony Liguori 已提交
303 304 305 306 307 308 309 310 311
        gdk_window_set_cursor(window, s->null_cursor);
    } else {
        gdk_window_set_cursor(window, NULL);
    }
}

static void gd_update_caption(GtkDisplayState *s)
{
    const char *status = "";
G
Gerd Hoffmann 已提交
312
    gchar *prefix;
A
Anthony Liguori 已提交
313
    gchar *title;
314
    const char *grab = "";
315
    bool is_paused = !runstate_is_running();
G
Gerd Hoffmann 已提交
316 317 318 319 320 321 322
    int i;

    if (qemu_name) {
        prefix = g_strdup_printf("QEMU (%s)", qemu_name);
    } else {
        prefix = g_strdup_printf("QEMU");
    }
323

G
Gerd Hoffmann 已提交
324 325
    if (s->ptr_owner != NULL &&
        s->ptr_owner->window == NULL) {
326
        grab = _(" - Press Ctrl+Alt+G to release grab");
327
    }
A
Anthony Liguori 已提交
328

329
    if (is_paused) {
330
        status = _(" [Paused]");
A
Anthony Liguori 已提交
331
    }
332 333 334 335
    s->external_pause_update = true;
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->pause_item),
                                   is_paused);
    s->external_pause_update = false;
A
Anthony Liguori 已提交
336

G
Gerd Hoffmann 已提交
337
    title = g_strdup_printf("%s%s%s", prefix, status, grab);
A
Anthony Liguori 已提交
338 339
    gtk_window_set_title(GTK_WINDOW(s->window), title);
    g_free(title);
G
Gerd Hoffmann 已提交
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354

    for (i = 0; i < s->nb_vcs; i++) {
        VirtualConsole *vc = &s->vc[i];

        if (!vc->window) {
            continue;
        }
        title = g_strdup_printf("%s: %s%s%s", prefix, vc->label,
                                vc == s->kbd_owner ? " +kbd" : "",
                                vc == s->ptr_owner ? " +ptr" : "");
        gtk_window_set_title(GTK_WINDOW(vc->window), title);
        g_free(title);
    }

    g_free(prefix);
A
Anthony Liguori 已提交
355 356
}

G
Gerd Hoffmann 已提交
357
static void gd_update_geometry_hints(VirtualConsole *vc)
G
Gerd Hoffmann 已提交
358
{
359
    GtkDisplayState *s = vc->s;
G
Gerd Hoffmann 已提交
360 361 362 363
    GdkWindowHints mask = 0;
    GdkGeometry geo = {};
    GtkWidget *geo_widget = NULL;
    GtkWindow *geo_window;
364

G
Gerd Hoffmann 已提交
365 366 367 368 369 370 371 372 373 374 375 376
    if (vc->type == GD_VC_GFX) {
        if (s->free_scale) {
            geo.min_width  = surface_width(vc->gfx.ds) * VC_SCALE_MIN;
            geo.min_height = surface_height(vc->gfx.ds) * VC_SCALE_MIN;
            mask |= GDK_HINT_MIN_SIZE;
        } else {
            geo.min_width  = surface_width(vc->gfx.ds) * vc->gfx.scale_x;
            geo.min_height = surface_height(vc->gfx.ds) * vc->gfx.scale_y;
            mask |= GDK_HINT_MIN_SIZE;
        }
        geo_widget = vc->gfx.drawing_area;
        gtk_widget_set_size_request(geo_widget, geo.min_width, geo.min_height);
G
Gerd Hoffmann 已提交
377

G
Gerd Hoffmann 已提交
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
#if defined(CONFIG_VTE)
    } else if (vc->type == GD_VC_VTE) {
        VteTerminal *term = VTE_TERMINAL(vc->vte.terminal);
        GtkBorder *ib;

        geo.width_inc  = vte_terminal_get_char_width(term);
        geo.height_inc = vte_terminal_get_char_height(term);
        mask |= GDK_HINT_RESIZE_INC;
        geo.base_width  = geo.width_inc;
        geo.base_height = geo.height_inc;
        mask |= GDK_HINT_BASE_SIZE;
        geo.min_width  = geo.width_inc * VC_TERM_X_MIN;
        geo.min_height = geo.height_inc * VC_TERM_Y_MIN;
        mask |= GDK_HINT_MIN_SIZE;
        gtk_widget_style_get(vc->vte.terminal, "inner-border", &ib, NULL);
        geo.base_width  += ib->left + ib->right;
        geo.base_height += ib->top + ib->bottom;
        geo.min_width   += ib->left + ib->right;
        geo.min_height  += ib->top + ib->bottom;
        geo_widget = vc->vte.terminal;
#endif
G
Gerd Hoffmann 已提交
399
    }
G
Gerd Hoffmann 已提交
400 401 402 403 404 405 406 407 408 409 410 411 412 413

    geo_window = GTK_WINDOW(vc->window ? vc->window : s->window);
    gtk_window_set_geometry_hints(geo_window, geo_widget, &geo, mask);
}

static void gd_update_windowsize(VirtualConsole *vc)
{
    GtkDisplayState *s = vc->s;

    gd_update_geometry_hints(vc);

    if (vc->type == GD_VC_GFX && !s->full_screen && !s->free_scale) {
        gtk_window_resize(GTK_WINDOW(vc->window ? vc->window : s->window),
                          VC_WINDOW_X_MIN, VC_WINDOW_Y_MIN);
G
Gerd Hoffmann 已提交
414
    }
G
Gerd Hoffmann 已提交
415 416
}

417
static void gd_update_full_redraw(VirtualConsole *vc)
G
Gerd Hoffmann 已提交
418
{
419
    GtkWidget *area = vc->gfx.drawing_area;
G
Gerd Hoffmann 已提交
420
    int ww, wh;
421 422
    gdk_drawable_get_size(gtk_widget_get_window(area), &ww, &wh);
    gtk_widget_queue_draw_area(area, 0, 0, ww, wh);
G
Gerd Hoffmann 已提交
423 424
}

425 426
static void gtk_release_modifiers(GtkDisplayState *s)
{
427
    VirtualConsole *vc = gd_vc_find_current(s);
428 429
    int i, keycode;

430
    if (vc->type != GD_VC_GFX) {
431 432 433 434 435 436 437
        return;
    }
    for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) {
        keycode = modifier_keycode[i];
        if (!s->modifier_pressed[i]) {
            continue;
        }
438
        qemu_input_event_send_key_number(vc->gfx.dcl.con, keycode, false);
439 440 441 442
        s->modifier_pressed[i] = false;
    }
}

443 444 445 446 447 448 449 450 451
static void gd_widget_reparent(GtkWidget *from, GtkWidget *to,
                               GtkWidget *widget)
{
    g_object_ref(G_OBJECT(widget));
    gtk_container_remove(GTK_CONTAINER(from), widget);
    gtk_container_add(GTK_CONTAINER(to), widget);
    g_object_unref(G_OBJECT(widget));
}

A
Anthony Liguori 已提交
452 453
/** DisplayState Callbacks **/

454
static void gd_update(DisplayChangeListener *dcl,
455
                      int x, int y, int w, int h)
A
Anthony Liguori 已提交
456
{
457
    VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
A
Anthony Liguori 已提交
458
    int x1, x2, y1, y2;
459 460 461
    int mx, my;
    int fbw, fbh;
    int ww, wh;
A
Anthony Liguori 已提交
462

G
Gerd Hoffmann 已提交
463
    trace_gd_update(vc->label, x, y, w, h);
A
Anthony Liguori 已提交
464

465 466 467 468
    if (!gtk_widget_get_realized(vc->gfx.drawing_area)) {
        return;
    }

469 470 471
    if (vc->gfx.convert) {
        pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image,
                               NULL, vc->gfx.convert,
472 473 474
                               x, y, 0, 0, x, y, w, h);
    }

475 476
    x1 = floor(x * vc->gfx.scale_x);
    y1 = floor(y * vc->gfx.scale_y);
A
Anthony Liguori 已提交
477

478 479
    x2 = ceil(x * vc->gfx.scale_x + w * vc->gfx.scale_x);
    y2 = ceil(y * vc->gfx.scale_y + h * vc->gfx.scale_y);
A
Anthony Liguori 已提交
480

481 482
    fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x;
    fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y;
483

484 485
    gdk_drawable_get_size(gtk_widget_get_window(vc->gfx.drawing_area),
                          &ww, &wh);
486 487 488 489 490 491 492 493 494

    mx = my = 0;
    if (ww > fbw) {
        mx = (ww - fbw) / 2;
    }
    if (wh > fbh) {
        my = (wh - fbh) / 2;
    }

495 496
    gtk_widget_queue_draw_area(vc->gfx.drawing_area,
                               mx + x1, my + y1, (x2 - x1), (y2 - y1));
A
Anthony Liguori 已提交
497 498
}

499
static void gd_refresh(DisplayChangeListener *dcl)
A
Anthony Liguori 已提交
500
{
501
    graphic_hw_update(dcl->con);
A
Anthony Liguori 已提交
502 503
}

504 505 506 507
#if GTK_CHECK_VERSION(3, 0, 0)
static void gd_mouse_set(DisplayChangeListener *dcl,
                         int x, int y, int visible)
{
508
    VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
509 510 511 512
    GdkDisplay *dpy;
    GdkDeviceManager *mgr;
    gint x_root, y_root;

C
Cole Robinson 已提交
513 514 515 516
    if (qemu_input_is_absolute()) {
        return;
    }

517
    dpy = gtk_widget_get_display(vc->gfx.drawing_area);
518
    mgr = gdk_display_get_device_manager(dpy);
519
    gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area),
520 521
                               x, y, &x_root, &y_root);
    gdk_device_warp(gdk_device_manager_get_client_pointer(mgr),
522
                    gtk_widget_get_screen(vc->gfx.drawing_area),
C
Cole Robinson 已提交
523
                    x_root, y_root);
524 525
}
#else
G
Gerd Hoffmann 已提交
526 527 528
static void gd_mouse_set(DisplayChangeListener *dcl,
                         int x, int y, int visible)
{
529
    VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
G
Gerd Hoffmann 已提交
530 531
    gint x_root, y_root;

C
Cole Robinson 已提交
532 533 534 535
    if (qemu_input_is_absolute()) {
        return;
    }

536
    gdk_window_get_root_coords(gtk_widget_get_window(vc->gfx.drawing_area),
G
Gerd Hoffmann 已提交
537
                               x, y, &x_root, &y_root);
538 539
    gdk_display_warp_pointer(gtk_widget_get_display(vc->gfx.drawing_area),
                             gtk_widget_get_screen(vc->gfx.drawing_area),
G
Gerd Hoffmann 已提交
540 541
                             x_root, y_root);
}
542
#endif
G
Gerd Hoffmann 已提交
543 544 545 546

static void gd_cursor_define(DisplayChangeListener *dcl,
                             QEMUCursor *c)
{
547
    VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
G
Gerd Hoffmann 已提交
548 549 550
    GdkPixbuf *pixbuf;
    GdkCursor *cursor;

551 552 553 554
    if (!gtk_widget_get_realized(vc->gfx.drawing_area)) {
        return;
    }

G
Gerd Hoffmann 已提交
555 556 557 558
    pixbuf = gdk_pixbuf_new_from_data((guchar *)(c->data),
                                      GDK_COLORSPACE_RGB, true, 8,
                                      c->width, c->height, c->width * 4,
                                      NULL, NULL);
559 560 561 562
    cursor = gdk_cursor_new_from_pixbuf
        (gtk_widget_get_display(vc->gfx.drawing_area),
         pixbuf, c->hot_x, c->hot_y);
    gdk_window_set_cursor(gtk_widget_get_window(vc->gfx.drawing_area), cursor);
G
Gerd Hoffmann 已提交
563
    g_object_unref(pixbuf);
564
#if !GTK_CHECK_VERSION(3, 0, 0)
565
    gdk_cursor_unref(cursor);
566 567 568
#else
    g_object_unref(cursor);
#endif
G
Gerd Hoffmann 已提交
569 570
}

571 572
static void gd_switch(DisplayChangeListener *dcl,
                      DisplaySurface *surface)
A
Anthony Liguori 已提交
573
{
574
    VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
G
Gerd Hoffmann 已提交
575
    bool resized = true;
A
Anthony Liguori 已提交
576

G
Gerd Hoffmann 已提交
577
    trace_gd_switch(vc->label, surface_width(surface), surface_height(surface));
A
Anthony Liguori 已提交
578

579 580
    if (vc->gfx.surface) {
        cairo_surface_destroy(vc->gfx.surface);
A
Anthony Liguori 已提交
581 582
    }

583 584 585
    if (vc->gfx.ds &&
        surface_width(vc->gfx.ds) == surface_width(surface) &&
        surface_height(vc->gfx.ds) == surface_height(surface)) {
G
Gerd Hoffmann 已提交
586 587
        resized = false;
    }
588
    vc->gfx.ds = surface;
A
Anthony Liguori 已提交
589

590 591 592
    if (vc->gfx.convert) {
        pixman_image_unref(vc->gfx.convert);
        vc->gfx.convert = NULL;
593
    }
A
Anthony Liguori 已提交
594

595 596 597 598 599 600 601
    if (surface->format == PIXMAN_x8r8g8b8) {
        /*
         * PIXMAN_x8r8g8b8 == CAIRO_FORMAT_RGB24
         *
         * No need to convert, use surface directly.  Should be the
         * common case as this is qemu_default_pixelformat(32) too.
         */
602
        vc->gfx.surface = cairo_image_surface_create_for_data
603 604 605 606 607 608 609
            (surface_data(surface),
             CAIRO_FORMAT_RGB24,
             surface_width(surface),
             surface_height(surface),
             surface_stride(surface));
    } else {
        /* Must convert surface, use pixman to do it. */
610 611 612 613 614 615
        vc->gfx.convert = pixman_image_create_bits(PIXMAN_x8r8g8b8,
                                                   surface_width(surface),
                                                   surface_height(surface),
                                                   NULL, 0);
        vc->gfx.surface = cairo_image_surface_create_for_data
            ((void *)pixman_image_get_data(vc->gfx.convert),
616
             CAIRO_FORMAT_RGB24,
617 618 619 620 621
             pixman_image_get_width(vc->gfx.convert),
             pixman_image_get_height(vc->gfx.convert),
             pixman_image_get_stride(vc->gfx.convert));
        pixman_image_composite(PIXMAN_OP_SRC, vc->gfx.ds->image,
                               NULL, vc->gfx.convert,
622
                               0, 0, 0, 0, 0, 0,
623 624
                               pixman_image_get_width(vc->gfx.convert),
                               pixman_image_get_height(vc->gfx.convert));
625
    }
626

G
Gerd Hoffmann 已提交
627
    if (resized) {
628
        gd_update_windowsize(vc);
G
Gerd Hoffmann 已提交
629
    } else {
630
        gd_update_full_redraw(vc);
631
    }
A
Anthony Liguori 已提交
632 633 634 635 636 637 638 639 640 641 642 643 644
}

/** QEMU Events **/

static void gd_change_runstate(void *opaque, int running, RunState state)
{
    GtkDisplayState *s = opaque;

    gd_update_caption(s);
}

static void gd_mouse_mode_change(Notifier *notify, void *data)
{
645
    GtkDisplayState *s;
646
    int i;
647 648 649 650 651 652 653

    s = container_of(notify, GtkDisplayState, mouse_mode_notifier);
    /* release the grab at switching to absolute mode */
    if (qemu_input_is_absolute() && gd_is_grab_active(s)) {
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
                                       FALSE);
    }
654 655 656 657
    for (i = 0; i < s->nb_vcs; i++) {
        VirtualConsole *vc = &s->vc[i];
        gd_update_cursor(vc);
    }
A
Anthony Liguori 已提交
658 659 660 661 662 663 664 665
}

/** GTK Events **/

static gboolean gd_window_close(GtkWidget *widget, GdkEvent *event,
                                void *opaque)
{
    GtkDisplayState *s = opaque;
666
    int i;
A
Anthony Liguori 已提交
667 668

    if (!no_quit) {
669 670 671 672 673 674
        for (i = 0; i < s->nb_vcs; i++) {
            if (s->vc[i].type != GD_VC_GFX) {
                continue;
            }
            unregister_displaychangelistener(&s->vc[i].gfx.dcl);
        }
A
Anthony Liguori 已提交
675 676 677 678 679 680 681 682 683
        qmp_quit(NULL);
        return FALSE;
    }

    return TRUE;
}

static gboolean gd_draw_event(GtkWidget *widget, cairo_t *cr, void *opaque)
{
684 685
    VirtualConsole *vc = opaque;
    GtkDisplayState *s = vc->s;
686
    int mx, my;
A
Anthony Liguori 已提交
687 688 689
    int ww, wh;
    int fbw, fbh;

690 691 692 693
    if (!gtk_widget_get_realized(widget)) {
        return FALSE;
    }

694 695
    fbw = surface_width(vc->gfx.ds);
    fbh = surface_height(vc->gfx.ds);
A
Anthony Liguori 已提交
696 697 698

    gdk_drawable_get_size(gtk_widget_get_window(widget), &ww, &wh);

699
    if (s->full_screen) {
700 701
        vc->gfx.scale_x = (double)ww / fbw;
        vc->gfx.scale_y = (double)wh / fbh;
702 703 704 705 706 707
    } else if (s->free_scale) {
        double sx, sy;

        sx = (double)ww / fbw;
        sy = (double)wh / fbh;

708
        vc->gfx.scale_x = vc->gfx.scale_y = MIN(sx, sy);
A
Anthony Liguori 已提交
709 710
    }

711 712
    fbw *= vc->gfx.scale_x;
    fbh *= vc->gfx.scale_y;
713

714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
    mx = my = 0;
    if (ww > fbw) {
        mx = (ww - fbw) / 2;
    }
    if (wh > fbh) {
        my = (wh - fbh) / 2;
    }

    cairo_rectangle(cr, 0, 0, ww, wh);

    /* Optionally cut out the inner area where the pixmap
       will be drawn. This avoids 'flashing' since we're
       not double-buffering. Note we're using the undocumented
       behaviour of drawing the rectangle from right to left
       to cut out the whole */
    cairo_rectangle(cr, mx + fbw, my,
                    -1 * fbw, fbh);
    cairo_fill(cr);

733 734 735
    cairo_scale(cr, vc->gfx.scale_x, vc->gfx.scale_y);
    cairo_set_source_surface(cr, vc->gfx.surface,
                             mx / vc->gfx.scale_x, my / vc->gfx.scale_y);
A
Anthony Liguori 已提交
736 737 738 739 740
    cairo_paint(cr);

    return TRUE;
}

741
#if !GTK_CHECK_VERSION(3, 0, 0)
A
Anthony Liguori 已提交
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
static gboolean gd_expose_event(GtkWidget *widget, GdkEventExpose *expose,
                                void *opaque)
{
    cairo_t *cr;
    gboolean ret;

    cr = gdk_cairo_create(gtk_widget_get_window(widget));
    cairo_rectangle(cr,
                    expose->area.x,
                    expose->area.y,
                    expose->area.width,
                    expose->area.height);
    cairo_clip(cr);

    ret = gd_draw_event(widget, cr, opaque);

    cairo_destroy(cr);

    return ret;
}
762
#endif
A
Anthony Liguori 已提交
763 764 765 766

static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion,
                                void *opaque)
{
767 768
    VirtualConsole *vc = opaque;
    GtkDisplayState *s = vc->s;
A
Anthony Liguori 已提交
769
    int x, y;
770 771 772 773
    int mx, my;
    int fbh, fbw;
    int ww, wh;

774 775
    fbw = surface_width(vc->gfx.ds) * vc->gfx.scale_x;
    fbh = surface_height(vc->gfx.ds) * vc->gfx.scale_y;
A
Anthony Liguori 已提交
776

777 778
    gdk_drawable_get_size(gtk_widget_get_window(vc->gfx.drawing_area),
                          &ww, &wh);
779 780 781 782 783 784 785 786 787

    mx = my = 0;
    if (ww > fbw) {
        mx = (ww - fbw) / 2;
    }
    if (wh > fbh) {
        my = (wh - fbh) / 2;
    }

788 789
    x = (motion->x - mx) / vc->gfx.scale_x;
    y = (motion->y - my) / vc->gfx.scale_y;
790

791
    if (qemu_input_is_absolute()) {
792
        if (x < 0 || y < 0 ||
793 794
            x >= surface_width(vc->gfx.ds) ||
            y >= surface_height(vc->gfx.ds)) {
795 796
            return TRUE;
        }
797 798 799 800
        qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_X, x,
                             surface_width(vc->gfx.ds));
        qemu_input_queue_abs(vc->gfx.dcl.con, INPUT_AXIS_Y, y,
                             surface_height(vc->gfx.ds));
801
        qemu_input_event_sync();
G
Gerd Hoffmann 已提交
802
    } else if (s->last_set && s->ptr_owner == vc) {
803 804
        qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_X, x - s->last_x);
        qemu_input_queue_rel(vc->gfx.dcl.con, INPUT_AXIS_Y, y - s->last_y);
805
        qemu_input_event_sync();
A
Anthony Liguori 已提交
806 807 808
    }
    s->last_x = x;
    s->last_y = y;
809
    s->last_set = TRUE;
A
Anthony Liguori 已提交
810

G
Gerd Hoffmann 已提交
811
    if (!qemu_input_is_absolute() && s->ptr_owner == vc) {
812
        GdkScreen *screen = gtk_widget_get_screen(vc->gfx.drawing_area);
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
        int x = (int)motion->x_root;
        int y = (int)motion->y_root;

        /* In relative mode check to see if client pointer hit
         * one of the screen edges, and if so move it back by
         * 200 pixels. This is important because the pointer
         * in the server doesn't correspond 1-for-1, and so
         * may still be only half way across the screen. Without
         * this warp, the server pointer would thus appear to hit
         * an invisible wall */
        if (x == 0) {
            x += 200;
        }
        if (y == 0) {
            y += 200;
        }
        if (x == (gdk_screen_get_width(screen) - 1)) {
            x -= 200;
        }
        if (y == (gdk_screen_get_height(screen) - 1)) {
            y -= 200;
        }

        if (x != (int)motion->x_root || y != (int)motion->y_root) {
837 838 839 840 841
#if GTK_CHECK_VERSION(3, 0, 0)
            GdkDevice *dev = gdk_event_get_device((GdkEvent *)motion);
            gdk_device_warp(dev, screen, x, y);
#else
            GdkDisplay *display = gtk_widget_get_display(widget);
842
            gdk_display_warp_pointer(display, screen, x, y);
843
#endif
844
            s->last_set = FALSE;
845 846 847
            return FALSE;
        }
    }
A
Anthony Liguori 已提交
848 849 850 851 852 853
    return TRUE;
}

static gboolean gd_button_event(GtkWidget *widget, GdkEventButton *button,
                                void *opaque)
{
854 855
    VirtualConsole *vc = opaque;
    GtkDisplayState *s = vc->s;
856
    InputButton btn;
A
Anthony Liguori 已提交
857

858 859
    /* implicitly grab the input at the first click in the relative mode */
    if (button->button == 1 && button->type == GDK_BUTTON_PRESS &&
G
Gerd Hoffmann 已提交
860 861 862 863 864 865 866 867 868
        !qemu_input_is_absolute() && s->ptr_owner != vc) {
        gd_ungrab_pointer(s);
        if (!vc->window) {
            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
                                           TRUE);
        } else {
            gd_grab_pointer(vc);
            gd_update_caption(s);
        }
869 870 871
        return TRUE;
    }

A
Anthony Liguori 已提交
872
    if (button->button == 1) {
873
        btn = INPUT_BUTTON_LEFT;
A
Anthony Liguori 已提交
874
    } else if (button->button == 2) {
875
        btn = INPUT_BUTTON_MIDDLE;
A
Anthony Liguori 已提交
876
    } else if (button->button == 3) {
877
        btn = INPUT_BUTTON_RIGHT;
A
Anthony Liguori 已提交
878
    } else {
879
        return TRUE;
A
Anthony Liguori 已提交
880 881
    }

882 883
    qemu_input_queue_btn(vc->gfx.dcl.con, btn,
                         button->type == GDK_BUTTON_PRESS);
884
    qemu_input_event_sync();
A
Anthony Liguori 已提交
885 886 887
    return TRUE;
}

J
Jan Kiszka 已提交
888 889 890
static gboolean gd_scroll_event(GtkWidget *widget, GdkEventScroll *scroll,
                                void *opaque)
{
891
    VirtualConsole *vc = opaque;
J
Jan Kiszka 已提交
892 893 894 895 896 897 898 899 900 901
    InputButton btn;

    if (scroll->direction == GDK_SCROLL_UP) {
        btn = INPUT_BUTTON_WHEEL_UP;
    } else if (scroll->direction == GDK_SCROLL_DOWN) {
        btn = INPUT_BUTTON_WHEEL_DOWN;
    } else {
        return TRUE;
    }

902
    qemu_input_queue_btn(vc->gfx.dcl.con, btn, true);
J
Jan Kiszka 已提交
903
    qemu_input_event_sync();
904
    qemu_input_queue_btn(vc->gfx.dcl.con, btn, false);
J
Jan Kiszka 已提交
905 906 907 908
    qemu_input_event_sync();
    return TRUE;
}

909
static int gd_map_keycode(GtkDisplayState *s, GdkDisplay *dpy, int gdk_keycode)
A
Anthony Liguori 已提交
910
{
G
Gerd Hoffmann 已提交
911
    int qemu_keycode;
A
Anthony Liguori 已提交
912

913 914 915 916 917 918 919 920 921
#ifdef GDK_WINDOWING_WIN32
    if (GDK_IS_WIN32_DISPLAY(dpy)) {
        qemu_keycode = MapVirtualKey(gdk_keycode, MAPVK_VK_TO_VSC);
        switch (qemu_keycode) {
        case 103:   /* alt gr */
            qemu_keycode = 56 | SCANCODE_GREY;
            break;
        }
        return qemu_keycode;
922
    }
923
#endif
A
Anthony Liguori 已提交
924 925 926 927 928

    if (gdk_keycode < 9) {
        qemu_keycode = 0;
    } else if (gdk_keycode < 97) {
        qemu_keycode = gdk_keycode - 8;
929 930
#ifdef GDK_WINDOWING_X11
    } else if (GDK_IS_X11_DISPLAY(dpy) && gdk_keycode < 158) {
931 932 933 934 935
        if (s->has_evdev) {
            qemu_keycode = translate_evdev_keycode(gdk_keycode - 97);
        } else {
            qemu_keycode = translate_xfree86_keycode(gdk_keycode - 97);
        }
936
#endif
A
Anthony Liguori 已提交
937 938 939 940 941 942 943 944
    } else if (gdk_keycode == 208) { /* Hiragana_Katakana */
        qemu_keycode = 0x70;
    } else if (gdk_keycode == 211) { /* backslash */
        qemu_keycode = 0x73;
    } else {
        qemu_keycode = 0;
    }

G
Gerd Hoffmann 已提交
945 946 947 948 949 950 951 952 953 954 955
    return qemu_keycode;
}

static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
{
    VirtualConsole *vc = opaque;
    GtkDisplayState *s = vc->s;
    int gdk_keycode = key->hardware_keycode;
    int qemu_keycode;
    int i;

M
Martin Decky 已提交
956 957 958 959 960 961
    if (key->keyval == GDK_KEY_Pause) {
        qemu_input_event_send_key_qcode(vc->gfx.dcl.con, Q_KEY_CODE_PAUSE,
                                        key->type == GDK_KEY_PRESS);
        return TRUE;
    }

962 963
    qemu_keycode = gd_map_keycode(s, gtk_widget_get_display(widget),
                                  gdk_keycode);
G
Gerd Hoffmann 已提交
964

G
Gerd Hoffmann 已提交
965
    trace_gd_key_event(vc->label, gdk_keycode, qemu_keycode,
966
                       (key->type == GDK_KEY_PRESS) ? "down" : "up");
A
Anthony Liguori 已提交
967

968 969 970 971 972 973
    for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) {
        if (qemu_keycode == modifier_keycode[i]) {
            s->modifier_pressed[i] = (key->type == GDK_KEY_PRESS);
        }
    }

974
    qemu_input_event_send_key_number(vc->gfx.dcl.con, qemu_keycode,
975
                                     key->type == GDK_KEY_PRESS);
A
Anthony Liguori 已提交
976 977 978 979

    return TRUE;
}

980 981 982 983 984 985 986 987
static gboolean gd_event(GtkWidget *widget, GdkEvent *event, void *opaque)
{
    if (event->type == GDK_MOTION_NOTIFY) {
        return gd_motion_event(widget, &event->motion, opaque);
    }
    return FALSE;
}

A
Anthony Liguori 已提交
988 989
/** Window Menu Actions **/

990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
static void gd_menu_pause(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;

    if (s->external_pause_update) {
        return;
    }
    if (runstate_is_running()) {
        qmp_stop(NULL);
    } else {
        qmp_cont(NULL);
    }
}

static void gd_menu_reset(GtkMenuItem *item, void *opaque)
{
    qmp_system_reset(NULL);
}

static void gd_menu_powerdown(GtkMenuItem *item, void *opaque)
{
    qmp_system_powerdown(NULL);
}

A
Anthony Liguori 已提交
1014 1015 1016 1017 1018 1019 1020 1021
static void gd_menu_quit(GtkMenuItem *item, void *opaque)
{
    qmp_quit(NULL);
}

static void gd_menu_switch_vc(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;
1022
    VirtualConsole *vc = gd_vc_find_by_menu(s);
1023 1024
    GtkNotebook *nb = GTK_NOTEBOOK(s->notebook);
    GtkWidget *child;
1025
    gint page;
A
Anthony Liguori 已提交
1026

1027 1028
    gtk_release_modifiers(s);
    if (vc) {
1029 1030 1031 1032
        page = gtk_notebook_page_num(nb, vc->tab_item);
        gtk_notebook_set_current_page(nb, page);
        child = gtk_notebook_get_nth_page(nb, page);
        gtk_widget_grab_focus(child);
A
Anthony Liguori 已提交
1033 1034 1035
    }
}

1036 1037 1038 1039 1040 1041
static void gd_accel_switch_vc(void *opaque)
{
    VirtualConsole *vc = opaque;
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item), TRUE);
}

A
Anthony Liguori 已提交
1042 1043 1044
static void gd_menu_show_tabs(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;
1045
    VirtualConsole *vc = gd_vc_find_current(s);
A
Anthony Liguori 已提交
1046 1047 1048 1049 1050 1051

    if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->show_tabs_item))) {
        gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), TRUE);
    } else {
        gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
    }
1052
    gd_update_windowsize(vc);
A
Anthony Liguori 已提交
1053 1054
}

1055 1056 1057 1058 1059 1060 1061
static gboolean gd_tab_window_close(GtkWidget *widget, GdkEvent *event,
                                    void *opaque)
{
    VirtualConsole *vc = opaque;
    GtkDisplayState *s = vc->s;

    gtk_widget_set_sensitive(vc->menu_item, true);
1062
    gd_widget_reparent(vc->window, s->notebook, vc->tab_item);
1063 1064 1065 1066 1067 1068 1069
    gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(s->notebook),
                                    vc->tab_item, vc->label);
    gtk_widget_destroy(vc->window);
    vc->window = NULL;
    return TRUE;
}

1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
static gboolean gd_win_grab(void *opaque)
{
    VirtualConsole *vc = opaque;

    fprintf(stderr, "%s: %s\n", __func__, vc->label);
    if (vc->s->ptr_owner) {
        gd_ungrab_pointer(vc->s);
    } else {
        gd_grab_pointer(vc);
    }
    gd_update_caption(vc->s);
    return TRUE;
}

1084 1085 1086 1087 1088 1089
static void gd_menu_untabify(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;
    VirtualConsole *vc = gd_vc_find_current(s);

    if (vc->type == GD_VC_GFX) {
G
Gerd Hoffmann 已提交
1090 1091
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
                                       FALSE);
1092 1093 1094 1095
    }
    if (!vc->window) {
        gtk_widget_set_sensitive(vc->menu_item, false);
        vc->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1096
        gd_widget_reparent(s->notebook, vc->window, vc->tab_item);
1097 1098 1099 1100

        g_signal_connect(vc->window, "delete-event",
                         G_CALLBACK(gd_tab_window_close), vc);
        gtk_widget_show_all(vc->window);
G
Gerd Hoffmann 已提交
1101

1102 1103 1104 1105 1106 1107
        GtkAccelGroup *ag = gtk_accel_group_new();
        gtk_window_add_accel_group(GTK_WINDOW(vc->window), ag);

        GClosure *cb = g_cclosure_new_swap(G_CALLBACK(gd_win_grab), vc, NULL);
        gtk_accel_group_connect(ag, GDK_KEY_g, HOTKEY_MODIFIERS, 0, cb);

G
Gerd Hoffmann 已提交
1108
        gd_update_geometry_hints(vc);
G
Gerd Hoffmann 已提交
1109
        gd_update_caption(s);
1110 1111 1112
    }
}

1113 1114 1115
static void gd_menu_full_screen(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;
1116
    VirtualConsole *vc = gd_vc_find_current(s);
1117

1118
    if (!s->full_screen) {
1119
        gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
1120
        gtk_widget_hide(s->menu_bar);
1121 1122 1123 1124
        if (vc->type == GD_VC_GFX) {
            gtk_widget_set_size_request(vc->gfx.drawing_area, -1, -1);
            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
                                           TRUE);
1125
        }
1126
        gtk_window_fullscreen(GTK_WINDOW(s->window));
1127 1128 1129 1130
        s->full_screen = TRUE;
    } else {
        gtk_window_unfullscreen(GTK_WINDOW(s->window));
        gd_menu_show_tabs(GTK_MENU_ITEM(s->show_tabs_item), s);
1131
        gtk_widget_show(s->menu_bar);
1132
        s->full_screen = FALSE;
1133 1134 1135
        if (vc->type == GD_VC_GFX) {
            vc->gfx.scale_x = 1.0;
            vc->gfx.scale_y = 1.0;
G
Gerd Hoffmann 已提交
1136
            gd_update_windowsize(vc);
1137 1138 1139
            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
                                           FALSE);
        }
1140 1141
    }

1142
    gd_update_cursor(vc);
1143 1144
}

1145 1146 1147 1148 1149 1150
static void gd_accel_full_screen(void *opaque)
{
    GtkDisplayState *s = opaque;
    gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item));
}

1151 1152 1153
static void gd_menu_zoom_in(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;
1154
    VirtualConsole *vc = gd_vc_find_current(s);
1155 1156 1157 1158

    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item),
                                   FALSE);

G
Gerd Hoffmann 已提交
1159 1160
    vc->gfx.scale_x += VC_SCALE_STEP;
    vc->gfx.scale_y += VC_SCALE_STEP;
1161

1162
    gd_update_windowsize(vc);
1163 1164 1165 1166 1167
}

static void gd_menu_zoom_out(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;
1168
    VirtualConsole *vc = gd_vc_find_current(s);
1169 1170 1171 1172

    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item),
                                   FALSE);

G
Gerd Hoffmann 已提交
1173 1174
    vc->gfx.scale_x -= VC_SCALE_STEP;
    vc->gfx.scale_y -= VC_SCALE_STEP;
1175

G
Gerd Hoffmann 已提交
1176 1177
    vc->gfx.scale_x = MAX(vc->gfx.scale_x, VC_SCALE_MIN);
    vc->gfx.scale_y = MAX(vc->gfx.scale_y, VC_SCALE_MIN);
1178

1179
    gd_update_windowsize(vc);
1180 1181 1182 1183 1184
}

static void gd_menu_zoom_fixed(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;
1185
    VirtualConsole *vc = gd_vc_find_current(s);
1186

1187 1188
    vc->gfx.scale_x = 1.0;
    vc->gfx.scale_y = 1.0;
1189

1190
    gd_update_windowsize(vc);
1191 1192 1193 1194 1195
}

static void gd_menu_zoom_fit(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;
1196
    VirtualConsole *vc = gd_vc_find_current(s);
1197 1198 1199 1200 1201

    if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item))) {
        s->free_scale = TRUE;
    } else {
        s->free_scale = FALSE;
1202 1203
        vc->gfx.scale_x = 1.0;
        vc->gfx.scale_y = 1.0;
1204 1205
    }

G
Gerd Hoffmann 已提交
1206
    gd_update_windowsize(vc);
1207
    gd_update_full_redraw(vc);
1208 1209
}

1210
#if GTK_CHECK_VERSION(3, 0, 0)
1211 1212 1213 1214
static void gd_grab_devices(VirtualConsole *vc, bool grab,
                            GdkInputSource source, GdkEventMask mask,
                            GdkCursor *cursor)
{
1215
    GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
1216
    GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
1217 1218 1219 1220
    GList *devs = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER);
    GList *tmp = devs;

    for (tmp = devs; tmp; tmp = tmp->next) {
1221
        GdkDevice *dev = tmp->data;
1222 1223 1224 1225 1226 1227 1228 1229 1230
        if (gdk_device_get_source(dev) != source) {
            continue;
        }
        if (grab) {
            GdkWindow *win = gtk_widget_get_window(vc->gfx.drawing_area);
            gdk_device_grab(dev, win, GDK_OWNERSHIP_NONE, FALSE,
                            mask, cursor, GDK_CURRENT_TIME);
        } else {
            gdk_device_ungrab(dev, GDK_CURRENT_TIME);
1231 1232
        }
    }
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
    g_list_free(devs);
}
#endif

static void gd_grab_keyboard(VirtualConsole *vc)
{
#if GTK_CHECK_VERSION(3, 0, 0)
    gd_grab_devices(vc, true, GDK_SOURCE_KEYBOARD,
                   GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
                   NULL);
1243
#else
1244
    gdk_keyboard_grab(gtk_widget_get_window(vc->gfx.drawing_area),
1245 1246
                      FALSE,
                      GDK_CURRENT_TIME);
1247
#endif
G
Gerd Hoffmann 已提交
1248
    vc->s->kbd_owner = vc;
G
Gerd Hoffmann 已提交
1249
    trace_gd_grab(vc->label, "kbd", true);
1250 1251
}

G
Gerd Hoffmann 已提交
1252
static void gd_ungrab_keyboard(GtkDisplayState *s)
1253
{
G
Gerd Hoffmann 已提交
1254 1255 1256 1257 1258 1259 1260
    VirtualConsole *vc = s->kbd_owner;

    if (vc == NULL) {
        return;
    }
    s->kbd_owner = NULL;

1261
#if GTK_CHECK_VERSION(3, 0, 0)
1262
    gd_grab_devices(vc, false, GDK_SOURCE_KEYBOARD, 0, NULL);
1263
#else
1264
    gdk_keyboard_ungrab(GDK_CURRENT_TIME);
1265
#endif
G
Gerd Hoffmann 已提交
1266
    trace_gd_grab(vc->label, "kbd", false);
1267 1268
}

1269
static void gd_grab_pointer(VirtualConsole *vc)
1270
{
1271
    GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
1272
#if GTK_CHECK_VERSION(3, 0, 0)
1273
    GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
1274 1275 1276 1277 1278 1279 1280
    gd_grab_devices(vc, true, GDK_SOURCE_MOUSE,
                    GDK_POINTER_MOTION_MASK |
                    GDK_BUTTON_PRESS_MASK |
                    GDK_BUTTON_RELEASE_MASK |
                    GDK_BUTTON_MOTION_MASK |
                    GDK_SCROLL_MASK,
                    vc->s->null_cursor);
1281
    gdk_device_get_position(gdk_device_manager_get_client_pointer(mgr),
1282
                            NULL, &vc->s->grab_x_root, &vc->s->grab_y_root);
1283
#else
1284
    gdk_pointer_grab(gtk_widget_get_window(vc->gfx.drawing_area),
1285 1286 1287 1288 1289 1290 1291
                     FALSE, /* All events to come to our window directly */
                     GDK_POINTER_MOTION_MASK |
                     GDK_BUTTON_PRESS_MASK |
                     GDK_BUTTON_RELEASE_MASK |
                     GDK_BUTTON_MOTION_MASK |
                     GDK_SCROLL_MASK,
                     NULL, /* Allow cursor to move over entire desktop */
1292
                     vc->s->null_cursor,
1293
                     GDK_CURRENT_TIME);
1294
    gdk_display_get_pointer(display, NULL,
1295
                            &vc->s->grab_x_root, &vc->s->grab_y_root, NULL);
1296
#endif
G
Gerd Hoffmann 已提交
1297
    vc->s->ptr_owner = vc;
G
Gerd Hoffmann 已提交
1298
    trace_gd_grab(vc->label, "ptr", true);
1299 1300
}

G
Gerd Hoffmann 已提交
1301
static void gd_ungrab_pointer(GtkDisplayState *s)
1302
{
G
Gerd Hoffmann 已提交
1303 1304 1305 1306 1307 1308 1309
    VirtualConsole *vc = s->ptr_owner;

    if (vc == NULL) {
        return;
    }
    s->ptr_owner = NULL;

1310
    GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
1311
#if GTK_CHECK_VERSION(3, 0, 0)
1312
    GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
1313
    gd_grab_devices(vc, false, GDK_SOURCE_MOUSE, 0, NULL);
1314
    gdk_device_warp(gdk_device_manager_get_client_pointer(mgr),
1315 1316
                    gtk_widget_get_screen(vc->gfx.drawing_area),
                    vc->s->grab_x_root, vc->s->grab_y_root);
1317 1318
#else
    gdk_pointer_ungrab(GDK_CURRENT_TIME);
1319
    gdk_display_warp_pointer(display,
1320 1321
                             gtk_widget_get_screen(vc->gfx.drawing_area),
                             vc->s->grab_x_root, vc->s->grab_y_root);
1322
#endif
G
Gerd Hoffmann 已提交
1323
    trace_gd_grab(vc->label, "ptr", false);
1324 1325
}

1326 1327 1328
static void gd_menu_grab_input(GtkMenuItem *item, void *opaque)
{
    GtkDisplayState *s = opaque;
1329
    VirtualConsole *vc = gd_vc_find_current(s);
1330 1331

    if (gd_is_grab_active(s)) {
1332 1333 1334
        if (!gd_grab_on_hover(s)) {
            gd_grab_keyboard(vc);
        }
1335
        gd_grab_pointer(vc);
1336
    } else {
G
Gerd Hoffmann 已提交
1337 1338
        gd_ungrab_keyboard(s);
        gd_ungrab_pointer(s);
1339 1340 1341
    }

    gd_update_caption(s);
1342
    gd_update_cursor(vc);
1343 1344
}

A
Anthony Liguori 已提交
1345 1346 1347 1348
static void gd_change_page(GtkNotebook *nb, gpointer arg1, guint arg2,
                           gpointer data)
{
    GtkDisplayState *s = data;
1349
    VirtualConsole *vc;
1350
    gboolean on_vga;
A
Anthony Liguori 已提交
1351 1352 1353 1354 1355

    if (!gtk_widget_get_realized(s->notebook)) {
        return;
    }

1356 1357 1358 1359 1360 1361
#ifdef VTE_RESIZE_HACK
    vc = gd_vc_find_current(s);
    if (vc && vc->type == GD_VC_VTE) {
        gtk_widget_hide(vc->vte.terminal);
    }
#endif
1362 1363 1364 1365
    vc = gd_vc_find_by_page(s, arg2);
    if (!vc) {
        return;
    }
1366 1367 1368 1369 1370
#ifdef VTE_RESIZE_HACK
    if (vc->type == GD_VC_VTE) {
        gtk_widget_show(vc->vte.terminal);
    }
#endif
1371 1372 1373
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(vc->menu_item),
                                   TRUE);
    on_vga = (vc->type == GD_VC_GFX);
1374 1375 1376
    if (!on_vga) {
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
                                       FALSE);
1377 1378 1379
    } else if (s->full_screen) {
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item),
                                       TRUE);
1380 1381 1382
    }
    gtk_widget_set_sensitive(s->grab_item, on_vga);

G
Gerd Hoffmann 已提交
1383
    gd_update_windowsize(vc);
1384
    gd_update_cursor(vc);
A
Anthony Liguori 已提交
1385 1386
}

1387 1388
static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing,
                               gpointer opaque)
1389
{
1390 1391
    VirtualConsole *vc = opaque;
    GtkDisplayState *s = vc->s;
1392

G
Gerd Hoffmann 已提交
1393 1394
    if (gd_grab_on_hover(s)) {
        gd_ungrab_keyboard(s);
1395
        gd_grab_keyboard(vc);
G
Gerd Hoffmann 已提交
1396
        gd_update_caption(s);
1397 1398 1399 1400
    }
    return TRUE;
}

1401 1402
static gboolean gd_leave_event(GtkWidget *widget, GdkEventCrossing *crossing,
                               gpointer opaque)
1403
{
1404 1405
    VirtualConsole *vc = opaque;
    GtkDisplayState *s = vc->s;
1406

G
Gerd Hoffmann 已提交
1407
    if (gd_grab_on_hover(s)) {
G
Gerd Hoffmann 已提交
1408
        gd_ungrab_keyboard(s);
G
Gerd Hoffmann 已提交
1409
        gd_update_caption(s);
1410 1411 1412 1413
    }
    return TRUE;
}

1414
static gboolean gd_focus_out_event(GtkWidget *widget,
1415
                                   GdkEventCrossing *crossing, gpointer opaque)
1416
{
1417 1418
    VirtualConsole *vc = opaque;
    GtkDisplayState *s = vc->s;
1419 1420 1421 1422 1423

    gtk_release_modifiers(s);
    return TRUE;
}

1424 1425
/** Virtual Console Callbacks **/

1426
static GSList *gd_vc_menu_init(GtkDisplayState *s, VirtualConsole *vc,
1427
                               int idx, GSList *group, GtkWidget *view_menu)
1428
{
1429
    vc->menu_item = gtk_radio_menu_item_new_with_mnemonic(group, vc->label);
1430 1431 1432 1433 1434 1435 1436 1437
    gtk_accel_group_connect(s->accel_group, GDK_KEY_1 + idx,
            HOTKEY_MODIFIERS, 0,
            g_cclosure_new_swap(G_CALLBACK(gd_accel_switch_vc), vc, NULL));
#if GTK_CHECK_VERSION(3, 8, 0)
    gtk_accel_label_set_accel(
            GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(vc->menu_item))),
            GDK_KEY_1 + idx, HOTKEY_MODIFIERS);
#endif
1438 1439 1440 1441 1442

    g_signal_connect(vc->menu_item, "activate",
                     G_CALLBACK(gd_menu_switch_vc), s);
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), vc->menu_item);

1443
    group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(vc->menu_item));
1444 1445 1446
    return group;
}

1447
#if defined(CONFIG_VTE)
1448 1449 1450 1451 1452 1453
static void gd_vc_adjustment_changed(GtkAdjustment *adjustment, void *opaque)
{
    VirtualConsole *vc = opaque;

    if (gtk_adjustment_get_upper(adjustment) >
        gtk_adjustment_get_page_size(adjustment)) {
G
Gerd Hoffmann 已提交
1454
        gtk_widget_show(vc->vte.scrollbar);
1455
    } else {
G
Gerd Hoffmann 已提交
1456
        gtk_widget_hide(vc->vte.scrollbar);
1457 1458 1459
    }
}

1460 1461 1462 1463
static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
    VirtualConsole *vc = chr->opaque;

G
Gerd Hoffmann 已提交
1464
    vte_terminal_feed(VTE_TERMINAL(vc->vte.terminal), (const char *)buf, len);
C
Cole Robinson 已提交
1465
    return len;
1466 1467 1468 1469 1470
}

static int nb_vcs;
static CharDriverState *vcs[MAX_VCS];

G
Gerd Hoffmann 已提交
1471
static CharDriverState *gd_vc_handler(ChardevVC *unused)
1472 1473 1474 1475 1476
{
    CharDriverState *chr;

    chr = g_malloc0(sizeof(*chr));
    chr->chr_write = gd_vc_chr_write;
1477 1478
    /* defer OPENED events until our vc is fully initialized */
    chr->explicit_be_open = true;
1479 1480 1481 1482 1483 1484

    vcs[nb_vcs++] = chr;

    return chr;
}

C
Cole Robinson 已提交
1485 1486
static gboolean gd_vc_in(VteTerminal *terminal, gchar *text, guint size,
                         gpointer user_data)
1487
{
C
Cole Robinson 已提交
1488
    VirtualConsole *vc = user_data;
1489

G
Gerd Hoffmann 已提交
1490
    qemu_chr_be_write(vc->vte.chr, (uint8_t  *)text, (unsigned int)size);
1491 1492 1493
    return TRUE;
}

1494 1495
static GSList *gd_vc_vte_init(GtkDisplayState *s, VirtualConsole *vc,
                              CharDriverState *chr, int idx,
1496
                              GSList *group, GtkWidget *view_menu)
1497 1498
{
    char buffer[32];
1499 1500 1501
    GtkWidget *box;
    GtkWidget *scrollbar;
    GtkAdjustment *vadjustment;
1502

1503
    vc->s = s;
1504
    vc->vte.chr = chr;
1505

1506
    snprintf(buffer, sizeof(buffer), "vc%d", idx);
1507 1508 1509
    vc->label = g_strdup_printf("%s", vc->vte.chr->label
                                ? vc->vte.chr->label : buffer);
    group = gd_vc_menu_init(s, vc, idx, group, view_menu);
1510

G
Gerd Hoffmann 已提交
1511 1512
    vc->vte.terminal = vte_terminal_new();
    g_signal_connect(vc->vte.terminal, "commit", G_CALLBACK(gd_vc_in), vc);
1513

G
Gerd Hoffmann 已提交
1514
    vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->vte.terminal), -1);
G
Gerd Hoffmann 已提交
1515 1516
    vte_terminal_set_size(VTE_TERMINAL(vc->vte.terminal),
                          VC_TERM_X_MIN, VC_TERM_Y_MIN);
1517

1518
#if VTE_CHECK_VERSION(0, 28, 0) && GTK_CHECK_VERSION(3, 0, 0)
G
Gerd Hoffmann 已提交
1519 1520
    vadjustment = gtk_scrollable_get_vadjustment
        (GTK_SCROLLABLE(vc->vte.terminal));
1521
#else
G
Gerd Hoffmann 已提交
1522
    vadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->vte.terminal));
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
#endif

#if GTK_CHECK_VERSION(3, 0, 0)
    box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
    scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, vadjustment);
#else
    box = gtk_hbox_new(false, 2);
    scrollbar = gtk_vscrollbar_new(vadjustment);
#endif

G
Gerd Hoffmann 已提交
1533
    gtk_box_pack_start(GTK_BOX(box), vc->vte.terminal, TRUE, TRUE, 0);
1534 1535
    gtk_box_pack_start(GTK_BOX(box), scrollbar, FALSE, FALSE, 0);

G
Gerd Hoffmann 已提交
1536 1537 1538
    vc->vte.chr->opaque = vc;
    vc->vte.box = box;
    vc->vte.scrollbar = scrollbar;
1539 1540 1541

    g_signal_connect(vadjustment, "changed",
                     G_CALLBACK(gd_vc_adjustment_changed), vc);
1542

1543
    vc->type = GD_VC_VTE;
G
Gerd Hoffmann 已提交
1544 1545
    vc->tab_item = box;
    gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), vc->tab_item,
1546
                             gtk_label_new(vc->label));
1547

G
Gerd Hoffmann 已提交
1548 1549 1550
    qemu_chr_be_generic_open(vc->vte.chr);
    if (vc->vte.chr->init) {
        vc->vte.chr->init(vc->vte.chr);
1551 1552 1553
    }

    return group;
A
Anthony Liguori 已提交
1554 1555
}

1556
static void gd_vcs_init(GtkDisplayState *s, GSList *group,
1557 1558 1559 1560 1561
                        GtkWidget *view_menu)
{
    int i;

    for (i = 0; i < nb_vcs; i++) {
1562 1563
        VirtualConsole *vc = &s->vc[s->nb_vcs];
        group = gd_vc_vte_init(s, vc, vcs[i], s->nb_vcs, group, view_menu);
1564 1565 1566 1567 1568
        s->nb_vcs++;
    }
}
#endif /* CONFIG_VTE */

A
Anthony Liguori 已提交
1569 1570
/** Window Creation **/

1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600
static void gd_connect_vc_gfx_signals(VirtualConsole *vc)
{
#if GTK_CHECK_VERSION(3, 0, 0)
    g_signal_connect(vc->gfx.drawing_area, "draw",
                     G_CALLBACK(gd_draw_event), vc);
#else
    g_signal_connect(vc->gfx.drawing_area, "expose-event",
                     G_CALLBACK(gd_expose_event), vc);
#endif
    g_signal_connect(vc->gfx.drawing_area, "event",
                     G_CALLBACK(gd_event), vc);
    g_signal_connect(vc->gfx.drawing_area, "button-press-event",
                     G_CALLBACK(gd_button_event), vc);
    g_signal_connect(vc->gfx.drawing_area, "button-release-event",
                     G_CALLBACK(gd_button_event), vc);
    g_signal_connect(vc->gfx.drawing_area, "scroll-event",
                     G_CALLBACK(gd_scroll_event), vc);
    g_signal_connect(vc->gfx.drawing_area, "key-press-event",
                     G_CALLBACK(gd_key_event), vc);
    g_signal_connect(vc->gfx.drawing_area, "key-release-event",
                     G_CALLBACK(gd_key_event), vc);

    g_signal_connect(vc->gfx.drawing_area, "enter-notify-event",
                     G_CALLBACK(gd_enter_event), vc);
    g_signal_connect(vc->gfx.drawing_area, "leave-notify-event",
                     G_CALLBACK(gd_leave_event), vc);
    g_signal_connect(vc->gfx.drawing_area, "focus-out-event",
                     G_CALLBACK(gd_focus_out_event), vc);
}

A
Anthony Liguori 已提交
1601 1602 1603 1604
static void gd_connect_signals(GtkDisplayState *s)
{
    g_signal_connect(s->show_tabs_item, "activate",
                     G_CALLBACK(gd_menu_show_tabs), s);
1605 1606
    g_signal_connect(s->untabify_item, "activate",
                     G_CALLBACK(gd_menu_untabify), s);
A
Anthony Liguori 已提交
1607 1608 1609 1610

    g_signal_connect(s->window, "delete-event",
                     G_CALLBACK(gd_window_close), s);

1611 1612 1613 1614 1615 1616
    g_signal_connect(s->pause_item, "activate",
                     G_CALLBACK(gd_menu_pause), s);
    g_signal_connect(s->reset_item, "activate",
                     G_CALLBACK(gd_menu_reset), s);
    g_signal_connect(s->powerdown_item, "activate",
                     G_CALLBACK(gd_menu_powerdown), s);
A
Anthony Liguori 已提交
1617 1618
    g_signal_connect(s->quit_item, "activate",
                     G_CALLBACK(gd_menu_quit), s);
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
    g_signal_connect(s->full_screen_item, "activate",
                     G_CALLBACK(gd_menu_full_screen), s);
    g_signal_connect(s->zoom_in_item, "activate",
                     G_CALLBACK(gd_menu_zoom_in), s);
    g_signal_connect(s->zoom_out_item, "activate",
                     G_CALLBACK(gd_menu_zoom_out), s);
    g_signal_connect(s->zoom_fixed_item, "activate",
                     G_CALLBACK(gd_menu_zoom_fixed), s);
    g_signal_connect(s->zoom_fit_item, "activate",
                     G_CALLBACK(gd_menu_zoom_fit), s);
1629 1630
    g_signal_connect(s->grab_item, "activate",
                     G_CALLBACK(gd_menu_grab_input), s);
A
Anthony Liguori 已提交
1631 1632 1633 1634
    g_signal_connect(s->notebook, "switch-page",
                     G_CALLBACK(gd_change_page), s);
}

1635
static GtkWidget *gd_create_menu_machine(GtkDisplayState *s)
A
Anthony Liguori 已提交
1636
{
A
Anthony Liguori 已提交
1637
    GtkWidget *machine_menu;
A
Anthony Liguori 已提交
1638 1639
    GtkWidget *separator;

A
Anthony Liguori 已提交
1640
    machine_menu = gtk_menu_new();
1641
    gtk_menu_set_accel_group(GTK_MENU(machine_menu), s->accel_group);
1642 1643

    s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause"));
A
Anthony Liguori 已提交
1644
    gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->pause_item);
1645 1646

    separator = gtk_separator_menu_item_new();
A
Anthony Liguori 已提交
1647
    gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
1648

1649
    s->reset_item = gtk_menu_item_new_with_mnemonic(_("_Reset"));
A
Anthony Liguori 已提交
1650
    gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->reset_item);
1651

1652
    s->powerdown_item = gtk_menu_item_new_with_mnemonic(_("Power _Down"));
A
Anthony Liguori 已提交
1653
    gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->powerdown_item);
1654 1655

    separator = gtk_separator_menu_item_new();
A
Anthony Liguori 已提交
1656
    gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
A
Anthony Liguori 已提交
1657

1658
    s->quit_item = gtk_menu_item_new_with_mnemonic(_("_Quit"));
A
Anthony Liguori 已提交
1659
    gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item),
1660
                                 "<QEMU>/Machine/Quit");
1661
    gtk_accel_map_add_entry("<QEMU>/Machine/Quit",
1662
                            GDK_KEY_q, HOTKEY_MODIFIERS);
A
Anthony Liguori 已提交
1663
    gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->quit_item);
A
Anthony Liguori 已提交
1664

A
Anthony Liguori 已提交
1665 1666 1667
    return machine_menu;
}

1668
static const DisplayChangeListenerOps dcl_ops = {
1669 1670 1671 1672 1673 1674 1675
    .dpy_name             = "gtk",
    .dpy_gfx_update       = gd_update,
    .dpy_gfx_switch       = gd_switch,
    .dpy_gfx_check_format = qemu_pixman_check_format,
    .dpy_refresh          = gd_refresh,
    .dpy_mouse_set        = gd_mouse_set,
    .dpy_cursor_define    = gd_cursor_define,
1676 1677 1678
};

static GSList *gd_vc_gfx_init(GtkDisplayState *s, VirtualConsole *vc,
1679
                              QemuConsole *con, int idx,
1680 1681
                              GSList *group, GtkWidget *view_menu)
{
G
Gerd Hoffmann 已提交
1682 1683
    Object *obj;

1684
    obj = object_property_get_link(OBJECT(con), "device", NULL);
G
Gerd Hoffmann 已提交
1685
    if (obj) {
1686 1687 1688
        vc->label = g_strdup_printf("%s", object_get_typename(obj));
    } else {
        vc->label = g_strdup_printf("VGA");
G
Gerd Hoffmann 已提交
1689 1690
    }

1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709
    vc->s = s;
    vc->gfx.scale_x = 1.0;
    vc->gfx.scale_y = 1.0;

    vc->gfx.drawing_area = gtk_drawing_area_new();
    gtk_widget_add_events(vc->gfx.drawing_area,
                          GDK_POINTER_MOTION_MASK |
                          GDK_BUTTON_PRESS_MASK |
                          GDK_BUTTON_RELEASE_MASK |
                          GDK_BUTTON_MOTION_MASK |
                          GDK_ENTER_NOTIFY_MASK |
                          GDK_LEAVE_NOTIFY_MASK |
                          GDK_SCROLL_MASK |
                          GDK_KEY_PRESS_MASK);
    gtk_widget_set_can_focus(vc->gfx.drawing_area, TRUE);

    vc->type = GD_VC_GFX;
    vc->tab_item = vc->gfx.drawing_area;
    gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook),
1710
                             vc->tab_item, gtk_label_new(vc->label));
1711 1712
    gd_connect_vc_gfx_signals(vc);

1713
    group = gd_vc_menu_init(s, vc, idx, group, view_menu);
1714 1715 1716 1717 1718 1719 1720 1721

    vc->gfx.dcl.ops = &dcl_ops;
    vc->gfx.dcl.con = con;
    register_displaychangelistener(&vc->gfx.dcl);

    return group;
}

1722
static GtkWidget *gd_create_menu_view(GtkDisplayState *s)
A
Anthony Liguori 已提交
1723 1724 1725 1726
{
    GSList *group = NULL;
    GtkWidget *view_menu;
    GtkWidget *separator;
1727 1728
    QemuConsole *con;
    int vc;
A
Anthony Liguori 已提交
1729 1730

    view_menu = gtk_menu_new();
1731
    gtk_menu_set_accel_group(GTK_MENU(view_menu), s->accel_group);
A
Anthony Liguori 已提交
1732

1733
    s->full_screen_item = gtk_menu_item_new_with_mnemonic(_("_Fullscreen"));
1734 1735 1736 1737 1738 1739 1740 1741

    gtk_accel_group_connect(s->accel_group, GDK_KEY_f, HOTKEY_MODIFIERS, 0,
            g_cclosure_new_swap(G_CALLBACK(gd_accel_full_screen), s, NULL));
#if GTK_CHECK_VERSION(3, 8, 0)
    gtk_accel_label_set_accel(
            GTK_ACCEL_LABEL(gtk_bin_get_child(GTK_BIN(s->full_screen_item))),
            GDK_KEY_f, HOTKEY_MODIFIERS);
#endif
A
Anthony Liguori 已提交
1742
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->full_screen_item);
1743 1744

    separator = gtk_separator_menu_item_new();
A
Anthony Liguori 已提交
1745
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1746

1747
    s->zoom_in_item = gtk_menu_item_new_with_mnemonic(_("Zoom _In"));
1748 1749
    gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_in_item),
                                 "<QEMU>/View/Zoom In");
J
Jan Kiszka 已提交
1750 1751
    gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus,
                            HOTKEY_MODIFIERS);
A
Anthony Liguori 已提交
1752
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_in_item);
1753

1754
    s->zoom_out_item = gtk_menu_item_new_with_mnemonic(_("Zoom _Out"));
1755 1756
    gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_out_item),
                                 "<QEMU>/View/Zoom Out");
J
Jan Kiszka 已提交
1757 1758
    gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus,
                            HOTKEY_MODIFIERS);
A
Anthony Liguori 已提交
1759
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_out_item);
1760

1761
    s->zoom_fixed_item = gtk_menu_item_new_with_mnemonic(_("Best _Fit"));
1762 1763
    gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_fixed_item),
                                 "<QEMU>/View/Zoom Fixed");
J
Jan Kiszka 已提交
1764 1765
    gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0,
                            HOTKEY_MODIFIERS);
A
Anthony Liguori 已提交
1766
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fixed_item);
1767

1768
    s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit"));
A
Anthony Liguori 已提交
1769
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fit_item);
1770 1771

    separator = gtk_separator_menu_item_new();
A
Anthony Liguori 已提交
1772
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
1773

1774
    s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover"));
A
Anthony Liguori 已提交
1775
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_on_hover_item);
1776

1777
    s->grab_item = gtk_check_menu_item_new_with_mnemonic(_("_Grab Input"));
1778 1779
    gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->grab_item),
                                 "<QEMU>/View/Grab Input");
J
Jan Kiszka 已提交
1780 1781
    gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g,
                            HOTKEY_MODIFIERS);
A
Anthony Liguori 已提交
1782
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_item);
1783

A
Anthony Liguori 已提交
1784
    separator = gtk_separator_menu_item_new();
A
Anthony Liguori 已提交
1785
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
A
Anthony Liguori 已提交
1786

1787
    /* gfx */
1788 1789 1790 1791 1792 1793 1794 1795 1796
    for (vc = 0;; vc++) {
        con = qemu_console_lookup_by_index(vc);
        if (!con || !qemu_console_is_graphic(con)) {
            break;
        }
        group = gd_vc_gfx_init(s, &s->vc[vc], con,
                               vc, group, view_menu);
        s->nb_vcs++;
    }
A
Anthony Liguori 已提交
1797

1798
#if defined(CONFIG_VTE)
1799
    /* vte */
1800
    gd_vcs_init(s, group, view_menu);
1801
#endif
1802

A
Anthony Liguori 已提交
1803
    separator = gtk_separator_menu_item_new();
A
Anthony Liguori 已提交
1804
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
A
Anthony Liguori 已提交
1805

1806
    s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs"));
A
Anthony Liguori 已提交
1807
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_tabs_item);
A
Anthony Liguori 已提交
1808

1809 1810 1811
    s->untabify_item = gtk_menu_item_new_with_mnemonic(_("Detach Tab"));
    gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->untabify_item);

A
Anthony Liguori 已提交
1812 1813 1814 1815 1816
    return view_menu;
}

static void gd_create_menus(GtkDisplayState *s)
{
1817 1818 1819
    s->accel_group = gtk_accel_group_new();
    s->machine_menu = gd_create_menu_machine(s);
    s->view_menu = gd_create_menu_view(s);
A
Anthony Liguori 已提交
1820 1821

    s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine"));
1822 1823 1824
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->machine_menu_item),
                              s->machine_menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->machine_menu_item);
A
Anthony Liguori 已提交
1825

A
Anthony Liguori 已提交
1826
    s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View"));
A
Anthony Liguori 已提交
1827 1828
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(s->view_menu_item), s->view_menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item);
A
Anthony Liguori 已提交
1829

1830 1831
    g_object_set_data(G_OBJECT(s->window), "accel_group", s->accel_group);
    gtk_window_add_accel_group(GTK_WINDOW(s->window), s->accel_group);
A
Anthony Liguori 已提交
1832 1833
}

1834 1835
static void gd_set_keycode_type(GtkDisplayState *s)
{
1836
#ifdef GDK_WINDOWING_X11
1837
    GdkDisplay *display = gtk_widget_get_display(s->window);
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
    if (GDK_IS_X11_DISPLAY(display)) {
        Display *x11_display = gdk_x11_display_get_xdisplay(display);
        XkbDescPtr desc = XkbGetKeyboard(x11_display, XkbGBN_AllComponentsMask,
                                         XkbUseCoreKbd);
        char *keycodes = NULL;

        if (desc && desc->names) {
            keycodes = XGetAtomName(x11_display, desc->names->keycodes);
        }
        if (keycodes == NULL) {
            fprintf(stderr, "could not lookup keycode name\n");
        } else if (strstart(keycodes, "evdev", NULL)) {
            s->has_evdev = true;
        } else if (!strstart(keycodes, "xfree86", NULL)) {
            fprintf(stderr, "unknown keycodes `%s', please report to "
                    "qemu-devel@nongnu.org\n", keycodes);
        }
1855 1856 1857 1858 1859 1860 1861

        if (desc) {
            XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True);
        }
        if (keycodes) {
            XFree(keycodes);
        }
1862 1863 1864 1865
    }
#endif
}

1866
void gtk_display_init(DisplayState *ds, bool full_screen, bool grab_on_hover)
A
Anthony Liguori 已提交
1867 1868
{
    GtkDisplayState *s = g_malloc0(sizeof(*s));
S
Stefan Weil 已提交
1869
    char *filename;
A
Anthony Liguori 已提交
1870 1871 1872 1873

    gtk_init(NULL, NULL);

    s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1874 1875 1876
#if GTK_CHECK_VERSION(3, 2, 0)
    s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
A
Anthony Liguori 已提交
1877
    s->vbox = gtk_vbox_new(FALSE, 0);
1878
#endif
A
Anthony Liguori 已提交
1879 1880 1881
    s->notebook = gtk_notebook_new();
    s->menu_bar = gtk_menu_bar_new();

1882
    s->free_scale = FALSE;
A
Anthony Liguori 已提交
1883

1884 1885 1886 1887
    setlocale(LC_ALL, "");
    bindtextdomain("qemu", CONFIG_QEMU_LOCALEDIR);
    textdomain("qemu");

A
Anthony Liguori 已提交
1888 1889 1890 1891 1892 1893
    s->null_cursor = gdk_cursor_new(GDK_BLANK_CURSOR);

    s->mouse_mode_notifier.notify = gd_mouse_mode_change;
    qemu_add_mouse_mode_change_notifier(&s->mouse_mode_notifier);
    qemu_add_vm_change_state_handler(gd_change_runstate, s);

A
Anthony Liguori 已提交
1894
    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu_logo_no_text.svg");
S
Stefan Weil 已提交
1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905
    if (filename) {
        GError *error = NULL;
        GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(filename, &error);
        if (pixbuf) {
            gtk_window_set_icon(GTK_WINDOW(s->window), pixbuf);
        } else {
            g_error_free(error);
        }
        g_free(filename);
    }

A
Anthony Liguori 已提交
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
    gd_create_menus(s);

    gd_connect_signals(s);

    gtk_notebook_set_show_tabs(GTK_NOTEBOOK(s->notebook), FALSE);
    gtk_notebook_set_show_border(GTK_NOTEBOOK(s->notebook), FALSE);

    gd_update_caption(s);

    gtk_box_pack_start(GTK_BOX(s->vbox), s->menu_bar, FALSE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(s->vbox), s->notebook, TRUE, TRUE, 0);

    gtk_container_add(GTK_CONTAINER(s->window), s->vbox);

    gtk_widget_show_all(s->window);

1922 1923 1924
#ifdef VTE_RESIZE_HACK
    {
        VirtualConsole *cur = gd_vc_find_current(s);
F
Fam Zheng 已提交
1925 1926 1927 1928 1929 1930 1931 1932
        if (cur) {
            int i;

            for (i = 0; i < s->nb_vcs; i++) {
                VirtualConsole *vc = &s->vc[i];
                if (vc && vc->type == GD_VC_VTE && vc != cur) {
                    gtk_widget_hide(vc->vte.terminal);
                }
1933
            }
F
Fam Zheng 已提交
1934
            gd_update_windowsize(cur);
1935 1936 1937 1938
        }
    }
#endif

P
Peter Wu 已提交
1939 1940 1941
    if (full_screen) {
        gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item));
    }
1942 1943 1944
    if (grab_on_hover) {
        gtk_menu_item_activate(GTK_MENU_ITEM(s->grab_on_hover_item));
    }
P
Peter Wu 已提交
1945

1946
    gd_set_keycode_type(s);
A
Anthony Liguori 已提交
1947
}
1948 1949 1950 1951 1952 1953 1954

void early_gtk_display_init(void)
{
#if defined(CONFIG_VTE)
    register_vc_handler(gd_vc_handler);
#endif
}