← Back to branch summary

~darkxst/gnome-settings-daemon/enable_nm

« back to all changes in this revision

Viewing changes to debian/patches/unity-modifier-media-keys.patch

  • Committer: Daniel Holbach
  • Date: 2014-05-28 12:42:05 UTC
  • Revision ID: daniel.holbach@canonical.com-20140528124205-nsl4atink1jsxtq9
https://launchpad.net/bugs/1318539
* Drop all Unity patches and legacy features (LP: #1318539)
  - Keep schemas for background plugin, since they are used by u-s-d
* debian/patches: Refreshed
  - git_new_screencast_keybinding.patch
  - git_xsettings_segfaults.patch
* debian/control.in: Fix lintian warnings
  - gnome-settings-daemon-schemas add ${misc:Depends}
  - gnome-settings-daemon fix binNMUable error for gnome-settings-daemon-schemas
* Bump standards to 3.9.5 (No changes)

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/patches/unity-modifier-media-keys.patch
1
 
--- a/plugins/common/gsd-keygrab.c
2
 
+++ b/plugins/common/gsd-keygrab.c
3
 
@@ -170,6 +170,7 @@
4
 
              key->keysym != GDK_KEY_Pause &&
5
 
              key->keysym != GDK_KEY_Print &&
6
 
              key->keysym != GDK_KEY_Scroll_Lock &&
7
 
+             key->keysym != GDK_KEY_Caps_Lock &&
8
 
              key->keysym != GDK_KEY_Pause &&
9
 
              key->keysym != GDK_KEY_Break &&
10
 
              key->keysym != GDK_KEY_Menu) {
11
 
@@ -239,19 +240,277 @@
12
 
         g_array_free (all_mods, TRUE);
13
 
 }
14
 
 
15
 
+static void
16
 
+get_keys_for_bit (guint  bit,
17
 
+                  guint *left,
18
 
+                  guint *right)
19
 
+{
20
 
+       guint left_dummy;
21
 
+       guint right_dummy;
22
 
+
23
 
+       if (left == NULL)
24
 
+               left = &left_dummy;
25
 
+       if (right == NULL)
26
 
+               right = &right_dummy;
27
 
+
28
 
+       *left = 0;
29
 
+       *right = 0;
30
 
+
31
 
+       switch (1 << bit) {
32
 
+       case GDK_SHIFT_MASK:
33
 
+               *left = GDK_KEY_Shift_L;
34
 
+               *right = GDK_KEY_Shift_R;
35
 
+               break;
36
 
+       case GDK_CONTROL_MASK:
37
 
+               *left = GDK_KEY_Control_L;
38
 
+               *right = GDK_KEY_Control_R;
39
 
+               break;
40
 
+       case GDK_LOCK_MASK:
41
 
+               *left = GDK_KEY_Caps_Lock;
42
 
+               *right = GDK_KEY_Shift_Lock;
43
 
+               break;
44
 
+       case GDK_META_MASK:
45
 
+       case GDK_MOD1_MASK:
46
 
+               *left = GDK_KEY_Alt_L;
47
 
+               *right = GDK_KEY_Alt_R;
48
 
+               break;
49
 
+       case GDK_SUPER_MASK:
50
 
+               *left = GDK_KEY_Super_L;
51
 
+               *right = GDK_KEY_Super_R;
52
 
+               break;
53
 
+       }
54
 
+}
55
 
+
56
 
+static guint
57
 
+get_mask_for_key (guint key)
58
 
+{
59
 
+       switch (key) {
60
 
+       case GDK_KEY_Shift_L:
61
 
+       case GDK_KEY_Shift_R:
62
 
+               return GDK_SHIFT_MASK;
63
 
+       case GDK_KEY_Control_L:
64
 
+       case GDK_KEY_Control_R:
65
 
+               return GDK_CONTROL_MASK;
66
 
+       case GDK_KEY_Caps_Lock:
67
 
+       case GDK_KEY_Shift_Lock:
68
 
+               return GDK_LOCK_MASK;
69
 
+       case GDK_KEY_Meta_L:
70
 
+       case GDK_KEY_Meta_R:
71
 
+       case GDK_KEY_Alt_L:
72
 
+       case GDK_KEY_Alt_R:
73
 
+               return GDK_MOD1_MASK;
74
 
+       case GDK_KEY_Super_L:
75
 
+       case GDK_KEY_Super_R:
76
 
+               return GDK_SUPER_MASK;
77
 
+       }
78
 
+
79
 
+       return 0;
80
 
+}
81
 
+
82
 
+static guint
83
 
+get_mirrored_key (guint key)
84
 
+{
85
 
+       switch (key) {
86
 
+       case GDK_KEY_Shift_L:
87
 
+               return GDK_KEY_Shift_R;
88
 
+       case GDK_KEY_Shift_R:
89
 
+               return GDK_KEY_Shift_L;
90
 
+       case GDK_KEY_Control_L:
91
 
+               return GDK_KEY_Control_R;
92
 
+       case GDK_KEY_Control_R:
93
 
+               return GDK_KEY_Control_L;
94
 
+       case GDK_KEY_Meta_L:
95
 
+               return GDK_KEY_Meta_R;
96
 
+       case GDK_KEY_Meta_R:
97
 
+               return GDK_KEY_Meta_L;
98
 
+       case GDK_KEY_Alt_L:
99
 
+               return GDK_KEY_Alt_R;
100
 
+       case GDK_KEY_Alt_R:
101
 
+               return GDK_KEY_Alt_L;
102
 
+       case GDK_KEY_Super_L:
103
 
+               return GDK_KEY_Super_R;
104
 
+       case GDK_KEY_Super_R:
105
 
+               return GDK_KEY_Super_L;
106
 
+       case GDK_KEY_Hyper_L:
107
 
+               return GDK_KEY_Hyper_R;
108
 
+       case GDK_KEY_Hyper_R:
109
 
+               return GDK_KEY_Hyper_L;
110
 
+       }
111
 
+
112
 
+       return 0;
113
 
+}
114
 
+
115
 
 void
116
 
 grab_key_unsafe (Key             *key,
117
 
                  GsdKeygrabFlags  flags,
118
 
                  GSList          *screens)
119
 
 {
120
 
+        guint key_mask = get_mask_for_key (key->keysym);
121
 
+
122
 
         grab_key_internal (key, TRUE, flags, screens);
123
 
+
124
 
+        if (key_mask != 0) {
125
 
+                Key copy;
126
 
+                guint i, j;
127
 
+
128
 
+                if ((key->state & key_mask) != 0) {
129
 
+                        guint mirror = get_mirrored_key (key->keysym);
130
 
+
131
 
+                        if (mirror != 0) {
132
 
+                                gint mirror_keys_len;
133
 
+                                GdkKeymapKey *mirror_keys;
134
 
+
135
 
+                                gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (),
136
 
+                                                                   mirror,
137
 
+                                                                   &mirror_keys,
138
 
+                                                                   &mirror_keys_len);
139
 
+
140
 
+                                copy.keysym = mirror;
141
 
+                                copy.state = key->state;
142
 
+                                copy.keycodes = g_new0 (guint, mirror_keys_len + 1);
143
 
+
144
 
+                                for (j = 0; j < mirror_keys_len; j++)
145
 
+                                        copy.keycodes[j] = mirror_keys[j].keycode;
146
 
+
147
 
+                                grab_key_internal (&copy, TRUE, flags, screens);
148
 
+
149
 
+                                g_free (copy.keycodes);
150
 
+                                g_free (mirror_keys);
151
 
+                        }
152
 
+                }
153
 
+
154
 
+                for (i = 0; i < 8 * sizeof (guint); i++) {
155
 
+                        guint left, right;
156
 
+                        gint left_keys_len, right_keys_len;
157
 
+                        GdkKeymapKey *left_keys, *right_keys;
158
 
+
159
 
+                        if (1 << i == key_mask || (key->state & 1 << i) == 0)
160
 
+                                continue;
161
 
+
162
 
+                        get_keys_for_bit (i, &left, &right);
163
 
+
164
 
+                        if (left == 0 && right == 0)
165
 
+                                continue;
166
 
+
167
 
+                        left_keys_len = 0;
168
 
+                        right_keys_len = 0;
169
 
+                        left_keys = NULL;
170
 
+                        right_keys = NULL;
171
 
+
172
 
+                        if (left != 0)
173
 
+                                gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (),
174
 
+                                                                   left,
175
 
+                                                                   &left_keys,
176
 
+                                                                   &left_keys_len);
177
 
+
178
 
+                        if (right != 0)
179
 
+                                gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (),
180
 
+                                                                   right,
181
 
+                                                                   &right_keys,
182
 
+                                                                   &right_keys_len);
183
 
+
184
 
+                        copy.keysym = left != 0 ? left : right;
185
 
+                        copy.state = (key->state | key_mask) & ~(1 << i);
186
 
+                        copy.keycodes = g_new0 (guint, left_keys_len + right_keys_len + 1);
187
 
+
188
 
+                        for (j = 0; j < left_keys_len; j++)
189
 
+                                copy.keycodes[j] = left_keys[j].keycode;
190
 
+                        for (j = 0; j < right_keys_len; j++)
191
 
+                                copy.keycodes[left_keys_len + j] = right_keys[j].keycode;
192
 
+
193
 
+                        grab_key_internal (&copy, TRUE, flags, screens);
194
 
+
195
 
+                        g_free (copy.keycodes);
196
 
+                        g_free (right_keys);
197
 
+                        g_free (left_keys);
198
 
+                }
199
 
+        }
200
 
 }
201
 
 
202
 
 void
203
 
 ungrab_key_unsafe (Key    *key,
204
 
                    GSList *screens)
205
 
 {
206
 
+        guint key_mask = get_mask_for_key (key->keysym);
207
 
+
208
 
         grab_key_internal (key, FALSE, 0, screens);
209
 
+
210
 
+        if (key_mask != 0) {
211
 
+                Key copy;
212
 
+                guint i, j;
213
 
+
214
 
+                if ((key->state & key_mask) != 0) {
215
 
+                        guint mirror = get_mirrored_key (key->keysym);
216
 
+
217
 
+                        if (mirror != 0) {
218
 
+                                gint mirror_keys_len;
219
 
+                                GdkKeymapKey *mirror_keys;
220
 
+
221
 
+                                gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (),
222
 
+                                                                   mirror,
223
 
+                                                                   &mirror_keys,
224
 
+                                                                   &mirror_keys_len);
225
 
+
226
 
+                                copy.keysym = mirror;
227
 
+                                copy.state = key->state;
228
 
+                                copy.keycodes = g_new0 (guint, mirror_keys_len + 1);
229
 
+
230
 
+                                for (j = 0; j < mirror_keys_len; j++)
231
 
+                                        copy.keycodes[j] = mirror_keys[j].keycode;
232
 
+
233
 
+                                grab_key_internal (&copy, FALSE, 0, screens);
234
 
+
235
 
+                                g_free (copy.keycodes);
236
 
+                                g_free (mirror_keys);
237
 
+                        }
238
 
+                }
239
 
+
240
 
+                for (i = 0; i < 8 * sizeof (guint); i++) {
241
 
+                        guint left, right;
242
 
+                        gint left_keys_len, right_keys_len;
243
 
+                        GdkKeymapKey *left_keys, *right_keys;
244
 
+
245
 
+                        if (1 << i == key_mask || (key->state & 1 << i) == 0)
246
 
+                                continue;
247
 
+
248
 
+                        get_keys_for_bit (i, &left, &right);
249
 
+
250
 
+                        if (left == 0 && right == 0)
251
 
+                                continue;
252
 
+
253
 
+                        left_keys_len = 0;
254
 
+                        right_keys_len = 0;
255
 
+                        left_keys = NULL;
256
 
+                        right_keys = NULL;
257
 
+
258
 
+                        if (left != 0)
259
 
+                                gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (),
260
 
+                                                                   left,
261
 
+                                                                   &left_keys,
262
 
+                                                                   &left_keys_len);
263
 
+
264
 
+                        if (right != 0)
265
 
+                                gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (),
266
 
+                                                                   right,
267
 
+                                                                   &right_keys,
268
 
+                                                                   &right_keys_len);
269
 
+
270
 
+                        copy.keysym = left != 0 ? left : right;
271
 
+                        copy.state = (key->state | key_mask) & ~(1 << i);
272
 
+                        copy.keycodes = g_new0 (guint, left_keys_len + right_keys_len + 1);
273
 
+
274
 
+                        for (j = 0; j < left_keys_len; j++)
275
 
+                                copy.keycodes[j] = left_keys[j].keycode;
276
 
+                        for (j = 0; j < right_keys_len; j++)
277
 
+                                copy.keycodes[left_keys_len + j] = right_keys[j].keycode;
278
 
+
279
 
+                        grab_key_internal (&copy, FALSE, 0, screens);
280
 
+
281
 
+                        g_free (copy.keycodes);
282
 
+                        g_free (right_keys);
283
 
+                        g_free (left_keys);
284
 
+                }
285
 
+        }
286
 
 }
287
 
 
288
 
 static gboolean
289
 
@@ -333,8 +592,9 @@
290
 
        if (gdk_keymap_translate_keyboard_state (gdk_keymap_get_default (), keycode,
291
 
                                                 state, group,
292
 
                                                 &keyval, NULL, NULL, &consumed)) {
293
 
+               guint key_bit, event_bit;
294
 
                guint lower, upper;
295
 
-               guint mask;
296
 
+               guint mask, full_mask;
297
 
 
298
 
                /* HACK: we don't want to use SysRq as a keybinding, so we avoid
299
 
                 * its translation from Alt+Print. */
300
 
@@ -346,20 +606,33 @@
301
 
 
302
 
                /* The Key structure contains virtual modifiers, whereas
303
 
                 * the XEvent will be using the real modifier, so translate those */
304
 
+               key_bit = get_mask_for_key (key->keysym);
305
 
+               event_bit = get_mask_for_key (keyval);
306
 
                mask = key->state;
307
 
+               full_mask = mask | key_bit;
308
 
                gdk_keymap_map_virtual_modifiers (gdk_keymap_get_default (), &mask);
309
 
+               gdk_keymap_map_virtual_modifiers (gdk_keymap_get_default (), &full_mask);
310
 
                 mask &= ~(GDK_META_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK);
311
 
+                full_mask &= ~(GDK_META_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK);
312
 
 
313
 
                gdk_keyval_convert_case (keyval, &lower, &upper);
314
 
 
315
 
                /* If we are checking against the lower version of the
316
 
                 * keysym, we might need the Shift state for matching,
317
 
                 * so remove it from the consumed modifiers */
318
 
-               if (lower == key->keysym)
319
 
+               if (lower == key->keysym || event_bit != 0)
320
 
                        consumed &= ~GDK_SHIFT_MASK;
321
 
 
322
 
-               return ((lower == key->keysym || upper == key->keysym)
323
 
-                       && (state & ~consumed & gsd_used_mods) == mask);
324
 
+               state &= ~consumed & gsd_used_mods;
325
 
+
326
 
+               if (key_bit != 0 && event_bit != 0) {
327
 
+                       state |= event_bit;
328
 
+                       gdk_keymap_map_virtual_modifiers (gdk_keymap_get_default (), &state);
329
 
+                       state &= ~(GDK_META_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK);
330
 
+                       return state == full_mask;
331
 
+               }
332
 
+
333
 
+               return (lower == key->keysym || upper == key->keysym) && state == mask;
334
 
        }
335
 
 
336
 
        /* The key we passed doesn't have a keysym, so try with just the keycode */
337
 
--- a/plugins/keyboard/gsd-keyboard-manager.c
338
 
+++ b/plugins/keyboard/gsd-keyboard-manager.c
339
 
@@ -959,7 +959,7 @@
340
 
          * and doesn't call us so we can't set the group switching XKB
341
 
          * option in the first place otherwise the X server's switch
342
 
          * will take effect and we get a broken configuration. */
343
 
-        if (n_sources < 2)
344
 
+        if (n_sources < 2 || g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "Unity") == 0)
345
 
                 strip_xkb_option (options, "grp:");
346
 
 
347
 
         options_str = build_xkb_options_string (options);
348
 
@@ -1006,6 +1006,8 @@
349
 
 
350
 
         gnome_xkb_info_free_var_defs (xkb_var_defs);
351
 
         g_free (rules_file_path);
352
 
+
353
 
+        XkbLockModifiers (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), XkbUseCoreKbd, LockMask, 0);
354
 
 }
355
 
 
356
 
 static void
357
 
--- a/plugins/media-keys/gsd-media-keys-manager.c
358
 
+++ b/plugins/media-keys/gsd-media-keys-manager.c
359
 
@@ -2559,6 +2559,8 @@
360
 
                    GdkEvent            *event,
361
 
                    GsdMediaKeysManager *manager)
362
 
 {
363
 
+    static gboolean ok_to_switch = TRUE;
364
 
+
365
 
     XIEvent             *xiev;
366
 
     XIDeviceEvent       *xev;
367
 
     XGenericEventCookie *cookie;
368
 
@@ -2582,6 +2584,9 @@
369
 
 
370
 
     deviceid = xev->sourceid;
371
 
 
372
 
+    if (xiev->evtype == XI_KeyPress)
373
 
+        ok_to_switch = TRUE;
374
 
+
375
 
         for (i = 0; i < manager->priv->keys->len; i++) {
376
 
                 MediaKey *key;
377
 
 
378
 
@@ -2614,6 +2619,15 @@
379
 
                                 return GDK_FILTER_REMOVE;
380
 
                         }
381
 
 
382
 
+                        if (key->key_type == SWITCH_INPUT_SOURCE_KEY || key->key_type == SWITCH_INPUT_SOURCE_BACKWARD_KEY) {
383
 
+                                if (ok_to_switch) {
384
 
+                                        do_action (manager, deviceid, key->key_type, xev->time);
385
 
+                                        ok_to_switch = FALSE;
386
 
+                                }
387
 
+
388
 
+                                return GDK_FILTER_CONTINUE;
389
 
+                        }
390
 
+
391
 
                         if (do_action (manager, deviceid, key->key_type, xev->time) == FALSE) {
392
 
                                 return GDK_FILTER_REMOVE;
393
 
                         } else {