On Tue, Jun 14, 2005 at 11:46:32PM +0200, Heike C. Zimmerer wrote:
> "Jim C. Brown" <[EMAIL PROTECTED]> writes:
>
> > E.g. I'm the developer of the gtk2 interface for qemu, and I have no
> > idea about what bugs it may have as no one has reported any to
> > me. In fact, I have no idea if anyone is even using it because I get
> > no direct feedback.
>
> I'm using the snapshots from dad-answers.com/qemu/, and from time to
> time did a grep for gtk through the entire source tree, but didn't
> find any mention of it there.
>
> Maybe I've missed something, so could you explain how to get hold of
> the gtk code? Thanks.
>
> - Heike
>
They weren't committed to the CVS tree yet. You'll need to get it in patch
form. I'm reattaching all the necessary patches and files here, so you can get
it all in one place. (The .c files I've attached should be dropped in the main
qemu
directory).
--
Infinite complexity begets infinite beauty.
Infinite precision begets infinite perfection.
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);
--- 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);
/*
* 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();
}
}
#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},
};
/* 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
/* 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);
}
/* 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)
{
}
/* 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);
_______________________________________________
Qemu-devel mailing list
Qemu-devel@nongnu.org
http://lists.nongnu.org/mailman/listinfo/qemu-devel
