vitalif
/
mirror_qemu
mirror of https://github.com/proxmox/mirror_qemu
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ui: windows keyboard fixes for gtk & sdl. 

ui: require GTK 3.22 or newer.
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v2.0.22 (GNU/Linux)
 
 iQIcBAABCgAGBQJexO1MAAoJEEy22O7T6HE4xLEP/jHTGFdh7Sz5iyRQ/fD8HJdS
 gMeLgPznDHMYoVhEtXPk90Y25cFvr4r0Y2Io1D6fyKK/hbyKRNKIj7JleAhH2aPY
 MYfGbY4sjyNuxG6b6mXOTqQSI6IBmvrPuZyOPh46LzRSTANpP9Mn/zl1B2DqzBnV
 z+N/Yq/+f2TMZGPVjzOtsOfomGADXF96naWaaKdAI/o2OD0xFIw/pfHjjiOud2To
 7+rQLwhzdmDsNZfcwZqq6H/8TXpUrUqe4OxSMAlyzidW5dZQYa4EIre1pyc9Y51o
 C69wnD4wqGyJ93jUbZM/60owUYQ8wuvO98Gx27Ofqluuz3tTDrz+dMRVKxSw7AOC
 xZDhPzKTJcg9XeWE7sYzu3+nwXW/h8D9xFLu3RYKmPXCsVs9BwXJM5O3jsRc6kSt
 62eqXsh4oAXxqJZSwH0uGMTrnKO7TGNscgmmFEUj+kT95sjiYegTYKHagubDiLCP
 6Z1f7svueinCvLGwj79IEBdueSCIHMf5nB87aIPxGkaaI958Eb2y/parnPYrAzag
 IXrniGL2qx/TSUzaR5nRAkA4bd3zVaNrO5r/4cBWBF0SgZ9disICdO7vm6gVUpVt
 VXG/EOTYvMgHiDKaJ+O2z9OVzRyWKoEotOKNjUG8Tgcq1zcGyt+MYpUv2c1B2Yay
 lTctgEfn4zEQLFNQiOjN
 =DIyS
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/kraxel/tags/ui-20200520-pull-request' into staging

ui: windows keyboard fixes for gtk & sdl.
ui: require GTK 3.22 or newer.

# gpg: Signature made Wed 20 May 2020 09:41:48 BST
# gpg:                using RSA key 4CB6D8EED3E87138
# gpg: Good signature from "Gerd Hoffmann (work) <kraxel@redhat.com>" [full]
# gpg:                 aka "Gerd Hoffmann <gerd@kraxel.org>" [full]
# gpg:                 aka "Gerd Hoffmann (private) <kraxel@gmail.com>" [full]
# Primary key fingerprint: A032 8CFF B93A 17A7 9901  FE7D 4CB6 D8EE D3E8 7138

* remotes/kraxel/tags/ui-20200520-pull-request:
  ui: increase min required GTK version to 3.22.0
  ui/gtk: use native keyboard scancodes on Windows
  ui/gtk: don't pass on win keys without keyboard grab
  ui/sdl2-input: use trace-events to debug key events
  ui/sdl2: start in full screen with grab enabled
  ui/sdl2: fix handling of AltGr key on Windows
  ui/gtk: remove unused variable ignore_keys
  ui/gtk: remove unused code
  ui/gkt: release all keys on grab-broken-event
  ui/gtk: fix handling of AltGr key on Windows
  ui/win32-kbd-hook: handle AltGr in a hook procedure

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
master
Peter Maydell 2020-05-21 14:48:15 +01:00
parent 8b9112e4ae 7b23d121f9
commit ad5a59124c
10 changed files with 264 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configure vendored
View File

@ -2897,7 +2897,7 @@ fi
if test "$gtk" != "no"; then if test "$gtk" != "no"; then
gtkpackage="gtk+-3.0" gtkpackage="gtk+-3.0"
gtkx11package="gtk+-x11-3.0" gtkx11package="gtk+-x11-3.0"
gtkversion="3.14.0" gtkversion="3.22.0"
if $pkg_config --exists "$gtkpackage >= $gtkversion"; then if $pkg_config --exists "$gtkpackage >= $gtkversion"; then
gtk_cflags=$($pkg_config --cflags $gtkpackage) gtk_cflags=$($pkg_config --cflags $gtkpackage)
gtk_libs=$($pkg_config --libs $gtkpackage) gtk_libs=$($pkg_config --libs $gtkpackage)

14
include/ui/win32-kbd-hook.h Normal file
View File

@ -0,0 +1,14 @@
/*
* SPDX-License-Identifier: GPL-2.0-or-later
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#ifndef UI_WIN32_KBD_HOOK_H
#define UI_WIN32_KBD_HOOK_H
void win32_kbd_set_window(void *hwnd);
void win32_kbd_set_grab(bool grab);
#endif

1
stubs/Makefile.objs
View File

@ -32,6 +32,7 @@ stub-obj-y += trace-control.o
stub-obj-y += uuid.o stub-obj-y += uuid.o
stub-obj-y += vm-stop.o stub-obj-y += vm-stop.o
stub-obj-y += vmstate.o stub-obj-y += vmstate.o
stub-obj-y += win32-kbd-hook.o
stub-obj-y += fd-register.o stub-obj-y += fd-register.o
stub-obj-y += qmp_memory_device.o stub-obj-y += qmp_memory_device.o
stub-obj-y += target-monitor-defs.o stub-obj-y += target-monitor-defs.o

18
stubs/win32-kbd-hook.c Normal file
View File

@ -0,0 +1,18 @@
/*
* Win32 keyboard hook stubs
*
* This work is licensed under the terms of the GNU GPL, version 2 or
* (at your option) any later version. See the COPYING file in the
* top-level directory.
*/
#include "qemu/osdep.h"
#include "ui/win32-kbd-hook.h"
void win32_kbd_set_window(void *hwnd)
{
}
void win32_kbd_set_grab(bool grab)
{
}

3
ui/Makefile.objs
View File

@ -15,6 +15,9 @@ common-obj-$(CONFIG_SPICE) += spice-core.o spice-input.o spice-display.o
common-obj-$(CONFIG_COCOA) += cocoa.o common-obj-$(CONFIG_COCOA) += cocoa.o
common-obj-$(CONFIG_VNC) += $(vnc-obj-y) common-obj-$(CONFIG_VNC) += $(vnc-obj-y)
common-obj-$(call lnot,$(CONFIG_VNC)) += vnc-stubs.o common-obj-$(call lnot,$(CONFIG_VNC)) += vnc-stubs.o
ifneq (,$(findstring m,$(CONFIG_SDL)$(CONFIG_GTK)))
common-obj-$(CONFIG_WIN32) += win32-kbd-hook.o
endif
# ui-sdl module # ui-sdl module
common-obj-$(CONFIG_SDL) += sdl.mo common-obj-$(CONFIG_SDL) += sdl.mo

188
ui/gtk.c
View File

@ -38,6 +38,10 @@
#include "ui/console.h" #include "ui/console.h"
#include "ui/gtk.h" #include "ui/gtk.h"
#ifdef G_OS_WIN32
#include <gdk/gdkwin32.h>
#endif
#include "ui/win32-kbd-hook.h"
#include <glib/gi18n.h> #include <glib/gi18n.h>
#include <locale.h> #include <locale.h>
@ -108,15 +112,6 @@
# define VTE_CHECK_VERSION(a, b, c) 0 # define VTE_CHECK_VERSION(a, b, c) 0
#endif #endif
/* Some older mingw versions lack this constant or have
* it conditionally defined */
#ifdef _WIN32
# ifndef MAPVK_VK_TO_VSC
# define MAPVK_VK_TO_VSC 0
# endif
#endif
#define HOTKEY_MODIFIERS (GDK_CONTROL_MASK | GDK_MOD1_MASK) #define HOTKEY_MODIFIERS (GDK_CONTROL_MASK | GDK_MOD1_MASK)
static const guint16 *keycode_map; static const guint16 *keycode_map;
@ -173,8 +168,6 @@ struct GtkDisplayState {
bool external_pause_update; bool external_pause_update;
bool ignore_keys;
DisplayOptions *opts; DisplayOptions *opts;
}; };
@ -428,6 +421,16 @@ static void gd_widget_reparent(GtkWidget *from, GtkWidget *to,
g_object_unref(G_OBJECT(widget)); g_object_unref(G_OBJECT(widget));
} }
static void *gd_win32_get_hwnd(VirtualConsole *vc)
{
#ifdef G_OS_WIN32
return gdk_win32_window_get_impl_hwnd(
gtk_widget_get_window(vc->window ? vc->window : vc->s->window));
#else
return NULL;
#endif
}
/** DisplayState Callbacks **/ /** DisplayState Callbacks **/
static void gd_update(DisplayChangeListener *dcl, static void gd_update(DisplayChangeListener *dcl,
@ -487,12 +490,7 @@ static void gd_refresh(DisplayChangeListener *dcl)
static GdkDevice *gd_get_pointer(GdkDisplay *dpy) static GdkDevice *gd_get_pointer(GdkDisplay *dpy)
{ {
#if GTK_CHECK_VERSION(3, 20, 0)
return gdk_seat_get_pointer(gdk_display_get_default_seat(dpy)); return gdk_seat_get_pointer(gdk_display_get_default_seat(dpy));
#else
return gdk_device_manager_get_client_pointer(
gdk_display_get_device_manager(dpy));
#endif
} }
static void gd_mouse_set(DisplayChangeListener *dcl, static void gd_mouse_set(DisplayChangeListener *dcl,
@ -874,27 +872,18 @@ static gboolean gd_motion_event(GtkWidget *widget, GdkEventMotion *motion,
if (!qemu_input_is_absolute() && s->ptr_owner == vc) { if (!qemu_input_is_absolute() && s->ptr_owner == vc) {
GdkScreen *screen = gtk_widget_get_screen(vc->gfx.drawing_area); GdkScreen *screen = gtk_widget_get_screen(vc->gfx.drawing_area);
GdkDisplay *dpy = gtk_widget_get_display(widget);
GdkWindow *win = gtk_widget_get_window(widget);
GdkMonitor *monitor = gdk_display_get_monitor_at_window(dpy, win);
GdkRectangle geometry;
int screen_width, screen_height; int screen_width, screen_height;
int x = (int)motion->x_root; int x = (int)motion->x_root;
int y = (int)motion->y_root; int y = (int)motion->y_root;
#if GTK_CHECK_VERSION(3, 22, 0)
{
GdkDisplay *dpy = gtk_widget_get_display(widget);
GdkWindow *win = gtk_widget_get_window(widget);
GdkMonitor *monitor = gdk_display_get_monitor_at_window(dpy, win);
GdkRectangle geometry;
gdk_monitor_get_geometry(monitor, &geometry); gdk_monitor_get_geometry(monitor, &geometry);
screen_width = geometry.width; screen_width = geometry.width;
screen_height = geometry.height; screen_height = geometry.height;
}
#else
{
screen_width = gdk_screen_get_width(screen);
screen_height = gdk_screen_get_height(screen);
}
#endif
/* In relative mode check to see if client pointer hit /* In relative mode check to see if client pointer hit
* one of the screen edges, and if so move it back by * one of the screen edges, and if so move it back by
@ -1023,8 +1012,8 @@ static const guint16 *gd_get_keymap(size_t *maplen)
#ifdef GDK_WINDOWING_WIN32 #ifdef GDK_WINDOWING_WIN32
if (GDK_IS_WIN32_DISPLAY(dpy)) { if (GDK_IS_WIN32_DISPLAY(dpy)) {
trace_gd_keymap_windowing("win32"); trace_gd_keymap_windowing("win32");
*maplen = qemu_input_map_win32_to_qcode_len; *maplen = qemu_input_map_atset1_to_qcode_len;
return qemu_input_map_win32_to_qcode; return qemu_input_map_atset1_to_qcode;
} }
#endif #endif
@ -1070,6 +1059,25 @@ static int gd_map_keycode(int scancode)
return keycode_map[scancode]; return keycode_map[scancode];
} }
static int gd_get_keycode(GdkEventKey *key)
{
#ifdef G_OS_WIN32
int scancode = gdk_event_get_scancode((GdkEvent *)key);
/* translate Windows native scancodes to atset1 keycodes */
switch (scancode & (KF_EXTENDED | 0xff)) {
case 0x145: /* NUMLOCK */
return scancode & 0xff;
}
return scancode & KF_EXTENDED ?
0xe000 | (scancode & 0xff) : scancode & 0xff;
#else
return key->hardware_keycode;
#endif
}
static gboolean gd_text_key_down(GtkWidget *widget, static gboolean gd_text_key_down(GtkWidget *widget,
GdkEventKey *key, void *opaque) GdkEventKey *key, void *opaque)
{ {
@ -1081,7 +1089,7 @@ static gboolean gd_text_key_down(GtkWidget *widget,
} else if (key->length) { } else if (key->length) {
kbd_put_string_console(con, key->string, key->length); kbd_put_string_console(con, key->string, key->length);
} else { } else {
int qcode = gd_map_keycode(key->hardware_keycode); int qcode = gd_map_keycode(gd_get_keycode(key));
kbd_put_qcode_console(con, qcode, false); kbd_put_qcode_console(con, qcode, false);
} }
return TRUE; return TRUE;
@ -1090,18 +1098,19 @@ static gboolean gd_text_key_down(GtkWidget *widget,
static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque) static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
{ {
VirtualConsole *vc = opaque; VirtualConsole *vc = opaque;
GtkDisplayState *s = vc->s; int keycode, qcode;
int qcode;
if (s->ignore_keys) { #ifdef G_OS_WIN32
s->ignore_keys = (key->type == GDK_KEY_PRESS);
return TRUE;
}
#ifdef WIN32
/* on windows, we ought to ignore the reserved key event? */ /* on windows, we ought to ignore the reserved key event? */
if (key->hardware_keycode == 0xff) if (key->hardware_keycode == 0xff)
return false; return false;
if (!vc->s->kbd_owner) {
if (key->hardware_keycode == VK_LWIN ||
key->hardware_keycode == VK_RWIN) {
return FALSE;
}
}
#endif #endif
if (key->keyval == GDK_KEY_Pause if (key->keyval == GDK_KEY_Pause
@ -1117,9 +1126,10 @@ static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
return TRUE; return TRUE;
} }
qcode = gd_map_keycode(key->hardware_keycode); keycode = gd_get_keycode(key);
qcode = gd_map_keycode(keycode);
trace_gd_key_event(vc->label, key->hardware_keycode, qcode, trace_gd_key_event(vc->label, keycode, qcode,
(key->type == GDK_KEY_PRESS) ? "down" : "up"); (key->type == GDK_KEY_PRESS) ? "down" : "up");
qkbd_state_key_event(vc->gfx.kbd, qcode, qkbd_state_key_event(vc->gfx.kbd, qcode,
@ -1128,6 +1138,25 @@ static gboolean gd_key_event(GtkWidget *widget, GdkEventKey *key, void *opaque)
return TRUE; return TRUE;
} }
static gboolean gd_grab_broken_event(GtkWidget *widget,
GdkEventGrabBroken *event, void *opaque)
{
#ifdef CONFIG_WIN32
/*
* On Windows the Ctrl-Alt-Del key combination can't be grabbed. This
* key combination leaves all three keys in a stuck condition. We use
* the grab-broken-event to release all keys.
*/
if (event->keyboard) {
VirtualConsole *vc = opaque;
GtkDisplayState *s = vc->s;
gtk_release_modifiers(s);
}
#endif
return TRUE;
}
static gboolean gd_event(GtkWidget *widget, GdkEvent *event, void *opaque) static gboolean gd_event(GtkWidget *widget, GdkEvent *event, void *opaque)
{ {
if (event->type == GDK_MOTION_NOTIFY) { if (event->type == GDK_MOTION_NOTIFY) {
@ -1180,7 +1209,6 @@ static void gd_menu_switch_vc(GtkMenuItem *item, void *opaque)
gtk_notebook_set_current_page(nb, page); gtk_notebook_set_current_page(nb, page);
gtk_widget_grab_focus(vc->focus); gtk_widget_grab_focus(vc->focus);
} }
s->ignore_keys = false;
} }
static void gd_accel_switch_vc(void *opaque) static void gd_accel_switch_vc(void *opaque)
@ -1390,7 +1418,6 @@ static void gd_menu_zoom_fit(GtkMenuItem *item, void *opaque)
gd_update_full_redraw(vc); gd_update_full_redraw(vc);
} }
#if GTK_CHECK_VERSION(3, 20, 0)
static void gd_grab_update(VirtualConsole *vc, bool kbd, bool ptr) static void gd_grab_update(VirtualConsole *vc, bool kbd, bool ptr)
{ {
GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area); GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
@ -1414,32 +1441,6 @@ static void gd_grab_update(VirtualConsole *vc, bool kbd, bool ptr)
gdk_seat_ungrab(seat); gdk_seat_ungrab(seat);
} }
} }
#else
static void gd_grab_devices(VirtualConsole *vc, bool grab,
GdkInputSource source, GdkEventMask mask,
GdkCursor *cursor)
{
GdkDisplay *display = gtk_widget_get_display(vc->gfx.drawing_area);
GdkDeviceManager *mgr = gdk_display_get_device_manager(display);
GList *devs = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER);
GList *tmp = devs;
for (tmp = devs; tmp; tmp = tmp->next) {
GdkDevice *dev = tmp->data;
if (gdk_device_get_source(dev) != source) {
continue;
}
if (grab) {
GdkWindow *win = gtk_widget_get_window(vc->gfx.drawing_area);
gdk_device_grab(dev, win, GDK_OWNERSHIP_NONE, FALSE,
mask, cursor, GDK_CURRENT_TIME);
} else {
gdk_device_ungrab(dev, GDK_CURRENT_TIME);
}
}
g_list_free(devs);
}
#endif
static void gd_grab_keyboard(VirtualConsole *vc, const char *reason) static void gd_grab_keyboard(VirtualConsole *vc, const char *reason)
{ {
@ -1451,13 +1452,8 @@ static void gd_grab_keyboard(VirtualConsole *vc, const char *reason)
} }
} }
#if GTK_CHECK_VERSION(3, 20, 0) win32_kbd_set_grab(true);
gd_grab_update(vc, true, vc->s->ptr_owner == vc); gd_grab_update(vc, true, vc->s->ptr_owner == vc);
#else
gd_grab_devices(vc, true, GDK_SOURCE_KEYBOARD,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL);
#endif
vc->s->kbd_owner = vc; vc->s->kbd_owner = vc;
gd_update_caption(vc->s); gd_update_caption(vc->s);
trace_gd_grab(vc->label, "kbd", reason); trace_gd_grab(vc->label, "kbd", reason);
@ -1472,11 +1468,8 @@ static void gd_ungrab_keyboard(GtkDisplayState *s)
} }
s->kbd_owner = NULL; s->kbd_owner = NULL;
#if GTK_CHECK_VERSION(3, 20, 0) win32_kbd_set_grab(false);
gd_grab_update(vc, false, vc->s->ptr_owner == vc); gd_grab_update(vc, false, vc->s->ptr_owner == vc);
#else
gd_grab_devices(vc, false, GDK_SOURCE_KEYBOARD, 0, NULL);
#endif
gd_update_caption(s); gd_update_caption(s);
trace_gd_ungrab(vc->label, "kbd"); trace_gd_ungrab(vc->label, "kbd");
} }
@ -1493,21 +1486,9 @@ static void gd_grab_pointer(VirtualConsole *vc, const char *reason)
} }
} }
#if GTK_CHECK_VERSION(3, 20, 0)
gd_grab_update(vc, vc->s->kbd_owner == vc, true); gd_grab_update(vc, vc->s->kbd_owner == vc, true);
gdk_device_get_position(gd_get_pointer(display), gdk_device_get_position(gd_get_pointer(display),
NULL, &vc->s->grab_x_root, &vc->s->grab_y_root); NULL, &vc->s->grab_x_root, &vc->s->grab_y_root);
#else
gd_grab_devices(vc, true, GDK_SOURCE_MOUSE,
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_SCROLL_MASK,
vc->s->null_cursor);
gdk_device_get_position(gd_get_pointer(display),
NULL, &vc->s->grab_x_root, &vc->s->grab_y_root);
#endif
vc->s->ptr_owner = vc; vc->s->ptr_owner = vc;
gd_update_caption(vc->s); gd_update_caption(vc->s);
trace_gd_grab(vc->label, "ptr", reason); trace_gd_grab(vc->label, "ptr", reason);
@ -1524,17 +1505,10 @@ static void gd_ungrab_pointer(GtkDisplayState *s)
s->ptr_owner = NULL; s->ptr_owner = NULL;
display = gtk_widget_get_display(vc->gfx.drawing_area); display = gtk_widget_get_display(vc->gfx.drawing_area);
#if GTK_CHECK_VERSION(3, 20, 0)
gd_grab_update(vc, vc->s->kbd_owner == vc, false); gd_grab_update(vc, vc->s->kbd_owner == vc, false);
gdk_device_warp(gd_get_pointer(display), gdk_device_warp(gd_get_pointer(display),
gtk_widget_get_screen(vc->gfx.drawing_area), gtk_widget_get_screen(vc->gfx.drawing_area),
vc->s->grab_x_root, vc->s->grab_y_root); vc->s->grab_x_root, vc->s->grab_y_root);
#else
gd_grab_devices(vc, false, GDK_SOURCE_MOUSE, 0, NULL);
gdk_device_warp(gd_get_pointer(display),
gtk_widget_get_screen(vc->gfx.drawing_area),
vc->s->grab_x_root, vc->s->grab_y_root);
#endif
gd_update_caption(s); gd_update_caption(s);
trace_gd_ungrab(vc->label, "ptr"); trace_gd_ungrab(vc->label, "ptr");
} }
@ -1614,12 +1588,22 @@ static gboolean gd_leave_event(GtkWidget *widget, GdkEventCrossing *crossing,
return TRUE; return TRUE;
} }
static gboolean gd_focus_in_event(GtkWidget *widget,
GdkEventFocus *event, gpointer opaque)
{
VirtualConsole *vc = opaque;
win32_kbd_set_window(gd_win32_get_hwnd(vc));
return TRUE;
}
static gboolean gd_focus_out_event(GtkWidget *widget, static gboolean gd_focus_out_event(GtkWidget *widget,
GdkEventCrossing *crossing, gpointer opaque) GdkEventFocus *event, gpointer opaque)
{ {
VirtualConsole *vc = opaque; VirtualConsole *vc = opaque;
GtkDisplayState *s = vc->s; GtkDisplayState *s = vc->s;
win32_kbd_set_window(NULL);
gtk_release_modifiers(s); gtk_release_modifiers(s);
return TRUE; return TRUE;
} }
@ -1878,10 +1862,14 @@ static void gd_connect_vc_gfx_signals(VirtualConsole *vc)
G_CALLBACK(gd_enter_event), vc); G_CALLBACK(gd_enter_event), vc);
g_signal_connect(vc->gfx.drawing_area, "leave-notify-event", g_signal_connect(vc->gfx.drawing_area, "leave-notify-event",
G_CALLBACK(gd_leave_event), vc); G_CALLBACK(gd_leave_event), vc);
g_signal_connect(vc->gfx.drawing_area, "focus-in-event",
G_CALLBACK(gd_focus_in_event), vc);
g_signal_connect(vc->gfx.drawing_area, "focus-out-event", g_signal_connect(vc->gfx.drawing_area, "focus-out-event",
G_CALLBACK(gd_focus_out_event), vc); G_CALLBACK(gd_focus_out_event), vc);
g_signal_connect(vc->gfx.drawing_area, "configure-event", g_signal_connect(vc->gfx.drawing_area, "configure-event",
G_CALLBACK(gd_configure), vc); G_CALLBACK(gd_configure), vc);
g_signal_connect(vc->gfx.drawing_area, "grab-broken-event",
G_CALLBACK(gd_grab_broken_event), vc);
} else { } else {
g_signal_connect(vc->gfx.drawing_area, "key-press-event", g_signal_connect(vc->gfx.drawing_area, "key-press-event",
G_CALLBACK(gd_text_key_down), vc); G_CALLBACK(gd_text_key_down), vc);

3
ui/sdl2-input.c
View File

@ -27,6 +27,7 @@
#include "ui/console.h" #include "ui/console.h"
#include "ui/input.h" #include "ui/input.h"
#include "ui/sdl2.h" #include "ui/sdl2.h"
#include "trace.h"
void sdl2_process_key(struct sdl2_console *scon, void sdl2_process_key(struct sdl2_console *scon,
SDL_KeyboardEvent *ev) SDL_KeyboardEvent *ev)
@ -38,6 +39,8 @@ void sdl2_process_key(struct sdl2_console *scon,
return; return;
} }
qcode = qemu_input_map_usb_to_qcode[ev->keysym.scancode]; qcode = qemu_input_map_usb_to_qcode[ev->keysym.scancode];
trace_sdl2_process_key(ev->keysym.scancode, qcode,
ev->type == SDL_KEYDOWN ? "down" : "up");
qkbd_state_key_event(scon->kbd, qcode, ev->type == SDL_KEYDOWN); qkbd_state_key_event(scon->kbd, qcode, ev->type == SDL_KEYDOWN);
if (!qemu_console_is_graphic(con)) { if (!qemu_console_is_graphic(con)) {

33
ui/sdl2.c
View File

@ -30,6 +30,7 @@
#include "ui/sdl2.h" #include "ui/sdl2.h"
#include "sysemu/runstate.h" #include "sysemu/runstate.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "ui/win32-kbd-hook.h"
static int sdl2_num_outputs; static int sdl2_num_outputs;
static struct sdl2_console *sdl2_console; static struct sdl2_console *sdl2_console;
@ -220,6 +221,7 @@ static void sdl_grab_start(struct sdl2_console *scon)
} }
SDL_SetWindowGrab(scon->real_window, SDL_TRUE); SDL_SetWindowGrab(scon->real_window, SDL_TRUE);
gui_grab = 1; gui_grab = 1;
win32_kbd_set_grab(true);
sdl_update_caption(scon); sdl_update_caption(scon);
} }
@ -227,6 +229,7 @@ static void sdl_grab_end(struct sdl2_console *scon)
{ {
SDL_SetWindowGrab(scon->real_window, SDL_FALSE); SDL_SetWindowGrab(scon->real_window, SDL_FALSE);
gui_grab = 0; gui_grab = 0;
win32_kbd_set_grab(false);
sdl_show_cursor(scon); sdl_show_cursor(scon);
sdl_update_caption(scon); sdl_update_caption(scon);
} }
@ -325,6 +328,19 @@ static int get_mod_state(void)
} }
} }
static void *sdl2_win32_get_hwnd(struct sdl2_console *scon)
{
#ifdef CONFIG_WIN32
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if (SDL_GetWindowWMInfo(scon->real_window, &info)) {
return info.info.win.window;
}
#endif
return NULL;
}
static void handle_keydown(SDL_Event *ev) static void handle_keydown(SDL_Event *ev)
{ {
int win; int win;
@ -544,6 +560,11 @@ static void handle_windowevent(SDL_Event *ev)
sdl2_redraw(scon); sdl2_redraw(scon);
break; break;
case SDL_WINDOWEVENT_FOCUS_GAINED: case SDL_WINDOWEVENT_FOCUS_GAINED:
win32_kbd_set_grab(gui_grab);
if (qemu_console_is_graphic(scon->dcl.con)) {
win32_kbd_set_window(sdl2_win32_get_hwnd(scon));
}
/* fall through */
case SDL_WINDOWEVENT_ENTER: case SDL_WINDOWEVENT_ENTER:
if (!gui_grab && (qemu_input_is_absolute() || absolute_enabled)) { if (!gui_grab && (qemu_input_is_absolute() || absolute_enabled)) {
absolute_mouse_grab(scon); absolute_mouse_grab(scon);
@ -558,6 +579,9 @@ static void handle_windowevent(SDL_Event *ev)
scon->ignore_hotkeys = get_mod_state(); scon->ignore_hotkeys = get_mod_state();
break; break;
case SDL_WINDOWEVENT_FOCUS_LOST: case SDL_WINDOWEVENT_FOCUS_LOST:
if (qemu_console_is_graphic(scon->dcl.con)) {
win32_kbd_set_window(NULL);
}
if (gui_grab && !gui_fullscreen) { if (gui_grab && !gui_fullscreen) {
sdl_grab_end(scon); sdl_grab_end(scon);
} }
@ -857,17 +881,16 @@ static void sdl2_display_init(DisplayState *ds, DisplayOptions *o)
SDL_SetWindowIcon(sdl2_console[0].real_window, icon); SDL_SetWindowIcon(sdl2_console[0].real_window, icon);
} }
gui_grab = 0;
if (gui_fullscreen) {
sdl_grab_start(0);
}
mouse_mode_notifier.notify = sdl_mouse_mode_change; mouse_mode_notifier.notify = sdl_mouse_mode_change;
qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier); qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier);
sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0); sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
sdl_cursor_normal = SDL_GetCursor(); sdl_cursor_normal = SDL_GetCursor();
if (gui_fullscreen) {
sdl_grab_start(&sdl2_console[0]);
}
atexit(sdl_cleanup); atexit(sdl_cleanup);
} }

3
ui/trace-events
View File

@ -75,6 +75,9 @@ input_event_abs(int conidx, const char *axis, int value) "con %d, axis %s, value
input_event_sync(void) "" input_event_sync(void) ""
input_mouse_mode(int absolute) "absolute %d" input_mouse_mode(int absolute) "absolute %d"
# sdl2-input.c
sdl2_process_key(int sdl_scancode, int qcode, const char *action) "translated SDL scancode %d to QKeyCode %d (%s)"
# spice-display.c # spice-display.c
qemu_spice_add_memslot(int qid, uint32_t slot_id, unsigned long virt_start, unsigned long virt_end, int async) "%d %u: host virt 0x%lx - 0x%lx async=%d" qemu_spice_add_memslot(int qid, uint32_t slot_id, unsigned long virt_start, unsigned long virt_end, int async) "%d %u: host virt 0x%lx - 0x%lx async=%d"
qemu_spice_del_memslot(int qid, uint32_t gid, uint32_t slot_id) "%d gid=%u sid=%u" qemu_spice_del_memslot(int qid, uint32_t gid, uint32_t slot_id) "%d gid=%u sid=%u"

102
ui/win32-kbd-hook.c Normal file
View File

@ -0,0 +1,102 @@
/*
* This work is licensed under the terms of the GNU GPL, version 2 or
* (at your option) any later version. See the COPYING file in the
* top-level directory.
*
* The win32 keyboard hooking code was imported from project spice-gtk.
*/
#include "qemu/osdep.h"
#include "sysemu/sysemu.h"
#include "ui/win32-kbd-hook.h"
static Notifier win32_unhook_notifier;
static HHOOK win32_keyboard_hook;
static HWND win32_window;
static DWORD win32_grab;
static LRESULT CALLBACK keyboard_hook_cb(int code, WPARAM wparam, LPARAM lparam)
{
if (win32_window && code == HC_ACTION && win32_window == GetFocus()) {
KBDLLHOOKSTRUCT *hooked = (KBDLLHOOKSTRUCT *)lparam;
if (wparam != WM_KEYUP) {
DWORD dwmsg = (hooked->flags << 24) |
((hooked->scanCode & 0xff) << 16) | 1;
switch (hooked->vkCode) {
case VK_CAPITAL:
/* fall through */
case VK_SCROLL:
/* fall through */
case VK_NUMLOCK:
/* fall through */
case VK_LSHIFT:
/* fall through */
case VK_RSHIFT:
/* fall through */
case VK_RCONTROL:
/* fall through */
case VK_LMENU:
/* fall through */
case VK_RMENU:
break;
case VK_LCONTROL:
/*
* When pressing AltGr, an extra VK_LCONTROL with a special
* scancode with bit 9 set is sent. Let's ignore the extra
* VK_LCONTROL, as that will make AltGr misbehave.
*/
if (hooked->scanCode & 0x200) {
return 1;
}
break;
default:
if (win32_grab) {
SendMessage(win32_window, wparam, hooked->vkCode, dwmsg);
return 1;
}
break;
}
} else {
switch (hooked->vkCode) {
case VK_LCONTROL:
if (hooked->scanCode & 0x200) {
return 1;
}
break;
}
}
}
return CallNextHookEx(NULL, code, wparam, lparam);
}
static void keyboard_hook_unhook(Notifier *n, void *data)
{
UnhookWindowsHookEx(win32_keyboard_hook);
win32_keyboard_hook = NULL;
}
void win32_kbd_set_window(void *hwnd)
{
if (hwnd && !win32_keyboard_hook) {
/* note: the installing thread must have a message loop */
win32_keyboard_hook = SetWindowsHookEx(WH_KEYBOARD_LL, keyboard_hook_cb,
GetModuleHandle(NULL), 0);
if (win32_keyboard_hook) {
win32_unhook_notifier.notify = keyboard_hook_unhook;
qemu_add_exit_notifier(&win32_unhook_notifier);
}
}
win32_window = hwnd;
}
void win32_kbd_set_grab(bool grab)
{
win32_grab = grab;
}