sugar-toolkit-gtk3/bindings/globalkeys/sugar-key-grabber.c

250 lines
6.6 KiB
C
Raw Normal View History

2006-08-25 11:19:27 +02:00
/*
* Copyright (C) 2006 Red Hat, Inc
*
* Sugar is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Sugar is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
*/
2006-08-25 12:28:52 +02:00
#include <X11/X.h>
#include <gdk/gdkscreen.h>
#include <gdk/gdkx.h>
#include <gdk/gdk.h>
2006-08-25 12:28:52 +02:00
2006-08-25 11:19:27 +02:00
#include "sugar-key-grabber.h"
#include "eggaccelerators.h"
2006-08-25 11:19:27 +02:00
2006-08-25 12:28:52 +02:00
/* we exclude shift, GDK_CONTROL_MASK and GDK_MOD1_MASK since we know what
these modifiers mean
these are the mods whose combinations are bound by the keygrabbing code */
#define IGNORED_MODS (0x2000 /*Xkb modifier*/ | GDK_LOCK_MASK | \
GDK_MOD2_MASK | GDK_MOD3_MASK | GDK_MOD4_MASK | GDK_MOD5_MASK)
/* these are the ones we actually use for global keys, we always only check
* for these set */
#define USED_MODS (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)
2006-08-25 12:28:52 +02:00
2006-08-25 11:19:27 +02:00
struct _SugarKeyGrabber {
2006-08-25 12:28:52 +02:00
GObject base_instance;
GdkWindow *root;
GList *keys;
2006-08-25 11:19:27 +02:00
};
struct _SugarKeyGrabberClass {
GObjectClass base_class;
void (* key_pressed) (SugarKeyGrabber *grabber,
const char *key);
void (* key_released) (SugarKeyGrabber *grabber,
const char *key);
};
enum {
KEY_PRESSED,
KEY_RELEASED,
N_SIGNALS
2006-08-25 11:19:27 +02:00
};
typedef struct {
char *key;
guint keysym;
guint state;
guint keycode;
} Key;
2006-08-25 11:19:27 +02:00
G_DEFINE_TYPE(SugarKeyGrabber, sugar_key_grabber, G_TYPE_OBJECT)
static guint signals[N_SIGNALS];
static void
free_key_info(Key *key_info)
{
g_free(key_info->key);
g_free(key_info);
}
static void
sugar_key_grabber_dispose (GObject *object)
{
SugarKeyGrabber *grabber = SUGAR_KEY_GRABBER(object);
if (grabber->keys) {
g_list_foreach(grabber->keys, (GFunc)free_key_info, NULL);
g_list_free(grabber->keys);
grabber->keys = NULL;
}
}
2006-08-25 11:19:27 +02:00
static void
sugar_key_grabber_class_init(SugarKeyGrabberClass *grabber_class)
{
GObjectClass *g_object_class = G_OBJECT_CLASS (grabber_class);
g_object_class->dispose = sugar_key_grabber_dispose;
signals[KEY_PRESSED] = g_signal_new ("key-pressed",
G_TYPE_FROM_CLASS (grabber_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (SugarKeyGrabberClass, key_pressed),
NULL, NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING);
signals[KEY_RELEASED] = g_signal_new ("key-released",
G_TYPE_FROM_CLASS (grabber_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (SugarKeyGrabberClass, key_released),
NULL, NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING);
}
static char *
get_key_from_event(SugarKeyGrabber *grabber, XEvent *xev)
{
GList *l;
guint keycode, state;
keycode = xev->xkey.keycode;
state = xev->xkey.state;
for (l = grabber->keys; l != NULL; l = l->next) {
Key *keyinfo = (Key *)l->data;
if (keyinfo->keycode == keycode &&
(state & USED_MODS) == keyinfo->state) {
return g_strdup(keyinfo->key);
}
}
return NULL;
2006-08-25 11:19:27 +02:00
}
2006-08-25 12:28:52 +02:00
static GdkFilterReturn
filter_events(GdkXEvent *xevent, GdkEvent *event, gpointer data)
{
SugarKeyGrabber *grabber = (SugarKeyGrabber *)data;
2006-08-25 12:28:52 +02:00
XEvent *xev = (XEvent *)xevent;
if (xev->type == KeyRelease) {
char *key;
key = get_key_from_event(grabber, xevent);
if (key) {
g_signal_emit (grabber, signals[KEY_RELEASED], 0, key);
g_free(key);
XUngrabKeyboard (GDK_WINDOW_XDISPLAY (grabber->root), 0L);
return GDK_FILTER_REMOVE;
}
}
if (xev->type == KeyPress) {
char *key;
key = get_key_from_event(grabber, xevent);
if (key) {
g_signal_emit (grabber, signals[KEY_PRESSED], 0, key);
g_free(key);
XGrabKeyboard (GDK_WINDOW_XDISPLAY (grabber->root),
GDK_WINDOW_XID (grabber->root),
0, GrabModeAsync, GrabModeAsync, 0L);
return GDK_FILTER_REMOVE;
}
}
2006-08-25 12:28:52 +02:00
return GDK_FILTER_CONTINUE;
2006-08-25 12:28:52 +02:00
}
2006-08-25 11:19:27 +02:00
static void
2006-08-25 12:28:52 +02:00
sugar_key_grabber_init(SugarKeyGrabber *grabber)
{
GdkScreen *screen;
screen = gdk_screen_get_default();
grabber->root = gdk_screen_get_root_window(screen);
grabber->keys = NULL;
2006-08-25 12:28:52 +02:00
gdk_window_add_filter(grabber->root, filter_events, grabber);
}
/* grab_key and grab_key_real are from
* gnome-control-center/gnome-settings-daemon/gnome-settings-multimedia-keys.c
*/
2006-08-25 12:28:52 +02:00
static gboolean
grab_key_real (Key *key, GdkWindow *root, gboolean grab, int result)
2006-08-25 11:19:27 +02:00
{
gdk_error_trap_push ();
if (grab)
XGrabKey (GDK_DISPLAY(), key->keycode, (result | key->state),
GDK_WINDOW_XID (root), True, GrabModeAsync, GrabModeAsync);
else
XUngrabKey(GDK_DISPLAY(), key->keycode, (result | key->state),
GDK_WINDOW_XID (root));
gdk_flush ();
gdk_error_trap_pop ();
return TRUE;
}
2006-08-25 12:28:52 +02:00
#define N_BITS 32
static void
grab_key (SugarKeyGrabber *grabber, Key *key, gboolean grab)
{
int indexes[N_BITS];/*indexes of bits we need to flip*/
int i, bit, bits_set_cnt;
int uppervalue;
guint mask_to_traverse = IGNORED_MODS & ~ key->state;
bit = 0;
for (i = 0; i < N_BITS; i++) {
if (mask_to_traverse & (1<<i))
indexes[bit++]=i;
}
bits_set_cnt = bit;
uppervalue = 1<<bits_set_cnt;
for (i = 0; i < uppervalue; i++) {
int j, result = 0;
for (j = 0; j < bits_set_cnt; j++) {
if (i & (1<<j))
result |= (1<<indexes[j]);
}
if (grab_key_real (key, grabber->root, grab, result) == FALSE)
return;
}
2006-08-25 12:28:52 +02:00
}
void
sugar_key_grabber_grab(SugarKeyGrabber *grabber, const char *key)
{
Key *keyinfo;
2006-08-25 12:28:52 +02:00
keyinfo = g_new0 (Key, 1);
keyinfo->key = g_strdup(key);
egg_accelerator_parse_virtual (key, &keyinfo->keysym,
&keyinfo->keycode, &keyinfo->state);
2006-08-25 12:28:52 +02:00
grab_key(grabber, keyinfo, TRUE);
2006-08-25 12:28:52 +02:00
grabber->keys = g_list_append(grabber->keys, keyinfo);
2006-08-25 11:19:27 +02:00
}