← Back to branch summary

~ubuntu-branches/ubuntu/dapper/xfce-mcs-plugins/dapper

« back to all changes in this revision

Viewing changes to plugins/keyboard_plugin/keys_management.c

  • Committer: Bazaar Package Importer
  • Author(s): Jani Monoses
  • Date: 2006-04-11 17:40:35 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20060411174035-4y90hf4358m65r1k
Tags: 4.3.0svn+r20838-0ubuntu1
Upstream svn snapshot (merge keyboard and shortcut plugins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/keyboard_plugin/keys_management.c
 
1
/*      $Id: keys_management.c 20800 2006-04-07 22:18:46Z olivier $
 
2
 
 
3
        This program is free software; you can redistribute it and/or modify
 
4
        it under the terms of the GNU General Public License as published by
 
5
        the Free Software Foundation; either version 2, or (at your option)
 
6
        any later version.
 
7
 
 
8
        This program is distributed in the hope that it will be useful,
 
9
        but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
        GNU General Public License for more details.
 
12
 
 
13
        You should have received a copy of the GNU General Public License
 
14
        along with this program; if not, write to the Free Software
 
15
        Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
16
 
 
17
        keys_management - (c) 2002-2006 Olivier Fourdan
 
18
 
 
19
 */
 
20
 
 
21
#ifdef HAVE_CONFIG_H
 
22
#include <config.h>
 
23
#endif
 
24
 
 
25
#include <X11/Xlib.h>
 
26
#include <X11/keysym.h>
 
27
 
 
28
#include <glib.h>
 
29
#include <gdk/gdk.h>
 
30
#include <gdk/gdkx.h>
 
31
#include <stdlib.h>
 
32
#include <stdio.h>
 
33
#include <string.h>
 
34
 
 
35
#include "keys_management.h"
 
36
 
 
37
unsigned int KeyMask = 0;
 
38
unsigned int ButtonMask = 0;
 
39
unsigned int ButtonKeyMask = 0;
 
40
unsigned int AltMask = 0;
 
41
unsigned int MetaMask = 0;
 
42
unsigned int NumLockMask = 0;
 
43
unsigned int ScrollLockMask = 0;
 
44
unsigned int SuperMask = 0;
 
45
unsigned int HyperMask = 0;
 
46
 
 
47
MyKey *
 
48
parseKeyString (char *str)
 
49
{
 
50
    MyKey *my_key;
 
51
    GdkDisplay *gdisplay;
 
52
    char *k;
 
53
 
 
54
    gdisplay = gdk_display_get_default ();
 
55
 
 
56
    g_return_val_if_fail (str != NULL, NULL);
 
57
 
 
58
    my_key = g_new (MyKey, 1);
 
59
    my_key->keycode = 0;
 
60
    my_key->modifier = 0;
 
61
 
 
62
    k = strrchr (str, '+');
 
63
    if (k)
 
64
    {
 
65
        /* There is a modifier */
 
66
        gchar *tmp;
 
67
 
 
68
        tmp = g_ascii_strdown ((gchar *) str, -1);
 
69
 
 
70
        my_key->keycode = XKeysymToKeycode (GDK_DISPLAY_XDISPLAY (gdisplay), XStringToKeysym (++k));
 
71
        if (strstr (tmp, "shift"))
 
72
        {
 
73
            my_key->modifier = my_key->modifier | ShiftMask;
 
74
        }
 
75
        if (strstr (tmp, "control"))
 
76
        {
 
77
            my_key->modifier = my_key->modifier | ControlMask;
 
78
        }
 
79
        if (strstr (tmp, "alt"))
 
80
        {
 
81
            my_key->modifier = my_key->modifier | AltMask;
 
82
        }
 
83
        if (strstr (tmp, "meta"))
 
84
        {
 
85
            my_key->modifier = my_key->modifier | MetaMask;
 
86
        }
 
87
        if (strstr (tmp, "super"))
 
88
        {
 
89
            my_key->modifier = my_key->modifier | SuperMask;
 
90
        }
 
91
        if (strstr (tmp, "hyper"))
 
92
        {
 
93
            my_key->modifier = my_key->modifier | HyperMask;
 
94
        }
 
95
        if (strstr (tmp, "mod1"))
 
96
        {
 
97
            my_key->modifier = my_key->modifier | Mod1Mask;
 
98
        }
 
99
        if (strstr (tmp, "mod2"))
 
100
        {
 
101
            my_key->modifier = my_key->modifier | Mod2Mask;
 
102
        }
 
103
        if (strstr (tmp, "mod3"))
 
104
        {
 
105
            my_key->modifier = my_key->modifier | Mod3Mask;
 
106
        }
 
107
        if (strstr (tmp, "mod4"))
 
108
        {
 
109
            my_key->modifier = my_key->modifier | Mod4Mask;
 
110
        }
 
111
        if (strstr (tmp, "mod5"))
 
112
        {
 
113
            my_key->modifier = my_key->modifier | Mod5Mask;
 
114
        }
 
115
        g_free (tmp);
 
116
    }
 
117
    else
 
118
    {
 
119
        my_key->keycode = XKeysymToKeycode (GDK_DISPLAY_XDISPLAY (gdisplay), XStringToKeysym (str));
 
120
        my_key->modifier = 0;
 
121
    }
 
122
 
 
123
    return (my_key);
 
124
}
 
125
 
 
126
void
 
127
grab_key (MyKey * key)
 
128
{
 
129
    gint i, nscreens;
 
130
    GdkDisplay *gdisplay;
 
131
 
 
132
    gdisplay = gdk_display_get_default ();
 
133
    nscreens = gdk_display_get_n_screens(gdisplay);
 
134
    for(i = 0; i < nscreens; i++) 
 
135
    {
 
136
        GdkScreen *gscr;
 
137
        Window w;
 
138
        
 
139
        gscr = gdk_display_get_screen(gdisplay, i);
 
140
        w = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (gscr));
 
141
 
 
142
        if (key->keycode)
 
143
        {
 
144
            if (key->modifier == 0)
 
145
            {
 
146
                XGrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, AnyModifier, 
 
147
                          w, FALSE, GrabModeAsync, GrabModeAsync);
 
148
            }
 
149
            else
 
150
            {
 
151
                /* Here we grab all combinations of well known modifiers */
 
152
                XGrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
153
                          key->modifier, w, FALSE, GrabModeAsync, GrabModeAsync);
 
154
                XGrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
155
                          key->modifier | ScrollLockMask, w, FALSE, GrabModeAsync, GrabModeAsync);
 
156
                XGrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
157
                          key->modifier | NumLockMask, w, FALSE, GrabModeAsync, GrabModeAsync);
 
158
                XGrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
159
                          key->modifier | LockMask, w, FALSE, GrabModeAsync, GrabModeAsync);
 
160
                XGrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
161
                          key->modifier | ScrollLockMask | NumLockMask, w, FALSE, GrabModeAsync, GrabModeAsync);
 
162
                XGrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
163
                          key->modifier | ScrollLockMask | LockMask, w, FALSE, GrabModeAsync, GrabModeAsync);
 
164
                XGrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
165
                          key->modifier | LockMask | NumLockMask, w, FALSE, GrabModeAsync, GrabModeAsync);
 
166
                XGrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode,
 
167
                          key->modifier | ScrollLockMask | LockMask | NumLockMask, w, FALSE, GrabModeAsync, GrabModeAsync);
 
168
            }
 
169
        }
 
170
    }
 
171
}
 
172
 
 
173
void
 
174
ungrab_key (MyKey * key)
 
175
{
 
176
    gint i, nscreens;
 
177
    GdkDisplay *gdisplay;
 
178
 
 
179
    gdisplay = gdk_display_get_default ();
 
180
    nscreens = gdk_display_get_n_screens(gdisplay);
 
181
    for(i = 0; i < nscreens; i++) 
 
182
    {
 
183
        GdkScreen *gscr;
 
184
        Window w;
 
185
        
 
186
        gscr = gdk_display_get_screen(gdisplay, i);
 
187
        w = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (gscr));
 
188
 
 
189
        if (key->keycode)
 
190
        {
 
191
            if (key->modifier == 0)
 
192
            {
 
193
                XUngrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, AnyModifier, w);
 
194
            }
 
195
            else
 
196
            {
 
197
                XUngrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
198
                            key->modifier, w);
 
199
                XUngrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
200
                            key->modifier | ScrollLockMask, w);
 
201
                XUngrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
202
                            key->modifier | NumLockMask, w);
 
203
                XUngrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
204
                            key->modifier | LockMask, w);
 
205
                XUngrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
206
                            key->modifier | ScrollLockMask | NumLockMask, w);
 
207
                XUngrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
208
                            key->modifier | ScrollLockMask | LockMask, w);
 
209
                XUngrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
210
                            key->modifier | LockMask | NumLockMask, w);
 
211
                XUngrabKey (GDK_DISPLAY_XDISPLAY (gdisplay), key->keycode, 
 
212
                            key->modifier | ScrollLockMask | LockMask | NumLockMask, w);
 
213
            }
 
214
        }
 
215
    }
 
216
}
 
217
 
 
218
void
 
219
init_modifiers (void)
 
220
{
 
221
    GdkDisplay *gdisplay;
 
222
    GdkScreen *gscr;
 
223
    Window w;
 
224
 
 
225
    XModifierKeymap *modmap;
 
226
    KeySym *keymap;
 
227
    int i;
 
228
    int keysyms_per_keycode;
 
229
    int min_keycode;
 
230
    int max_keycode;
 
231
 
 
232
    gdisplay = gdk_display_get_default ();
 
233
    gscr = gdk_display_get_default_screen (gdisplay);
 
234
    w = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (gscr));
 
235
 
 
236
    AltMask = 0;
 
237
    MetaMask = 0;
 
238
    NumLockMask = 0;
 
239
    ScrollLockMask = 0;
 
240
    SuperMask = 0;
 
241
    HyperMask = 0;
 
242
    keysyms_per_keycode = 0;
 
243
    min_keycode = 0;
 
244
    max_keycode = 0;
 
245
 
 
246
    XDisplayKeycodes (GDK_DISPLAY_XDISPLAY (gdisplay), &min_keycode, &max_keycode);
 
247
    modmap = XGetModifierMapping (GDK_DISPLAY_XDISPLAY (gdisplay));
 
248
    keymap = XGetKeyboardMapping (GDK_DISPLAY_XDISPLAY (gdisplay), min_keycode, max_keycode - min_keycode + 1, &keysyms_per_keycode);
 
249
 
 
250
    for (i = 3 * modmap->max_keypermod; i < 8 * modmap->max_keypermod; i++)
 
251
    {
 
252
        unsigned int keycode = modmap->modifiermap[i];
 
253
 
 
254
        if ((keycode >= min_keycode) && (keycode <= max_keycode))
 
255
        {
 
256
            int j;
 
257
            KeySym *syms = keymap + (keycode - min_keycode) * keysyms_per_keycode;
 
258
 
 
259
            for (j = 0; j < keysyms_per_keycode; j++)
 
260
            {
 
261
                if (syms[j] == XK_Num_Lock)
 
262
                {
 
263
                    NumLockMask |= (1 << (i / modmap->max_keypermod));
 
264
                }
 
265
                else if (syms[j] == XK_Scroll_Lock)
 
266
                {
 
267
                    ScrollLockMask |= (1 << (i / modmap->max_keypermod));
 
268
                }
 
269
                else if ((syms[j] == XK_Super_L) || (syms[j] == XK_Super_R))
 
270
                {
 
271
                    SuperMask |= (1 << (i / modmap->max_keypermod));
 
272
                }
 
273
                else if ((syms[j] == XK_Hyper_L) || (syms[j] == XK_Hyper_R))
 
274
                {
 
275
                    HyperMask |= (1 << (i / modmap->max_keypermod));
 
276
                }
 
277
                else if ((syms[j] == XK_Meta_L) || (syms[j] == XK_Meta_R))
 
278
                {
 
279
                    MetaMask |= (1 << (i / modmap->max_keypermod));
 
280
                }
 
281
                else if ((syms[j] == XK_Alt_L) || (syms[j] == XK_Alt_R))
 
282
                {
 
283
                    AltMask |= (1 << (i / modmap->max_keypermod));
 
284
                }
 
285
            }
 
286
        }
 
287
    }
 
288
    KeyMask = ControlMask | ShiftMask | AltMask | MetaMask | SuperMask | HyperMask;
 
289
 
 
290
    ButtonMask = Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask;
 
291
 
 
292
    ButtonKeyMask = KeyMask | ButtonMask;
 
293
}