#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 "qmp-commands.h"
#include "x_keymap.h"
#include "keymaps.h"
-#include "char/char.h"
+#include "sysemu/char.h"
//#define DEBUG_GTK
#define MAX_VCS 10
+
+/* 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
+
+#if !GTK_CHECK_VERSION(2, 20, 0)
+#define gtk_widget_get_realized(widget) GTK_WIDGET_REALIZED(widget)
+#endif
+
+#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
+#define GDK_KEY_plus GDK_plus
+#define GDK_KEY_minus GDK_minus
+#endif
+
+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 *drawing_area;
cairo_surface_t *surface;
DisplayChangeListener dcl;
- DisplayState *ds;
+ DisplaySurface *ds;
int button_mask;
int last_x;
int last_y;
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),
g_free(title);
}
+static void gd_update_windowsize(GtkDisplayState *s)
+{
+ if (!s->full_screen) {
+ GtkRequisition req;
+ double sx, sy;
+
+ if (s->free_scale) {
+ sx = s->scale_x;
+ sy = s->scale_y;
+
+ s->scale_y = 1.0;
+ s->scale_x = 1.0;
+ } else {
+ sx = 1.0;
+ sy = 1.0;
+ }
+
+ gtk_widget_set_size_request(s->drawing_area,
+ surface_width(s->ds) * s->scale_x,
+ surface_height(s->ds) * s->scale_y);
+#if GTK_CHECK_VERSION(3, 0, 0)
+ gtk_widget_get_preferred_size(s->vbox, NULL, &req);
+#else
+ gtk_widget_size_request(s->vbox, &req);
+#endif
+
+ gtk_window_resize(GTK_WINDOW(s->window),
+ req.width * sx, req.height * sy);
+ }
+}
+
+static void gd_update_full_redraw(GtkDisplayState *s)
+{
+ int ww, wh;
+ gdk_drawable_get_size(gtk_widget_get_window(s->drawing_area), &ww, &wh);
+ 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(DisplayState *ds, int x, int y, int w, int h)
+static void gd_update(DisplayChangeListener *dcl,
+ int x, int y, int w, int h)
{
- GtkDisplayState *s = ds->opaque;
+ GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
int x1, x2, y1, y2;
int mx, my;
int fbw, fbh;
x2 = ceil(x * s->scale_x + w * s->scale_x);
y2 = ceil(y * s->scale_y + h * s->scale_y);
- fbw = ds_get_width(s->ds) * s->scale_x;
- fbh = ds_get_height(s->ds) * s->scale_y;
+ fbw = surface_width(s->ds) * s->scale_x;
+ fbh = surface_height(s->ds) * s->scale_y;
gdk_drawable_get_size(gtk_widget_get_window(s->drawing_area), &ww, &wh);
gtk_widget_queue_draw_area(s->drawing_area, mx + x1, my + y1, (x2 - x1), (y2 - y1));
}
-static void gd_refresh(DisplayState *ds)
+static void gd_refresh(DisplayChangeListener *dcl)
+{
+ graphic_hw_update(dcl->con);
+}
+
+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(s->drawing_area->window,
+ 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);
+}
+
+static void gd_cursor_define(DisplayChangeListener *dcl,
+ QEMUCursor *c)
{
- vga_hw_update();
+ 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(s->drawing_area->window, cursor);
+ g_object_unref(pixbuf);
+ g_object_unref(cursor);
}
-static void gd_resize(DisplayState *ds)
+static void gd_switch(DisplayChangeListener *dcl,
+ DisplaySurface *surface)
{
- GtkDisplayState *s = ds->opaque;
+ GtkDisplayState *s = container_of(dcl, GtkDisplayState, dcl);
cairo_format_t kind;
+ bool resized = true;
int stride;
DPRINTF("resize(width=%d, height=%d)\n",
- ds_get_width(ds), ds_get_height(ds));
+ surface_width(surface), surface_height(surface));
if (s->surface) {
cairo_surface_destroy(s->surface);
}
- switch (ds->surface->pf.bits_per_pixel) {
+ if (s->ds &&
+ surface_width(s->ds) == surface_width(surface) &&
+ surface_height(s->ds) == surface_height(surface)) {
+ resized = false;
+ }
+ s->ds = surface;
+ switch (surface_bits_per_pixel(surface)) {
case 8:
kind = CAIRO_FORMAT_A8;
break;
break;
}
- stride = cairo_format_stride_for_width(kind, ds_get_width(ds));
- g_assert(ds_get_linesize(ds) == stride);
+ stride = cairo_format_stride_for_width(kind, surface_width(surface));
+ g_assert(surface_stride(surface) == stride);
- s->surface = cairo_image_surface_create_for_data(ds_get_data(ds),
+ s->surface = cairo_image_surface_create_for_data(surface_data(surface),
kind,
- ds_get_width(ds),
- ds_get_height(ds),
- ds_get_linesize(ds));
-
- if (!s->full_screen) {
- GtkRequisition req;
- double sx, sy;
-
- if (s->free_scale) {
- sx = s->scale_x;
- sy = s->scale_y;
+ surface_width(surface),
+ surface_height(surface),
+ surface_stride(surface));
- s->scale_y = 1.0;
- s->scale_x = 1.0;
- } else {
- sx = 1.0;
- sy = 1.0;
- }
-
- gtk_widget_set_size_request(s->drawing_area,
- ds_get_width(ds) * s->scale_x,
- ds_get_height(ds) * s->scale_y);
- gtk_widget_size_request(s->vbox, &req);
-
- gtk_window_resize(GTK_WINDOW(s->window),
- req.width * sx, req.height * sy);
+ if (resized) {
+ gd_update_windowsize(s);
+ } else {
+ gd_update_full_redraw(s);
}
}
if (!handled && propagate_accel) {
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);
}
GtkDisplayState *s = opaque;
if (!no_quit) {
- unregister_displaychangelistener(s->ds, &s->dcl);
+ unregister_displaychangelistener(&s->dcl);
qmp_quit(NULL);
return FALSE;
}
return FALSE;
}
- fbw = ds_get_width(s->ds);
- fbh = ds_get_height(s->ds);
+ fbw = surface_width(s->ds);
+ fbh = surface_height(s->ds);
gdk_drawable_get_size(gtk_widget_get_window(widget), &ww, &wh);
return TRUE;
}
+#if !GTK_CHECK_VERSION(3, 0, 0)
static gboolean gd_expose_event(GtkWidget *widget, GdkEventExpose *expose,
void *opaque)
{
return ret;
}
+#endif
static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion,
void *opaque)
int fbh, fbw;
int ww, wh;
- fbw = ds_get_width(s->ds) * s->scale_x;
- fbh = ds_get_height(s->ds) * s->scale_y;
+ fbw = surface_width(s->ds) * s->scale_x;
+ fbh = surface_height(s->ds) * s->scale_y;
gdk_drawable_get_size(gtk_widget_get_window(s->drawing_area), &ww, &wh);
y = (motion->y - my) / s->scale_y;
if (x < 0 || y < 0 ||
- x >= ds_get_width(s->ds) ||
- y >= ds_get_height(s->ds)) {
+ x >= surface_width(s->ds) ||
+ y >= surface_height(s->ds)) {
return TRUE;
}
if (kbd_mouse_is_absolute()) {
- dx = x * 0x7FFF / (ds_get_width(s->ds) - 1);
- dy = y * 0x7FFF / (ds_get_height(s->ds) - 1);
+ dx = x * 0x7FFF / (surface_width(s->ds) - 1);
+ dy = y * 0x7FFF / (surface_height(s->ds) - 1);
} else if (s->last_x == -1 || s->last_y == -1) {
dx = 0;
dy = 0;
}
if (!kbd_mouse_is_absolute() && gd_is_grab_active(s)) {
- GdkDrawable *drawable = GDK_DRAWABLE(gtk_widget_get_window(s->drawing_area));
- GdkDisplay *display = gdk_drawable_get_display(drawable);
- GdkScreen *screen = gdk_drawable_get_screen(drawable);
+ GdkScreen *screen = gtk_widget_get_screen(s->drawing_area);
int x = (int)motion->x_root;
int y = (int)motion->y_root;
}
if (x != (int)motion->x_root || y != (int)motion->y_root) {
+#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);
gdk_display_warp_pointer(display, screen, x, y);
+#endif
s->last_x = -1;
s->last_y = -1;
return FALSE;
}
if (kbd_mouse_is_absolute()) {
- dx = s->last_x * 0x7FFF / (ds_get_width(s->ds) - 1);
- dy = s->last_y * 0x7FFF / (ds_get_height(s->ds) - 1);
+ dx = s->last_x * 0x7FFF / (surface_width(s->ds) - 1);
+ dy = s->last_y * 0x7FFF / (surface_height(s->ds) - 1);
} else {
dx = 0;
dy = 0;
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);
gd_menu_show_tabs(GTK_MENU_ITEM(s->show_tabs_item), s);
gtk_widget_set_size_request(s->menu_bar, -1, -1);
gtk_widget_set_size_request(s->drawing_area,
- ds_get_width(s->ds), ds_get_height(s->ds));
+ surface_width(s->ds),
+ surface_height(s->ds));
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(s->grab_item), FALSE);
s->full_screen = FALSE;
s->scale_x = 1.0;
s->scale_x += .25;
s->scale_y += .25;
- gd_resize(s->ds);
+ gd_update_windowsize(s);
}
static void gd_menu_zoom_out(GtkMenuItem *item, void *opaque)
s->scale_x = MAX(s->scale_x, .25);
s->scale_y = MAX(s->scale_y, .25);
- gd_resize(s->ds);
+ gd_update_windowsize(s);
}
static void gd_menu_zoom_fixed(GtkMenuItem *item, void *opaque)
s->scale_x = 1.0;
s->scale_y = 1.0;
- gd_resize(s->ds);
+ gd_update_windowsize(s);
}
static void gd_menu_zoom_fit(GtkMenuItem *item, void *opaque)
{
GtkDisplayState *s = opaque;
- int ww, wh;
if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(s->zoom_fit_item))) {
s->free_scale = TRUE;
s->free_scale = FALSE;
}
- gd_resize(s->ds);
-
- gdk_drawable_get_size(gtk_widget_get_window(s->drawing_area), &ww, &wh);
- gtk_widget_queue_draw_area(s->drawing_area, 0, 0, ww, wh);
+ gd_update_windowsize(s);
+ gd_update_full_redraw(s);
}
static void gd_grab_keyboard(GtkDisplayState *s)
{
- gdk_keyboard_grab(gtk_widget_get_window(GTK_WIDGET(s->drawing_area)),
+#if GTK_CHECK_VERSION(3, 0, 0)
+ GdkDisplay *display = gtk_widget_get_display(s->drawing_area);
+ GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
+ GList *devices = gdk_device_manager_list_devices(mgr,
+ GDK_DEVICE_TYPE_MASTER);
+ GList *tmp = devices;
+ while (tmp) {
+ GdkDevice *dev = tmp->data;
+ if (gdk_device_get_source(dev) == GDK_SOURCE_KEYBOARD) {
+ gdk_device_grab(dev,
+ gtk_widget_get_window(s->drawing_area),
+ GDK_OWNERSHIP_NONE,
+ FALSE,
+ GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
+ NULL,
+ GDK_CURRENT_TIME);
+ }
+ tmp = tmp->next;
+ }
+ g_list_free(devices);
+#else
+ gdk_keyboard_grab(gtk_widget_get_window(s->drawing_area),
FALSE,
GDK_CURRENT_TIME);
+#endif
}
static void gd_ungrab_keyboard(GtkDisplayState *s)
{
+#if GTK_CHECK_VERSION(3, 0, 0)
+ GdkDisplay *display = gtk_widget_get_display(s->drawing_area);
+ GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
+ GList *devices = gdk_device_manager_list_devices(mgr,
+ GDK_DEVICE_TYPE_MASTER);
+ GList *tmp = devices;
+ while (tmp) {
+ GdkDevice *dev = tmp->data;
+ if (gdk_device_get_source(dev) == GDK_SOURCE_KEYBOARD) {
+ gdk_device_ungrab(dev,
+ GDK_CURRENT_TIME);
+ }
+ tmp = tmp->next;
+ }
+ g_list_free(devices);
+#else
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
+#endif
+}
+
+static void gd_grab_pointer(GtkDisplayState *s)
+{
+#if GTK_CHECK_VERSION(3, 0, 0)
+ GdkDisplay *display = gtk_widget_get_display(s->drawing_area);
+ GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
+ GList *devices = gdk_device_manager_list_devices(mgr,
+ GDK_DEVICE_TYPE_MASTER);
+ GList *tmp = devices;
+ while (tmp) {
+ GdkDevice *dev = tmp->data;
+ if (gdk_device_get_source(dev) == GDK_SOURCE_MOUSE) {
+ gdk_device_grab(dev,
+ gtk_widget_get_window(s->drawing_area),
+ GDK_OWNERSHIP_NONE,
+ 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,
+ s->null_cursor,
+ GDK_CURRENT_TIME);
+ }
+ tmp = tmp->next;
+ }
+ g_list_free(devices);
+#else
+ gdk_pointer_grab(gtk_widget_get_window(s->drawing_area),
+ 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 */
+ s->null_cursor,
+ GDK_CURRENT_TIME);
+#endif
+}
+
+static void gd_ungrab_pointer(GtkDisplayState *s)
+{
+#if GTK_CHECK_VERSION(3, 0, 0)
+ GdkDisplay *display = gtk_widget_get_display(s->drawing_area);
+ GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
+ GList *devices = gdk_device_manager_list_devices(mgr,
+ GDK_DEVICE_TYPE_MASTER);
+ GList *tmp = devices;
+ while (tmp) {
+ GdkDevice *dev = tmp->data;
+ if (gdk_device_get_source(dev) == GDK_SOURCE_MOUSE) {
+ gdk_device_ungrab(dev,
+ GDK_CURRENT_TIME);
+ }
+ tmp = tmp->next;
+ }
+ g_list_free(devices);
+#else
+ gdk_pointer_ungrab(GDK_CURRENT_TIME);
+#endif
}
static void gd_menu_grab_input(GtkMenuItem *item, void *opaque)
if (gd_is_grab_active(s)) {
gd_grab_keyboard(s);
- gdk_pointer_grab(gtk_widget_get_window(GTK_WIDGET(s->drawing_area)),
- 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 */
- s->null_cursor,
- GDK_CURRENT_TIME);
+ gd_grab_pointer(s);
} else {
gd_ungrab_keyboard(s);
- gdk_pointer_ungrab(GDK_CURRENT_TIME);
+ gd_ungrab_pointer(s);
}
gd_update_caption(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)
static int nb_vcs;
static CharDriverState *vcs[MAX_VCS];
-static CharDriverState *gd_vc_handler(QemuOpts *opts)
+static CharDriverState *gd_vc_handler(ChardevVC *unused)
{
CharDriverState *chr;
g_signal_connect(vc->menu_item, "activate",
G_CALLBACK(gd_menu_switch_vc), s);
- gtk_menu_append(GTK_MENU(s->view_menu), vc->menu_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->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_signal_connect(s->window, "delete-event",
G_CALLBACK(gd_window_close), s);
+#if GTK_CHECK_VERSION(3, 0, 0)
+ g_signal_connect(s->drawing_area, "draw",
+ G_CALLBACK(gd_draw_event), s);
+#else
g_signal_connect(s->drawing_area, "expose-event",
G_CALLBACK(gd_expose_event), s);
+#endif
g_signal_connect(s->drawing_area, "motion-notify-event",
G_CALLBACK(gd_motion_event), s);
g_signal_connect(s->drawing_area, "button-press-event",
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)
s->machine_menu_item = gtk_menu_item_new_with_mnemonic(_("_Machine"));
s->pause_item = gtk_check_menu_item_new_with_mnemonic(_("_Pause"));
- gtk_menu_append(GTK_MENU(s->machine_menu), s->pause_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), s->pause_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_append(GTK_MENU(s->machine_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), separator);
s->reset_item = gtk_image_menu_item_new_with_mnemonic(_("_Reset"));
- gtk_menu_append(GTK_MENU(s->machine_menu), s->reset_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), s->reset_item);
s->powerdown_item = gtk_image_menu_item_new_with_mnemonic(_("Power _Down"));
- gtk_menu_append(GTK_MENU(s->machine_menu), s->powerdown_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), s->powerdown_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_append(GTK_MENU(s->machine_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->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_append(GTK_MENU(s->machine_menu), s->quit_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->machine_menu), s->quit_item);
s->view_menu = gtk_menu_new();
gtk_menu_set_accel_group(GTK_MENU(s->view_menu), accel_group);
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_append(GTK_MENU(s->view_menu), s->full_screen_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->full_screen_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_append(GTK_MENU(s->view_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->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_append(GTK_MENU(s->view_menu), s->zoom_in_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->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_append(GTK_MENU(s->view_menu), s->zoom_out_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->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_append(GTK_MENU(s->view_menu), s->zoom_fixed_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->zoom_fixed_item);
s->zoom_fit_item = gtk_check_menu_item_new_with_mnemonic(_("Zoom To _Fit"));
- gtk_menu_append(GTK_MENU(s->view_menu), s->zoom_fit_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->zoom_fit_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_append(GTK_MENU(s->view_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), separator);
s->grab_on_hover_item = gtk_check_menu_item_new_with_mnemonic(_("Grab On _Hover"));
- gtk_menu_append(GTK_MENU(s->view_menu), s->grab_on_hover_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->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_append(GTK_MENU(s->view_menu), s->grab_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->grab_item);
separator = gtk_separator_menu_item_new();
- gtk_menu_append(GTK_MENU(s->view_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->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_append(GTK_MENU(s->view_menu), s->vga_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), s->vga_item);
for (i = 0; i < nb_vcs; i++) {
VirtualConsole *vc = &s->vc[i];
}
separator = gtk_separator_menu_item_new();
- gtk_menu_append(GTK_MENU(s->view_menu), separator);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->view_menu), separator);
s->show_tabs_item = gtk_check_menu_item_new_with_mnemonic(_("Show _Tabs"));
- gtk_menu_append(GTK_MENU(s->view_menu), s->show_tabs_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(s->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);
gtk_menu_shell_append(GTK_MENU_SHELL(s->menu_bar), s->view_menu_item);
}
+static const DisplayChangeListenerOps dcl_ops = {
+ .dpy_name = "gtk",
+ .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)
{
GtkDisplayState *s = g_malloc0(sizeof(*s));
+ char *filename;
gtk_init(NULL, NULL);
- ds->opaque = s;
- s->ds = ds;
- s->dcl.dpy_gfx_update = gd_update;
- s->dcl.dpy_gfx_resize = gd_resize;
- s->dcl.dpy_refresh = gd_refresh;
+ 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)
+ s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+#else
s->vbox = gtk_vbox_new(FALSE, 0);
+#endif
s->notebook = gtk_notebook_new();
s->drawing_area = gtk_drawing_area_new();
s->menu_bar = gtk_menu_bar_new();
gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), s->drawing_area, gtk_label_new("VGA"));
+ filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "qemu-icon.bmp");
+ 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);
projects / qemu.git / blobdiff