#ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
/* Work around an -Wstrict-prototypes warning in GTK headers */
+#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-prototypes"
#endif
#include <gtk/gtk.h>
#ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
-#pragma GCC diagnostic error "-Wstrict-prototypes"
+#pragma GCC diagnostic pop
#endif
#include <glib/gi18n.h>
#include <locale.h>
#include <vte/vte.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/wait.h>
-#include <pty.h>
#include <math.h>
#include "ui/console.h"
#include "qmp-commands.h"
#include "x_keymap.h"
#include "keymaps.h"
-#include "char/char.h"
+#include "sysemu/char.h"
//#define DEBUG_GTK
#define GDK_KEY_minus GDK_minus
#endif
+#define HOTKEY_MODIFIERS (GDK_CONTROL_MASK | GDK_MOD1_MASK)
+#define IGNORE_MODIFIER_MASK \
+ (GDK_MODIFIER_MASK & ~(GDK_LOCK_MASK | GDK_MOD2_MASK))
+
+static const int modifier_keycode[] = {
+ /* shift, control, alt keys, meta keys, both left & right */
+ 0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8, 0xdb, 0xdd,
+};
+
typedef struct VirtualConsole
{
GtkWidget *menu_item;
GtkWidget *notebook;
GtkWidget *drawing_area;
cairo_surface_t *surface;
+ pixman_image_t *convert;
DisplayChangeListener dcl;
DisplaySurface *ds;
int button_mask;
gboolean free_scale;
bool external_pause_update;
+
+ bool modifier_pressed[ARRAY_SIZE(modifier_keycode)];
} GtkDisplayState;
static GtkDisplayState *global_state;
bool is_paused = !runstate_is_running();
if (gd_is_grab_active(s)) {
- grab = " - Press Ctrl+Alt+G to release grab";
+ grab = _(" - Press Ctrl+Alt+G to release grab");
}
if (is_paused) {
- status = " [Paused]";
+ status = _(" [Paused]");
}
s->external_pause_update = true;
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->pause_item),
gtk_widget_queue_draw_area(s->drawing_area, 0, 0, ww, wh);
}
+static void gtk_release_modifiers(GtkDisplayState *s)
+{
+ int i, keycode;
+
+ if (!gd_on_vga(s)) {
+ return;
+ }
+ for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) {
+ keycode = modifier_keycode[i];
+ if (!s->modifier_pressed[i]) {
+ continue;
+ }
+ if (keycode & SCANCODE_GREY) {
+ kbd_put_keycode(SCANCODE_EMUL0);
+ }
+ kbd_put_keycode(keycode | SCANCODE_UP);
+ s->modifier_pressed[i] = false;
+ }
+}
+
/** DisplayState Callbacks **/
static void gd_update(DisplayChangeListener *dcl,
DPRINTF("update(x=%d, y=%d, w=%d, h=%d)\n", x, y, w, h);
+ if (s->convert) {
+ pixman_image_composite(PIXMAN_OP_SRC, s->ds->image, NULL, s->convert,
+ x, y, 0, 0, x, y, w, h);
+ }
+
x1 = floor(x * s->scale_x);
y1 = floor(y * s->scale_y);
static void gd_refresh(DisplayChangeListener *dcl)
{
- vga_hw_update();
+ graphic_hw_update(dcl->con);
+}
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+static void gd_mouse_set(DisplayChangeListener *dcl,
+ int x, int y, int visible)
+{
+ GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
+ GdkDisplay *dpy;
+ GdkDeviceManager *mgr;
+ gint x_root, y_root;
+
+ dpy = gtk_widget_get_display(s->drawing_area);
+ mgr = gdk_display_get_device_manager(dpy);
+ gdk_window_get_root_coords(gtk_widget_get_window(s->drawing_area),
+ x, y, &x_root, &y_root);
+ gdk_device_warp(gdk_device_manager_get_client_pointer(mgr),
+ gtk_widget_get_screen(s->drawing_area),
+ x, y);
+}
+#else
+static void gd_mouse_set(DisplayChangeListener *dcl,
+ int x, int y, int visible)
+{
+ GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
+ gint x_root, y_root;
+
+ gdk_window_get_root_coords(gtk_widget_get_window(s->drawing_area),
+ x, y, &x_root, &y_root);
+ gdk_display_warp_pointer(gtk_widget_get_display(s->drawing_area),
+ gtk_widget_get_screen(s->drawing_area),
+ x_root, y_root);
+}
+#endif
+
+static void gd_cursor_define(DisplayChangeListener *dcl,
+ QEMUCursor *c)
+{
+ GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
+ GdkPixbuf *pixbuf;
+ GdkCursor *cursor;
+
+ pixbuf = gdk_pixbuf_new_from_data((guchar *)(c->data),
+ GDK_COLORSPACE_RGB, true, 8,
+ c->width, c->height, c->width * 4,
+ NULL, NULL);
+ cursor = gdk_cursor_new_from_pixbuf(gtk_widget_get_display(s->drawing_area),
+ pixbuf, c->hot_x, c->hot_y);
+ gdk_window_set_cursor(gtk_widget_get_window(s->drawing_area), cursor);
+ g_object_unref(pixbuf);
+#if !GTK_CHECK_VERSION(3, 0, 0)
+ gdk_cursor_unref(cursor);
+#else
+ g_object_unref(cursor);
+#endif
}
static void gd_switch(DisplayChangeListener *dcl,
DisplaySurface *surface)
{
GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
- cairo_format_t kind;
bool resized = true;
- int stride;
DPRINTF("resize(width=%d, height=%d)\n",
surface_width(surface), surface_height(surface));
resized = false;
}
s->ds = surface;
- switch (surface_bits_per_pixel(surface)) {
- case 8:
- kind = CAIRO_FORMAT_A8;
- break;
- case 16:
- kind = CAIRO_FORMAT_RGB16_565;
- break;
- case 32:
- kind = CAIRO_FORMAT_RGB24;
- break;
- default:
- g_assert_not_reached();
- break;
- }
- stride = cairo_format_stride_for_width(kind, surface_width(surface));
- g_assert(surface_stride(surface) == stride);
+ if (s->convert) {
+ pixman_image_unref(s->convert);
+ s->convert = NULL;
+ }
- s->surface = cairo_image_surface_create_for_data(surface_data(surface),
- kind,
- surface_width(surface),
- surface_height(surface),
- surface_stride(surface));
+ 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.
+ */
+ s->surface = cairo_image_surface_create_for_data
+ (surface_data(surface),
+ CAIRO_FORMAT_RGB24,
+ surface_width(surface),
+ surface_height(surface),
+ surface_stride(surface));
+ } else {
+ /* Must convert surface, use pixman to do it. */
+ s->convert = pixman_image_create_bits(PIXMAN_x8r8g8b8,
+ surface_width(surface),
+ surface_height(surface),
+ NULL, 0);
+ s->surface = cairo_image_surface_create_for_data
+ ((void *)pixman_image_get_data(s->convert),
+ CAIRO_FORMAT_RGB24,
+ pixman_image_get_width(s->convert),
+ pixman_image_get_height(s->convert),
+ pixman_image_get_stride(s->convert));
+ pixman_image_composite(PIXMAN_OP_SRC, s->ds->image, NULL, s->convert,
+ 0, 0, 0, 0, 0, 0,
+ pixman_image_get_width(s->convert),
+ pixman_image_get_height(s->convert));
+ }
if (resized) {
gd_update_windowsize(s);
static gboolean gd_window_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
{
GtkDisplayState *s = opaque;
- GtkAccelGroupEntry *entries;
- guint n_entries = 0;
- gboolean propagate_accel = TRUE;
gboolean handled = FALSE;
- entries = gtk_accel_group_query(s->accel_group, key->keyval,
- key->state, &n_entries);
- if (n_entries) {
- const char *quark = g_quark_to_string(entries[0].accel_path_quark);
-
- if (gd_is_grab_active(s) && strstart(quark, "<QEMU>/File/", NULL)) {
- propagate_accel = FALSE;
- }
- }
-
- if (!handled && propagate_accel) {
+ if (!gd_is_grab_active(s) ||
+ (key->state & IGNORE_MODIFIER_MASK) == HOTKEY_MODIFIERS) {
handled = gtk_window_activate_key(GTK_WINDOW(widget), key);
}
-
- if (!handled) {
+ if (handled) {
+ gtk_release_modifiers(s);
+ } else {
handled = gtk_window_propagate_key_event(GTK_WINDOW(widget), key);
}
static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
{
+ GtkDisplayState *s = opaque;
int gdk_keycode;
int qemu_keycode;
+ int i;
gdk_keycode = key->hardware_keycode;
gdk_keycode, qemu_keycode,
(key->type == GDK_KEY_PRESS) ? "down" : "up");
+ for (i = 0; i < ARRAY_SIZE(modifier_keycode); i++) {
+ if (qemu_keycode == modifier_keycode[i]) {
+ s->modifier_pressed[i] = (key->type == GDK_KEY_PRESS);
+ }
+ }
+
if (qemu_keycode & SCANCODE_GREY) {
kbd_put_keycode(SCANCODE_EMUL0);
}
} else {
int i;
+ gtk_release_modifiers(s);
for (i = 0; i < s->nb_vcs; i++) {
if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->vc[i].menu_item))) {
gtk_notebook_set_current_page(GTK_NOTEBOOK(s->notebook), i + 1);
s->free_scale = TRUE;
} else {
s->free_scale = FALSE;
+ s->scale_x = 1.0;
+ s->scale_y = 1.0;
+ gd_update_windowsize(s);
}
- gd_update_windowsize(s);
gd_update_full_redraw(s);
}
return TRUE;
}
+static gboolean gd_focus_out_event(GtkWidget *widget,
+ GdkEventCrossing *crossing, gpointer data)
+{
+ GtkDisplayState *s = data;
+
+ gtk_release_modifiers(s);
+
+ return TRUE;
+}
+
/** Virtual Console Callbacks **/
static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
chr = g_malloc0(sizeof(*chr));
chr->chr_write = gd_vc_chr_write;
+ /* defer OPENED events until our vc is fully initialized */
+ chr->explicit_be_open = true;
vcs[nb_vcs++] = chr;
return TRUE;
}
-static GSList *gd_vc_init(GtkDisplayState *s, VirtualConsole *vc, int index, GSList *group)
+static GSList *gd_vc_init(GtkDisplayState *s, VirtualConsole *vc, int index, GSList *group,
+ GtkWidget *view_menu)
{
const char *label;
char buffer[32];
GIOChannel *chan;
GtkWidget *scrolled_window;
GtkAdjustment *vadjustment;
- int master_fd, slave_fd, ret;
- struct termios tty;
+ int master_fd, slave_fd;
snprintf(buffer, sizeof(buffer), "vc%d", index);
snprintf(path, sizeof(path), "<QEMU>/View/VC%d", index);
vc->menu_item = gtk_radio_menu_item_new_with_mnemonic(group, label);
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(vc->menu_item));
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(vc->menu_item), path);
- gtk_accel_map_add_entry(path, GDK_KEY_2 + index, GDK_CONTROL_MASK | GDK_MOD1_MASK);
+ gtk_accel_map_add_entry(path, GDK_KEY_2 + index, HOTKEY_MODIFIERS);
vc->terminal = vte_terminal_new();
- ret = openpty(&master_fd, &slave_fd, NULL, NULL, NULL);
- g_assert(ret != -1);
-
- /* Set raw attributes on the pty. */
- tcgetattr(slave_fd, &tty);
- cfmakeraw(&tty);
- tcsetattr(slave_fd, TCSAFLUSH, &tty);
+ master_fd = qemu_openpty_raw(&slave_fd, NULL);
+ g_assert(master_fd != -1);
#if VTE_CHECK_VERSION(0, 26, 0)
pty = vte_pty_new_foreign(master_fd, NULL);
g_signal_connect(vc->menu_item, "activate",
G_CALLBACK(gd_menu_switch_vc), s);
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), vc->menu_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), vc->menu_item);
- qemu_chr_generic_open(vc->chr);
+ qemu_chr_be_generic_open(vc->chr);
if (vc->chr->init) {
vc->chr->init(vc->chr);
}
G_CALLBACK(gd_enter_event), s);
g_signal_connect(s->drawing_area, "leave-notify-event",
G_CALLBACK(gd_leave_event), s);
+ g_signal_connect(s->drawing_area, "focus-out-event",
+ G_CALLBACK(gd_focus_out_event), s);
}
-static void gd_create_menus(GtkDisplayState *s)
+static GtkWidget *gd_create_menu_machine(GtkDisplayState *s, GtkAccelGroup *accel_group)
{
- GtkStockItem item;
- GtkAccelGroup *accel_group;
- GSList *group = NULL;
+ GtkWidget *machine_menu;
GtkWidget *separator;
- int i;
+ GtkStockItem item;
- accel_group = gtk_accel_group_new();
- s->machine_menu = gtk_menu_new();
- gtk_menu_set_accel_group(GTK_MENU(s->machine_menu), accel_group);
- s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine"));
+ machine_menu = gtk_menu_new();
+ gtk_menu_set_accel_group(GTK_MENU(machine_menu), accel_group);
s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause"));
- gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), s->pause_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->pause_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
s->reset_item = gtk_image_menu_item_new_with_mnemonic(_("_Reset"));
- gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), s->reset_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->reset_item);
s->powerdown_item = gtk_image_menu_item_new_with_mnemonic(_("Power _Down"));
- gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), s->powerdown_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->powerdown_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), separator);
s->quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
gtk_stock_lookup(GTK_STOCK_QUIT, &item);
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->quit_item),
"<QEMU>/Machine/Quit");
gtk_accel_map_add_entry("<QEMU>/Machine/Quit", item.keyval, item.modifier);
- gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), s->quit_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(machine_menu), s->quit_item);
- s->view_menu = gtk_menu_new();
- gtk_menu_set_accel_group(GTK_MENU(s->view_menu), accel_group);
- s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View"));
+ return machine_menu;
+}
+
+static GtkWidget *gd_create_menu_view(GtkDisplayState *s, GtkAccelGroup *accel_group)
+{
+ GSList *group = NULL;
+ GtkWidget *view_menu;
+ GtkWidget *separator;
+ int i;
+
+ view_menu = gtk_menu_new();
+ gtk_menu_set_accel_group(GTK_MENU(view_menu), accel_group);
s->full_screen_item =
gtk_image_menu_item_new_from_stock(GTK_STOCK_FULLSCREEN, NULL);
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->full_screen_item),
"<QEMU>/View/Full Screen");
- gtk_accel_map_add_entry("<QEMU>/View/Full Screen", GDK_KEY_f, GDK_CONTROL_MASK | GDK_MOD1_MASK);
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->full_screen_item);
+ gtk_accel_map_add_entry("<QEMU>/View/Full Screen", GDK_KEY_f,
+ HOTKEY_MODIFIERS);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->full_screen_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
s->zoom_in_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_in_item),
"<QEMU>/View/Zoom In");
- gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus, GDK_CONTROL_MASK | GDK_MOD1_MASK);
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->zoom_in_item);
+ gtk_accel_map_add_entry("<QEMU>/View/Zoom In", GDK_KEY_plus,
+ HOTKEY_MODIFIERS);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_in_item);
s->zoom_out_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_out_item),
"<QEMU>/View/Zoom Out");
- gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus, GDK_CONTROL_MASK | GDK_MOD1_MASK);
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->zoom_out_item);
+ gtk_accel_map_add_entry("<QEMU>/View/Zoom Out", GDK_KEY_minus,
+ HOTKEY_MODIFIERS);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_out_item);
s->zoom_fixed_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->zoom_fixed_item),
"<QEMU>/View/Zoom Fixed");
- gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0, GDK_CONTROL_MASK | GDK_MOD1_MASK);
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->zoom_fixed_item);
+ gtk_accel_map_add_entry("<QEMU>/View/Zoom Fixed", GDK_KEY_0,
+ HOTKEY_MODIFIERS);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fixed_item);
s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit"));
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->zoom_fit_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->zoom_fit_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover"));
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->grab_on_hover_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_on_hover_item);
s->grab_item = gtk_check_menu_item_new_with_mnemonic(_("_Grab Input"));
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->grab_item),
"<QEMU>/View/Grab Input");
- gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g, GDK_CONTROL_MASK | GDK_MOD1_MASK);
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->grab_item);
+ gtk_accel_map_add_entry("<QEMU>/View/Grab Input", GDK_KEY_g,
+ HOTKEY_MODIFIERS);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->grab_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
s->vga_item = gtk_radio_menu_item_new_with_mnemonic(group, "_VGA");
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(s->vga_item));
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(s->vga_item),
"<QEMU>/View/VGA");
- gtk_accel_map_add_entry("<QEMU>/View/VGA", GDK_KEY_1, GDK_CONTROL_MASK | GDK_MOD1_MASK);
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->vga_item);
+ gtk_accel_map_add_entry("<QEMU>/View/VGA", GDK_KEY_1, HOTKEY_MODIFIERS);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->vga_item);
for (i = 0; i < nb_vcs; i++) {
VirtualConsole *vc = &s->vc[i];
- group = gd_vc_init(s, vc, i, group);
+ group = gd_vc_init(s, vc, i, group, view_menu);
s->nb_vcs++;
}
separator = gtk_separator_menu_item_new();
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator);
s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs"));
- gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->show_tabs_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), s->show_tabs_item);
- g_object_set_data(G_OBJECT(s->window), "accel_group", accel_group);
- gtk_window_add_accel_group(GTK_WINDOW(s->window), accel_group);
- s->accel_group = accel_group;
+ return view_menu;
+}
+
+static void gd_create_menus(GtkDisplayState *s)
+{
+ GtkAccelGroup *accel_group;
+
+ accel_group = gtk_accel_group_new();
+ s->machine_menu = gd_create_menu_machine(s, accel_group);
+ s->view_menu = gd_create_menu_view(s, accel_group);
+ s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine"));
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);
+ s->view_menu_item = gtk_menu_item_new_with_mnemonic(_("_View"));
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);
+
+ g_object_set_data(G_OBJECT(s->window), "accel_group", accel_group);
+ gtk_window_add_accel_group(GTK_WINDOW(s->window), accel_group);
+ s->accel_group = accel_group;
}
static const DisplayChangeListenerOps dcl_ops = {
.dpy_gfx_update = gd_update,
.dpy_gfx_switch = gd_switch,
.dpy_refresh = gd_refresh,
+ .dpy_mouse_set = gd_mouse_set,
+ .dpy_cursor_define = gd_cursor_define,
};
-void gtk_display_init(DisplayState *ds)
+void gtk_display_init(DisplayState *ds, bool full_screen)
{
GtkDisplayState *s = g_malloc0(sizeof(*s));
+ char *filename;
gtk_init(NULL, NULL);
s->dcl.ops = &dcl_ops;
+ s->dcl.con = qemu_console_lookup_by_index(0);
s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#if GTK_CHECK_VERSION(3, 2, 0)
gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), s->drawing_area, gtk_label_new("VGA"));
+ filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu_logo_no_text.svg");
+ 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);
+ }
+
gd_create_menus(s);
gd_connect_signals(s);
gtk_widget_show_all(s->window);
- register_displaychangelistener(ds, &s->dcl);
+ if (full_screen) {
+ gtk_menu_item_activate(GTK_MENU_ITEM(s->full_screen_item));
+ }
+
+ register_displaychangelistener(&s->dcl);
global_state = s;
}
projects / qemu.git / blobdiff