* [Qemu-devel] gtk2 driver
@ 2005-05-30 17:11 Jim C. Brown
2005-05-30 19:10 ` Lionel Ulmer
0 siblings, 1 reply; 12+ messages in thread
From: Jim C. Brown @ 2005-05-30 17:11 UTC (permalink / raw)
To: qemu-devel
[-- Attachment #1: Type: text/plain, Size: 844 bytes --]
Mouse grabbing works now (cursor will go invisible and strange "bumping"
problems). Also you can grab the mouse just by clicking the left mouse
button again.
The user can no longer manually resize the qemu gtk window.
Now when you close the GTK window, it signals qemu to shutdown (as if you had
typed "quit" from the monitor).
Fullscreen mode is still broken (the window will resize, but the image on the
window will not). This will be tricky to fix as software scaling will be
necessary to get the image to be the right size/shape. Unlike SDL or OpenGL,
which could alter the video resolution of the X server. Perhaps the best
solution is to use an embedded GTK GLX widget to render the image. What do
you think Fabrice?
New gtk2.c attached.
--
Infinite complexity begets infinite beauty.
Infinite precision begets infinite perfection.
[-- Attachment #2: gtk2.c --]
[-- Type: text/plain, Size: 20447 bytes --]
/*
* QEMU GTK2 display driver
* based on SDL driver by Fabrice
*
* Copyright (c) 2005 Jim Brown
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "vl.h"
#include <gtk/gtk.h>
#include <gdk/gdk.h>
/* define our own bitshift enums to allow qemugtk to know difference between left and right alt - something gtk doesnt provide in its modifiers mask. this uses qemu's own modifier_state[] map in order to guess correctly */
typedef enum
{
gtkshiftleft = 1 << 0,
gtkshiftright = 1 << 1,
gtkcontrolleft = 1 << 2,
gtkcontrolright = 1 << 3,
gtkaltleft = 1 << 4,
gtkaltright = 1 << 5,
gtkcapslock = 1 << 6
} gtk2keymod;
static GtkWidget *screen;
static GdkImage *image=NULL;
static GdkCursor *invisible_cursor;
static int ox = 0, oy = 0;
static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
static int last_vm_running;
static int gui_saved_grab;
static int gui_fullscreen;
static int gui_key_modifier_pressed;
static int gui_keysym;
static int gui_fullscreen_initial_grab;
static int gui_grab_code = gtkaltleft | gtkcontrolleft;
static uint8_t modifiers_state[256];
static unsigned int cw, ch;
static gboolean gtk2_expose(GtkWidget *wid, GdkEventExpose *event)
{
gdk_draw_image(wid->window, wid->style->fg_gc[GTK_WIDGET_STATE(wid)], image, event->area.x, event->area.y, event->area.x, event->area.y, event->area.width, event->area.height);
return TRUE;
}
static void gtk2_update(DisplayState *ds, int x, int y, int w, int h)
{
// printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
GdkEventExpose ev;
ev.area.x = x;
ev.area.y = y;
ev.area.width = w;
ev.area.height = h;
gtk2_expose(screen, &ev);
}
static void gtk2_resize(DisplayState *ds, int w, int h)
{
// printf(" resizing to %d %d\n", w, h);
cw = w; ch = h;
if (gui_fullscreen)
gtk_window_fullscreen(GTK_WINDOW(screen));
else
gtk_window_unfullscreen(GTK_WINDOW(screen));
if (image)
g_object_unref(image);
/* gdk_visual_get_best_with_depth() ??? but then how to paint onto window? */
image = gdk_image_new(GDK_IMAGE_NORMAL, gdk_visual_get_system(), w, h);
gdk_image_set_colormap(image, gdk_colormap_get_system());
if (!gui_fullscreen)
{
gtk_window_set_default_size(GTK_WINDOW(screen), w, h);
gtk_widget_set_size_request(screen, w, h);
gtk_window_resize(GTK_WINDOW(screen), w, h);
}
ds->data = image->mem;
ds->linesize = image->bpl;
ds->depth = image->bits_per_pixel;
ds->width = w;
ds->height = h;
gtk2_update(ds, 0, 0, w, h);
}
/* generic keyboard conversion */
#include "gdk_keysym.h"
#include "keymaps.c"
static kbd_layout_t *kbd_layout = NULL;
static uint8_t gtk2_keyevent_to_keycode_generic(const GdkEventKey *ev)
{
int keysym;
/* workaround for X11+SDL bug with AltGR - is it still needed for Gtk2? */
keysym = ev->keyval;
if (keysym == 0 && ev->hardware_keycode == 113)
keysym = GDK_Mode_switch;
return keysym2scancode(kbd_layout, keysym);
}
/* specific keyboard conversions from scan codes */
#if defined(_WIN32)
static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev)
{
return ev->hardware_keycode; /* does this work on win32 gtk? */
}
#else
static const uint8_t x_keycode_to_pc_keycode[61] = {
0xc7, /* 97 Home */
0xc8, /* 98 Up */
0xc9, /* 99 PgUp */
0xcb, /* 100 Left */
0x4c, /* 101 KP-5 */
0xcd, /* 102 Right */
0xcf, /* 103 End */
0xd0, /* 104 Down */
0xd1, /* 105 PgDn */
0xd2, /* 106 Ins */
0xd3, /* 107 Del */
0x9c, /* 108 Enter */
0x9d, /* 109 Ctrl-R */
0x0, /* 110 Pause */
0xb7, /* 111 Print */
0xb5, /* 112 Divide */
0xb8, /* 113 Alt-R */
0xc6, /* 114 Break */
0x0, /* 115 */
0x0, /* 116 */
0x0, /* 117 */
0x0, /* 118 */
0x0, /* 119 */
0x70, /* 120 Hiragana_Katakana */
0x0, /* 121 */
0x0, /* 122 */
0x73, /* 123 backslash */
0x0, /* 124 */
0x0, /* 125 */
0x0, /* 126 */
0x0, /* 127 */
0x0, /* 128 */
0x79, /* 129 Henkan */
0x0, /* 130 */
0x7b, /* 131 Muhenkan */
0x0, /* 132 */
0x7d, /* 133 Yen */
0x0, /* 134 */
0x0, /* 135 */
0x47, /* 136 KP_7 */
0x48, /* 137 KP_8 */
0x49, /* 138 KP_9 */
0x4b, /* 139 KP_4 */
0x4c, /* 140 KP_5 */
0x4d, /* 141 KP_6 */
0x4f, /* 142 KP_1 */
0x50, /* 143 KP_2 */
0x51, /* 144 KP_3 */
0x52, /* 145 KP_0 */
0x53, /* 146 KP_. */
0x47, /* 147 KP_HOME */
0x48, /* 148 KP_UP */
0x49, /* 149 KP_PgUp */
0x4b, /* 150 KP_Left */
0x4c, /* 151 KP_ */
0x4d, /* 152 KP_Right */
0x4f, /* 153 KP_End */
0x50, /* 154 KP_Down */
0x51, /* 155 KP_PgDn */
0x52, /* 156 KP_Ins */
0x53, /* 157 KP_Del */
};
static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev)
{
int keycode;
keycode = ev->hardware_keycode;
if (keycode < 9) {
keycode = 0;
} else if (keycode < 97) {
keycode -= 8; /* just an offset */
} else if (keycode < 158) {
/* use conversion table */
keycode = x_keycode_to_pc_keycode[keycode - 97];
} else {
keycode = 0;
}
return keycode;
}
#endif
static void reset_keys(void)
{
int i;
for(i = 0; i < 256; i++) {
if (modifiers_state[i]) {
if (i & 0x80)
kbd_put_keycode(0xe0);
kbd_put_keycode(i | 0x80);
modifiers_state[i] = 0;
}
}
}
/* convert GDK modifiers and invoke ugly hack to distinguish
between left and right shift/control/alt */
static guint gtk2_GetModState(const GdkEventKey *ev)
{
guint key = 0, keyval = ev->keyval, state = ev->state;
switch(keyval)
{
case GDK_Shift_L:
if (ev->type != GDK_KEY_RELEASE)
key |= gtkshiftleft;
keyval = 1;
break;
case GDK_Shift_R:
if (ev->type != GDK_KEY_RELEASE)
key |= gtkshiftright;
keyval = 1;
break;
case GDK_Control_L:
if (ev->type != GDK_KEY_RELEASE)
key |= gtkcontrolleft;
keyval = 2;
break;
case GDK_Control_R:
if (ev->type != GDK_KEY_RELEASE)
key |= gtkcontrolright;
keyval = 2;
break;
case GDK_Alt_L:
if (ev->type != GDK_KEY_RELEASE)
key |= gtkaltleft;
keyval = 3;
break;
case GDK_Alt_R:
if (ev->type != GDK_KEY_RELEASE)
key |= gtkaltright;
keyval = 3;
break;
case GDK_Caps_Lock:
if (ev->type != GDK_KEY_RELEASE)
key |= gtkcapslock;
keyval = 4;
break;
default:
keyval = 0;
break;
}
if (keyval != 1 && (state & GDK_SHIFT_MASK))
{
if (modifiers_state[0x2a])
key |= gtkshiftleft;
if (modifiers_state[0x36])
key |= gtkshiftright;
}
if (keyval != 2 && (state & GDK_CONTROL_MASK))
{
if (modifiers_state[0x1d])
key |= gtkcontrolleft;
if (modifiers_state[0x9d])
key |= gtkcontrolright;
}
if (keyval != 3 && (state & GDK_MOD1_MASK)) /* fixme: need to do a check to make sure that alt is mapped to GDK_MOD1_MASK in the GDK_Keymap */
{
if (modifiers_state[0x38])
key |= gtkaltleft;
if (modifiers_state[0xb8])
key |= gtkaltright;
}
if (keyval != 4 && (state & GDK_LOCK_MASK))
key |= gtkcapslock;
return key;
}
static void gtk2_process_key(GdkEventKey *ev)
{
int keycode, v;
if (ev->keyval == GDK_Pause) {
/* specific case */
v = 0;
if (ev->type == GDK_KEY_RELEASE)
v |= 0x80;
kbd_put_keycode(0xe1);
kbd_put_keycode(0x1d | v);
kbd_put_keycode(0x45 | v);
return;
}
if (kbd_layout) {
keycode = gtk2_keyevent_to_keycode_generic(ev);
} else {
keycode = gtk2_keyevent_to_keycode(ev);
}
switch(keycode) {
case 0x00:
/* sent when leaving window: reset the modifiers state */
reset_keys();
return;
case 0x2a: /* Left Shift */
case 0x36: /* Right Shift */
case 0x1d: /* Left CTRL */
case 0x9d: /* Right CTRL */
case 0x38: /* Left ALT */
case 0xb8: /* Right ALT */
if (ev->type == GDK_KEY_RELEASE)
modifiers_state[keycode] = 0;
else
modifiers_state[keycode] = 1;
break;
case 0x45: /* num lock */
case 0x3a: /* caps lock */
/* GTK does send the key up event, so we dont generate it */
/*kbd_put_keycode(keycode);
kbd_put_keycode(keycode | 0x80);
return;*/
break;
}
/* now send the key code */
if (keycode & 0x80)
kbd_put_keycode(0xe0);
if (ev->type == GDK_KEY_RELEASE)
kbd_put_keycode(keycode | 0x80);
else
kbd_put_keycode(keycode & 0x7f);
}
static void gtk2_update_caption(void)
{
char buf[1024];
strcpy(buf, "QEMU");
if (!vm_running) {
strcat(buf, " [Stopped]");
}
if (gui_grab) {
strcat(buf, " - Press Ctrl-Alt to exit grab");
}
gtk_window_set_title(GTK_WINDOW(screen), buf);
}
static void gtk2_grab_start(void)
{
guint events;
gint y;
GdkModifierType state; /* dummy var */
events = GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK;
y = gdk_pointer_grab(screen->window, TRUE, events, NULL, invisible_cursor, GDK_CURRENT_TIME);
if (y)
printf("GTK Warning - pointer grab failed!\n");
y = gdk_keyboard_grab(screen->window, TRUE, GDK_CURRENT_TIME);
if (y)
printf("GTK Warning - keyboard grab failed!\n");
/* do a dummy read to avoid moving mouse - set ox and oy to stay in sync */
gdk_window_get_pointer(screen->window, &ox, &oy, &state);
gui_grab = 1;
gtk2_update_caption();
}
static void gtk2_grab_end(void)
{
gdk_pointer_ungrab(GDK_CURRENT_TIME);
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
gui_grab = 0;
gtk2_update_caption();
}
static gboolean gtk2_send_mouse_scroll(GtkWidget *wid, GdkEventScroll *ev)
{
int x, y, dx, dy, dz, state, buttons;
if (gui_grab)
{
x = ev->x;
y = ev->y;
state = ev->state;
buttons = 0;
dx = x - ox;
dy = y - oy;
ox = x;
oy = y;
buttons = 0;
if ((state & GDK_BUTTON1_MASK))
buttons |= MOUSE_EVENT_LBUTTON;
if ((state & GDK_BUTTON3_MASK))
buttons |= MOUSE_EVENT_RBUTTON;
if ((state & GDK_BUTTON2_MASK))
buttons |= MOUSE_EVENT_MBUTTON;
/* test wheel - copied from Sebastien Bechet's gtk.c */
dz = 0;
if ((state & GDK_BUTTON4_MASK) || ev->direction == GDK_SCROLL_UP)
dz--;
if ((state & GDK_BUTTON5_MASK) || ev->direction == GDK_SCROLL_DOWN)
dz++;
kbd_mouse_event(dx, dy, dz, buttons);
}
return TRUE;
}
static gboolean gtk2_send_mouse_button(GtkWidget *wid, GdkEventButton *ev)
{
int x, y, dx, dy, dz, state, buttons;
if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS)
return TRUE; /* double or triple click - superflurious - ignore */
if (gui_grab)
{
x = ev->x;
y = ev->y;
state = ev->state;
buttons = 0;
dx = x - ox;
dy = y - oy;
ox = x;
oy = y;
buttons = 0;
if ((state & GDK_BUTTON1_MASK) || ev->button == 1)
buttons |= MOUSE_EVENT_LBUTTON;
if ((state & GDK_BUTTON3_MASK) || ev->button == 3)
buttons |= MOUSE_EVENT_RBUTTON;
if ((state & GDK_BUTTON2_MASK) || ev->button == 2)
buttons |= MOUSE_EVENT_MBUTTON;
/* XXX: test wheel */
dz = 0;
if ((state & GDK_BUTTON4_MASK) || ev->button == 4)
dz--;
if ((state & GDK_BUTTON5_MASK) || ev->button == 5)
dz++;
kbd_mouse_event(dx, dy, dz, buttons);
}
else
{
if (ev->button == 1 && ev->type == GDK_BUTTON_PRESS)
{
/* start grabbing all events */
gtk2_grab_start();
}
}
return TRUE;
}
static gboolean gtk2_send_mouse_move(GtkWidget *wid, GdkEventMotion *ev)
{
int x, y, dx, dy, dz, state, buttons;
if (gui_grab)
{
if (ev->is_hint)
{
gdk_window_get_pointer(ev->window, &x, &y, (GdkModifierType*)&state);
}
else
{
x = ev->x;
y = ev->y;
state = ev->state;
}
dx = x - ox;
dy = y - oy;
ox = x;
oy = y;
buttons = 0;
if (state & GDK_BUTTON1_MASK)
buttons |= MOUSE_EVENT_LBUTTON;
if (state & GDK_BUTTON3_MASK)
buttons |= MOUSE_EVENT_RBUTTON;
if (state & GDK_BUTTON2_MASK)
buttons |= MOUSE_EVENT_MBUTTON;
/* XXX: test wheel */
dz = 0;
if (state & GDK_BUTTON4_MASK)
dz--;
if (state & GDK_BUTTON5_MASK)
dz++;
kbd_mouse_event(dx, dy, dz, buttons);
}
return TRUE;
}
static void toggle_full_screen(DisplayState *ds)
{
gui_fullscreen = !gui_fullscreen;
gtk2_resize(ds, image->width, image->height);
if (gui_fullscreen) {
gui_saved_grab = gui_grab;
gtk2_grab_start();
} else {
if (!gui_saved_grab)
gtk2_grab_end();
}
vga_invalidate_display();
vga_update_display();
}
static gboolean gtk2_key_press(GtkWidget *wid, GdkEventKey *ev, DisplayState *ds)
{
int mod_state;
if (ev->type == GDK_KEY_PRESS) {
mod_state = (gtk2_GetModState(ev) & (int)gui_grab_code) == (int)gui_grab_code;
gui_key_modifier_pressed = mod_state;
if (gui_key_modifier_pressed) {
int keycode;
keycode = gtk2_keyevent_to_keycode(ev);
switch(keycode) {
case 0x21: /* 'f' key on US keyboard */
toggle_full_screen(ds);
gui_keysym = 1;
break;
case 0x02 ... 0x0a: /* '1' to '9' keys */
console_select(keycode - 0x02);
if (is_active_console(vga_console)) {
/* tell the vga console to redisplay itself */
vga_invalidate_display();
} else {
/* display grab if going to a text console */
if (gui_grab)
gtk2_grab_end();
}
gui_keysym = 1;
break;
default:
break;
}
} else if (!is_active_console(vga_console)) {
int keysym;
keysym = 0;
if (ev->state & GDK_CONTROL_MASK) {
switch(ev->keyval) {
case GDK_Up: keysym = QEMU_KEY_CTRL_UP; break;
case GDK_Down: keysym = QEMU_KEY_CTRL_DOWN; break;
case GDK_Left: keysym = QEMU_KEY_CTRL_LEFT; break;
case GDK_Right: keysym = QEMU_KEY_CTRL_RIGHT; break;
case GDK_Home: keysym = QEMU_KEY_CTRL_HOME; break;
case GDK_End: keysym = QEMU_KEY_CTRL_END; break;
case GDK_Page_Up: keysym = QEMU_KEY_CTRL_PAGEUP; break;
case GDK_Page_Down: keysym = QEMU_KEY_CTRL_PAGEDOWN; break;
default: break;
}
} else {
switch(ev->keyval) {
case GDK_Up: keysym = QEMU_KEY_UP; break;
case GDK_Down: keysym = QEMU_KEY_DOWN; break;
case GDK_Left: keysym = QEMU_KEY_LEFT; break;
case GDK_Right: keysym = QEMU_KEY_RIGHT; break;
case GDK_Home: keysym = QEMU_KEY_HOME; break;
case GDK_End: keysym = QEMU_KEY_END; break;
case GDK_Page_Up: keysym = QEMU_KEY_PAGEUP; break;
case GDK_Page_Down: keysym = QEMU_KEY_PAGEDOWN; break;
case GDK_BackSpace: keysym = QEMU_KEY_BACKSPACE; break;
case GDK_Delete: keysym = QEMU_KEY_DELETE; break;
default: break;
}
}
if (keysym) {
kbd_put_keysym(keysym);
} /*else if (ev->key.keysym.unicode != 0) {
kbd_put_keysym(ev->key.keysym.unicode);
}*/
}
} else if (ev->type == GDK_KEY_RELEASE) {
mod_state = (gtk2_GetModState(ev) & gui_grab_code);
if (!mod_state) {
if (gui_key_modifier_pressed) {
if (gui_keysym == 0) {
/* exit/enter grab if pressing Ctrl-Alt */
if (!gui_grab)
gtk2_grab_start();
else
gtk2_grab_end();
/* SDL does not send back all the
modifiers key, so we must correct it */
reset_keys();
return TRUE;
}
gui_key_modifier_pressed = 0;
gui_keysym = 0;
}
}
}
if (is_active_console(vga_console))
gtk2_process_key(ev);
return TRUE;
}
static void gtk2_refresh(DisplayState *ds)
{
if (last_vm_running != vm_running) {
last_vm_running = vm_running;
gtk2_update_caption();
}
if (ds->data != image->mem)
{
ds->data = image->mem;
}
if (is_active_console(vga_console))
vga_update_display();
while (gtk_events_pending())
gtk_main_iteration();
}
static void gtk2_cleanup(void)
{
gtk_main_quit();
}
static gboolean gtk2_deletewin(void)
{
/* signal qemu that its time to shut itself off - this is the place that we hook to trap attempts to close the main qemu window */
qemu_system_shutdown_request();
return TRUE; /* dont close the window right away! give qemu time to think */
}
static void gtk2_destroy(void)
{
/* ideally we would call a hook here so qemu could clean itself up */
gtk2_cleanup();
}
void gtk2_display_init(DisplayState *ds, int full_screen)
{
int events;
#if defined(__APPLE__)
/* always use generic keymaps */
if (!keyboard_layout)
keyboard_layout = "en-us";
#endif
if(keyboard_layout) {
kbd_layout = init_keyboard_layout(keyboard_layout);
if (!kbd_layout)
exit(1);
}
if (!gtk_init_check (0,NULL))
{
fprintf(stderr, "Could not load GTK\n");
exit(0);
}
/* note: adding GDK_DRAG_* and GDK_DROP_* would provide a mechanism for supporting drag and drop between host and guest */
events = GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK | GDK_SCROLL_MASK | GDK_STRUCTURE_MASK;
screen = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_events(screen, events);
gtk_window_set_default_size(GTK_WINDOW(screen), 720, 400);
gtk_widget_set_size_request(screen, 720, 400);
g_signal_connect(G_OBJECT(screen), "delete_event", G_CALLBACK(gtk2_deletewin), NULL);
g_signal_connect(G_OBJECT(screen), "destroy", G_CALLBACK(gtk2_destroy), NULL);
gtk_container_set_border_width(GTK_CONTAINER(screen), 10);
gtk_signal_connect(GTK_OBJECT(screen), "expose_event", (GtkSignalFunc) gtk2_expose, NULL);
gtk_signal_connect(GTK_OBJECT(screen), "motion_notify_event", (GtkSignalFunc) gtk2_send_mouse_move, NULL);
gtk_signal_connect(GTK_OBJECT(screen), "button_press_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL);
gtk_signal_connect(GTK_OBJECT(screen), "button_release_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL);
gtk_signal_connect(GTK_OBJECT(screen), "scroll_event", (GtkSignalFunc) gtk2_send_mouse_scroll, NULL);
gtk_signal_connect(GTK_OBJECT(screen), "key_press_event", (GtkSignalFunc) gtk2_key_press, ds);
gtk_signal_connect(GTK_OBJECT(screen), "key_release_event", (GtkSignalFunc) gtk2_key_press, ds);
ds->dpy_update = gtk2_update;
ds->dpy_resize = gtk2_resize;
ds->dpy_refresh = gtk2_refresh;
gchar nullpixdata[1] = { 0 };
GdkColor nullcolor = { 0, 0, 0, 0 };
GdkPixmap *invis = gdk_bitmap_create_from_data(screen->window, nullpixdata, 1, 1);
invisible_cursor = gdk_cursor_new_from_pixmap(invis, invis, &nullcolor, &nullcolor, 0, 0);
gtk2_resize(ds, 720, 400);
gtk2_update_caption();
gui_grab = 0;
gtk_window_set_policy(GTK_WINDOW(screen), FALSE, FALSE, FALSE);
gtk_widget_show(screen);
if (full_screen) {
gui_fullscreen = 1;
gui_fullscreen_initial_grab = 1;
gtk2_grab_start();
}
}
^ permalink raw reply [flat|nested] 12+ messages in thread* Re: [Qemu-devel] gtk2 driver 2005-05-30 17:11 [Qemu-devel] gtk2 driver Jim C. Brown @ 2005-05-30 19:10 ` Lionel Ulmer 2005-05-30 20:21 ` Jim C. Brown 0 siblings, 1 reply; 12+ messages in thread From: Lionel Ulmer @ 2005-05-30 19:10 UTC (permalink / raw) To: qemu-devel On Mon, May 30, 2005 at 01:11:09PM -0400, Jim C. Brown wrote: > Fullscreen mode is still broken (the window will resize, but the image on the > window will not). This will be tricky to fix as software scaling will be > necessary to get the image to be the right size/shape. Unlike SDL or OpenGL, > which could alter the video resolution of the X server. Perhaps the best > solution is to use an embedded GTK GLX widget to render the image. What do > you think Fabrice? Why not switch to SDL output when the user requests going 'full-screen' ? It would be a bit of a hack, but well, it could work :-) Otherwise, just use plain X11 calls to change resolution (via XRandr or via Xvidmode). The problem being always to properly 'align' this window to be the only one on screen. Lionel -- Lionel Ulmer - http://www.bbrox.org/ ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] gtk2 driver 2005-05-30 19:10 ` Lionel Ulmer @ 2005-05-30 20:21 ` Jim C. Brown 2005-05-30 21:10 ` Fabrice Bellard 0 siblings, 1 reply; 12+ messages in thread From: Jim C. Brown @ 2005-05-30 20:21 UTC (permalink / raw) To: qemu-devel On Mon, May 30, 2005 at 09:10:43PM +0200, Lionel Ulmer wrote: > On Mon, May 30, 2005 at 01:11:09PM -0400, Jim C. Brown wrote: > > Fullscreen mode is still broken (the window will resize, but the image on the > > window will not). This will be tricky to fix as software scaling will be > > necessary to get the image to be the right size/shape. Unlike SDL or OpenGL, > > which could alter the video resolution of the X server. Perhaps the best > > solution is to use an embedded GTK GLX widget to render the image. What do > > you think Fabrice? > > Why not switch to SDL output when the user requests going 'full-screen' ? It > would be a bit of a hack, but well, it could work :-) > It's a very easy hack to write, and it wouldnt be very difficult to get to work. There is a gtksdl widget for gtk2 that I could use just for this purpose - that way you could still have say a drop down menubar to use (for the GUI). Or the gtk code could simply call upon the SDL driver when it goes into fullscreen mode. > Otherwise, just use plain X11 calls to change resolution (via XRandr or via > Xvidmode). The problem being always to properly 'align' this window to be > the only one on screen. This is also doable, but it is less portable (e.g. it wouldnt work on Windows). Either of these approaches mean moving away from pure GTK/GDK. Fabrice hasn't explained why, but he has made it clear that he wants the Linux to use GTK. Also, I'd prefer not to use X11 in the gtk driver in the hopes of keeping it Windows compatible. > > Lionel > > -- > Lionel Ulmer - http://www.bbrox.org/ > > > _______________________________________________ > Qemu-devel mailing list > Qemu-devel@nongnu.org > http://lists.nongnu.org/mailman/listinfo/qemu-devel > -- Infinite complexity begets infinite beauty. Infinite precision begets infinite perfection. ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] gtk2 driver 2005-05-30 20:21 ` Jim C. Brown @ 2005-05-30 21:10 ` Fabrice Bellard 2005-05-30 23:03 ` Jim C. Brown 0 siblings, 1 reply; 12+ messages in thread From: Fabrice Bellard @ 2005-05-30 21:10 UTC (permalink / raw) To: qemu-devel >>Otherwise, just use plain X11 calls to change resolution (via XRandr or via >>Xvidmode). The problem being always to properly 'align' this window to be >>the only one on screen. > > > This is also doable, but it is less portable (e.g. it wouldnt work on Windows). > > Either of these approaches mean moving away from pure GTK/GDK. Fabrice hasn't > explained why, but he has made it clear that he wants the Linux to use GTK. > Also, I'd prefer not to use X11 in the gtk driver in the hopes of keeping it > Windows compatible. If GTK cannot support correct full screen output, then it is perfectly acceptable to do direct X11 calls thru DGA/Xvidmode for example. Using SDL for full screen is possible too, but I think it will be a source of problems (see the keyboard bugs we have with SDL/Windows). Fabrice. ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] gtk2 driver 2005-05-30 21:10 ` Fabrice Bellard @ 2005-05-30 23:03 ` Jim C. Brown 2005-05-31 0:24 ` Jim C. Brown 0 siblings, 1 reply; 12+ messages in thread From: Jim C. Brown @ 2005-05-30 23:03 UTC (permalink / raw) To: qemu-devel On Mon, May 30, 2005 at 11:10:26PM +0200, Fabrice Bellard wrote: > >>Otherwise, just use plain X11 calls to change resolution (via XRandr or > >>via > >>Xvidmode). The problem being always to properly 'align' this window to be > >>the only one on screen. > > > > > > If GTK cannot support correct full screen output, then it is perfectly > acceptable to do direct X11 calls thru DGA/Xvidmode for example. > > Fabrice. > > >This is also doable, but it is less portable (e.g. it wouldnt work on > >Windows). > > Ok this is what I've decided to do. In order to ensure that gtk2.c will work on windows, I have decided to keep the fullscreen code separate. There will be a fullscreen.h that defines the 4 functions that gtk2.c depends on, and there will be a fullscreen "driver" of the name <library>_fs.c that implements these functions. I've written an xvid_fs.c which implements fullscreen mode via the Xvidmode extension as well as a null_fs.c which doesn't do anything. This way, Linux/FreeBSD/etc users can use the xvid_fs driver to get fullscreen mode with gtk and Windows users can use the null_fs driver to use gtk mode. The idea is that someone could implement a win32_fs driver that would enable fullscreen mode in Windows. I do not know enough about win32api programming to write this myself. If gtk mode is enabled, the configure script will select the correct driver by default (xvid_fs on unix, null_fs for everyone else) but there will be an option to override this. I have a few kinks to work out (plus some configure/Makefile diffs to write) but expect a patch and the new files in a few hours. On a side note, has anyone tried to use the gtk2 driver on windows? If so, can you tell me what happened? -- Infinite complexity begets infinite beauty. Infinite precision begets infinite perfection. ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] gtk2 driver 2005-05-30 23:03 ` Jim C. Brown @ 2005-05-31 0:24 ` Jim C. Brown 2005-05-31 14:15 ` Sylvain Petreolle 2005-05-31 19:45 ` Jim C. Brown 0 siblings, 2 replies; 12+ messages in thread From: Jim C. Brown @ 2005-05-31 0:24 UTC (permalink / raw) To: qemu-devel [-- Attachment #1: Type: text/plain, Size: 362 bytes --] Here is the new driver. Patch is against a clean qemu directory. Once you apply the patch, dump the attached files into the qemu root directory and run configure with '--enable-gtk' option. The '--set-fs-driver=' option exists but there should be no need to use it. -- Infinite complexity begets infinite beauty. Infinite precision begets infinite perfection. [-- Attachment #2: gtk2.c --] [-- Type: text/plain, Size: 20794 bytes --] /* * QEMU GTK2 display driver * based on SDL driver by Fabrice * * Copyright (c) 2005 Jim Brown * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include "vl.h" #include <gtk/gtk.h> #include <gdk/gdk.h> #include "fullscreen.h" /* define our own bitshift enums to allow qemugtk to know difference between left and right alt - something gtk doesnt provide in its modifiers mask. this uses qemu's own modifier_state[] map in order to guess correctly */ typedef enum { gtkshiftleft = 1 << 0, gtkshiftright = 1 << 1, gtkcontrolleft = 1 << 2, gtkcontrolright = 1 << 3, gtkaltleft = 1 << 4, gtkaltright = 1 << 5, gtkcapslock = 1 << 6 } gtk2keymod; static GtkWidget *screen; static GdkImage *image=NULL; static GdkCursor *invisible_cursor; static int ox = 0, oy = 0; static int gui_grab; /* if true, all keyboard/mouse events are grabbed */ static int last_vm_running; static int gui_saved_grab; static int gui_fullscreen; static int gui_key_modifier_pressed; static int gui_keysym; static int gui_fullscreen_initial_grab; static int gui_grab_code = gtkaltleft | gtkcontrolleft; static uint8_t modifiers_state[256]; static unsigned int cw, ch; static gint cx, cy; static gboolean gtk2_expose(GtkWidget *wid, GdkEventExpose *event) { gdk_draw_image(wid->window, wid->style->fg_gc[GTK_WIDGET_STATE(wid)], image, event->area.x, event->area.y, event->area.x, event->area.y, event->area.width, event->area.height); return TRUE; } static void gtk2_update(DisplayState *ds, int x, int y, int w, int h) { // printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h); GdkEventExpose ev; ev.area.x = x; ev.area.y = y; ev.area.width = w; ev.area.height = h; gtk2_expose(screen, &ev); } static void gtk2_resize(DisplayState *ds, int w, int h) { // printf(" resizing to %d %d\n", w, h); if (gui_fullscreen) { if (cw != w || ch != h) fullscreen_switch(cx, cy, w, h); /* changing video modes */ //gtk_window_fullscreen(GTK_WINDOW(screen)); } else { //gtk_window_unfullscreen(GTK_WINDOW(screen)); } cw = w; ch = h; if (image) g_object_unref(image); /* gdk_visual_get_best_with_depth() ??? but then how to paint onto window? */ image = gdk_image_new(GDK_IMAGE_NORMAL, gdk_visual_get_system(), w, h); gdk_image_set_colormap(image, gdk_colormap_get_system()); gtk_window_set_default_size(GTK_WINDOW(screen), w, h); gtk_widget_set_size_request(screen, w, h); gtk_window_resize(GTK_WINDOW(screen), w, h); ds->data = image->mem; ds->linesize = image->bpl; ds->depth = image->bits_per_pixel; ds->width = w; ds->height = h; gtk2_update(ds, 0, 0, w, h); } /* generic keyboard conversion */ #include "gdk_keysym.h" #include "keymaps.c" static kbd_layout_t *kbd_layout = NULL; static uint8_t gtk2_keyevent_to_keycode_generic(const GdkEventKey *ev) { int keysym; /* workaround for X11+SDL bug with AltGR - is it still needed for Gtk2? */ keysym = ev->keyval; if (keysym == 0 && ev->hardware_keycode == 113) keysym = GDK_Mode_switch; return keysym2scancode(kbd_layout, keysym); } /* specific keyboard conversions from scan codes */ #if defined(_WIN32) static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev) { return ev->hardware_keycode; /* does this work on win32 gtk? */ } #else static const uint8_t x_keycode_to_pc_keycode[61] = { 0xc7, /* 97 Home */ 0xc8, /* 98 Up */ 0xc9, /* 99 PgUp */ 0xcb, /* 100 Left */ 0x4c, /* 101 KP-5 */ 0xcd, /* 102 Right */ 0xcf, /* 103 End */ 0xd0, /* 104 Down */ 0xd1, /* 105 PgDn */ 0xd2, /* 106 Ins */ 0xd3, /* 107 Del */ 0x9c, /* 108 Enter */ 0x9d, /* 109 Ctrl-R */ 0x0, /* 110 Pause */ 0xb7, /* 111 Print */ 0xb5, /* 112 Divide */ 0xb8, /* 113 Alt-R */ 0xc6, /* 114 Break */ 0x0, /* 115 */ 0x0, /* 116 */ 0x0, /* 117 */ 0x0, /* 118 */ 0x0, /* 119 */ 0x70, /* 120 Hiragana_Katakana */ 0x0, /* 121 */ 0x0, /* 122 */ 0x73, /* 123 backslash */ 0x0, /* 124 */ 0x0, /* 125 */ 0x0, /* 126 */ 0x0, /* 127 */ 0x0, /* 128 */ 0x79, /* 129 Henkan */ 0x0, /* 130 */ 0x7b, /* 131 Muhenkan */ 0x0, /* 132 */ 0x7d, /* 133 Yen */ 0x0, /* 134 */ 0x0, /* 135 */ 0x47, /* 136 KP_7 */ 0x48, /* 137 KP_8 */ 0x49, /* 138 KP_9 */ 0x4b, /* 139 KP_4 */ 0x4c, /* 140 KP_5 */ 0x4d, /* 141 KP_6 */ 0x4f, /* 142 KP_1 */ 0x50, /* 143 KP_2 */ 0x51, /* 144 KP_3 */ 0x52, /* 145 KP_0 */ 0x53, /* 146 KP_. */ 0x47, /* 147 KP_HOME */ 0x48, /* 148 KP_UP */ 0x49, /* 149 KP_PgUp */ 0x4b, /* 150 KP_Left */ 0x4c, /* 151 KP_ */ 0x4d, /* 152 KP_Right */ 0x4f, /* 153 KP_End */ 0x50, /* 154 KP_Down */ 0x51, /* 155 KP_PgDn */ 0x52, /* 156 KP_Ins */ 0x53, /* 157 KP_Del */ }; static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev) { int keycode; keycode = ev->hardware_keycode; if (keycode < 9) { keycode = 0; } else if (keycode < 97) { keycode -= 8; /* just an offset */ } else if (keycode < 158) { /* use conversion table */ keycode = x_keycode_to_pc_keycode[keycode - 97]; } else { keycode = 0; } return keycode; } #endif static void reset_keys(void) { int i; for(i = 0; i < 256; i++) { if (modifiers_state[i]) { if (i & 0x80) kbd_put_keycode(0xe0); kbd_put_keycode(i | 0x80); modifiers_state[i] = 0; } } } /* convert GDK modifiers and invoke ugly hack to distinguish between left and right shift/control/alt */ static guint gtk2_GetModState(const GdkEventKey *ev) { guint key = 0, keyval = ev->keyval, state = ev->state; switch(keyval) { case GDK_Shift_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkshiftleft; keyval = 1; break; case GDK_Shift_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkshiftright; keyval = 1; break; case GDK_Control_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkcontrolleft; keyval = 2; break; case GDK_Control_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkcontrolright; keyval = 2; break; case GDK_Alt_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkaltleft; keyval = 3; break; case GDK_Alt_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkaltright; keyval = 3; break; case GDK_Caps_Lock: if (ev->type != GDK_KEY_RELEASE) key |= gtkcapslock; keyval = 4; break; default: keyval = 0; break; } if (keyval != 1 && (state & GDK_SHIFT_MASK)) { if (modifiers_state[0x2a]) key |= gtkshiftleft; if (modifiers_state[0x36]) key |= gtkshiftright; } if (keyval != 2 && (state & GDK_CONTROL_MASK)) { if (modifiers_state[0x1d]) key |= gtkcontrolleft; if (modifiers_state[0x9d]) key |= gtkcontrolright; } if (keyval != 3 && (state & GDK_MOD1_MASK)) /* fixme: need to do a check to make sure that alt is mapped to GDK_MOD1_MASK in the GDK_Keymap */ { if (modifiers_state[0x38]) key |= gtkaltleft; if (modifiers_state[0xb8]) key |= gtkaltright; } if (keyval != 4 && (state & GDK_LOCK_MASK)) key |= gtkcapslock; return key; } static void gtk2_process_key(GdkEventKey *ev) { int keycode, v; if (ev->keyval == GDK_Pause) { /* specific case */ v = 0; if (ev->type == GDK_KEY_RELEASE) v |= 0x80; kbd_put_keycode(0xe1); kbd_put_keycode(0x1d | v); kbd_put_keycode(0x45 | v); return; } if (kbd_layout) { keycode = gtk2_keyevent_to_keycode_generic(ev); } else { keycode = gtk2_keyevent_to_keycode(ev); } switch(keycode) { case 0x00: /* sent when leaving window: reset the modifiers state */ reset_keys(); return; case 0x2a: /* Left Shift */ case 0x36: /* Right Shift */ case 0x1d: /* Left CTRL */ case 0x9d: /* Right CTRL */ case 0x38: /* Left ALT */ case 0xb8: /* Right ALT */ if (ev->type == GDK_KEY_RELEASE) modifiers_state[keycode] = 0; else modifiers_state[keycode] = 1; break; case 0x45: /* num lock */ case 0x3a: /* caps lock */ /* GTK does send the key up event, so we dont generate it */ /*kbd_put_keycode(keycode); kbd_put_keycode(keycode | 0x80); return;*/ break; } /* now send the key code */ if (keycode & 0x80) kbd_put_keycode(0xe0); if (ev->type == GDK_KEY_RELEASE) kbd_put_keycode(keycode | 0x80); else kbd_put_keycode(keycode & 0x7f); } static void gtk2_update_caption(void) { char buf[1024]; strcpy(buf, "QEMU"); if (!vm_running) { strcat(buf, " [Stopped]"); } if (gui_grab) { strcat(buf, " - Press Ctrl-Alt to exit grab"); } gtk_window_set_title(GTK_WINDOW(screen), buf); } static void gtk2_grab_start(void) { gint y; guint events; GdkModifierType state; /* dummy var */ events = GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK; y = gdk_pointer_grab(screen->window, TRUE, events, NULL, invisible_cursor, GDK_CURRENT_TIME); if (y) printf("GTK Warning - pointer grab failed!\n"); y = gdk_keyboard_grab(screen->window, TRUE, GDK_CURRENT_TIME); if (y) printf("GTK Warning - keyboard grab failed!\n"); /* do a dummy read to avoid moving mouse - set ox and oy to stay in sync */ gdk_window_get_pointer(screen->window, &ox, &oy, &state); gui_grab = 1; gtk2_update_caption(); } static void gtk2_grab_end(void) { gdk_pointer_ungrab(GDK_CURRENT_TIME); gdk_keyboard_ungrab(GDK_CURRENT_TIME); gui_grab = 0; gtk2_update_caption(); } static gboolean gtk2_send_mouse_scroll(GtkWidget *wid, GdkEventScroll *ev) { int x, y, dx, dy, dz, state, buttons; if (gui_grab) { x = ev->x; y = ev->y; state = ev->state; buttons = 0; dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if ((state & GDK_BUTTON1_MASK)) buttons |= MOUSE_EVENT_LBUTTON; if ((state & GDK_BUTTON3_MASK)) buttons |= MOUSE_EVENT_RBUTTON; if ((state & GDK_BUTTON2_MASK)) buttons |= MOUSE_EVENT_MBUTTON; /* test wheel - copied from Sebastien Bechet's gtk.c */ dz = 0; if ((state & GDK_BUTTON4_MASK) || ev->direction == GDK_SCROLL_UP) dz--; if ((state & GDK_BUTTON5_MASK) || ev->direction == GDK_SCROLL_DOWN) dz++; kbd_mouse_event(dx, dy, dz, buttons); } return TRUE; } static gboolean gtk2_send_mouse_button(GtkWidget *wid, GdkEventButton *ev) { int x, y, dx, dy, dz, state, buttons; if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS) return TRUE; /* double or triple click - superflurious - ignore */ if (gui_grab) { x = ev->x; y = ev->y; state = ev->state; buttons = 0; dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if ((state & GDK_BUTTON1_MASK) || ev->button == 1) buttons |= MOUSE_EVENT_LBUTTON; if ((state & GDK_BUTTON3_MASK) || ev->button == 3) buttons |= MOUSE_EVENT_RBUTTON; if ((state & GDK_BUTTON2_MASK) || ev->button == 2) buttons |= MOUSE_EVENT_MBUTTON; /* XXX: test wheel */ dz = 0; if ((state & GDK_BUTTON4_MASK) || ev->button == 4) dz--; if ((state & GDK_BUTTON5_MASK) || ev->button == 5) dz++; kbd_mouse_event(dx, dy, dz, buttons); } else { if (ev->button == 1 && ev->type == GDK_BUTTON_PRESS) { /* start grabbing all events */ gtk2_grab_start(); } } return TRUE; } static gboolean gtk2_send_mouse_move(GtkWidget *wid, GdkEventMotion *ev) { int x, y, dx, dy, dz, state, buttons; if (gui_grab) { if (ev->is_hint) { gdk_window_get_pointer(ev->window, &x, &y, (GdkModifierType*)&state); } else { x = ev->x; y = ev->y; state = ev->state; } dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if (state & GDK_BUTTON1_MASK) buttons |= MOUSE_EVENT_LBUTTON; if (state & GDK_BUTTON3_MASK) buttons |= MOUSE_EVENT_RBUTTON; if (state & GDK_BUTTON2_MASK) buttons |= MOUSE_EVENT_MBUTTON; /* XXX: test wheel */ dz = 0; if (state & GDK_BUTTON4_MASK) dz--; if (state & GDK_BUTTON5_MASK) dz++; kbd_mouse_event(dx, dy, dz, buttons); } return TRUE; } static void toggle_full_screen(DisplayState *ds) { gui_fullscreen = !gui_fullscreen; gtk2_resize(ds, image->width, image->height); if (gui_fullscreen) { gui_saved_grab = gui_grab; gtk2_grab_start(); gtk_window_get_position(GTK_WINDOW(screen), &cx, &cy); fullscreen_switch(cx, cy, ds->width, ds->height); } else { fullscreen_reset(); if (!gui_saved_grab) gtk2_grab_end(); } vga_invalidate_display(); vga_update_display(); } static gboolean gtk2_key_press(GtkWidget *wid, GdkEventKey *ev, DisplayState *ds) { int mod_state; if (ev->type == GDK_KEY_PRESS) { mod_state = (gtk2_GetModState(ev) & (int)gui_grab_code) == (int)gui_grab_code; gui_key_modifier_pressed = mod_state; if (gui_key_modifier_pressed) { int keycode; keycode = gtk2_keyevent_to_keycode(ev); switch(keycode) { case 0x21: /* 'f' key on US keyboard */ toggle_full_screen(ds); gui_keysym = 1; break; case 0x02 ... 0x0a: /* '1' to '9' keys */ console_select(keycode - 0x02); if (is_active_console(vga_console)) { /* tell the vga console to redisplay itself */ vga_invalidate_display(); } else { /* display grab if going to a text console */ if (gui_grab) gtk2_grab_end(); } gui_keysym = 1; break; default: break; } } else if (!is_active_console(vga_console)) { int keysym; keysym = 0; if (ev->state & GDK_CONTROL_MASK) { switch(ev->keyval) { case GDK_Up: keysym = QEMU_KEY_CTRL_UP; break; case GDK_Down: keysym = QEMU_KEY_CTRL_DOWN; break; case GDK_Left: keysym = QEMU_KEY_CTRL_LEFT; break; case GDK_Right: keysym = QEMU_KEY_CTRL_RIGHT; break; case GDK_Home: keysym = QEMU_KEY_CTRL_HOME; break; case GDK_End: keysym = QEMU_KEY_CTRL_END; break; case GDK_Page_Up: keysym = QEMU_KEY_CTRL_PAGEUP; break; case GDK_Page_Down: keysym = QEMU_KEY_CTRL_PAGEDOWN; break; default: break; } } else { switch(ev->keyval) { case GDK_Up: keysym = QEMU_KEY_UP; break; case GDK_Down: keysym = QEMU_KEY_DOWN; break; case GDK_Left: keysym = QEMU_KEY_LEFT; break; case GDK_Right: keysym = QEMU_KEY_RIGHT; break; case GDK_Home: keysym = QEMU_KEY_HOME; break; case GDK_End: keysym = QEMU_KEY_END; break; case GDK_Page_Up: keysym = QEMU_KEY_PAGEUP; break; case GDK_Page_Down: keysym = QEMU_KEY_PAGEDOWN; break; case GDK_BackSpace: keysym = QEMU_KEY_BACKSPACE; break; case GDK_Delete: keysym = QEMU_KEY_DELETE; break; default: break; } } if (keysym) { kbd_put_keysym(keysym); } /*else if (ev->key.keysym.unicode != 0) { kbd_put_keysym(ev->key.keysym.unicode); }*/ } } else if (ev->type == GDK_KEY_RELEASE) { mod_state = (gtk2_GetModState(ev) & gui_grab_code); if (!mod_state) { if (gui_key_modifier_pressed) { if (gui_keysym == 0) { /* exit/enter grab if pressing Ctrl-Alt */ if (!gui_grab) gtk2_grab_start(); else gtk2_grab_end(); /* SDL does not send back all the modifiers key, so we must correct it */ reset_keys(); return TRUE; } gui_key_modifier_pressed = 0; gui_keysym = 0; } } } if (is_active_console(vga_console)) gtk2_process_key(ev); return TRUE; } static void gtk2_refresh(DisplayState *ds) { if (last_vm_running != vm_running) { last_vm_running = vm_running; gtk2_update_caption(); } if (ds->data != image->mem) { ds->data = image->mem; } if (is_active_console(vga_console)) vga_update_display(); while (gtk_events_pending()) gtk_main_iteration(); } static void gtk2_cleanup(void) { gtk_main_quit(); fullscreen_cleanup(); } static gboolean gtk2_deletewin(void) { /* signal qemu that its time to shut itself off - this is the place that we hook to trap attempts to close the main qemu window */ qemu_system_shutdown_request(); return TRUE; /* dont close the window right away! give qemu time to think */ } static void gtk2_destroy(void) { /* ideally we would call a hook here so qemu could clean itself up */ gtk2_cleanup(); } void gtk2_display_init(DisplayState *ds, int full_screen) { int events; #if defined(__APPLE__) /* always use generic keymaps */ if (!keyboard_layout) keyboard_layout = "en-us"; #endif if(keyboard_layout) { kbd_layout = init_keyboard_layout(keyboard_layout); if (!kbd_layout) exit(1); } if (!gtk_init_check (0,NULL)) { fprintf(stderr, "Could not load GTK\n"); exit(0); } fullscreen_init(); /* note: adding GDK_DRAG_* and GDK_DROP_* would provide a mechanism for supporting drag and drop between host and guest */ events = GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK | GDK_SCROLL_MASK | GDK_STRUCTURE_MASK; screen = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_events(screen, events); gtk_window_set_default_size(GTK_WINDOW(screen), 720, 400); gtk_widget_set_size_request(screen, 720, 400); g_signal_connect(G_OBJECT(screen), "delete_event", G_CALLBACK(gtk2_deletewin), NULL); g_signal_connect(G_OBJECT(screen), "destroy", G_CALLBACK(gtk2_destroy), NULL); gtk_container_set_border_width(GTK_CONTAINER(screen), 10); gtk_signal_connect(GTK_OBJECT(screen), "expose_event", (GtkSignalFunc) gtk2_expose, NULL); gtk_signal_connect(GTK_OBJECT(screen), "motion_notify_event", (GtkSignalFunc) gtk2_send_mouse_move, NULL); gtk_signal_connect(GTK_OBJECT(screen), "button_press_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL); gtk_signal_connect(GTK_OBJECT(screen), "button_release_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL); gtk_signal_connect(GTK_OBJECT(screen), "scroll_event", (GtkSignalFunc) gtk2_send_mouse_scroll, NULL); gtk_signal_connect(GTK_OBJECT(screen), "key_press_event", (GtkSignalFunc) gtk2_key_press, ds); gtk_signal_connect(GTK_OBJECT(screen), "key_release_event", (GtkSignalFunc) gtk2_key_press, ds); ds->dpy_update = gtk2_update; ds->dpy_resize = gtk2_resize; ds->dpy_refresh = gtk2_refresh; gchar nullpixdata[1] = { 0 }; GdkColor nullcolor = { 0, 0, 0, 0 }; GdkPixmap *invis = gdk_bitmap_create_from_data(screen->window, nullpixdata, 1, 1); invisible_cursor = gdk_cursor_new_from_pixmap(invis, invis, &nullcolor, &nullcolor, 0, 0); gtk2_resize(ds, 720, 400); gtk2_update_caption(); gui_grab = 0; gtk_window_set_policy(GTK_WINDOW(screen), FALSE, FALSE, FALSE); gtk_widget_show(screen); if (full_screen) { gui_fullscreen = 1; gui_fullscreen_initial_grab = 1; gtk2_grab_start(); } } [-- Attachment #3: gdk_keysym.h --] [-- Type: text/plain, Size: 8786 bytes --] #include <gdk/gdkkeysyms.h> typedef struct { const char* name; int keysym; } name2keysym_t; static name2keysym_t name2keysym[]={ /* ascii */ { "space", 0x020}, { "exclam", 0x021}, { "quotedbl", 0x022}, { "numbersign", 0x023}, { "dollar", 0x024}, { "percent", 0x025}, { "ampersand", 0x026}, { "apostrophe", 0x027}, { "parenleft", 0x028}, { "parenright", 0x029}, { "asterisk", 0x02a}, { "plus", 0x02b}, { "comma", 0x02c}, { "minus", 0x02d}, { "period", 0x02e}, { "slash", 0x02f}, { "0", 0x030}, { "1", 0x031}, { "2", 0x032}, { "3", 0x033}, { "4", 0x034}, { "5", 0x035}, { "6", 0x036}, { "7", 0x037}, { "8", 0x038}, { "9", 0x039}, { "colon", 0x03a}, { "semicolon", 0x03b}, { "less", 0x03c}, { "equal", 0x03d}, { "greater", 0x03e}, { "question", 0x03f}, { "at", 0x040}, { "A", 0x041}, { "B", 0x042}, { "C", 0x043}, { "D", 0x044}, { "E", 0x045}, { "F", 0x046}, { "G", 0x047}, { "H", 0x048}, { "I", 0x049}, { "J", 0x04a}, { "K", 0x04b}, { "L", 0x04c}, { "M", 0x04d}, { "N", 0x04e}, { "O", 0x04f}, { "P", 0x050}, { "Q", 0x051}, { "R", 0x052}, { "S", 0x053}, { "T", 0x054}, { "U", 0x055}, { "V", 0x056}, { "W", 0x057}, { "X", 0x058}, { "Y", 0x059}, { "Z", 0x05a}, { "bracketleft", 0x05b}, { "backslash", 0x05c}, { "bracketright", 0x05d}, { "asciicircum", 0x05e}, { "underscore", 0x05f}, { "grave", 0x060}, { "a", 0x061}, { "b", 0x062}, { "c", 0x063}, { "d", 0x064}, { "e", 0x065}, { "f", 0x066}, { "g", 0x067}, { "h", 0x068}, { "i", 0x069}, { "j", 0x06a}, { "k", 0x06b}, { "l", 0x06c}, { "m", 0x06d}, { "n", 0x06e}, { "o", 0x06f}, { "p", 0x070}, { "q", 0x071}, { "r", 0x072}, { "s", 0x073}, { "t", 0x074}, { "u", 0x075}, { "v", 0x076}, { "w", 0x077}, { "x", 0x078}, { "y", 0x079}, { "z", 0x07a}, { "braceleft", 0x07b}, { "bar", 0x07c}, { "braceright", 0x07d}, { "asciitilde", 0x07e}, /* latin 1 extensions */ { "nobreakspace", 0x0a0}, { "exclamdown", 0x0a1}, { "cent", 0x0a2}, { "sterling", 0x0a3}, { "currency", 0x0a4}, { "yen", 0x0a5}, { "brokenbar", 0x0a6}, { "section", 0x0a7}, { "diaeresis", 0x0a8}, { "copyright", 0x0a9}, { "ordfeminine", 0x0aa}, { "guillemotleft", 0x0ab}, { "notsign", 0x0ac}, { "hyphen", 0x0ad}, { "registered", 0x0ae}, { "macron", 0x0af}, { "degree", 0x0b0}, { "plusminus", 0x0b1}, { "twosuperior", 0x0b2}, { "threesuperior", 0x0b3}, { "acute", 0x0b4}, { "mu", 0x0b5}, { "paragraph", 0x0b6}, { "periodcentered", 0x0b7}, { "cedilla", 0x0b8}, { "onesuperior", 0x0b9}, { "masculine", 0x0ba}, { "guillemotright", 0x0bb}, { "onequarter", 0x0bc}, { "onehalf", 0x0bd}, { "threequarters", 0x0be}, { "questiondown", 0x0bf}, { "Agrave", 0x0c0}, { "Aacute", 0x0c1}, { "Acircumflex", 0x0c2}, { "Atilde", 0x0c3}, { "Adiaeresis", 0x0c4}, { "Aring", 0x0c5}, { "AE", 0x0c6}, { "Ccedilla", 0x0c7}, { "Egrave", 0x0c8}, { "Eacute", 0x0c9}, { "Ecircumflex", 0x0ca}, { "Ediaeresis", 0x0cb}, { "Igrave", 0x0cc}, { "Iacute", 0x0cd}, { "Icircumflex", 0x0ce}, { "Idiaeresis", 0x0cf}, { "ETH", 0x0d0}, { "Eth", 0x0d0}, { "Ntilde", 0x0d1}, { "Ograve", 0x0d2}, { "Oacute", 0x0d3}, { "Ocircumflex", 0x0d4}, { "Otilde", 0x0d5}, { "Odiaeresis", 0x0d6}, { "multiply", 0x0d7}, { "Ooblique", 0x0d8}, { "Oslash", 0x0d8}, { "Ugrave", 0x0d9}, { "Uacute", 0x0da}, { "Ucircumflex", 0x0db}, { "Udiaeresis", 0x0dc}, { "Yacute", 0x0dd}, { "THORN", 0x0de}, { "Thorn", 0x0de}, { "ssharp", 0x0df}, { "agrave", 0x0e0}, { "aacute", 0x0e1}, { "acircumflex", 0x0e2}, { "atilde", 0x0e3}, { "adiaeresis", 0x0e4}, { "aring", 0x0e5}, { "ae", 0x0e6}, { "ccedilla", 0x0e7}, { "egrave", 0x0e8}, { "eacute", 0x0e9}, { "ecircumflex", 0x0ea}, { "ediaeresis", 0x0eb}, { "igrave", 0x0ec}, { "iacute", 0x0ed}, { "icircumflex", 0x0ee}, { "idiaeresis", 0x0ef}, { "eth", 0x0f0}, { "ntilde", 0x0f1}, { "ograve", 0x0f2}, { "oacute", 0x0f3}, { "ocircumflex", 0x0f4}, { "otilde", 0x0f5}, { "odiaeresis", 0x0f6}, { "division", 0x0f7}, { "oslash", 0x0f8}, { "ooblique", 0x0f8}, { "ugrave", 0x0f9}, { "uacute", 0x0fa}, { "ucircumflex", 0x0fb}, { "udiaeresis", 0x0fc}, { "yacute", 0x0fd}, { "thorn", 0x0fe}, { "ydiaeresis", 0x0ff}, {"EuroSign", GDK_EuroSign}, /* modifiers */ {"Control_L", GDK_Control_L}, {"Control_R", GDK_Control_R}, {"Alt_L", GDK_Alt_L}, {"Alt_R", GDK_Alt_R}, {"Caps_Lock", GDK_Caps_Lock}, {"Meta_L", GDK_Meta_L}, {"Meta_R", GDK_Meta_R}, {"Shift_L", GDK_Shift_L}, {"Shift_R", GDK_Shift_R}, {"Super_L", GDK_Super_L}, {"Super_R", GDK_Super_R}, /* special keys */ {"BackSpace", GDK_BackSpace}, {"Tab", GDK_Tab}, {"Return", GDK_Return}, {"Right", GDK_Right}, {"Left", GDK_Left}, {"Up", GDK_Up}, {"Down", GDK_Down}, {"Page_Down", GDK_Page_Down}, {"Page_Up", GDK_Page_Up}, {"Insert", GDK_Insert}, {"Delete", GDK_Delete}, {"Home", GDK_Home}, {"End", GDK_End}, {"Scroll_Lock", GDK_Scroll_Lock}, {"F1", GDK_F1}, {"F2", GDK_F2}, {"F3", GDK_F3}, {"F4", GDK_F4}, {"F5", GDK_F5}, {"F6", GDK_F6}, {"F7", GDK_F7}, {"F8", GDK_F8}, {"F9", GDK_F9}, {"F10", GDK_F10}, {"F11", GDK_F11}, {"F12", GDK_F12}, {"F13", GDK_F13}, {"F14", GDK_F14}, {"F15", GDK_F15}, {"Sys_Req", GDK_Sys_Req}, {"KP_0", GDK_KP_0}, {"KP_1", GDK_KP_1}, {"KP_2", GDK_KP_2}, {"KP_3", GDK_KP_3}, {"KP_4", GDK_KP_4}, {"KP_5", GDK_KP_5}, {"KP_6", GDK_KP_6}, {"KP_7", GDK_KP_7}, {"KP_8", GDK_KP_8}, {"KP_9", GDK_KP_9}, {"KP_Add", GDK_KP_Add}, {"KP_Decimal", GDK_KP_Decimal}, {"KP_Divide", GDK_KP_Divide}, {"KP_Enter", GDK_KP_Enter}, {"KP_Equal", GDK_KP_Equal}, {"KP_Multiply", GDK_KP_Multiply}, {"KP_Subtract", GDK_KP_Subtract}, {"help", GDK_Help}, {"Menu", GDK_Menu}, {"Power", GDK_VoidSymbol}, {"Print", GDK_Print}, {"Mode_switch", GDK_Mode_switch}, {"Multi_Key", GDK_Multi_key}, {"Num_Lock", GDK_Num_Lock}, {"Pause", GDK_Pause}, {"Escape", GDK_Escape}, {0,0}, }; [-- Attachment #4: fullscreen.h --] [-- Type: text/plain, Size: 163 bytes --] /* fullscreen defines */ int fullscreen_init(void); int fullscreen_switch(int x, int y, int w, int h); int fullscreen_reset(void); void fullscreen_cleanup(void); [-- Attachment #5: null_fs.c --] [-- Type: text/plain, Size: 326 bytes --] /* dummy functions - return successful but dont actually change the mode */ /* use this with Win32 GTK until someone writes a win32_fs.c */ int fullscreen_init(void) { return 1; } int fullscreen_switch(int x, int y, int w, int h) { return 1; } int fullscreen_reset(void) { return 1; } void fullscreen_cleanup(void) { } [-- Attachment #6: xvid_fs.c --] [-- Type: text/plain, Size: 2298 bytes --] /* Use X11 Xvid extension to implement fullscreen mode */ #include <stdlib.h> #include <X11/Xlib.h> #include <X11/Xutil.h> #include <X11/keysym.h> #include <X11/extensions/xf86dga.h> #include <X11/extensions/xf86vmode.h> static Display *dpy; static XF86VidModeModeInfo **mode_list; static XF86VidModeModeInfo * modeinfo; static int count; int fullscreen_init(void) { int event, error, dotclock; XF86VidModeModeLine * modeline; /* load up X display and make sure we have the Xvid extention */ dpy = XOpenDisplay(""); /* FIXME: make this the one that Gtk uses */ if (dpy == NULL) return 0; if (!XF86VidModeQueryExtension(dpy, &event, &error)) return 0; /* get list of all modes */ XF86VidModeGetAllModeLines(dpy, XDefaultScreen(dpy), &count, &mode_list); /* get current modeline */ modeline = (XF86VidModeModeLine *)malloc(sizeof(XF86VidModeModeLine)); XF86VidModeGetModeLine(dpy, XDefaultScreen(dpy), &dotclock, modeline); /* convert to ModeInfo structure */ modeinfo = (XF86VidModeModeInfo *)malloc(sizeof(XF86VidModeModeInfo)); modeinfo->dotclock = dotclock; modeinfo->hdisplay = modeline->hdisplay; modeinfo->hsyncstart = modeline->hsyncstart; modeinfo->hsyncend = modeline->hsyncend; modeinfo->htotal = modeline->htotal; modeinfo->vdisplay = modeline->vdisplay; modeinfo->vsyncstart = modeline->vsyncstart; modeinfo->vsyncend = modeline->vsyncend; modeinfo->vtotal = modeline->vtotal; modeinfo->flags = modeline->flags; modeinfo->privsize = modeline->privsize; modeinfo->private = modeline->private; free(modeline); return 1; } int fullscreen_switch(int x, int y, int w, int h) { int i; for (i = 0; i < count; i++) { if (w == mode_list[i]->hdisplay) if (h == mode_list[i]->vdisplay) { XF86VidModeSwitchToMode(dpy, XDefaultScreen(dpy), mode_list[i]); XF86VidModeSetViewPort(dpy, XDefaultScreen(dpy), x, y); XFlush(dpy); return 1; } } return 0; } int fullscreen_reset(void) { XF86VidModeSwitchToMode(dpy, XDefaultScreen(dpy), modeinfo); XFlush(dpy); return 1; } void fullscreen_cleanup(void) { int i; if (modeinfo->privsize != 0) free(modeinfo->private); free(modeinfo); for (i = 0; i < count; i++) { if (mode_list[i]->privsize != 0) free(mode_list[i]->private); free(mode_list[i]); } free(mode_list); } [-- Attachment #7: qemu-gtk-patch.diff --] [-- Type: text/plain, Size: 6253 bytes --] diff -u qemu.orig/Makefile.target qemu/Makefile.target --- qemu.orig/Makefile.target Mon May 30 19:42:28 2005 +++ qemu/Makefile.target Mon May 30 19:57:26 2005 @@ -357,6 +357,10 @@ ifdef CONFIG_SDL VL_OBJS+=sdl.o endif +ifdef CONFIG_GTK +VL_OBJS+=gtk2.o +VL_OBJS+=fullscreen.o +endif ifdef CONFIG_COCOA VL_OBJS+=cocoa.o COCOA_LIBS=-F/System/Library/Frameworks -framework Cocoa @@ -392,13 +396,19 @@ endif $(QEMU_SYSTEM): $(VL_OBJS) libqemu.a - $(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(COCOA_LIBS) $(VL_LIBS) + $(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(COCOA_LIBS) $(GTK_LIBS) $(FS_LIBS) $(VL_LIBS) cocoa.o: cocoa.m $(CC) $(CFLAGS) $(DEFINES) -c -o $@ $< sdl.o: sdl.c keymaps.c sdl_keysym.h $(CC) $(CFLAGS) $(DEFINES) $(SDL_CFLAGS) -c -o $@ $< + +gtk2.o: gtk2.c keymaps.c gdk_keysym.h fullscreen.h + $(CC) $(CFLAGS) $(DEFINES) $(GTK_CFLAGS) -c -o $@ $< + +fullscreen.o: $(FSDRV) fullscreen.h + $(CC) $(CFLAGS) $(DEFINES) -c -o $@ $< sdlaudio.o: sdlaudio.c $(CC) $(CFLAGS) $(DEFINES) $(SDL_CFLAGS) -c -o $@ $< diff -u qemu.orig/configure qemu/configure --- qemu.orig/configure Mon May 30 19:40:14 2005 +++ qemu/configure Mon May 30 20:10:11 2005 @@ -15,6 +15,7 @@ TMPO="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.o" TMPE="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}" TMPS="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.S" +TMPF="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}-conf" # default parameters prefix="" @@ -171,6 +172,10 @@ ;; --disable-sdl) sdl="no" ;; + --enable-gtk) gtk="yes" + ;; + --set-fs-driver=*) fsdrv=`echo $opt | cut -d '=' -f 2` + ;; --enable-fmod) fmod="yes" ;; --fmod-lib=*) fmod_lib=${opt#--fmod-lib=} @@ -311,6 +316,62 @@ fi # cross compilation fi # -z $sdl +########################################## +# GTK probe + +gtk_too_old=no + +if test -z "$gtk" ; then + +gtk=no + +# normal GTK probe +cat > $TMPC << EOF +#include <stdlib.h> +#include <gtk/gtk.h> +int main(int argc, char **argv) { gtk_init(&argc, &argv); return EXIT_SUCCESS; } +EOF + +if $cc -o $TMPE `pkg-config --cflags --libs gtk+-2.0 2> /dev/null` $TMPC 2> /dev/null ; then +_gtkversion=`pkg-config --modversion gtk+-2.0 | sed 's/[^0-9]//g'` +if test "$_sdlversion" -lt 240 ; then + gtk_too_old=yes +else + gtk=yes + +fi + +fi # gtk compile test + +fi # -z $gtk + +if [ "$gtk" = "yes" ]; then + +if [ "$fsdrv" = "" ] ; then + +if [ "$bsd" = "yes" -o "$linux" = "yes" ]; then + fsdrv=xvid_fs.c +else + fsdrv=null_fs.c +fi + +fi # fsdrv test + +if [ "$fsdrv" = "xvid_fs.c" -o "$fsdrv" = "null_fs.c" ]; then + echo "fsdrv=$fsdrv" >> $TMPF +else + echo "Warning: unknown gtk fullscreen driver: $fsdrv - using null driver" + echo 'fsdrv=null_fs.c' >> $TMPF + fsdrv=null_fs.c +fi + +if [ "$fsdrv" = "xvid_fs.c" ]; then + FS_LIBS="-lX11 -lXxf86vm -lXext -L/usr/X11R6/lib" + echo 'FS_LIBS="-lX11 -lXxf86vm -lXext -L/usr/X11R6/lib"' >> $TMPF +fi + +fi # gtk=yes test + if test x"$1" = x"-h" -o x"$1" = x"--help" ; then cat << EOF @@ -434,6 +495,8 @@ if test "$sdl" != "no" ; then echo "SDL static link $sdl_static" fi +echo "GTK support $gtk" +echo "GTK FS driver $fsdrv" echo "mingw32 support $mingw32" echo "Adlib support $adlib" echo -n "FMOD support $fmod" @@ -643,6 +706,8 @@ interp_prefix1=`echo "$interp_prefix" | sed "s/%M/$target_cpu/g"` echo "#define CONFIG_QEMU_PREFIX \"$interp_prefix1\"" >> $config_h +. $TMPF + if test "$target_cpu" = "i386" ; then echo "TARGET_ARCH=i386" >> $config_mak echo "#define TARGET_ARCH \"i386\"" >> $config_h @@ -720,6 +785,17 @@ fi fi +if test "$gtk" = "yes" ; then + . $TMPF + echo "#define CONFIG_GTK 1" >> $config_h + echo "CONFIG_GTK=yes" >> $config_mak + echo "GTK_LIBS=`pkg-config --libs gtk+-2.0`" >> $config_mak + echo "GTK_CFLAGS=`pkg-config --cflags gtk+-2.0`" >> $config_mak + echo "FSDRV=$fsdrv" >> $config_mak + echo "FS_LIBS=$FS_LIBS" >> $config_mak + echo "" >> $config_mak +fi + if test "$cocoa" = "yes" ; then echo "#define CONFIG_COCOA 1" >> $config_h echo "CONFIG_COCOA=yes" >> $config_mak @@ -739,4 +815,4 @@ done fi -rm -f $TMPO $TMPC $TMPE $TMPS +rm -f $TMPO $TMPC $TMPE $TMPS $TMPF diff -u qemu.orig/vl.c qemu/vl.c --- qemu.orig/vl.c Mon May 30 19:40:44 2005 +++ qemu/vl.c Sat May 28 16:17:30 2005 @@ -149,6 +149,7 @@ TextConsole *vga_console; CharDriverState *serial_hds[MAX_SERIAL_PORTS]; CharDriverState *parallel_hds[MAX_PARALLEL_PORTS]; +int use_gtk = 0; #ifdef TARGET_I386 int win2k_install_hack = 0; #endif @@ -2881,6 +2882,7 @@ QEMU_OPTION_std_vga, QEMU_OPTION_no_sdl_grab, QEMU_OPTION_funny_hack, + QEMU_OPTION_use_gtk, QEMU_OPTION_monitor, QEMU_OPTION_serial, QEMU_OPTION_parallel, @@ -2953,6 +2955,7 @@ { "std-vga", 0, QEMU_OPTION_std_vga }, { "no-sdl-grab", 0, QEMU_OPTION_no_sdl_grab }, { "funny_hack", 0, QEMU_OPTION_funny_hack }, + { "use-gtk", 0, QEMU_OPTION_use_gtk }, { "monitor", 1, QEMU_OPTION_monitor }, { "serial", 1, QEMU_OPTION_serial }, { "parallel", 1, QEMU_OPTION_parallel }, @@ -3357,6 +3360,9 @@ case QEMU_OPTION_funny_hack: funny_hack = 1; break; + case QEMU_OPTION_use_gtk: + use_gtk = 1; + break; case QEMU_OPTION_g: { const char *p; @@ -3611,7 +3617,17 @@ if (nographic) { dumb_display_init(ds); } else { +#if defined(CONFIG_GTK) #if defined(CONFIG_SDL) + /* so we can choose */ + if (use_gtk) + gtk2_display_init(ds, full_screen); + else + sdl_display_init(ds, full_screen); +#else + gtk2_display_init(ds, full_screen); +#endif +#elif defined(CONFIG_SDL) sdl_display_init(ds, full_screen); #elif defined(CONFIG_COCOA) cocoa_display_init(ds, full_screen); diff -u qemu.orig/vl.h qemu/vl.h --- qemu.orig/vl.h Mon May 30 19:40:14 2005 +++ qemu/vl.h Sat May 28 16:16:18 2005 @@ -579,6 +579,9 @@ /* sdl.c */ void sdl_display_init(DisplayState *ds, int full_screen); +/* gtk2.c */ +void gtk2_display_init(DisplayState *ds, int full_screen); + /* cocoa.m */ void cocoa_display_init(DisplayState *ds, int full_screen); ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] gtk2 driver 2005-05-31 0:24 ` Jim C. Brown @ 2005-05-31 14:15 ` Sylvain Petreolle 2005-05-31 18:54 ` Jim C. Brown 2005-05-31 19:45 ` Jim C. Brown 1 sibling, 1 reply; 12+ messages in thread From: Sylvain Petreolle @ 2005-05-31 14:15 UTC (permalink / raw) To: qemu-devel --- "Jim C. Brown" <jma5@umd.edu> a écrit : > Here is the new driver. Patch is against a clean qemu directory. Once you > apply the patch, dump the attached files into the qemu root directory and > run configure with '--enable-gtk' option. The '--set-fs-driver=' option > exists but there should be no need to use it. > Hunks #2 and #3 of vl.c fail to apply to a new tree checked today, could you post an updated patch ? Kind regards, Usurp (aka Sylvain Petreolle) humans are like computers, yesterday the BIOS was all - today its just a word ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] gtk2 driver 2005-05-31 14:15 ` Sylvain Petreolle @ 2005-05-31 18:54 ` Jim C. Brown 0 siblings, 0 replies; 12+ messages in thread From: Jim C. Brown @ 2005-05-31 18:54 UTC (permalink / raw) To: spetreolle, qemu-devel [-- Attachment #1: Type: text/plain, Size: 1094 bytes --] On Tue, May 31, 2005 at 04:15:34PM +0200, Sylvain Petreolle wrote: > --- "Jim C. Brown" <jma5@umd.edu> a ?crit : > > > Here is the new driver. Patch is against a clean qemu directory. Once you > > apply the patch, dump the attached files into the qemu root directory and > > run configure with '--enable-gtk' option. The '--set-fs-driver=' option > > exists but there should be no need to use it. > > > Hunks #2 and #3 of vl.c fail to apply to a new tree checked today, > could you post an updated patch ? Attached is a patch that omits the vl.c hunks and a vl.c.diff patch that should work. The problem was that I have the no-sdl-grab patch applied to my vl.c while a clean tree doesn't. > > Kind regards, > > Usurp (aka Sylvain Petreolle) > > humans are like computers, > yesterday the BIOS was all > - today its just a word > > > _______________________________________________ > Qemu-devel mailing list > Qemu-devel@nongnu.org > http://lists.nongnu.org/mailman/listinfo/qemu-devel > -- Infinite complexity begets infinite beauty. Infinite precision begets infinite perfection. [-- Attachment #2: qemu-gtk-patch.diff --] [-- Type: text/plain, Size: 4575 bytes --] diff -u qemu.orig/Makefile.target qemu/Makefile.target --- qemu.orig/Makefile.target Mon May 30 19:42:28 2005 +++ qemu/Makefile.target Mon May 30 19:57:26 2005 @@ -357,6 +357,10 @@ ifdef CONFIG_SDL VL_OBJS+=sdl.o endif +ifdef CONFIG_GTK +VL_OBJS+=gtk2.o +VL_OBJS+=fullscreen.o +endif ifdef CONFIG_COCOA VL_OBJS+=cocoa.o COCOA_LIBS=-F/System/Library/Frameworks -framework Cocoa @@ -392,13 +396,19 @@ endif $(QEMU_SYSTEM): $(VL_OBJS) libqemu.a - $(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(COCOA_LIBS) $(VL_LIBS) + $(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(COCOA_LIBS) $(GTK_LIBS) $(FS_LIBS) $(VL_LIBS) cocoa.o: cocoa.m $(CC) $(CFLAGS) $(DEFINES) -c -o $@ $< sdl.o: sdl.c keymaps.c sdl_keysym.h $(CC) $(CFLAGS) $(DEFINES) $(SDL_CFLAGS) -c -o $@ $< + +gtk2.o: gtk2.c keymaps.c gdk_keysym.h fullscreen.h + $(CC) $(CFLAGS) $(DEFINES) $(GTK_CFLAGS) -c -o $@ $< + +fullscreen.o: $(FSDRV) fullscreen.h + $(CC) $(CFLAGS) $(DEFINES) -c -o $@ $< sdlaudio.o: sdlaudio.c $(CC) $(CFLAGS) $(DEFINES) $(SDL_CFLAGS) -c -o $@ $< diff -u qemu.orig/configure qemu/configure --- qemu.orig/configure Mon May 30 19:40:14 2005 +++ qemu/configure Mon May 30 20:10:11 2005 @@ -15,6 +15,7 @@ TMPO="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.o" TMPE="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}" TMPS="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.S" +TMPF="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}-conf" # default parameters prefix="" @@ -171,6 +172,10 @@ ;; --disable-sdl) sdl="no" ;; + --enable-gtk) gtk="yes" + ;; + --set-fs-driver=*) fsdrv=`echo $opt | cut -d '=' -f 2` + ;; --enable-fmod) fmod="yes" ;; --fmod-lib=*) fmod_lib=${opt#--fmod-lib=} @@ -311,6 +316,62 @@ fi # cross compilation fi # -z $sdl +########################################## +# GTK probe + +gtk_too_old=no + +if test -z "$gtk" ; then + +gtk=no + +# normal GTK probe +cat > $TMPC << EOF +#include <stdlib.h> +#include <gtk/gtk.h> +int main(int argc, char **argv) { gtk_init(&argc, &argv); return EXIT_SUCCESS; } +EOF + +if $cc -o $TMPE `pkg-config --cflags --libs gtk+-2.0 2> /dev/null` $TMPC 2> /dev/null ; then +_gtkversion=`pkg-config --modversion gtk+-2.0 | sed 's/[^0-9]//g'` +if test "$_sdlversion" -lt 240 ; then + gtk_too_old=yes +else + gtk=yes + +fi + +fi # gtk compile test + +fi # -z $gtk + +if [ "$gtk" = "yes" ]; then + +if [ "$fsdrv" = "" ] ; then + +if [ "$bsd" = "yes" -o "$linux" = "yes" ]; then + fsdrv=xvid_fs.c +else + fsdrv=null_fs.c +fi + +fi # fsdrv test + +if [ "$fsdrv" = "xvid_fs.c" -o "$fsdrv" = "null_fs.c" ]; then + echo "fsdrv=$fsdrv" >> $TMPF +else + echo "Warning: unknown gtk fullscreen driver: $fsdrv - using null driver" + echo 'fsdrv=null_fs.c' >> $TMPF + fsdrv=null_fs.c +fi + +if [ "$fsdrv" = "xvid_fs.c" ]; then + FS_LIBS="-lX11 -lXxf86vm -lXext -L/usr/X11R6/lib" + echo 'FS_LIBS="-lX11 -lXxf86vm -lXext -L/usr/X11R6/lib"' >> $TMPF +fi + +fi # gtk=yes test + if test x"$1" = x"-h" -o x"$1" = x"--help" ; then cat << EOF @@ -434,6 +495,8 @@ if test "$sdl" != "no" ; then echo "SDL static link $sdl_static" fi +echo "GTK support $gtk" +echo "GTK FS driver $fsdrv" echo "mingw32 support $mingw32" echo "Adlib support $adlib" echo -n "FMOD support $fmod" @@ -643,6 +706,8 @@ interp_prefix1=`echo "$interp_prefix" | sed "s/%M/$target_cpu/g"` echo "#define CONFIG_QEMU_PREFIX \"$interp_prefix1\"" >> $config_h +. $TMPF + if test "$target_cpu" = "i386" ; then echo "TARGET_ARCH=i386" >> $config_mak echo "#define TARGET_ARCH \"i386\"" >> $config_h @@ -720,6 +785,17 @@ fi fi +if test "$gtk" = "yes" ; then + . $TMPF + echo "#define CONFIG_GTK 1" >> $config_h + echo "CONFIG_GTK=yes" >> $config_mak + echo "GTK_LIBS=`pkg-config --libs gtk+-2.0`" >> $config_mak + echo "GTK_CFLAGS=`pkg-config --cflags gtk+-2.0`" >> $config_mak + echo "FSDRV=$fsdrv" >> $config_mak + echo "FS_LIBS=$FS_LIBS" >> $config_mak + echo "" >> $config_mak +fi + if test "$cocoa" = "yes" ; then echo "#define CONFIG_COCOA 1" >> $config_h echo "CONFIG_COCOA=yes" >> $config_mak @@ -739,4 +815,4 @@ done fi -rm -f $TMPO $TMPC $TMPE $TMPS +rm -f $TMPO $TMPC $TMPE $TMPS $TMPF diff -u qemu.orig/vl.h qemu/vl.h --- qemu.orig/vl.h Mon May 30 19:40:14 2005 +++ qemu/vl.h Sat May 28 16:16:18 2005 @@ -579,6 +579,9 @@ /* sdl.c */ void sdl_display_init(DisplayState *ds, int full_screen); +/* gtk2.c */ +void gtk2_display_init(DisplayState *ds, int full_screen); + /* cocoa.m */ void cocoa_display_init(DisplayState *ds, int full_screen); [-- Attachment #3: vl.c.diff --] [-- Type: text/plain, Size: 1611 bytes --] --- vl.c.orig Tue May 31 14:53:22 2005 +++ vl.c Tue May 31 14:52:55 2005 @@ -147,6 +147,7 @@ TextConsole *vga_console; CharDriverState *serial_hds[MAX_SERIAL_PORTS]; CharDriverState *parallel_hds[MAX_PARALLEL_PORTS]; +int use_gtk = 0; #ifdef TARGET_I386 int win2k_install_hack = 0; #endif @@ -2877,6 +2878,7 @@ QEMU_OPTION_cirrusvga, QEMU_OPTION_g, QEMU_OPTION_std_vga, + QEMU_OPTION_use_gtk, QEMU_OPTION_monitor, QEMU_OPTION_serial, QEMU_OPTION_parallel, @@ -2947,6 +2949,7 @@ { "localtime", 0, QEMU_OPTION_localtime }, { "isa", 0, QEMU_OPTION_isa }, { "std-vga", 0, QEMU_OPTION_std_vga }, + { "use-gtk", 0, QEMU_OPTION_use_gtk }, { "monitor", 1, QEMU_OPTION_monitor }, { "serial", 1, QEMU_OPTION_serial }, { "parallel", 1, QEMU_OPTION_parallel }, @@ -3345,6 +3348,9 @@ case QEMU_OPTION_std_vga: cirrus_vga_enabled = 0; break; + case QEMU_OPTION_use_gtk: + use_gtk = 1; + break; case QEMU_OPTION_g: { const char *p; @@ -3599,7 +3605,17 @@ if (nographic) { dumb_display_init(ds); } else { +#if defined(CONFIG_GTK) #if defined(CONFIG_SDL) + /* so we can choose */ + if (use_gtk) + gtk2_display_init(ds, full_screen); + else + sdl_display_init(ds, full_screen); +#else + gtk2_display_init(ds, full_screen); +#endif +#elif defined(CONFIG_SDL) sdl_display_init(ds, full_screen); #elif defined(CONFIG_COCOA) cocoa_display_init(ds, full_screen); ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] gtk2 driver 2005-05-31 0:24 ` Jim C. Brown 2005-05-31 14:15 ` Sylvain Petreolle @ 2005-05-31 19:45 ` Jim C. Brown 2005-05-31 20:28 ` Jim C. Brown 1 sibling, 1 reply; 12+ messages in thread From: Jim C. Brown @ 2005-05-31 19:45 UTC (permalink / raw) To: qemu-devel [-- Attachment #1: Type: text/plain, Size: 941 bytes --] On Mon, May 30, 2005 at 08:24:09PM -0400, Jim C. Brown wrote: > Here is the new driver. Patch is against a clean qemu directory. Once you > apply the patch, dump the attached files into the qemu root directory and > run configure with '--enable-gtk' option. The '--set-fs-driver=' option > exists but there should be no need to use it. > > -- > Infinite complexity begets infinite beauty. > Infinite precision begets infinite perfection. Here is an updated version that partically fixes problems with moving the mouse when in fullscreen mode (sometimes you can move the mouse anyways and screw up alignment in spite of this). New gtk2.c attached. Also gdk_window_set_pointer.c attached. This works for Linux/X11, Windows code should be ok but it is untested. (This is to overcome a deliberate oversight in the GDK library, which does not provide a way to set the location of the mouse pointer. GTK-fb will require an even uglier hack.) [-- Attachment #2: gtk2.c --] [-- Type: text/plain, Size: 21500 bytes --] /* * QEMU GTK2 display driver * based on SDL driver by Fabrice * * Copyright (c) 2005 Jim Brown * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include "vl.h" #include <gtk/gtk.h> #include <gdk/gdk.h> #include "fullscreen.h" /* define our own bitshift enums to allow qemugtk to know difference between left and right alt - something gtk doesnt provide in its modifiers mask. this uses qemu's own modifier_state[] map in order to guess correctly */ typedef enum { gtkshiftleft = 1 << 0, gtkshiftright = 1 << 1, gtkcontrolleft = 1 << 2, gtkcontrolright = 1 << 3, gtkaltleft = 1 << 4, gtkaltright = 1 << 5, gtkcapslock = 1 << 6 } gtk2keymod; static GtkWidget *screen; static GdkImage *image=NULL; static GdkCursor *invisible_cursor; static int ox = 0, oy = 0; static int gui_grab; /* if true, all keyboard/mouse events are grabbed */ static int last_vm_running; static int gui_saved_grab; static int gui_fullscreen; static int gui_key_modifier_pressed; static int gui_keysym; static int gui_fullscreen_initial_grab; static int gui_grab_code = gtkaltleft | gtkcontrolleft; static uint8_t modifiers_state[256]; static unsigned int cw, ch; static gint cx, cy; static gboolean gtk2_expose(GtkWidget *wid, GdkEventExpose *event) { gdk_draw_image(wid->window, wid->style->fg_gc[GTK_WIDGET_STATE(wid)], image, event->area.x, event->area.y, event->area.x, event->area.y, event->area.width, event->area.height); return TRUE; } static void gtk2_update(DisplayState *ds, int x, int y, int w, int h) { // printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h); GdkEventExpose ev; ev.area.x = x; ev.area.y = y; ev.area.width = w; ev.area.height = h; gtk2_expose(screen, &ev); } static void gtk2_resize(DisplayState *ds, int w, int h) { // printf(" resizing to %d %d\n", w, h); if (gui_fullscreen) { if (cw != w || ch != h) fullscreen_switch(cx, cy, w, h); /* changing video modes */ //gtk_window_fullscreen(GTK_WINDOW(screen)); } else { //gtk_window_unfullscreen(GTK_WINDOW(screen)); } cw = w; ch = h; if (image) g_object_unref(image); /* gdk_visual_get_best_with_depth() ??? but then how to paint onto window? */ image = gdk_image_new(GDK_IMAGE_NORMAL, gdk_visual_get_system(), w, h); gdk_image_set_colormap(image, gdk_colormap_get_system()); gtk_window_set_default_size(GTK_WINDOW(screen), w, h); gtk_widget_set_size_request(screen, w, h); gtk_window_resize(GTK_WINDOW(screen), w, h); ds->data = image->mem; ds->linesize = image->bpl; ds->depth = image->bits_per_pixel; ds->width = w; ds->height = h; gtk2_update(ds, 0, 0, w, h); } /* generic keyboard conversion */ #include "gdk_keysym.h" #include "keymaps.c" static kbd_layout_t *kbd_layout = NULL; static uint8_t gtk2_keyevent_to_keycode_generic(const GdkEventKey *ev) { int keysym; /* workaround for X11+SDL bug with AltGR - is it still needed for Gtk2? */ keysym = ev->keyval; if (keysym == 0 && ev->hardware_keycode == 113) keysym = GDK_Mode_switch; return keysym2scancode(kbd_layout, keysym); } /* specific keyboard conversions from scan codes */ #if defined(_WIN32) static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev) { return ev->hardware_keycode; /* does this work on win32 gtk? */ } #else static const uint8_t x_keycode_to_pc_keycode[61] = { 0xc7, /* 97 Home */ 0xc8, /* 98 Up */ 0xc9, /* 99 PgUp */ 0xcb, /* 100 Left */ 0x4c, /* 101 KP-5 */ 0xcd, /* 102 Right */ 0xcf, /* 103 End */ 0xd0, /* 104 Down */ 0xd1, /* 105 PgDn */ 0xd2, /* 106 Ins */ 0xd3, /* 107 Del */ 0x9c, /* 108 Enter */ 0x9d, /* 109 Ctrl-R */ 0x0, /* 110 Pause */ 0xb7, /* 111 Print */ 0xb5, /* 112 Divide */ 0xb8, /* 113 Alt-R */ 0xc6, /* 114 Break */ 0x0, /* 115 */ 0x0, /* 116 */ 0x0, /* 117 */ 0x0, /* 118 */ 0x0, /* 119 */ 0x70, /* 120 Hiragana_Katakana */ 0x0, /* 121 */ 0x0, /* 122 */ 0x73, /* 123 backslash */ 0x0, /* 124 */ 0x0, /* 125 */ 0x0, /* 126 */ 0x0, /* 127 */ 0x0, /* 128 */ 0x79, /* 129 Henkan */ 0x0, /* 130 */ 0x7b, /* 131 Muhenkan */ 0x0, /* 132 */ 0x7d, /* 133 Yen */ 0x0, /* 134 */ 0x0, /* 135 */ 0x47, /* 136 KP_7 */ 0x48, /* 137 KP_8 */ 0x49, /* 138 KP_9 */ 0x4b, /* 139 KP_4 */ 0x4c, /* 140 KP_5 */ 0x4d, /* 141 KP_6 */ 0x4f, /* 142 KP_1 */ 0x50, /* 143 KP_2 */ 0x51, /* 144 KP_3 */ 0x52, /* 145 KP_0 */ 0x53, /* 146 KP_. */ 0x47, /* 147 KP_HOME */ 0x48, /* 148 KP_UP */ 0x49, /* 149 KP_PgUp */ 0x4b, /* 150 KP_Left */ 0x4c, /* 151 KP_ */ 0x4d, /* 152 KP_Right */ 0x4f, /* 153 KP_End */ 0x50, /* 154 KP_Down */ 0x51, /* 155 KP_PgDn */ 0x52, /* 156 KP_Ins */ 0x53, /* 157 KP_Del */ }; static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev) { int keycode; keycode = ev->hardware_keycode; if (keycode < 9) { keycode = 0; } else if (keycode < 97) { keycode -= 8; /* just an offset */ } else if (keycode < 158) { /* use conversion table */ keycode = x_keycode_to_pc_keycode[keycode - 97]; } else { keycode = 0; } return keycode; } #endif static void reset_keys(void) { int i; for(i = 0; i < 256; i++) { if (modifiers_state[i]) { if (i & 0x80) kbd_put_keycode(0xe0); kbd_put_keycode(i | 0x80); modifiers_state[i] = 0; } } } /* convert GDK modifiers and invoke ugly hack to distinguish between left and right shift/control/alt */ static guint gtk2_GetModState(const GdkEventKey *ev) { guint key = 0, keyval = ev->keyval, state = ev->state; switch(keyval) { case GDK_Shift_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkshiftleft; keyval = 1; break; case GDK_Shift_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkshiftright; keyval = 1; break; case GDK_Control_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkcontrolleft; keyval = 2; break; case GDK_Control_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkcontrolright; keyval = 2; break; case GDK_Alt_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkaltleft; keyval = 3; break; case GDK_Alt_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkaltright; keyval = 3; break; case GDK_Caps_Lock: if (ev->type != GDK_KEY_RELEASE) key |= gtkcapslock; keyval = 4; break; default: keyval = 0; break; } if (keyval != 1 && (state & GDK_SHIFT_MASK)) { if (modifiers_state[0x2a]) key |= gtkshiftleft; if (modifiers_state[0x36]) key |= gtkshiftright; } if (keyval != 2 && (state & GDK_CONTROL_MASK)) { if (modifiers_state[0x1d]) key |= gtkcontrolleft; if (modifiers_state[0x9d]) key |= gtkcontrolright; } if (keyval != 3 && (state & GDK_MOD1_MASK)) /* fixme: need to do a check to make sure that alt is mapped to GDK_MOD1_MASK in the GDK_Keymap */ { if (modifiers_state[0x38]) key |= gtkaltleft; if (modifiers_state[0xb8]) key |= gtkaltright; } if (keyval != 4 && (state & GDK_LOCK_MASK)) key |= gtkcapslock; return key; } static void gtk2_process_key(GdkEventKey *ev) { int keycode, v; if (ev->keyval == GDK_Pause) { /* specific case */ v = 0; if (ev->type == GDK_KEY_RELEASE) v |= 0x80; kbd_put_keycode(0xe1); kbd_put_keycode(0x1d | v); kbd_put_keycode(0x45 | v); return; } if (kbd_layout) { keycode = gtk2_keyevent_to_keycode_generic(ev); } else { keycode = gtk2_keyevent_to_keycode(ev); } switch(keycode) { case 0x00: /* sent when leaving window: reset the modifiers state */ reset_keys(); return; case 0x2a: /* Left Shift */ case 0x36: /* Right Shift */ case 0x1d: /* Left CTRL */ case 0x9d: /* Right CTRL */ case 0x38: /* Left ALT */ case 0xb8: /* Right ALT */ if (ev->type == GDK_KEY_RELEASE) modifiers_state[keycode] = 0; else modifiers_state[keycode] = 1; break; case 0x45: /* num lock */ case 0x3a: /* caps lock */ /* GTK does send the key up event, so we dont generate it */ /*kbd_put_keycode(keycode); kbd_put_keycode(keycode | 0x80); return;*/ break; } /* now send the key code */ if (keycode & 0x80) kbd_put_keycode(0xe0); if (ev->type == GDK_KEY_RELEASE) kbd_put_keycode(keycode | 0x80); else kbd_put_keycode(keycode & 0x7f); } static void gtk2_update_caption(void) { char buf[1024]; strcpy(buf, "QEMU"); if (!vm_running) { strcat(buf, " [Stopped]"); } if (gui_grab) { strcat(buf, " - Press Ctrl-Alt to exit grab"); } gtk_window_set_title(GTK_WINDOW(screen), buf); } /* what a nasty hack. this should be a part of the GDK, not external!!! */ #include "gdk_set_window_pointer.c" static gboolean gtk2_wrap_pointer(GtkWidget *wid, GdkEventCrossing *ev) { gdouble x = ev->x, y = ev->y; if (gui_grab) { /* wrap the x,y coordinates back onto the window */ if (ev->x <= 0.0) x = (double)(cw-1); if (ev->y <= 0.0) y = (double)(ch-1); if (ev->x >= (double)cw) x = 1.0; if (ev->y >= (double)ch) y = 1.0; gdk_window_set_pointer(screen->window, (gint)x, (gint)y); } return TRUE; } static void gtk2_grab_start(void) { gint y; guint events; GdkModifierType state; /* dummy var */ events = GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK; y = gdk_pointer_grab(screen->window, TRUE, events, NULL, invisible_cursor, GDK_CURRENT_TIME); if (y) printf("GTK Warning - pointer grab failed!\n"); y = gdk_keyboard_grab(screen->window, TRUE, GDK_CURRENT_TIME); if (y) printf("GTK Warning - keyboard grab failed!\n"); /* do a dummy read to avoid moving mouse - set ox and oy to stay in sync */ gdk_window_get_pointer(screen->window, &ox, &oy, &state); gui_grab = 1; gtk2_update_caption(); } static void gtk2_grab_end(void) { gdk_pointer_ungrab(GDK_CURRENT_TIME); gdk_keyboard_ungrab(GDK_CURRENT_TIME); gui_grab = 0; gtk2_update_caption(); } static gboolean gtk2_send_mouse_scroll(GtkWidget *wid, GdkEventScroll *ev) { int x, y, dx, dy, dz, state, buttons; if (gui_grab) { x = ev->x; y = ev->y; state = ev->state; buttons = 0; dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if ((state & GDK_BUTTON1_MASK)) buttons |= MOUSE_EVENT_LBUTTON; if ((state & GDK_BUTTON3_MASK)) buttons |= MOUSE_EVENT_RBUTTON; if ((state & GDK_BUTTON2_MASK)) buttons |= MOUSE_EVENT_MBUTTON; /* test wheel - copied from Sebastien Bechet's gtk.c */ dz = 0; if ((state & GDK_BUTTON4_MASK) || ev->direction == GDK_SCROLL_UP) dz--; if ((state & GDK_BUTTON5_MASK) || ev->direction == GDK_SCROLL_DOWN) dz++; kbd_mouse_event(dx, dy, dz, buttons); } return TRUE; } static gboolean gtk2_send_mouse_button(GtkWidget *wid, GdkEventButton *ev) { int x, y, dx, dy, dz, state, buttons; if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS) return TRUE; /* double or triple click - superflurious - ignore */ if (gui_grab) { x = ev->x; y = ev->y; state = ev->state; buttons = 0; dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if ((state & GDK_BUTTON1_MASK) || ev->button == 1) buttons |= MOUSE_EVENT_LBUTTON; if ((state & GDK_BUTTON3_MASK) || ev->button == 3) buttons |= MOUSE_EVENT_RBUTTON; if ((state & GDK_BUTTON2_MASK) || ev->button == 2) buttons |= MOUSE_EVENT_MBUTTON; /* XXX: test wheel */ dz = 0; if ((state & GDK_BUTTON4_MASK) || ev->button == 4) dz--; if ((state & GDK_BUTTON5_MASK) || ev->button == 5) dz++; kbd_mouse_event(dx, dy, dz, buttons); } else { if (ev->button == 1 && ev->type == GDK_BUTTON_PRESS) { /* start grabbing all events */ gtk2_grab_start(); } } return TRUE; } static gboolean gtk2_send_mouse_move(GtkWidget *wid, GdkEventMotion *ev) { int x, y, dx, dy, dz, state, buttons; if (gui_grab) { if (ev->is_hint) { gdk_window_get_pointer(ev->window, &x, &y, (GdkModifierType*)&state); } else { x = ev->x; y = ev->y; state = ev->state; } dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if (state & GDK_BUTTON1_MASK) buttons |= MOUSE_EVENT_LBUTTON; if (state & GDK_BUTTON3_MASK) buttons |= MOUSE_EVENT_RBUTTON; if (state & GDK_BUTTON2_MASK) buttons |= MOUSE_EVENT_MBUTTON; /* XXX: test wheel */ dz = 0; if (state & GDK_BUTTON4_MASK) dz--; if (state & GDK_BUTTON5_MASK) dz++; kbd_mouse_event(dx, dy, dz, buttons); } return TRUE; } static void toggle_full_screen(DisplayState *ds) { gui_fullscreen = !gui_fullscreen; gtk2_resize(ds, image->width, image->height); if (gui_fullscreen) { gui_saved_grab = gui_grab; gtk2_grab_start(); gtk_window_get_position(GTK_WINDOW(screen), &cx, &cy); fullscreen_switch(cx, cy, ds->width, ds->height); } else { fullscreen_reset(); if (!gui_saved_grab) gtk2_grab_end(); } vga_invalidate_display(); vga_update_display(); } static gboolean gtk2_key_press(GtkWidget *wid, GdkEventKey *ev, DisplayState *ds) { int mod_state; if (ev->type == GDK_KEY_PRESS) { mod_state = (gtk2_GetModState(ev) & (int)gui_grab_code) == (int)gui_grab_code; gui_key_modifier_pressed = mod_state; if (gui_key_modifier_pressed) { int keycode; keycode = gtk2_keyevent_to_keycode(ev); switch(keycode) { case 0x21: /* 'f' key on US keyboard */ toggle_full_screen(ds); gui_keysym = 1; break; case 0x02 ... 0x0a: /* '1' to '9' keys */ console_select(keycode - 0x02); if (is_active_console(vga_console)) { /* tell the vga console to redisplay itself */ vga_invalidate_display(); } else { /* display grab if going to a text console */ if (gui_grab) gtk2_grab_end(); } gui_keysym = 1; break; default: break; } } else if (!is_active_console(vga_console)) { int keysym; keysym = 0; if (ev->state & GDK_CONTROL_MASK) { switch(ev->keyval) { case GDK_Up: keysym = QEMU_KEY_CTRL_UP; break; case GDK_Down: keysym = QEMU_KEY_CTRL_DOWN; break; case GDK_Left: keysym = QEMU_KEY_CTRL_LEFT; break; case GDK_Right: keysym = QEMU_KEY_CTRL_RIGHT; break; case GDK_Home: keysym = QEMU_KEY_CTRL_HOME; break; case GDK_End: keysym = QEMU_KEY_CTRL_END; break; case GDK_Page_Up: keysym = QEMU_KEY_CTRL_PAGEUP; break; case GDK_Page_Down: keysym = QEMU_KEY_CTRL_PAGEDOWN; break; default: break; } } else { switch(ev->keyval) { case GDK_Up: keysym = QEMU_KEY_UP; break; case GDK_Down: keysym = QEMU_KEY_DOWN; break; case GDK_Left: keysym = QEMU_KEY_LEFT; break; case GDK_Right: keysym = QEMU_KEY_RIGHT; break; case GDK_Home: keysym = QEMU_KEY_HOME; break; case GDK_End: keysym = QEMU_KEY_END; break; case GDK_Page_Up: keysym = QEMU_KEY_PAGEUP; break; case GDK_Page_Down: keysym = QEMU_KEY_PAGEDOWN; break; case GDK_BackSpace: keysym = QEMU_KEY_BACKSPACE; break; case GDK_Delete: keysym = QEMU_KEY_DELETE; break; default: break; } } if (keysym) { kbd_put_keysym(keysym); } /*else if (ev->key.keysym.unicode != 0) { kbd_put_keysym(ev->key.keysym.unicode); }*/ } } else if (ev->type == GDK_KEY_RELEASE) { mod_state = (gtk2_GetModState(ev) & gui_grab_code); if (!mod_state) { if (gui_key_modifier_pressed) { if (gui_keysym == 0) { /* exit/enter grab if pressing Ctrl-Alt */ if (!gui_grab) gtk2_grab_start(); else gtk2_grab_end(); /* SDL does not send back all the modifiers key, so we must correct it */ reset_keys(); return TRUE; } gui_key_modifier_pressed = 0; gui_keysym = 0; } } } if (is_active_console(vga_console)) gtk2_process_key(ev); return TRUE; } static void gtk2_refresh(DisplayState *ds) { if (last_vm_running != vm_running) { last_vm_running = vm_running; gtk2_update_caption(); } if (ds->data != image->mem) { ds->data = image->mem; } if (is_active_console(vga_console)) vga_update_display(); while (gtk_events_pending()) gtk_main_iteration(); } static void gtk2_cleanup(void) { gtk_main_quit(); fullscreen_cleanup(); } static gboolean gtk2_deletewin(void) { /* signal qemu that its time to shut itself off - this is the place that we hook to trap attempts to close the main qemu window */ qemu_system_shutdown_request(); return TRUE; /* dont close the window right away! give qemu time to think */ } static void gtk2_destroy(void) { /* ideally we would call a hook here so qemu could clean itself up */ gtk2_cleanup(); } void gtk2_display_init(DisplayState *ds, int full_screen) { int events; #if defined(__APPLE__) /* always use generic keymaps */ if (!keyboard_layout) keyboard_layout = "en-us"; #endif if(keyboard_layout) { kbd_layout = init_keyboard_layout(keyboard_layout); if (!kbd_layout) exit(1); } if (!gtk_init_check (0,NULL)) { fprintf(stderr, "Could not load GTK\n"); exit(0); } fullscreen_init(); /* note: adding GDK_DRAG_* and GDK_DROP_* would provide a mechanism for supporting drag and drop between host and guest */ events = GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK | GDK_SCROLL_MASK | GDK_STRUCTURE_MASK; screen = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_events(screen, events); gtk_window_set_default_size(GTK_WINDOW(screen), 720, 400); gtk_widget_set_size_request(screen, 720, 400); g_signal_connect(G_OBJECT(screen), "delete_event", G_CALLBACK(gtk2_deletewin), NULL); g_signal_connect(G_OBJECT(screen), "destroy", G_CALLBACK(gtk2_destroy), NULL); gtk_container_set_border_width(GTK_CONTAINER(screen), 10); gtk_signal_connect(GTK_OBJECT(screen), "expose_event", (GtkSignalFunc) gtk2_expose, NULL); gtk_signal_connect(GTK_OBJECT(screen), "motion_notify_event", (GtkSignalFunc) gtk2_send_mouse_move, NULL); gtk_signal_connect(GTK_OBJECT(screen), "button_press_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL); gtk_signal_connect(GTK_OBJECT(screen), "button_release_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL); gtk_signal_connect(GTK_OBJECT(screen), "scroll_event", (GtkSignalFunc) gtk2_send_mouse_scroll, NULL); gtk_signal_connect(GTK_OBJECT(screen), "key_press_event", (GtkSignalFunc) gtk2_key_press, ds); gtk_signal_connect(GTK_OBJECT(screen), "key_release_event", (GtkSignalFunc) gtk2_key_press, ds); gtk_signal_connect(GTK_OBJECT(screen), "leave_notify_event", (GtkSignalFunc) gtk2_wrap_pointer, NULL); ds->dpy_update = gtk2_update; ds->dpy_resize = gtk2_resize; ds->dpy_refresh = gtk2_refresh; gchar nullpixdata[1] = { 0 }; GdkColor nullcolor = { 0, 0, 0, 0 }; GdkPixmap *invis = gdk_bitmap_create_from_data(screen->window, nullpixdata, 1, 1); invisible_cursor = gdk_cursor_new_from_pixmap(invis, invis, &nullcolor, &nullcolor, 0, 0); gtk2_resize(ds, 720, 400); gtk2_update_caption(); gui_grab = 0; gtk_window_set_policy(GTK_WINDOW(screen), FALSE, FALSE, FALSE); gtk_widget_show(screen); if (full_screen) { gui_fullscreen = 1; gui_fullscreen_initial_grab = 1; gtk2_grab_start(); } } [-- Attachment #3: gdk_set_window_pointer.c --] [-- Type: text/plain, Size: 1262 bytes --] /* TODO: figure out how to handle linux framebuffer case - need to call the gdk-fb specific handle_mouse_movement() function in gdkmouse-fb.c ... that gets ugly fast .. */ #ifndef _WIN32 #include <gdk/gdk.h> #include <gdk/gdkx.h> #include <X11/X.h> GdkWindow* gdk_window_set_pointer (GdkWindow *window, gint x, gint y) { GdkWindow *return_val; return_val = NULL; XWarpPointer (GDK_WINDOW_XDISPLAY(window), None, GDK_WINDOW_XID(window), 0, 0, 0, 0, x, y); return return_val; } #else /* untested code based on MSDN library code... URL is : http://msdn.microsoft.com/library/default.asp?url=/library/ en-us/winui/winui/windowsuserinterface/resources/cursors/ usingcursors.asp Someone who codes on Windows want to tell me how to actually make this work?? */ #include <windows.h> GdkWindow* gdk_window_set_pointer (GdkWindow *window, gint x, gint y) { GdkWindow *return_val; POINT pt; pt.x = x; pt.y = y; ClientToScreen(GDK_WINDOW_HWND(window), &pt); SetCursorPos(pt.x, pt.y); return_val = NULL; return return_val; } #endif ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] gtk2 driver 2005-05-31 19:45 ` Jim C. Brown @ 2005-05-31 20:28 ` Jim C. Brown 2005-05-31 23:44 ` Jim C. Brown 0 siblings, 1 reply; 12+ messages in thread From: Jim C. Brown @ 2005-05-31 20:28 UTC (permalink / raw) To: qemu-devel [-- Attachment #1: Type: text/plain, Size: 1549 bytes --] On Tue, May 31, 2005 at 03:45:03PM -0400, Jim C. Brown wrote: > On Mon, May 30, 2005 at 08:24:09PM -0400, Jim C. Brown wrote: > > Here is the new driver. Patch is against a clean qemu directory. Once you > > apply the patch, dump the attached files into the qemu root directory and > > run configure with '--enable-gtk' option. The '--set-fs-driver=' option > > exists but there should be no need to use it. > > > > -- > > Infinite complexity begets infinite beauty. > > Infinite precision begets infinite perfection. > > Here is an updated version that partically fixes problems with moving the mouse > when in fullscreen mode (sometimes you can move the mouse anyways and screw up > alignment in spite of this). > > New gtk2.c attached. Also gdk_window_set_pointer.c attached. This works for > Linux/X11, Windows code should be ok but it is untested. (This is to overcome > a deliberate oversight in the GDK library, which does not provide a way to > set the location of the mouse pointer. GTK-fb will require an even uglier > hack.) > > _______________________________________________ > Qemu-devel mailing list > Qemu-devel@nongnu.org > http://lists.nongnu.org/mailman/listinfo/qemu-devel This gtk2.c does a better job of fixing the bug. Mouse shouldnt be able to affect alignment anymore. Seems to make the mouse cursor move slower, not sure why, otherwise it has no known bugs. Requires the gdk_set_window_pointer.c that I posted previously. -- Infinite complexity begets infinite beauty. Infinite precision begets infinite perfection. [-- Attachment #2: gtk2.c --] [-- Type: text/plain, Size: 21379 bytes --] /* * QEMU GTK2 display driver * based on SDL driver by Fabrice * * Copyright (c) 2005 Jim Brown * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include "vl.h" #include <gtk/gtk.h> #include <gdk/gdk.h> #include "fullscreen.h" /* define our own bitshift enums to allow qemugtk to know difference between left and right alt - something gtk doesnt provide in its modifiers mask. this uses qemu's own modifier_state[] map in order to guess correctly */ typedef enum { gtkshiftleft = 1 << 0, gtkshiftright = 1 << 1, gtkcontrolleft = 1 << 2, gtkcontrolright = 1 << 3, gtkaltleft = 1 << 4, gtkaltright = 1 << 5, gtkcapslock = 1 << 6 } gtk2keymod; static GtkWidget *screen; static GdkImage *image=NULL; static GdkCursor *invisible_cursor; static int ox = 0, oy = 0; static int gui_grab; /* if true, all keyboard/mouse events are grabbed */ static int last_vm_running; static int gui_saved_grab; static int gui_fullscreen; static int gui_key_modifier_pressed; static int gui_keysym; static int gui_fullscreen_initial_grab; static int gui_grab_code = gtkaltleft | gtkcontrolleft; static uint8_t modifiers_state[256]; static unsigned int cw, ch; static gint cx, cy; static gboolean gtk2_expose(GtkWidget *wid, GdkEventExpose *event) { gdk_draw_image(wid->window, wid->style->fg_gc[GTK_WIDGET_STATE(wid)], image, event->area.x, event->area.y, event->area.x, event->area.y, event->area.width, event->area.height); return TRUE; } static void gtk2_update(DisplayState *ds, int x, int y, int w, int h) { // printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h); GdkEventExpose ev; ev.area.x = x; ev.area.y = y; ev.area.width = w; ev.area.height = h; gtk2_expose(screen, &ev); } static void gtk2_resize(DisplayState *ds, int w, int h) { // printf(" resizing to %d %d\n", w, h); if (gui_fullscreen) { if (cw != w || ch != h) fullscreen_switch(cx, cy, w, h); /* changing video modes */ //gtk_window_fullscreen(GTK_WINDOW(screen)); } else { //gtk_window_unfullscreen(GTK_WINDOW(screen)); } cw = w; ch = h; if (image) g_object_unref(image); /* gdk_visual_get_best_with_depth() ??? but then how to paint onto window? */ image = gdk_image_new(GDK_IMAGE_NORMAL, gdk_visual_get_system(), w, h); gdk_image_set_colormap(image, gdk_colormap_get_system()); gtk_window_set_default_size(GTK_WINDOW(screen), w, h); gtk_widget_set_size_request(screen, w, h); gtk_window_resize(GTK_WINDOW(screen), w, h); ds->data = image->mem; ds->linesize = image->bpl; ds->depth = image->bits_per_pixel; ds->width = w; ds->height = h; gtk2_update(ds, 0, 0, w, h); } /* generic keyboard conversion */ #include "gdk_keysym.h" #include "keymaps.c" static kbd_layout_t *kbd_layout = NULL; static uint8_t gtk2_keyevent_to_keycode_generic(const GdkEventKey *ev) { int keysym; /* workaround for X11+SDL bug with AltGR - is it still needed for Gtk2? */ keysym = ev->keyval; if (keysym == 0 && ev->hardware_keycode == 113) keysym = GDK_Mode_switch; return keysym2scancode(kbd_layout, keysym); } /* specific keyboard conversions from scan codes */ #if defined(_WIN32) static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev) { return ev->hardware_keycode; /* does this work on win32 gtk? */ } #else static const uint8_t x_keycode_to_pc_keycode[61] = { 0xc7, /* 97 Home */ 0xc8, /* 98 Up */ 0xc9, /* 99 PgUp */ 0xcb, /* 100 Left */ 0x4c, /* 101 KP-5 */ 0xcd, /* 102 Right */ 0xcf, /* 103 End */ 0xd0, /* 104 Down */ 0xd1, /* 105 PgDn */ 0xd2, /* 106 Ins */ 0xd3, /* 107 Del */ 0x9c, /* 108 Enter */ 0x9d, /* 109 Ctrl-R */ 0x0, /* 110 Pause */ 0xb7, /* 111 Print */ 0xb5, /* 112 Divide */ 0xb8, /* 113 Alt-R */ 0xc6, /* 114 Break */ 0x0, /* 115 */ 0x0, /* 116 */ 0x0, /* 117 */ 0x0, /* 118 */ 0x0, /* 119 */ 0x70, /* 120 Hiragana_Katakana */ 0x0, /* 121 */ 0x0, /* 122 */ 0x73, /* 123 backslash */ 0x0, /* 124 */ 0x0, /* 125 */ 0x0, /* 126 */ 0x0, /* 127 */ 0x0, /* 128 */ 0x79, /* 129 Henkan */ 0x0, /* 130 */ 0x7b, /* 131 Muhenkan */ 0x0, /* 132 */ 0x7d, /* 133 Yen */ 0x0, /* 134 */ 0x0, /* 135 */ 0x47, /* 136 KP_7 */ 0x48, /* 137 KP_8 */ 0x49, /* 138 KP_9 */ 0x4b, /* 139 KP_4 */ 0x4c, /* 140 KP_5 */ 0x4d, /* 141 KP_6 */ 0x4f, /* 142 KP_1 */ 0x50, /* 143 KP_2 */ 0x51, /* 144 KP_3 */ 0x52, /* 145 KP_0 */ 0x53, /* 146 KP_. */ 0x47, /* 147 KP_HOME */ 0x48, /* 148 KP_UP */ 0x49, /* 149 KP_PgUp */ 0x4b, /* 150 KP_Left */ 0x4c, /* 151 KP_ */ 0x4d, /* 152 KP_Right */ 0x4f, /* 153 KP_End */ 0x50, /* 154 KP_Down */ 0x51, /* 155 KP_PgDn */ 0x52, /* 156 KP_Ins */ 0x53, /* 157 KP_Del */ }; static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev) { int keycode; keycode = ev->hardware_keycode; if (keycode < 9) { keycode = 0; } else if (keycode < 97) { keycode -= 8; /* just an offset */ } else if (keycode < 158) { /* use conversion table */ keycode = x_keycode_to_pc_keycode[keycode - 97]; } else { keycode = 0; } return keycode; } #endif static void reset_keys(void) { int i; for(i = 0; i < 256; i++) { if (modifiers_state[i]) { if (i & 0x80) kbd_put_keycode(0xe0); kbd_put_keycode(i | 0x80); modifiers_state[i] = 0; } } } /* convert GDK modifiers and invoke ugly hack to distinguish between left and right shift/control/alt */ static guint gtk2_GetModState(const GdkEventKey *ev) { guint key = 0, keyval = ev->keyval, state = ev->state; switch(keyval) { case GDK_Shift_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkshiftleft; keyval = 1; break; case GDK_Shift_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkshiftright; keyval = 1; break; case GDK_Control_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkcontrolleft; keyval = 2; break; case GDK_Control_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkcontrolright; keyval = 2; break; case GDK_Alt_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkaltleft; keyval = 3; break; case GDK_Alt_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkaltright; keyval = 3; break; case GDK_Caps_Lock: if (ev->type != GDK_KEY_RELEASE) key |= gtkcapslock; keyval = 4; break; default: keyval = 0; break; } if (keyval != 1 && (state & GDK_SHIFT_MASK)) { if (modifiers_state[0x2a]) key |= gtkshiftleft; if (modifiers_state[0x36]) key |= gtkshiftright; } if (keyval != 2 && (state & GDK_CONTROL_MASK)) { if (modifiers_state[0x1d]) key |= gtkcontrolleft; if (modifiers_state[0x9d]) key |= gtkcontrolright; } if (keyval != 3 && (state & GDK_MOD1_MASK)) /* fixme: need to do a check to make sure that alt is mapped to GDK_MOD1_MASK in the GDK_Keymap */ { if (modifiers_state[0x38]) key |= gtkaltleft; if (modifiers_state[0xb8]) key |= gtkaltright; } if (keyval != 4 && (state & GDK_LOCK_MASK)) key |= gtkcapslock; return key; } static void gtk2_process_key(GdkEventKey *ev) { int keycode, v; if (ev->keyval == GDK_Pause) { /* specific case */ v = 0; if (ev->type == GDK_KEY_RELEASE) v |= 0x80; kbd_put_keycode(0xe1); kbd_put_keycode(0x1d | v); kbd_put_keycode(0x45 | v); return; } if (kbd_layout) { keycode = gtk2_keyevent_to_keycode_generic(ev); } else { keycode = gtk2_keyevent_to_keycode(ev); } switch(keycode) { case 0x00: /* sent when leaving window: reset the modifiers state */ reset_keys(); return; case 0x2a: /* Left Shift */ case 0x36: /* Right Shift */ case 0x1d: /* Left CTRL */ case 0x9d: /* Right CTRL */ case 0x38: /* Left ALT */ case 0xb8: /* Right ALT */ if (ev->type == GDK_KEY_RELEASE) modifiers_state[keycode] = 0; else modifiers_state[keycode] = 1; break; case 0x45: /* num lock */ case 0x3a: /* caps lock */ /* GTK does send the key up event, so we dont generate it */ /*kbd_put_keycode(keycode); kbd_put_keycode(keycode | 0x80); return;*/ break; } /* now send the key code */ if (keycode & 0x80) kbd_put_keycode(0xe0); if (ev->type == GDK_KEY_RELEASE) kbd_put_keycode(keycode | 0x80); else kbd_put_keycode(keycode & 0x7f); } static void gtk2_update_caption(void) { char buf[1024]; strcpy(buf, "QEMU"); if (!vm_running) { strcat(buf, " [Stopped]"); } if (gui_grab) { strcat(buf, " - Press Ctrl-Alt to exit grab"); } gtk_window_set_title(GTK_WINDOW(screen), buf); } /* what a nasty hack. this should be a part of the GDK, not external!!! */ #include "gdk_set_window_pointer.c" static void gtk2_grab_start(void) { gint y; guint events; GdkModifierType state; /* dummy var */ events = GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK; y = gdk_pointer_grab(screen->window, TRUE, events, screen->window, invisible_cursor, GDK_CURRENT_TIME); if (y) printf("GTK Warning - pointer grab failed!\n"); y = gdk_keyboard_grab(screen->window, TRUE, GDK_CURRENT_TIME); if (y) printf("GTK Warning - keyboard grab failed!\n"); /* do a dummy read to avoid moving mouse - set ox and oy to stay in sync */ gdk_window_get_pointer(screen->window, &ox, &oy, &state); gui_grab = 1; gtk2_update_caption(); } static void gtk2_grab_end(void) { gdk_pointer_ungrab(GDK_CURRENT_TIME); gdk_keyboard_ungrab(GDK_CURRENT_TIME); gdk_window_set_pointer(screen->window, cx, cy); gui_grab = 0; gtk2_update_caption(); } static gboolean gtk2_send_mouse_scroll(GtkWidget *wid, GdkEventScroll *ev) { int x, y, dx, dy, dz, state, buttons; if (gui_grab) { x = ev->x; y = ev->y; state = ev->state; buttons = 0; dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if ((state & GDK_BUTTON1_MASK)) buttons |= MOUSE_EVENT_LBUTTON; if ((state & GDK_BUTTON3_MASK)) buttons |= MOUSE_EVENT_RBUTTON; if ((state & GDK_BUTTON2_MASK)) buttons |= MOUSE_EVENT_MBUTTON; /* test wheel - copied from Sebastien Bechet's gtk.c */ dz = 0; if ((state & GDK_BUTTON4_MASK) || ev->direction == GDK_SCROLL_UP) dz--; if ((state & GDK_BUTTON5_MASK) || ev->direction == GDK_SCROLL_DOWN) dz++; kbd_mouse_event(dx, dy, dz, buttons); } return TRUE; } static gboolean gtk2_send_mouse_button(GtkWidget *wid, GdkEventButton *ev) { int x, y, dx, dy, dz, state, buttons; if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS) return TRUE; /* double or triple click - superflurious - ignore */ if (gui_grab) { x = ev->x; y = ev->y; state = ev->state; buttons = 0; dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if ((state & GDK_BUTTON1_MASK) || ev->button == 1) buttons |= MOUSE_EVENT_LBUTTON; if ((state & GDK_BUTTON3_MASK) || ev->button == 3) buttons |= MOUSE_EVENT_RBUTTON; if ((state & GDK_BUTTON2_MASK) || ev->button == 2) buttons |= MOUSE_EVENT_MBUTTON; /* XXX: test wheel */ dz = 0; if ((state & GDK_BUTTON4_MASK) || ev->button == 4) dz--; if ((state & GDK_BUTTON5_MASK) || ev->button == 5) dz++; kbd_mouse_event(dx, dy, dz, buttons); } else { if (ev->button == 1 && ev->type == GDK_BUTTON_PRESS) { /* start grabbing all events */ gtk2_grab_start(); } } return TRUE; } static gboolean gtk2_send_mouse_move(GtkWidget *wid, GdkEventMotion *ev) { int x, y, dx, dy, dz, state, buttons; if (gui_grab) { if (ev->is_hint) { gdk_window_get_pointer(ev->window, &x, &y, (GdkModifierType*)&state); } else { x = ev->x; y = ev->y; state = ev->state; } dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if (state & GDK_BUTTON1_MASK) buttons |= MOUSE_EVENT_LBUTTON; if (state & GDK_BUTTON3_MASK) buttons |= MOUSE_EVENT_RBUTTON; if (state & GDK_BUTTON2_MASK) buttons |= MOUSE_EVENT_MBUTTON; /* XXX: test wheel */ dz = 0; if (state & GDK_BUTTON4_MASK) dz--; if (state & GDK_BUTTON5_MASK) dz++; /* wrap the x,y coordinates back onto the window */ if (ev->x <= (cw/4)) x = ((3*cw/4)-1); if (ev->y <= (ch/4)) y = ((3*ch/4)-1); if (ev->x >= (3*cw/4)) x = (cw/4)+1; if (ev->y >= (3*ch/4)) y = (ch/4)+1; gdk_window_set_pointer(screen->window, (gint)x, (gint)y); kbd_mouse_event(dx, dy, dz, buttons); } return TRUE; } static void toggle_full_screen(DisplayState *ds) { gui_fullscreen = !gui_fullscreen; gtk2_resize(ds, image->width, image->height); if (gui_fullscreen) { gui_saved_grab = gui_grab; gtk2_grab_start(); gtk_window_get_position(GTK_WINDOW(screen), &cx, &cy); gtk_window_move(GTK_WINDOW(screen), 0, 0); fullscreen_switch(cx, cy, ds->width, ds->height); } else { fullscreen_reset(); gtk_window_move(GTK_WINDOW(screen), cx, cy); if (!gui_saved_grab) gtk2_grab_end(); } vga_invalidate_display(); vga_update_display(); } static gboolean gtk2_key_press(GtkWidget *wid, GdkEventKey *ev, DisplayState *ds) { int mod_state; if (ev->type == GDK_KEY_PRESS) { mod_state = (gtk2_GetModState(ev) & (int)gui_grab_code) == (int)gui_grab_code; gui_key_modifier_pressed = mod_state; if (gui_key_modifier_pressed) { int keycode; keycode = gtk2_keyevent_to_keycode(ev); switch(keycode) { case 0x21: /* 'f' key on US keyboard */ toggle_full_screen(ds); gui_keysym = 1; break; case 0x02 ... 0x0a: /* '1' to '9' keys */ console_select(keycode - 0x02); if (is_active_console(vga_console)) { /* tell the vga console to redisplay itself */ vga_invalidate_display(); } else { /* display grab if going to a text console */ if (gui_grab) gtk2_grab_end(); } gui_keysym = 1; break; default: break; } } else if (!is_active_console(vga_console)) { int keysym; keysym = 0; if (ev->state & GDK_CONTROL_MASK) { switch(ev->keyval) { case GDK_Up: keysym = QEMU_KEY_CTRL_UP; break; case GDK_Down: keysym = QEMU_KEY_CTRL_DOWN; break; case GDK_Left: keysym = QEMU_KEY_CTRL_LEFT; break; case GDK_Right: keysym = QEMU_KEY_CTRL_RIGHT; break; case GDK_Home: keysym = QEMU_KEY_CTRL_HOME; break; case GDK_End: keysym = QEMU_KEY_CTRL_END; break; case GDK_Page_Up: keysym = QEMU_KEY_CTRL_PAGEUP; break; case GDK_Page_Down: keysym = QEMU_KEY_CTRL_PAGEDOWN; break; default: break; } } else { switch(ev->keyval) { case GDK_Up: keysym = QEMU_KEY_UP; break; case GDK_Down: keysym = QEMU_KEY_DOWN; break; case GDK_Left: keysym = QEMU_KEY_LEFT; break; case GDK_Right: keysym = QEMU_KEY_RIGHT; break; case GDK_Home: keysym = QEMU_KEY_HOME; break; case GDK_End: keysym = QEMU_KEY_END; break; case GDK_Page_Up: keysym = QEMU_KEY_PAGEUP; break; case GDK_Page_Down: keysym = QEMU_KEY_PAGEDOWN; break; case GDK_BackSpace: keysym = QEMU_KEY_BACKSPACE; break; case GDK_Delete: keysym = QEMU_KEY_DELETE; break; default: break; } } if (keysym) { kbd_put_keysym(keysym); } /*else if (ev->key.keysym.unicode != 0) { kbd_put_keysym(ev->key.keysym.unicode); }*/ } } else if (ev->type == GDK_KEY_RELEASE) { mod_state = (gtk2_GetModState(ev) & gui_grab_code); if (!mod_state) { if (gui_key_modifier_pressed) { if (gui_keysym == 0) { /* exit/enter grab if pressing Ctrl-Alt */ if (!gui_grab) gtk2_grab_start(); else gtk2_grab_end(); /* SDL does not send back all the modifiers key, so we must correct it */ reset_keys(); return TRUE; } gui_key_modifier_pressed = 0; gui_keysym = 0; } } } if (is_active_console(vga_console)) gtk2_process_key(ev); return TRUE; } static void gtk2_refresh(DisplayState *ds) { if (last_vm_running != vm_running) { last_vm_running = vm_running; gtk2_update_caption(); } if (ds->data != image->mem) { ds->data = image->mem; } if (is_active_console(vga_console)) vga_update_display(); while (gtk_events_pending()) gtk_main_iteration(); } static void gtk2_cleanup(void) { gtk_main_quit(); fullscreen_cleanup(); } static gboolean gtk2_deletewin(void) { /* signal qemu that its time to shut itself off - this is the place that we hook to trap attempts to close the main qemu window */ qemu_system_shutdown_request(); return TRUE; /* dont close the window right away! give qemu time to think */ } static void gtk2_destroy(void) { /* ideally we would call a hook here so qemu could clean itself up */ gtk2_cleanup(); } void gtk2_display_init(DisplayState *ds, int full_screen) { int events; #if defined(__APPLE__) /* always use generic keymaps */ if (!keyboard_layout) keyboard_layout = "en-us"; #endif if(keyboard_layout) { kbd_layout = init_keyboard_layout(keyboard_layout); if (!kbd_layout) exit(1); } if (!gtk_init_check (0,NULL)) { fprintf(stderr, "Could not load GTK\n"); exit(0); } fullscreen_init(); /* note: adding GDK_DRAG_* and GDK_DROP_* would provide a mechanism for supporting drag and drop between host and guest */ events = GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK | GDK_SCROLL_MASK | GDK_STRUCTURE_MASK; screen = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_events(screen, events); gtk_window_set_default_size(GTK_WINDOW(screen), 720, 400); gtk_widget_set_size_request(screen, 720, 400); g_signal_connect(G_OBJECT(screen), "delete_event", G_CALLBACK(gtk2_deletewin), NULL); g_signal_connect(G_OBJECT(screen), "destroy", G_CALLBACK(gtk2_destroy), NULL); gtk_container_set_border_width(GTK_CONTAINER(screen), 10); gtk_signal_connect(GTK_OBJECT(screen), "expose_event", (GtkSignalFunc) gtk2_expose, NULL); gtk_signal_connect(GTK_OBJECT(screen), "motion_notify_event", (GtkSignalFunc) gtk2_send_mouse_move, NULL); gtk_signal_connect(GTK_OBJECT(screen), "button_press_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL); gtk_signal_connect(GTK_OBJECT(screen), "button_release_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL); gtk_signal_connect(GTK_OBJECT(screen), "scroll_event", (GtkSignalFunc) gtk2_send_mouse_scroll, NULL); gtk_signal_connect(GTK_OBJECT(screen), "key_press_event", (GtkSignalFunc) gtk2_key_press, ds); gtk_signal_connect(GTK_OBJECT(screen), "key_release_event", (GtkSignalFunc) gtk2_key_press, ds); ds->dpy_update = gtk2_update; ds->dpy_resize = gtk2_resize; ds->dpy_refresh = gtk2_refresh; gchar nullpixdata[1] = { 0 }; GdkColor nullcolor = { 0, 0, 0, 0 }; GdkPixmap *invis = gdk_bitmap_create_from_data(screen->window, nullpixdata, 1, 1); invisible_cursor = gdk_cursor_new_from_pixmap(invis, invis, &nullcolor, &nullcolor, 0, 0); gtk2_resize(ds, 720, 400); gtk2_update_caption(); gui_grab = 0; gtk_window_set_policy(GTK_WINDOW(screen), FALSE, FALSE, FALSE); gtk_widget_show(screen); if (full_screen) { gui_fullscreen = 1; gui_fullscreen_initial_grab = 1; gtk2_grab_start(); } } ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] gtk2 driver 2005-05-31 20:28 ` Jim C. Brown @ 2005-05-31 23:44 ` Jim C. Brown 0 siblings, 0 replies; 12+ messages in thread From: Jim C. Brown @ 2005-05-31 23:44 UTC (permalink / raw) To: qemu-devel [-- Attachment #1: Type: text/plain, Size: 530 bytes --] Updated gtk2.c and xvid_fs.c; Fullscreen mode now works perfectly, there is no more title bar above qemu window. "Your illusion is now complete." I may or may not hack gdk_set_window_pointer.c to support linux framebuffer, if I do I'll probably add a fb_fs.c to support fullscreen mode in the framebuffer as well. Otherwise I do not plan on adding more to this - for X11 it already fully supports everything that the SDL version did. -- Infinite complexity begets infinite beauty. Infinite precision begets infinite perfection. [-- Attachment #2: gtk2.c --] [-- Type: text/plain, Size: 21578 bytes --] /* * QEMU GTK2 display driver * based on SDL driver by Fabrice * * Copyright (c) 2005 Jim Brown * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include "vl.h" #include <gtk/gtk.h> #include <gdk/gdk.h> #include "fullscreen.h" /* define our own bitshift enums to allow qemugtk to know difference between left and right alt - something gtk doesnt provide in its modifiers mask. this uses qemu's own modifier_state[] map in order to guess correctly */ typedef enum { gtkshiftleft = 1 << 0, gtkshiftright = 1 << 1, gtkcontrolleft = 1 << 2, gtkcontrolright = 1 << 3, gtkaltleft = 1 << 4, gtkaltright = 1 << 5, gtkcapslock = 1 << 6 } gtk2keymod; static GtkWidget *screen; static GdkImage *image=NULL; static GdkCursor *invisible_cursor; static int ox = 0, oy = 0; static int gui_grab; /* if true, all keyboard/mouse events are grabbed */ static int last_vm_running; static int gui_saved_grab; static int gui_fullscreen; static int gui_key_modifier_pressed; static int gui_keysym; static int gui_fullscreen_initial_grab; static int gui_grab_code = gtkaltleft | gtkcontrolleft; static uint8_t modifiers_state[256]; static unsigned int cw, ch; static gint cx, cy; static gboolean gtk2_expose(GtkWidget *wid, GdkEventExpose *event) { gdk_draw_image(wid->window, wid->style->fg_gc[GTK_WIDGET_STATE(wid)], image, event->area.x, event->area.y, event->area.x, event->area.y, event->area.width, event->area.height); return TRUE; } static void gtk2_update(DisplayState *ds, int x, int y, int w, int h) { // printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h); GdkEventExpose ev; ev.area.x = x; ev.area.y = y; ev.area.width = w; ev.area.height = h; gtk2_expose(screen, &ev); } static void gtk2_resize(DisplayState *ds, int w, int h) { // printf(" resizing to %d %d\n", w, h); if (gui_fullscreen) { if (cw != w || ch != h) fullscreen_switch(cx, cy, w, h); /* changing video modes */ //gtk_window_fullscreen(GTK_WINDOW(screen)); } else { //gtk_window_unfullscreen(GTK_WINDOW(screen)); } cw = w; ch = h; if (image) g_object_unref(image); /* gdk_visual_get_best_with_depth() ??? but then how to paint onto window? */ image = gdk_image_new(GDK_IMAGE_NORMAL, gdk_visual_get_system(), w, h); gdk_image_set_colormap(image, gdk_colormap_get_system()); gtk_window_set_default_size(GTK_WINDOW(screen), w, h); gtk_widget_set_size_request(screen, w, h); gtk_window_resize(GTK_WINDOW(screen), w, h); ds->data = image->mem; ds->linesize = image->bpl; ds->depth = image->bits_per_pixel; ds->width = w; ds->height = h; gtk2_update(ds, 0, 0, w, h); } /* generic keyboard conversion */ #include "gdk_keysym.h" #include "keymaps.c" static kbd_layout_t *kbd_layout = NULL; static uint8_t gtk2_keyevent_to_keycode_generic(const GdkEventKey *ev) { int keysym; /* workaround for X11+SDL bug with AltGR - is it still needed for Gtk2? */ keysym = ev->keyval; if (keysym == 0 && ev->hardware_keycode == 113) keysym = GDK_Mode_switch; return keysym2scancode(kbd_layout, keysym); } /* specific keyboard conversions from scan codes */ #if defined(_WIN32) static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev) { return ev->hardware_keycode; /* does this work on win32 gtk? */ } #else static const uint8_t x_keycode_to_pc_keycode[61] = { 0xc7, /* 97 Home */ 0xc8, /* 98 Up */ 0xc9, /* 99 PgUp */ 0xcb, /* 100 Left */ 0x4c, /* 101 KP-5 */ 0xcd, /* 102 Right */ 0xcf, /* 103 End */ 0xd0, /* 104 Down */ 0xd1, /* 105 PgDn */ 0xd2, /* 106 Ins */ 0xd3, /* 107 Del */ 0x9c, /* 108 Enter */ 0x9d, /* 109 Ctrl-R */ 0x0, /* 110 Pause */ 0xb7, /* 111 Print */ 0xb5, /* 112 Divide */ 0xb8, /* 113 Alt-R */ 0xc6, /* 114 Break */ 0x0, /* 115 */ 0x0, /* 116 */ 0x0, /* 117 */ 0x0, /* 118 */ 0x0, /* 119 */ 0x70, /* 120 Hiragana_Katakana */ 0x0, /* 121 */ 0x0, /* 122 */ 0x73, /* 123 backslash */ 0x0, /* 124 */ 0x0, /* 125 */ 0x0, /* 126 */ 0x0, /* 127 */ 0x0, /* 128 */ 0x79, /* 129 Henkan */ 0x0, /* 130 */ 0x7b, /* 131 Muhenkan */ 0x0, /* 132 */ 0x7d, /* 133 Yen */ 0x0, /* 134 */ 0x0, /* 135 */ 0x47, /* 136 KP_7 */ 0x48, /* 137 KP_8 */ 0x49, /* 138 KP_9 */ 0x4b, /* 139 KP_4 */ 0x4c, /* 140 KP_5 */ 0x4d, /* 141 KP_6 */ 0x4f, /* 142 KP_1 */ 0x50, /* 143 KP_2 */ 0x51, /* 144 KP_3 */ 0x52, /* 145 KP_0 */ 0x53, /* 146 KP_. */ 0x47, /* 147 KP_HOME */ 0x48, /* 148 KP_UP */ 0x49, /* 149 KP_PgUp */ 0x4b, /* 150 KP_Left */ 0x4c, /* 151 KP_ */ 0x4d, /* 152 KP_Right */ 0x4f, /* 153 KP_End */ 0x50, /* 154 KP_Down */ 0x51, /* 155 KP_PgDn */ 0x52, /* 156 KP_Ins */ 0x53, /* 157 KP_Del */ }; static uint8_t gtk2_keyevent_to_keycode(const GdkEventKey *ev) { int keycode; keycode = ev->hardware_keycode; if (keycode < 9) { keycode = 0; } else if (keycode < 97) { keycode -= 8; /* just an offset */ } else if (keycode < 158) { /* use conversion table */ keycode = x_keycode_to_pc_keycode[keycode - 97]; } else { keycode = 0; } return keycode; } #endif static void reset_keys(void) { int i; for(i = 0; i < 256; i++) { if (modifiers_state[i]) { if (i & 0x80) kbd_put_keycode(0xe0); kbd_put_keycode(i | 0x80); modifiers_state[i] = 0; } } } /* convert GDK modifiers and invoke ugly hack to distinguish between left and right shift/control/alt */ static guint gtk2_GetModState(const GdkEventKey *ev) { guint key = 0, keyval = ev->keyval, state = ev->state; switch(keyval) { case GDK_Shift_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkshiftleft; keyval = 1; break; case GDK_Shift_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkshiftright; keyval = 1; break; case GDK_Control_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkcontrolleft; keyval = 2; break; case GDK_Control_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkcontrolright; keyval = 2; break; case GDK_Alt_L: if (ev->type != GDK_KEY_RELEASE) key |= gtkaltleft; keyval = 3; break; case GDK_Alt_R: if (ev->type != GDK_KEY_RELEASE) key |= gtkaltright; keyval = 3; break; case GDK_Caps_Lock: if (ev->type != GDK_KEY_RELEASE) key |= gtkcapslock; keyval = 4; break; default: keyval = 0; break; } if (keyval != 1 && (state & GDK_SHIFT_MASK)) { if (modifiers_state[0x2a]) key |= gtkshiftleft; if (modifiers_state[0x36]) key |= gtkshiftright; } if (keyval != 2 && (state & GDK_CONTROL_MASK)) { if (modifiers_state[0x1d]) key |= gtkcontrolleft; if (modifiers_state[0x9d]) key |= gtkcontrolright; } if (keyval != 3 && (state & GDK_MOD1_MASK)) /* fixme: need to do a check to make sure that alt is mapped to GDK_MOD1_MASK in the GDK_Keymap */ { if (modifiers_state[0x38]) key |= gtkaltleft; if (modifiers_state[0xb8]) key |= gtkaltright; } if (keyval != 4 && (state & GDK_LOCK_MASK)) key |= gtkcapslock; return key; } static void gtk2_process_key(GdkEventKey *ev) { int keycode, v; if (ev->keyval == GDK_Pause) { /* specific case */ v = 0; if (ev->type == GDK_KEY_RELEASE) v |= 0x80; kbd_put_keycode(0xe1); kbd_put_keycode(0x1d | v); kbd_put_keycode(0x45 | v); return; } if (kbd_layout) { keycode = gtk2_keyevent_to_keycode_generic(ev); } else { keycode = gtk2_keyevent_to_keycode(ev); } switch(keycode) { case 0x00: /* sent when leaving window: reset the modifiers state */ reset_keys(); return; case 0x2a: /* Left Shift */ case 0x36: /* Right Shift */ case 0x1d: /* Left CTRL */ case 0x9d: /* Right CTRL */ case 0x38: /* Left ALT */ case 0xb8: /* Right ALT */ if (ev->type == GDK_KEY_RELEASE) modifiers_state[keycode] = 0; else modifiers_state[keycode] = 1; break; case 0x45: /* num lock */ case 0x3a: /* caps lock */ /* GTK does send the key up event, so we dont generate it */ /*kbd_put_keycode(keycode); kbd_put_keycode(keycode | 0x80); return;*/ break; } /* now send the key code */ if (keycode & 0x80) kbd_put_keycode(0xe0); if (ev->type == GDK_KEY_RELEASE) kbd_put_keycode(keycode | 0x80); else kbd_put_keycode(keycode & 0x7f); } static void gtk2_update_caption(void) { char buf[1024]; strcpy(buf, "QEMU"); if (!vm_running) { strcat(buf, " [Stopped]"); } if (gui_grab) { strcat(buf, " - Press Ctrl-Alt to exit grab"); } gtk_window_set_title(GTK_WINDOW(screen), buf); } /* what a nasty hack. this should be a part of the GDK, not external!!! */ #include "gdk_set_window_pointer.c" static void gtk2_grab_start(void) { gint y; guint events; GdkModifierType state; /* dummy var */ events = GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK; y = gdk_pointer_grab(screen->window, TRUE, events, screen->window, invisible_cursor, GDK_CURRENT_TIME); if (y) printf("GTK Warning - pointer grab failed!\n"); y = gdk_keyboard_grab(screen->window, TRUE, GDK_CURRENT_TIME); if (y) printf("GTK Warning - keyboard grab failed!\n"); /* do a dummy read to avoid moving mouse - set ox and oy to stay in sync */ gdk_window_get_pointer(screen->window, &ox, &oy, &state); gui_grab = 1; gtk2_update_caption(); } static void gtk2_grab_end(void) { gdk_pointer_ungrab(GDK_CURRENT_TIME); gdk_keyboard_ungrab(GDK_CURRENT_TIME); gdk_window_set_pointer(screen->window, cx, cy); gui_grab = 0; gtk2_update_caption(); } static gboolean gtk2_send_mouse_scroll(GtkWidget *wid, GdkEventScroll *ev) { int x, y, dx, dy, dz, state, buttons; if (gui_grab) { x = ev->x; y = ev->y; state = ev->state; buttons = 0; dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if ((state & GDK_BUTTON1_MASK)) buttons |= MOUSE_EVENT_LBUTTON; if ((state & GDK_BUTTON3_MASK)) buttons |= MOUSE_EVENT_RBUTTON; if ((state & GDK_BUTTON2_MASK)) buttons |= MOUSE_EVENT_MBUTTON; /* test wheel - copied from Sebastien Bechet's gtk.c */ dz = 0; if ((state & GDK_BUTTON4_MASK) || ev->direction == GDK_SCROLL_UP) dz--; if ((state & GDK_BUTTON5_MASK) || ev->direction == GDK_SCROLL_DOWN) dz++; kbd_mouse_event(dx, dy, dz, buttons); } return TRUE; } static gboolean gtk2_send_mouse_button(GtkWidget *wid, GdkEventButton *ev) { int x, y, dx, dy, dz, state, buttons; if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS) return TRUE; /* double or triple click - superflurious - ignore */ if (gui_grab) { x = ev->x; y = ev->y; state = ev->state; buttons = 0; dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if ((state & GDK_BUTTON1_MASK) || ev->button == 1) buttons |= MOUSE_EVENT_LBUTTON; if ((state & GDK_BUTTON3_MASK) || ev->button == 3) buttons |= MOUSE_EVENT_RBUTTON; if ((state & GDK_BUTTON2_MASK) || ev->button == 2) buttons |= MOUSE_EVENT_MBUTTON; /* XXX: test wheel */ dz = 0; if ((state & GDK_BUTTON4_MASK) || ev->button == 4) dz--; if ((state & GDK_BUTTON5_MASK) || ev->button == 5) dz++; kbd_mouse_event(dx, dy, dz, buttons); } else { if (ev->button == 1 && ev->type == GDK_BUTTON_PRESS) { /* start grabbing all events */ gtk2_grab_start(); } } return TRUE; } static gboolean gtk2_send_mouse_move(GtkWidget *wid, GdkEventMotion *ev) { int x, y, dx, dy, dz, state, buttons; if (gui_grab) { if (ev->is_hint) { gdk_window_get_pointer(ev->window, &x, &y, (GdkModifierType*)&state); } else { x = ev->x; y = ev->y; state = ev->state; } dx = x - ox; dy = y - oy; ox = x; oy = y; buttons = 0; if (state & GDK_BUTTON1_MASK) buttons |= MOUSE_EVENT_LBUTTON; if (state & GDK_BUTTON3_MASK) buttons |= MOUSE_EVENT_RBUTTON; if (state & GDK_BUTTON2_MASK) buttons |= MOUSE_EVENT_MBUTTON; /* XXX: test wheel */ dz = 0; if (state & GDK_BUTTON4_MASK) dz--; if (state & GDK_BUTTON5_MASK) dz++; /* wrap the x,y coordinates back onto the window */ if (ev->x <= (cw/4)) x = ((3*cw/4)-1); if (ev->y <= (ch/4)) y = ((3*ch/4)-1); if (ev->x >= (3*cw/4)) x = (cw/4)+1; if (ev->y >= (3*ch/4)) y = (ch/4)+1; gdk_window_set_pointer(screen->window, (gint)x, (gint)y); kbd_mouse_event(dx, dy, dz, buttons); } return TRUE; } static void toggle_full_screen(DisplayState *ds) { gui_fullscreen = !gui_fullscreen; gtk2_resize(ds, image->width, image->height); if (gui_fullscreen) { gui_saved_grab = gui_grab; gtk2_grab_start(); gtk_window_get_position(GTK_WINDOW(screen), &cx, &cy); /* ignore window manager decorations when in fullscreen mode */ gtk_window_set_gravity(GTK_WINDOW(screen), GDK_GRAVITY_STATIC); gtk_window_move(GTK_WINDOW(screen), 0, 0); fullscreen_switch(cx, cy, ds->width, ds->height); } else { fullscreen_reset(); gtk_window_set_gravity(GTK_WINDOW(screen), GDK_GRAVITY_NORTH_WEST); gtk_window_move(GTK_WINDOW(screen), cx, cy); if (!gui_saved_grab) gtk2_grab_end(); } vga_invalidate_display(); vga_update_display(); } static gboolean gtk2_key_press(GtkWidget *wid, GdkEventKey *ev, DisplayState *ds) { int mod_state; if (ev->type == GDK_KEY_PRESS) { mod_state = (gtk2_GetModState(ev) & (int)gui_grab_code) == (int)gui_grab_code; gui_key_modifier_pressed = mod_state; if (gui_key_modifier_pressed) { int keycode; keycode = gtk2_keyevent_to_keycode(ev); switch(keycode) { case 0x21: /* 'f' key on US keyboard */ toggle_full_screen(ds); gui_keysym = 1; break; case 0x02 ... 0x0a: /* '1' to '9' keys */ console_select(keycode - 0x02); if (is_active_console(vga_console)) { /* tell the vga console to redisplay itself */ vga_invalidate_display(); } else { /* display grab if going to a text console */ if (gui_grab) gtk2_grab_end(); } gui_keysym = 1; break; default: break; } } else if (!is_active_console(vga_console)) { int keysym; keysym = 0; if (ev->state & GDK_CONTROL_MASK) { switch(ev->keyval) { case GDK_Up: keysym = QEMU_KEY_CTRL_UP; break; case GDK_Down: keysym = QEMU_KEY_CTRL_DOWN; break; case GDK_Left: keysym = QEMU_KEY_CTRL_LEFT; break; case GDK_Right: keysym = QEMU_KEY_CTRL_RIGHT; break; case GDK_Home: keysym = QEMU_KEY_CTRL_HOME; break; case GDK_End: keysym = QEMU_KEY_CTRL_END; break; case GDK_Page_Up: keysym = QEMU_KEY_CTRL_PAGEUP; break; case GDK_Page_Down: keysym = QEMU_KEY_CTRL_PAGEDOWN; break; default: break; } } else { switch(ev->keyval) { case GDK_Up: keysym = QEMU_KEY_UP; break; case GDK_Down: keysym = QEMU_KEY_DOWN; break; case GDK_Left: keysym = QEMU_KEY_LEFT; break; case GDK_Right: keysym = QEMU_KEY_RIGHT; break; case GDK_Home: keysym = QEMU_KEY_HOME; break; case GDK_End: keysym = QEMU_KEY_END; break; case GDK_Page_Up: keysym = QEMU_KEY_PAGEUP; break; case GDK_Page_Down: keysym = QEMU_KEY_PAGEDOWN; break; case GDK_BackSpace: keysym = QEMU_KEY_BACKSPACE; break; case GDK_Delete: keysym = QEMU_KEY_DELETE; break; default: break; } } if (keysym) { kbd_put_keysym(keysym); } /*else if (ev->key.keysym.unicode != 0) { kbd_put_keysym(ev->key.keysym.unicode); }*/ } } else if (ev->type == GDK_KEY_RELEASE) { mod_state = (gtk2_GetModState(ev) & gui_grab_code); if (!mod_state) { if (gui_key_modifier_pressed) { if (gui_keysym == 0) { /* exit/enter grab if pressing Ctrl-Alt */ if (!gui_grab) gtk2_grab_start(); else gtk2_grab_end(); /* SDL does not send back all the modifiers key, so we must correct it */ reset_keys(); return TRUE; } gui_key_modifier_pressed = 0; gui_keysym = 0; } } } if (is_active_console(vga_console)) gtk2_process_key(ev); return TRUE; } static void gtk2_refresh(DisplayState *ds) { if (last_vm_running != vm_running) { last_vm_running = vm_running; gtk2_update_caption(); } if (ds->data != image->mem) { ds->data = image->mem; } if (is_active_console(vga_console)) vga_update_display(); while (gtk_events_pending()) gtk_main_iteration(); } static void gtk2_cleanup(void) { gtk_main_quit(); fullscreen_cleanup(); } static gboolean gtk2_deletewin(void) { /* signal qemu that its time to shut itself off - this is the place that we hook to trap attempts to close the main qemu window */ qemu_system_shutdown_request(); return TRUE; /* dont close the window right away! give qemu time to think */ } static void gtk2_destroy(void) { /* ideally we would call a hook here so qemu could clean itself up */ gtk2_cleanup(); } void gtk2_display_init(DisplayState *ds, int full_screen) { int events; #if defined(__APPLE__) /* always use generic keymaps */ if (!keyboard_layout) keyboard_layout = "en-us"; #endif if(keyboard_layout) { kbd_layout = init_keyboard_layout(keyboard_layout); if (!kbd_layout) exit(1); } if (!gtk_init_check (0,NULL)) { fprintf(stderr, "Could not load GTK\n"); exit(0); } fullscreen_init(); /* note: adding GDK_DRAG_* and GDK_DROP_* would provide a mechanism for supporting drag and drop between host and guest */ events = GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK | GDK_SCROLL_MASK | GDK_STRUCTURE_MASK; screen = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_events(screen, events); gtk_window_set_default_size(GTK_WINDOW(screen), 720, 400); gtk_widget_set_size_request(screen, 720, 400); g_signal_connect(G_OBJECT(screen), "delete_event", G_CALLBACK(gtk2_deletewin), NULL); g_signal_connect(G_OBJECT(screen), "destroy", G_CALLBACK(gtk2_destroy), NULL); gtk_container_set_border_width(GTK_CONTAINER(screen), 10); gtk_signal_connect(GTK_OBJECT(screen), "expose_event", (GtkSignalFunc) gtk2_expose, NULL); gtk_signal_connect(GTK_OBJECT(screen), "motion_notify_event", (GtkSignalFunc) gtk2_send_mouse_move, NULL); gtk_signal_connect(GTK_OBJECT(screen), "button_press_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL); gtk_signal_connect(GTK_OBJECT(screen), "button_release_event", (GtkSignalFunc) gtk2_send_mouse_button, NULL); gtk_signal_connect(GTK_OBJECT(screen), "scroll_event", (GtkSignalFunc) gtk2_send_mouse_scroll, NULL); gtk_signal_connect(GTK_OBJECT(screen), "key_press_event", (GtkSignalFunc) gtk2_key_press, ds); gtk_signal_connect(GTK_OBJECT(screen), "key_release_event", (GtkSignalFunc) gtk2_key_press, ds); ds->dpy_update = gtk2_update; ds->dpy_resize = gtk2_resize; ds->dpy_refresh = gtk2_refresh; gchar nullpixdata[1] = { 0 }; GdkColor nullcolor = { 0, 0, 0, 0 }; GdkPixmap *invis = gdk_bitmap_create_from_data(screen->window, nullpixdata, 1, 1); invisible_cursor = gdk_cursor_new_from_pixmap(invis, invis, &nullcolor, &nullcolor, 0, 0); gtk2_resize(ds, 720, 400); gtk2_update_caption(); gui_grab = 0; gtk_window_set_policy(GTK_WINDOW(screen), FALSE, FALSE, FALSE); gtk_widget_show(screen); if (full_screen) { gui_fullscreen = 1; gui_fullscreen_initial_grab = 1; gtk2_grab_start(); } } [-- Attachment #3: xvid_fs.c --] [-- Type: text/plain, Size: 2298 bytes --] /* Use X11 Xvid extension to implement fullscreen mode */ #include <stdlib.h> #include <X11/Xlib.h> #include <X11/Xutil.h> #include <X11/keysym.h> #include <X11/extensions/xf86dga.h> #include <X11/extensions/xf86vmode.h> static Display *dpy; static XF86VidModeModeInfo **mode_list; static XF86VidModeModeInfo * modeinfo; static int count; int fullscreen_init(void) { int event, error, dotclock; XF86VidModeModeLine * modeline; /* load up X display and make sure we have the Xvid extention */ dpy = XOpenDisplay(""); /* FIXME: make this the one that Gtk uses */ if (dpy == NULL) return 0; if (!XF86VidModeQueryExtension(dpy, &event, &error)) return 0; /* get list of all modes */ XF86VidModeGetAllModeLines(dpy, XDefaultScreen(dpy), &count, &mode_list); /* get current modeline */ modeline = (XF86VidModeModeLine *)malloc(sizeof(XF86VidModeModeLine)); XF86VidModeGetModeLine(dpy, XDefaultScreen(dpy), &dotclock, modeline); /* convert to ModeInfo structure */ modeinfo = (XF86VidModeModeInfo *)malloc(sizeof(XF86VidModeModeInfo)); modeinfo->dotclock = dotclock; modeinfo->hdisplay = modeline->hdisplay; modeinfo->hsyncstart = modeline->hsyncstart; modeinfo->hsyncend = modeline->hsyncend; modeinfo->htotal = modeline->htotal; modeinfo->vdisplay = modeline->vdisplay; modeinfo->vsyncstart = modeline->vsyncstart; modeinfo->vsyncend = modeline->vsyncend; modeinfo->vtotal = modeline->vtotal; modeinfo->flags = modeline->flags; modeinfo->privsize = modeline->privsize; modeinfo->private = modeline->private; free(modeline); return 1; } int fullscreen_switch(int x, int y, int w, int h) { int i; for (i = 0; i < count; i++) { if (w == mode_list[i]->hdisplay) if (h == mode_list[i]->vdisplay) { XF86VidModeSwitchToMode(dpy, XDefaultScreen(dpy), mode_list[i]); XF86VidModeSetViewPort(dpy, XDefaultScreen(dpy), 0, 0); XFlush(dpy); return 1; } } return 0; } int fullscreen_reset(void) { XF86VidModeSwitchToMode(dpy, XDefaultScreen(dpy), modeinfo); XFlush(dpy); return 1; } void fullscreen_cleanup(void) { int i; if (modeinfo->privsize != 0) free(modeinfo->private); free(modeinfo); for (i = 0; i < count; i++) { if (mode_list[i]->privsize != 0) free(mode_list[i]->private); free(mode_list[i]); } free(mode_list); } ^ permalink raw reply [flat|nested] 12+ messages in thread
* [Qemu-devel] [PATCH] Embed QEmu screen on a custom window
@ 2005-05-26 11:42 Miguel Angel Fraile
2005-05-26 12:10 ` Christian MICHON
0 siblings, 1 reply; 12+ messages in thread
From: Miguel Angel Fraile @ 2005-05-26 11:42 UTC (permalink / raw)
To: qemu-devel
Hi,
I'm the author of QGui, a windows frontend for QEmu available at
http://perso.wanadoo.es/comike.
I've been trying to attach the QEmu screen to my frontend, but I
finally realized I needed to modify QEmu source to get it.
So I've attached a patch that adds a "-hwnd <handle>" argument to QEmu.
<handle> refers to the window handle where QEmu should be embedded (it
can be any control like a groupbox, form, etc).
Then, QEmu creates a new window that has the window specified at
command-line as parent. If QEmu screen size changes, parent and child
windows are resized automatically.
I hope the patch can be applied to CVS, as it would be very useful for
frontend authors.
PS: Please, add my mail address on CC, as I'm not subscribed to this list.
------------------------------------
--- vl.c Thu May 26 11:04:04 2005
+++ vl.c.new Thu May 26 11:03:34 2005
@@ -150,6 +150,9 @@
#ifdef TARGET_I386
int win2k_install_hack = 0;
#endif
+#ifdef _WIN32
+HWND fend_hwnd, qemu_hwnd;
+#endif
/***********************************************************/
/* x86 ISA bus support */
@@ -2785,6 +2788,9 @@
"-serial dev redirect the serial port to char device 'dev'\n"
"-parallel dev redirect the parallel port to char device 'dev'\n"
"-pidfile file Write PID to 'file'\n"
+#ifdef _WIN32
+ "-hwnd handle embed QEmu inside a custom window"
+#endif
"-S freeze CPU at startup (use 'c' to start
execution)\n"
"-s wait gdb connection to port %d\n"
"-p port change gdb connection port\n"
@@ -2883,6 +2889,7 @@
QEMU_OPTION_loadvm,
QEMU_OPTION_full_screen,
QEMU_OPTION_pidfile,
+ QEMU_OPTION_hwnd,
QEMU_OPTION_no_kqemu,
QEMU_OPTION_win2k_hack,
};
@@ -2953,6 +2960,9 @@
{ "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
{ "full-screen", 0, QEMU_OPTION_full_screen },
{ "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
+#ifdef _WIN32
+ { "hwnd", HAS_ARG, QEMU_OPTION_hwnd },
+#endif
{ "win2k-hack", 0, QEMU_OPTION_win2k_hack },
/* temporary options */
@@ -3036,7 +3046,13 @@
char parallel_devices[MAX_PARALLEL_PORTS][128];
int parallel_device_index;
const char *loadvm = NULL;
-
+
+#ifdef _WIN32
+ char widbuf[24];
+ fend_hwnd=NULL;
+ qemu_hwnd=NULL;
+#endif
+
#if !defined(CONFIG_SOFTMMU)
/* we never want that malloc() uses mmap() */
mallopt(M_MMAP_THRESHOLD, 4096 * 1024);
@@ -3405,6 +3421,16 @@
case QEMU_OPTION_pidfile:
create_pidfile(optarg);
break;
+#ifdef _WIN32
+ case QEMU_OPTION_hwnd:
+ fend_hwnd=(HWND)atoi(optarg);
+ qemu_hwnd=CreateWindow("BUTTON",NULL,BS_OWNERDRAW | WS_CHILD |
+ WS_VISIBLE,0,0,700,420,fend_hwnd,NULL,
+ GetModuleHandle(NULL),NULL);
+ sprintf(widbuf,"SDL_WINDOWID=%#x",(long)qemu_hwnd);
+ putenv(widbuf);
+ break;
+#endif
#ifdef TARGET_I386
case QEMU_OPTION_win2k_hack:
win2k_install_hack = 1;
--- sdl.c Thu May 26 11:03:50 2005
+++ sdl.c.new Thu May 26 11:03:44 2005
@@ -27,6 +27,9 @@
#ifndef _WIN32
#include <signal.h>
+#else
+#include <windows.h>
+extern HWND fend_hwnd,qemu_hwnd;
#endif
static SDL_Surface *screen;
@@ -66,6 +69,12 @@
ds->depth = screen->format->BitsPerPixel;
ds->width = w;
ds->height = h;
+#ifdef _WIN32
+ SetWindowPos(qemu_hwnd,NULL,0,0,w,h,SWP_NOMOVE |
+ SWP_NOREPOSITION | SWP_NOZORDER);
+ SetWindowPos(fend_hwnd,NULL,0,0,w,h,SWP_NOMOVE |
+ SWP_NOREPOSITION | SWP_NOZORDER);
+#endif
}
/* generic keyboard conversion */
@@ -258,6 +267,9 @@
if (gui_grab) {
strcat(buf, " - Press Ctrl-Alt to exit grab");
}
+#ifdef _WIN32
+ if (qemu_hwnd!=NULL)
+#endif
SDL_WM_SetCaption(buf, "QEMU");
}
-----------------------------------
Best regards.
Míguel
^ permalink raw reply [flat|nested] 12+ messages in thread* Re: [Qemu-devel] [PATCH] Embed QEmu screen on a custom window 2005-05-26 11:42 [Qemu-devel] [PATCH] Embed QEmu screen on a custom window Miguel Angel Fraile @ 2005-05-26 12:10 ` Christian MICHON 2005-05-26 20:03 ` Fabrice Bellard 0 siblings, 1 reply; 12+ messages in thread From: Christian MICHON @ 2005-05-26 12:10 UTC (permalink / raw) To: qemu-devel yes, but this is only for windows hosts, and you must install visual basic. wouldnt' it be better to add an extra sdl "console" (today we've main window, control, serial, parallel) where we could set parameters graphically ? or at least as a text form to read a cfg file ? this would pay more than to have 1 frontend for windows, 1 for linux, 1 for sparc, 1 for mac, etc... what's your opinion on this ? Christian On 5/26/05, Miguel Angel Fraile <mianfrar@gmail.com> wrote: > Hi, > > I'm the author of QGui, a windows frontend for QEmu available at > http://perso.wanadoo.es/comike. > ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] [PATCH] Embed QEmu screen on a custom window 2005-05-26 12:10 ` Christian MICHON @ 2005-05-26 20:03 ` Fabrice Bellard 2005-05-26 20:32 ` gtk [was Re: [Qemu-devel] [PATCH] Embed QEmu screen on a custom window] Jim C. Brown 0 siblings, 1 reply; 12+ messages in thread From: Fabrice Bellard @ 2005-05-26 20:03 UTC (permalink / raw) To: Christian MICHON, qemu-devel Christian MICHON wrote: > yes, but this is only for windows hosts, and you must install > visual basic. > > wouldnt' it be better to add an extra sdl "console" (today we've > main window, control, serial, parallel) where we could set parameters > graphically ? or at least as a text form to read a cfg file ? > > this would pay more than to have 1 frontend for windows, 1 for linux, > 1 for sparc, 1 for mac, etc... > > what's your opinion on this ? As I said earlier, I would prefer to integrate the GUI in QEMU like the cocoa.m implementation. GTK for Linux is the best option. For Windows, either GTK or a native GUI usage would be possible, depending on the reliability of the GTK port for Windows. Fabrice. ^ permalink raw reply [flat|nested] 12+ messages in thread
* gtk [was Re: [Qemu-devel] [PATCH] Embed QEmu screen on a custom window] 2005-05-26 20:03 ` Fabrice Bellard @ 2005-05-26 20:32 ` Jim C. Brown 2005-05-27 6:07 ` Jim C. Brown 0 siblings, 1 reply; 12+ messages in thread From: Jim C. Brown @ 2005-05-26 20:32 UTC (permalink / raw) To: qemu-devel On Thu, May 26, 2005 at 10:03:31PM +0200, Fabrice Bellard wrote: > >this would pay more than to have 1 frontend for windows, 1 for linux, > >1 for sparc, 1 for mac, etc... > > > >what's your opinion on this ? > > As I said earlier, I would prefer to integrate the GUI in QEMU like the > cocoa.m implementation. GTK for Linux is the best option. Out of curiosity, would you accept an intergrated GUI for Linux if it was based on Xlib or an updated QtC (which was a Qt wrapper that enabled Qt to be used in C programs) ? The main advantage, that I can see, with using GTK is that you can run it on the framebuffer (without X) - provided you have the proper GTK/GDK libs. > Fabrice. > -- Infinite complexity begets infinite beauty. Infinite precision begets infinite perfection. ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: gtk [was Re: [Qemu-devel] [PATCH] Embed QEmu screen on a custom window] 2005-05-26 20:32 ` gtk [was Re: [Qemu-devel] [PATCH] Embed QEmu screen on a custom window] Jim C. Brown @ 2005-05-27 6:07 ` Jim C. Brown 2005-05-27 10:59 ` [Qemu-devel] gtk2 driver Sebastien Bechet 0 siblings, 1 reply; 12+ messages in thread From: Jim C. Brown @ 2005-05-27 6:07 UTC (permalink / raw) To: qemu-devel On Thu, May 26, 2005 at 04:32:52PM -0400, Jim C. Brown wrote: > Out of curiosity, would you accept an intergrated GUI for Linux if it was based > on Xlib or an updated QtC (which was a Qt wrapper that enabled Qt to be used in > C programs) ? > > The main advantage, that I can see, with using GTK is that you can run it on > the framebuffer (without X) - provided you have the proper GTK/GDK libs. > > > Fabrice. > > Just for the curious - I have written a patch for qemu so that you can GTK2 instead of SDL. Its not a full gui, only provides the functions that SDL does, and it is not stable yet (segfaults consistently when attempting to change the graphics mode). Email me privately if you wish to look at it. Once the code becomes stable, I do plan on abstracting it quite a bit more - eventually to the point where user can dynamically change GUIs. But that is far off. -- Infinite complexity begets infinite beauty. Infinite precision begets infinite perfection. ^ permalink raw reply [flat|nested] 12+ messages in thread
* [Qemu-devel] gtk2 driver 2005-05-27 6:07 ` Jim C. Brown @ 2005-05-27 10:59 ` Sebastien Bechet 0 siblings, 0 replies; 12+ messages in thread From: Sebastien Bechet @ 2005-05-27 10:59 UTC (permalink / raw) To: qemu-devel; +Cc: jma5 [-- Attachment #1: Type: text/plain, Size: 312 bytes --] Hello Jim, As fabrice know, i have done some work about it, but no time to debug. Nevertheless, I think the code is near to work. Maybe it can help you or someone to finish gtk2 driver... (you can apply it directly on CVS, see TODO on gtk.c top for bugs) Bye. -- Sebastien Bechet <s.bechet@av7.net> av7.net [-- Attachment #2: qemu-gtk-diff1.txt --] [-- Type: text/x-patch, Size: 7150 bytes --] Index: Makefile =================================================================== RCS file: /cvsroot/qemu/qemu/Makefile,v retrieving revision 1.87 diff -u -r1.87 Makefile --- Makefile 28 Apr 2005 21:15:08 -0000 1.87 +++ Makefile 27 May 2005 10:48:38 -0000 @@ -25,8 +25,13 @@ endif endif +ifdef CONFIG_GTK +qemu-img$(EXESUF): qemu-img.c block.c block-cow.c block-qcow.c aes.c block-vmdk.c block-cloop.c block-dmg.c block-bochs.c block-vpc.c block-vvfat.c gtk-qemu-img/src/callbacks.c gtk-qemu-img/src/interface.c gtk-qemu-img/src/support.c + $(CC) -DQEMU_TOOL $(CFLAGS) $(LDFLAGS) $(DEFINES) -o $@ $^ -lz $(LIBS) +else qemu-img$(EXESUF): qemu-img.c block.c block-cow.c block-qcow.c aes.c block-vmdk.c block-cloop.c block-dmg.c block-bochs.c block-vpc.c block-vvfat.c $(CC) -DQEMU_TOOL $(CFLAGS) $(LDFLAGS) $(DEFINES) -o $@ $^ -lz $(LIBS) +endif dyngen$(EXESUF): dyngen.c $(HOST_CC) $(CFLAGS) $(DEFINES) -o $@ $^ Index: Makefile.target =================================================================== RCS file: /cvsroot/qemu/qemu/Makefile.target,v retrieving revision 1.69 diff -u -r1.69 Makefile.target --- Makefile.target 28 Apr 2005 21:15:08 -0000 1.69 +++ Makefile.target 27 May 2005 10:48:39 -0000 @@ -14,7 +14,7 @@ VPATH+=:$(SRC_PATH)/linux-user DEFINES+=-I$(SRC_PATH)/linux-user -I$(SRC_PATH)/linux-user/$(TARGET_ARCH) endif -CFLAGS=-Wall -O2 -g -fno-strict-aliasing +CFLAGS=-Wall -O2 -g -fno-strict-aliasing $(GTK_CFLAGS) #CFLAGS+=-Werror LDFLAGS=-g LIBS= @@ -357,6 +357,9 @@ ifdef CONFIG_SDL VL_OBJS+=sdl.o endif +ifdef CONFIG_GTK +VL_OBJS+=gtk.o +endif ifdef CONFIG_COCOA VL_OBJS+=cocoa.o COCOA_LIBS=-F/System/Library/Frameworks -framework Cocoa @@ -392,13 +395,16 @@ endif $(QEMU_SYSTEM): $(VL_OBJS) libqemu.a - $(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(COCOA_LIBS) $(VL_LIBS) + $(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(COCOA_LIBS) $(GTK_LIBS) $(VL_LIBS) cocoa.o: cocoa.m $(CC) $(CFLAGS) $(DEFINES) -c -o $@ $< sdl.o: sdl.c keymaps.c sdl_keysym.h - $(CC) $(CFLAGS) $(DEFINES) $(SDL_CFLAGS) -c -o $@ $< + $(CC) $(CFLAGS) $(DEFINES) $(SDL_CFLAGS) $(GTK_CFLAGS) -c -o $@ $< + +gtk.o : gtk.c + $(CC) $(CFLAGS) $(DEFINES) $(GTK_CFLAGS) -c -o $@ $< sdlaudio.o: sdlaudio.c $(CC) $(CFLAGS) $(DEFINES) $(SDL_CFLAGS) -c -o $@ $< Index: configure =================================================================== RCS file: /cvsroot/qemu/qemu/configure,v retrieving revision 1.66 diff -u -r1.66 configure --- configure 28 Apr 2005 20:41:53 -0000 1.66 +++ configure 27 May 2005 10:48:39 -0000 @@ -168,6 +168,8 @@ ;; --disable-sdl) sdl="no" ;; + --enable-gtk) gtk="yes" ; sdl="no" ; sdl_static="no" + ;; --enable-fmod) fmod="yes" ;; --fmod-lib=*) fmod_lib=${opt#--fmod-lib=} @@ -306,6 +308,34 @@ fi # cross compilation fi # -z $sdl +########################################## +# GTK probe + +gtk_too_old=no + +if test -z "$gtk" ; then + +gtk=no + +# normal GTK probe +cat > $TMPC << EOF +#include <stdlib.h> +#include <gtk/gtk.h> +int main(int argc, char **argv) { gtk_init(&argc, &argv); return EXIT_SUCCESS; } +EOF + +if $cc -o $TMPE `pkg-config --cflags --libs gtk+-2.0 2> /dev/null` $TMPC 2> /dev/null ; then +_gtkversion=`pkg-config --modversion gtk+-2.0 | sed 's/[^0-9]//g'` +if test "$_sdlversion" -lt 240 ; then + gtk_too_old=yes +else + gtk=yes +fi + +fi # gtk compile test + +fi # -z $gtk + if test x"$1" = x"-h" -o x"$1" = x"--help" ; then cat << EOF @@ -422,6 +452,7 @@ if test "$sdl" != "no" ; then echo "SDL static link $sdl_static" fi +echo "GTK support $gtk" echo "mingw32 support $mingw32" echo "Adlib support $adlib" echo -n "FMOD support $fmod" @@ -704,6 +735,14 @@ fi fi +if test "$gtk" = "yes" ; then + echo "#define CONFIG_GTK 1" >> $config_h + echo "CONFIG_GTK=yes" >> $config_mak + echo "GTK_LIBS=`pkg-config --libs gtk+-2.0`" >> $config_mak + echo "GTK_CFLAGS=`pkg-config --cflags gtk+-2.0`" >> $config_mak + echo "" >> $config_mak +fi + if test "$cocoa" = "yes" ; then echo "#define CONFIG_COCOA 1" >> $config_h echo "CONFIG_COCOA=yes" >> $config_mak Index: qemu-img.c =================================================================== RCS file: /cvsroot/qemu/qemu/qemu-img.c,v retrieving revision 1.7 diff -u -r1.7 qemu-img.c --- qemu-img.c 28 Apr 2005 21:15:08 -0000 1.7 +++ qemu-img.c 27 May 2005 10:48:39 -0000 @@ -21,6 +21,12 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ +#ifdef CONFIG_GTK +#include <gtk/gtk.h> +#include "interface.h" +#include "support.h" +#endif + #include "vl.h" void *get_mmap_addr(unsigned long size) @@ -675,6 +681,7 @@ return 0; } +#ifndef CONFIG_GTK int main(int argc, char **argv) { const char *cmd; @@ -697,3 +704,21 @@ } return 0; } +#else +int main(int argc, char **argv) +{ + GtkWidget *qimg; + + bdrv_init(); + + gtk_set_locale (); + gtk_init (&argc, &argv); + + qimg = create_qimg (); + gtk_widget_show (qimg); + + gtk_main (); + + return 0; +} +#endif Index: vl.c =================================================================== RCS file: /cvsroot/qemu/qemu/vl.c,v retrieving revision 1.127 diff -u -r1.127 vl.c --- vl.c 30 Apr 2005 16:10:35 -0000 1.127 +++ vl.c 27 May 2005 10:48:44 -0000 @@ -23,6 +23,8 @@ */ #include "vl.h" +#include <gtk/gtk.h> + #include <unistd.h> #include <fcntl.h> #include <signal.h> @@ -2679,7 +2681,6 @@ } } #endif - if (vm_running) { qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL], qemu_get_clock(vm_clock)); @@ -2721,6 +2722,11 @@ } else { timeout = 10; } + + if (gtk_events_pending ()) { + gtk_main_iteration_do (FALSE); + } + main_loop_wait(timeout); } cpu_disable_ticks(); @@ -3597,6 +3603,8 @@ } else { #if defined(CONFIG_SDL) sdl_display_init(ds, full_screen); +#elif defined(CONFIG_GTK) + gtk_display_init(ds, full_screen); #elif defined(CONFIG_COCOA) cocoa_display_init(ds, full_screen); #else Index: vl.h =================================================================== RCS file: /cvsroot/qemu/qemu/vl.h,v retrieving revision 1.74 diff -u -r1.74 vl.h --- vl.h 30 Apr 2005 16:10:35 -0000 1.74 +++ vl.h 27 May 2005 10:48:44 -0000 @@ -577,6 +577,9 @@ /* sdl.c */ void sdl_display_init(DisplayState *ds, int full_screen); +/* gtk.c */ +void gtk_display_init(DisplayState *ds, int full_screen); + /* cocoa.m */ void cocoa_display_init(DisplayState *ds, int full_screen); Index: hw/vga.c =================================================================== RCS file: /cvsroot/qemu/qemu/hw/vga.c,v retrieving revision 1.40 diff -u -r1.40 vga.c --- hw/vga.c 23 Apr 2005 18:43:45 -0000 1.40 +++ hw/vga.c 27 May 2005 10:48:44 -0000 @@ -803,7 +803,11 @@ static inline unsigned int rgb_to_pixel32(unsigned int r, unsigned int g, unsigned b) { - return (r << 16) | (g << 8) | b; +#ifdef CONFIG_GTK + return 0xFF000000 | (b << 16) | (g << 8) | r; +#else + return (r << 16) | (g << 8) | b; +#endif } #define DEPTH 8 [-- Attachment #3: gtk_keysym.h --] [-- Type: text/x-chdr, Size: 8683 bytes --] #include <gdk/gdkkeysyms.h> typedef struct { const char* name; int keysym; } name2keysym_t; static name2keysym_t name2keysym[]={ /* ascii */ { "space", 0x020}, { "exclam", 0x021}, { "quotedbl", 0x022}, { "numbersign", 0x023}, { "dollar", 0x024}, { "percent", 0x025}, { "ampersand", 0x026}, { "apostrophe", 0x027}, { "parenleft", 0x028}, { "parenright", 0x029}, { "asterisk", 0x02a}, { "plus", 0x02b}, { "comma", 0x02c}, { "minus", 0x02d}, { "period", 0x02e}, { "slash", 0x02f}, { "0", 0x030}, { "1", 0x031}, { "2", 0x032}, { "3", 0x033}, { "4", 0x034}, { "5", 0x035}, { "6", 0x036}, { "7", 0x037}, { "8", 0x038}, { "9", 0x039}, { "colon", 0x03a}, { "semicolon", 0x03b}, { "less", 0x03c}, { "equal", 0x03d}, { "greater", 0x03e}, { "question", 0x03f}, { "at", 0x040}, { "A", 0x041}, { "B", 0x042}, { "C", 0x043}, { "D", 0x044}, { "E", 0x045}, { "F", 0x046}, { "G", 0x047}, { "H", 0x048}, { "I", 0x049}, { "J", 0x04a}, { "K", 0x04b}, { "L", 0x04c}, { "M", 0x04d}, { "N", 0x04e}, { "O", 0x04f}, { "P", 0x050}, { "Q", 0x051}, { "R", 0x052}, { "S", 0x053}, { "T", 0x054}, { "U", 0x055}, { "V", 0x056}, { "W", 0x057}, { "X", 0x058}, { "Y", 0x059}, { "Z", 0x05a}, { "bracketleft", 0x05b}, { "backslash", 0x05c}, { "bracketright", 0x05d}, { "asciicircum", 0x05e}, { "underscore", 0x05f}, { "grave", 0x060}, { "a", 0x061}, { "b", 0x062}, { "c", 0x063}, { "d", 0x064}, { "e", 0x065}, { "f", 0x066}, { "g", 0x067}, { "h", 0x068}, { "i", 0x069}, { "j", 0x06a}, { "k", 0x06b}, { "l", 0x06c}, { "m", 0x06d}, { "n", 0x06e}, { "o", 0x06f}, { "p", 0x070}, { "q", 0x071}, { "r", 0x072}, { "s", 0x073}, { "t", 0x074}, { "u", 0x075}, { "v", 0x076}, { "w", 0x077}, { "x", 0x078}, { "y", 0x079}, { "z", 0x07a}, { "braceleft", 0x07b}, { "bar", 0x07c}, { "braceright", 0x07d}, { "asciitilde", 0x07e}, /* latin 1 extensions */ { "nobreakspace", 0x0a0}, { "exclamdown", 0x0a1}, { "cent", 0x0a2}, { "sterling", 0x0a3}, { "currency", 0x0a4}, { "yen", 0x0a5}, { "brokenbar", 0x0a6}, { "section", 0x0a7}, { "diaeresis", 0x0a8}, { "copyright", 0x0a9}, { "ordfeminine", 0x0aa}, { "guillemotleft", 0x0ab}, { "notsign", 0x0ac}, { "hyphen", 0x0ad}, { "registered", 0x0ae}, { "macron", 0x0af}, { "degree", 0x0b0}, { "plusminus", 0x0b1}, { "twosuperior", 0x0b2}, { "threesuperior", 0x0b3}, { "acute", 0x0b4}, { "mu", 0x0b5}, { "paragraph", 0x0b6}, { "periodcentered", 0x0b7}, { "cedilla", 0x0b8}, { "onesuperior", 0x0b9}, { "masculine", 0x0ba}, { "guillemotright", 0x0bb}, { "onequarter", 0x0bc}, { "onehalf", 0x0bd}, { "threequarters", 0x0be}, { "questiondown", 0x0bf}, { "Agrave", 0x0c0}, { "Aacute", 0x0c1}, { "Acircumflex", 0x0c2}, { "Atilde", 0x0c3}, { "Adiaeresis", 0x0c4}, { "Aring", 0x0c5}, { "AE", 0x0c6}, { "Ccedilla", 0x0c7}, { "Egrave", 0x0c8}, { "Eacute", 0x0c9}, { "Ecircumflex", 0x0ca}, { "Ediaeresis", 0x0cb}, { "Igrave", 0x0cc}, { "Iacute", 0x0cd}, { "Icircumflex", 0x0ce}, { "Idiaeresis", 0x0cf}, { "ETH", 0x0d0}, { "Eth", 0x0d0}, { "Ntilde", 0x0d1}, { "Ograve", 0x0d2}, { "Oacute", 0x0d3}, { "Ocircumflex", 0x0d4}, { "Otilde", 0x0d5}, { "Odiaeresis", 0x0d6}, { "multiply", 0x0d7}, { "Ooblique", 0x0d8}, { "Oslash", 0x0d8}, { "Ugrave", 0x0d9}, { "Uacute", 0x0da}, { "Ucircumflex", 0x0db}, { "Udiaeresis", 0x0dc}, { "Yacute", 0x0dd}, { "THORN", 0x0de}, { "Thorn", 0x0de}, { "ssharp", 0x0df}, { "agrave", 0x0e0}, { "aacute", 0x0e1}, { "acircumflex", 0x0e2}, { "atilde", 0x0e3}, { "adiaeresis", 0x0e4}, { "aring", 0x0e5}, { "ae", 0x0e6}, { "ccedilla", 0x0e7}, { "egrave", 0x0e8}, { "eacute", 0x0e9}, { "ecircumflex", 0x0ea}, { "ediaeresis", 0x0eb}, { "igrave", 0x0ec}, { "iacute", 0x0ed}, { "icircumflex", 0x0ee}, { "idiaeresis", 0x0ef}, { "eth", 0x0f0}, { "ntilde", 0x0f1}, { "ograve", 0x0f2}, { "oacute", 0x0f3}, { "ocircumflex", 0x0f4}, { "otilde", 0x0f5}, { "odiaeresis", 0x0f6}, { "division", 0x0f7}, { "oslash", 0x0f8}, { "ooblique", 0x0f8}, { "ugrave", 0x0f9}, { "uacute", 0x0fa}, { "ucircumflex", 0x0fb}, { "udiaeresis", 0x0fc}, { "yacute", 0x0fd}, { "thorn", 0x0fe}, { "ydiaeresis", 0x0ff}, {"EuroSign", GDK_EuroSign}, /* modifiers */ {"Control_L", GDK_Control_L}, {"Control_R", GDK_Control_R}, {"Alt_L", GDK_Alt_L}, {"Alt_R", GDK_Alt_R}, {"Caps_Lock", GDK_Caps_Lock}, {"Meta_L", GDK_Meta_L}, {"Meta_R", GDK_Meta_R}, {"Shift_L", GDK_Shift_L}, {"Shift_R", GDK_Shift_R}, /* special keys */ {"BackSpace", GDK_BackSpace}, {"Tab", GDK_Tab}, {"Return", GDK_Return}, {"Right", GDK_Right}, {"Left", GDK_Left}, {"Up", GDK_Up}, {"Down", GDK_Down}, {"Page_Down", GDK_Page_Down}, {"Page_Up", GDK_Page_Up}, {"Insert", GDK_Insert}, {"Delete", GDK_Delete}, {"Home", GDK_Home}, {"End", GDK_End}, {"Scroll_Lock", GDK_Scroll_Lock}, {"F1", GDK_F1}, {"F2", GDK_F2}, {"F3", GDK_F3}, {"F4", GDK_F4}, {"F5", GDK_F5}, {"F6", GDK_F6}, {"F7", GDK_F7}, {"F8", GDK_F8}, {"F9", GDK_F9}, {"F10", GDK_F10}, {"F11", GDK_F11}, {"F12", GDK_F12}, {"F13", GDK_F13}, {"F14", GDK_F14}, {"F15", GDK_F15}, {"Sys_Req", GDK_Sys_Req}, {"KP_0", GDK_KP_0}, {"KP_1", GDK_KP_1}, {"KP_2", GDK_KP_2}, {"KP_3", GDK_KP_3}, {"KP_4", GDK_KP_4}, {"KP_5", GDK_KP_5}, {"KP_6", GDK_KP_6}, {"KP_7", GDK_KP_7}, {"KP_8", GDK_KP_8}, {"KP_9", GDK_KP_9}, {"KP_Add", GDK_KP_Add}, {"KP_Decimal", GDK_KP_Decimal}, {"KP_Divide", GDK_KP_Divide}, {"KP_Enter", GDK_KP_Enter}, {"KP_Equal", GDK_KP_Equal}, {"KP_Multiply", GDK_KP_Multiply}, {"KP_Subtract", GDK_KP_Subtract}, {"help", GDK_Help}, {"Menu", GDK_Menu}, {"Print", GDK_Print}, {"Mode_switch", GDK_Mode_switch}, {"Multi_Key", GDK_Multi_key}, {"Num_Lock", GDK_Num_Lock}, {"Pause", GDK_Pause}, {0,0}, }; [-- Attachment #4: gtk.c --] [-- Type: text/x-csrc, Size: 15142 bytes --] /* * QEMU GTK display driver * * Copyright (c) 2004 Sebastien Bechet * Copyright (c) 2003 Fabrice Bellard * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ /* TODO : configure !i386-softmmu grab RGBA endian problem in vga.c fullscreen gtk key release event ok, remove modifiers_state, reset_keys ... */ #include "vl.h" #include <gdk-pixbuf/gdk-pixbuf.h> #include <gtk/gtk.h> GtkWidget *pWindow; GtkImage *pImage; GdkPixbuf *pPixbuf; static int mouse_dx, mouse_dy, mouse_dz, mouse_buttons; static int gui_grab; /* if true, all keyboard/mouse events are grabbed */ static int last_vm_running; static int gui_saved_grab; static int gui_fullscreen; static int gui_key_modifier_pressed; static int gui_keysym; static int gui_fullscreen_initial_grab; static int gui_grab_code = GDK_CONTROL_MASK | GDK_MOD1_MASK; static uint8_t modifiers_state[256]; static void gtk_update(DisplayState *ds, int x, int y, int w, int h) { GdkRectangle grect; GdkRegion *pRegion; grect.x = (gint)x; grect.y = (gint)y; grect.width = (gint)w; grect.height = (gint)h; pRegion = gdk_region_rectangle(&grect); gdk_window_invalidate_region(GTK_WIDGET(pImage)->window,pRegion,TRUE); gdk_region_destroy(pRegion); } static void gtk_resize(DisplayState *ds, int w, int h) { if (pPixbuf != NULL) g_object_unref(pPixbuf); pPixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,TRUE, 8, w, h); gtk_image_set_from_pixbuf(pImage,pPixbuf); gtk_window_resize(GTK_WINDOW(pWindow), w, h); if (gui_fullscreen) gtk_window_fullscreen(GTK_WINDOW(pWindow)); else gtk_window_unfullscreen(GTK_WINDOW(pWindow)); ds->data = gdk_pixbuf_get_pixels(pPixbuf); ds->linesize = gdk_pixbuf_get_rowstride(pPixbuf); ds->depth = gdk_pixbuf_get_n_channels(pPixbuf)*gdk_pixbuf_get_bits_per_sample(pPixbuf); //4*8; ds->width = gdk_pixbuf_get_width(pPixbuf); ds->height = gdk_pixbuf_get_height(pPixbuf); } /* generic keyboard conversion */ #include "gtk_keysym.h" #include "keymaps.c" static kbd_layout_t *kbd_layout = NULL; static uint8_t gtk_keyevent_to_keycode_generic(const GdkEventKey *ev) { int keysym; /* workaround for X11+SDL bug with AltGR */ keysym = ev->keyval; /* XXX : ? if (keysym == 0 && ev->keysym.scancode == 113) keysym = SDLK_MODE;*/ return keysym2scancode(kbd_layout, keysym); } /* specific keyboard conversions from scan codes */ #if defined(_WIN32) static uint8_t gtk_keyevent_to_keycode(const GdkEventKey *ev) { return ev->hardware_keycode; } #else static const uint8_t x_keycode_to_pc_keycode[61] = { 0xc7, /* 97 Home */ 0xc8, /* 98 Up */ 0xc9, /* 99 PgUp */ 0xcb, /* 100 Left */ 0x4c, /* 101 KP-5 */ 0xcd, /* 102 Right */ 0xcf, /* 103 End */ 0xd0, /* 104 Down */ 0xd1, /* 105 PgDn */ 0xd2, /* 106 Ins */ 0xd3, /* 107 Del */ 0x9c, /* 108 Enter */ 0x9d, /* 109 Ctrl-R */ 0x0, /* 110 Pause */ 0xb7, /* 111 Print */ 0xb5, /* 112 Divide */ 0xb8, /* 113 Alt-R */ 0xc6, /* 114 Break */ 0x0, /* 115 */ 0x0, /* 116 */ 0x0, /* 117 */ 0x0, /* 118 */ 0x0, /* 119 */ 0x70, /* 120 Hiragana_Katakana */ 0x0, /* 121 */ 0x0, /* 122 */ 0x73, /* 123 backslash */ 0x0, /* 124 */ 0x0, /* 125 */ 0x0, /* 126 */ 0x0, /* 127 */ 0x0, /* 128 */ 0x79, /* 129 Henkan */ 0x0, /* 130 */ 0x7b, /* 131 Muhenkan */ 0x0, /* 132 */ 0x7d, /* 133 Yen */ 0x0, /* 134 */ 0x0, /* 135 */ 0x47, /* 136 KP_7 */ 0x48, /* 137 KP_8 */ 0x49, /* 138 KP_9 */ 0x4b, /* 139 KP_4 */ 0x4c, /* 140 KP_5 */ 0x4d, /* 141 KP_6 */ 0x4f, /* 142 KP_1 */ 0x50, /* 143 KP_2 */ 0x51, /* 144 KP_3 */ 0x52, /* 145 KP_0 */ 0x53, /* 146 KP_. */ 0x47, /* 147 KP_HOME */ 0x48, /* 148 KP_UP */ 0x49, /* 149 KP_PgUp */ 0x4b, /* 150 KP_Left */ 0x4c, /* 151 KP_ */ 0x4d, /* 152 KP_Right */ 0x4f, /* 153 KP_End */ 0x50, /* 154 KP_Down */ 0x51, /* 155 KP_PgDn */ 0x52, /* 156 KP_Ins */ 0x53, /* 157 KP_Del */ }; static uint8_t gtk_keyevent_to_keycode(const GdkEventKey *ev) { int keycode; keycode = ev->hardware_keycode; if (keycode < 9) { keycode = 0; } else if (keycode < 97) { keycode -= 8; /* just an offset */ } else if (keycode < 158) { /* use conversion table */ keycode = x_keycode_to_pc_keycode[keycode - 97]; } else { keycode = 0; } return keycode; } #endif static void reset_keys(void) { int i; for(i = 0; i < 256; i++) { if (modifiers_state[i]) { if (i & 0x80) kbd_put_keycode(0xe0); kbd_put_keycode(i | 0x80); modifiers_state[i] = 0; } } } static void gtk_process_key(GdkEventKey *ev) { int keycode, v; /* Pause key */ if (ev->hardware_keycode == 0x6E) { /* specific case */ v = 0; if (ev->type == GDK_KEY_RELEASE) v |= 0x80; kbd_put_keycode(0xe1); kbd_put_keycode(0x1d | v); kbd_put_keycode(0x45 | v); return; } if (kbd_layout) { keycode = gtk_keyevent_to_keycode_generic(ev); } else { keycode = gtk_keyevent_to_keycode(ev); } switch(keycode) { case 0x00: /* sent when leaving window: reset the modifiers state */ reset_keys(); return; case 0x32: /* Left Shift */ case 0x3E: /* Right Shift */ case 0x25: /* Left CTRL */ case 0x6D: /* Right CTRL */ case 0x40: /* Left ALT */ case 0x71: /* Right ALT */ if (ev->type == GDK_KEY_RELEASE) modifiers_state[keycode] = 0; else modifiers_state[keycode] = 1; break; case 0x45: /* num lock */ case 0x3a: /* caps lock */ /*XXX : GTK send the key up event... */ kbd_put_keycode(keycode); kbd_put_keycode(keycode | 0x80); return; } /* now send the key code */ if (keycode & 0x80) kbd_put_keycode(0xe0); if (ev->type == GDK_KEY_RELEASE) kbd_put_keycode(keycode | 0x80); else kbd_put_keycode(keycode & 0x7f); } static void gtk_update_caption(void) { char buf[1024]; strcpy(buf, "QEMU"); if (!vm_running) { strcat(buf, " [Stopped]"); } if (gui_grab) { strcat(buf, " - Press Ctrl-Alt to exit grab"); } gtk_window_set_title(GTK_WINDOW(pWindow), buf); } static void gtk_grab_start(void) { /* showcursor(false),grabinput*/ /* gdk_pointer_grab(pWindow->window, TRUE, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK, pWindow->window, NULL, GDK_CURRENT_TIME);*/ gui_grab = 1; gtk_update_caption(); } static void gtk_grab_end(void) { /* gdk_pointer_ungrab(GDK_CURRENT_TIME);*/ gui_grab = 0; gtk_update_caption(); } static void gtk_send_mouse_event(void) { fprintf(stderr,"dx=%d, dy=%d dz=%d buttons=%d\n",mouse_dx, mouse_dy, mouse_dz, mouse_buttons); kbd_mouse_event(mouse_dx, mouse_dy, mouse_dz, mouse_buttons); } static void toggle_full_screen(DisplayState *ds) { gui_fullscreen = !gui_fullscreen; if (gui_fullscreen) { gui_saved_grab = gui_grab; gtk_grab_start(); } else { if (!gui_saved_grab) gtk_grab_end(); } vga_invalidate_display(); vga_update_display(); } static void gtk_refresh(DisplayState *ds) { if (last_vm_running != vm_running) { last_vm_running = vm_running; gtk_update_caption(); } if (is_active_console(vga_console)) vga_update_display(); if (gtk_events_pending ()) { gtk_main_iteration_do (FALSE); } // fprintf(stderr,"gtk_refresh d=%d, w=%d, h=%d, ls=%d\n",ds->depth,ds->width,ds->height,ds->linesize); } static gboolean on_key(GtkWidget *widget, GdkEventKey *ev, DisplayState *ds) { int mod_state; fprintf(stderr,"on_key : se=%02X state=%02X key=0x%02X hkey=0x%02X grp=%d\n",ev->send_event,ev->state,ev->keyval,ev->hardware_keycode,ev->group); if (ev->type == GDK_KEY_PRESS) { mod_state = (ev->state & gui_grab_code) == gui_grab_code; gui_key_modifier_pressed = mod_state; if (gui_key_modifier_pressed) { int keycode; keycode = ev->hardware_keycode; switch(keycode) { case 0x29: /* 'f' hardware key */ toggle_full_screen(ds); gui_keysym = 1; break; case 0x0a ... 0x12: /* '1' to '9' keys */ console_select(keycode - 0x0a); if (is_active_console(vga_console)) { /* tell the vga console to redisplay itself */ vga_invalidate_display(); } else { if (gui_grab) gtk_grab_end(); } gui_keysym = 1; break; default: break; } } else if (!is_active_console(vga_console)) { int keysym; keysym = 0; if (ev->state & GDK_CONTROL_MASK) { switch(ev->hardware_keycode) { case 0x62: keysym = QEMU_KEY_CTRL_UP; break; case 0x68: keysym = QEMU_KEY_CTRL_DOWN; break; case 0x64: keysym = QEMU_KEY_CTRL_LEFT; break; case 0x66: keysym = QEMU_KEY_CTRL_RIGHT; break; case 0x61: keysym = QEMU_KEY_CTRL_HOME; break; case 0x67: keysym = QEMU_KEY_CTRL_END; break; case 0x63: keysym = QEMU_KEY_CTRL_PAGEUP; break; case 0x69: keysym = QEMU_KEY_CTRL_PAGEDOWN; break; default: break; } } else { switch(ev->hardware_keycode) { case 0x62: keysym = QEMU_KEY_UP; break; case 0x68: keysym = QEMU_KEY_DOWN; break; case 0x64: keysym = QEMU_KEY_LEFT; break; case 0x66: keysym = QEMU_KEY_RIGHT; break; case 0x61: keysym = QEMU_KEY_HOME; break; case 0x67: keysym = QEMU_KEY_END; break; case 0x63: keysym = QEMU_KEY_PAGEUP; break; case 0x69: keysym = QEMU_KEY_PAGEDOWN; break; case 0x16: keysym = QEMU_KEY_BACKSPACE; break; case 0x6b: keysym = QEMU_KEY_DELETE; break; default: break; } } if (keysym) { kbd_put_keysym(keysym); } else { kbd_put_keysym(ev->keyval); } } } else if (ev->type == GDK_KEY_RELEASE) { mod_state = (ev->state & gui_grab_code); if (!mod_state) { if (gui_key_modifier_pressed) { if (gui_keysym == 0) { /* exit/enter grab if pressing Ctrl-Alt */ if (!gui_grab) gtk_grab_start(); else gtk_grab_end(); reset_keys(); return TRUE; } gui_key_modifier_pressed = 0; gui_keysym = 0; } } } if (is_active_console(vga_console)) gtk_process_key(ev); return TRUE; } static gboolean on_motion(GtkWidget *widget, GdkEventMotion *event, DisplayState *ds) { if (gui_grab) { mouse_dx = event->x; mouse_dy = event->y; gtk_send_mouse_event(); } return TRUE; } #ifdef SDL_BUTTON_WHEELUP static gboolean on_scroll(GtkWidget *widget, GdkEventScroll *event, DisplayState *ds) { if (event->direction == GDK_SCROLL_UP) mouse_dz--; if (event->direction == GDK_SCROLL_DOWN) mouse_dz++; gtk_send_mouse_event(); return TRUE; } #endif static gboolean on_button(GtkWidget *widget, GdkEventButton *event, DisplayState *ds) { mouse_dx = event->x; mouse_dy = event->y; if (!gui_grab) { if (event->type == GDK_BUTTON_PRESS && event->button == 1) { gtk_grab_start(); } } else { if (event->button == 1) mouse_buttons ^= MOUSE_EVENT_LBUTTON; else if (event->button == 2) mouse_buttons ^= MOUSE_EVENT_MBUTTON; else if (event->button == 3) mouse_buttons ^= MOUSE_EVENT_RBUTTON; gtk_send_mouse_event(); } return TRUE; } static void on_quit_clicked() { fprintf(stderr,"click\n"); } void gtk_display_init(DisplayState *ds, int full_screen) { mouse_dx = mouse_dy = mouse_dz = mouse_buttons = 0; #if defined(__APPLE__) /* always use generic keymaps */ if (!keyboard_layout) keyboard_layout = "en-us"; #endif if(keyboard_layout) { kbd_layout = init_keyboard_layout(keyboard_layout); if (!kbd_layout) exit(1); } gtk_init(NULL,NULL); pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); pImage = GTK_IMAGE(gtk_image_new()); pPixbuf = NULL; ds->dpy_update = gtk_update; ds->dpy_resize = gtk_resize; ds->dpy_refresh = gtk_refresh; gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pImage)); gtk_resize(ds, 640, 400); gtk_update_caption(); g_signal_connect(pWindow,"delete-event", G_CALLBACK(on_quit_clicked), NULL); g_signal_connect(pWindow,"key-press-event", G_CALLBACK(on_key), ds); g_signal_connect(pWindow,"key-release-event", G_CALLBACK(on_key), ds); g_signal_connect(pWindow,"motion-notify-event", G_CALLBACK(on_motion), ds); g_signal_connect(pWindow,"button-press-event", G_CALLBACK(on_button), ds); g_signal_connect(pWindow,"button-release-event", G_CALLBACK(on_button), ds); #ifdef SDL_BUTTON_WHEELUP g_signal_connect(pWindow,"scroll-event", G_CALLBACK(on_scroll), ds); gtk_widget_add_events(pWindow,GDK_SCROLL_MASK); #endif gtk_widget_add_events(pWindow,GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); gtk_widget_show_all(pWindow); if (full_screen) { gui_fullscreen = 1; gui_fullscreen_initial_grab = 1; gtk_grab_start(); } } ^ permalink raw reply [flat|nested] 12+ messages in thread
end of thread, other threads:[~2005-05-31 23:52 UTC | newest] Thread overview: 12+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2005-05-30 17:11 [Qemu-devel] gtk2 driver Jim C. Brown 2005-05-30 19:10 ` Lionel Ulmer 2005-05-30 20:21 ` Jim C. Brown 2005-05-30 21:10 ` Fabrice Bellard 2005-05-30 23:03 ` Jim C. Brown 2005-05-31 0:24 ` Jim C. Brown 2005-05-31 14:15 ` Sylvain Petreolle 2005-05-31 18:54 ` Jim C. Brown 2005-05-31 19:45 ` Jim C. Brown 2005-05-31 20:28 ` Jim C. Brown 2005-05-31 23:44 ` Jim C. Brown -- strict thread matches above, loose matches on Subject: below -- 2005-05-26 11:42 [Qemu-devel] [PATCH] Embed QEmu screen on a custom window Miguel Angel Fraile 2005-05-26 12:10 ` Christian MICHON 2005-05-26 20:03 ` Fabrice Bellard 2005-05-26 20:32 ` gtk [was Re: [Qemu-devel] [PATCH] Embed QEmu screen on a custom window] Jim C. Brown 2005-05-27 6:07 ` Jim C. Brown 2005-05-27 10:59 ` [Qemu-devel] gtk2 driver Sebastien Bechet
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).