gtk: Remove handling of virtual modifiers

These are going away. We expect to just have named modifiers in modifier masks now, so we longer juggle 'real' and 'virtual' modifiers.
gdk: Clean up GdkModifierType
2020-04-05 10:26:39 -04:00 · 2020-04-05 10:24:07 -04:00 · 2020-04-05 10:23:18 -04:00 · 2020-04-05 10:08:01 -04:00 · 2020-04-05 10:07:32 -04:00 · 2020-04-05 10:06:51 -04:00
57 changed files with 734 additions and 609 deletions
@@ -566,6 +566,11 @@ gdk_events_get_angle
 gdk_events_get_center
 gdk_events_get_distance

+<SUBSECTION>
+GdkEventMatch
+gdk_event_matches
+gdk_event_get_match
+
 <SUBSECTION Standard>
 GDK_TYPE_EVENT
 GDK_TYPE_EVENT_MASK
@@ -5960,7 +5960,6 @@ gtk_event_controller_motion_get_type
 GtkShortcutTrigger
 GtkNeverTrigger

-GtkShortcutTriggerMatch
 gtk_shortcut_trigger_trigger
 gtk_shortcut_trigger_hash
 gtk_shortcut_trigger_equal
@@ -78,11 +78,7 @@ const GDK_CROSSING_UNGRAB = 2;
 const GDK_SHIFT_MASK    = 1 << 0;
 const GDK_LOCK_MASK     = 1 << 1;
 const GDK_CONTROL_MASK  = 1 << 2;
-const GDK_MOD1_MASK     = 1 << 3;
-const GDK_MOD2_MASK     = 1 << 4;
-const GDK_MOD3_MASK     = 1 << 5;
-const GDK_MOD4_MASK     = 1 << 6;
-const GDK_MOD5_MASK     = 1 << 7;
+const GDK_ALT_MASK      = 1 << 3;
 const GDK_BUTTON1_MASK  = 1 << 8;
 const GDK_BUTTON2_MASK  = 1 << 9;
 const GDK_BUTTON3_MASK  = 1 << 10;
@@ -1383,13 +1379,13 @@ function updateKeyboardStatus() {
 }

 function updateForEvent(ev) {
-    lastState &= ~(GDK_SHIFT_MASK|GDK_CONTROL_MASK|GDK_MOD1_MASK);
+    lastState &= ~(GDK_SHIFT_MASK|GDK_CONTROL_MASK|GDK_ALT_MASK);
    if (ev.shiftKey)
        lastState |= GDK_SHIFT_MASK;
    if (ev.ctrlKey)
        lastState |= GDK_CONTROL_MASK;
    if (ev.altKey)
-        lastState |= GDK_MOD1_MASK;
+        lastState |= GDK_ALT_MASK;

    lastTimeStamp = ev.timeStamp;
 }
@@ -24,6 +24,7 @@
 #include "gdkdisplayprivate.h"
 #include "gdkinternals.h"
 #include "gdkintl.h"
+#include "gdkkeys.h"

 /* for the use of round() */
 #include "fallback-c89.c"
@@ -101,6 +102,12 @@ enum {
  PROP_NUM_TOUCHES,
  PROP_AXES,
  PROP_TOOL,
+  PROP_DIRECTION,
+  PROP_HAS_BIDI_LAYOUTS,
+  PROP_CAPS_LOCK_STATE,
+  PROP_NUM_LOCK_STATE,
+  PROP_SCROLL_LOCK_STATE,
+  PROP_MODIFIER_STATE,
  LAST_PROP
 };

@@ -281,6 +288,48 @@ gdk_device_class_init (GdkDeviceClass *klass)
                         GDK_TYPE_DEVICE_TOOL,
                         G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

+  device_props[PROP_DIRECTION] =
+      g_param_spec_enum ("direction",
+                         P_("Direction"),
+                         P_("The direction of the current layout of the keyboard"),
+                         PANGO_TYPE_DIRECTION, PANGO_DIRECTION_NEUTRAL,
+                         G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+  device_props[PROP_HAS_BIDI_LAYOUTS] =
+      g_param_spec_boolean ("has-bidi-layouts",
+                            P_("Has bidi layouts"),
+                            P_("Whether the keyboard has bidi layouts"),
+                            FALSE,
+                            G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+  device_props[PROP_CAPS_LOCK_STATE] =
+      g_param_spec_boolean ("caps-lock-state",
+                            P_("Caps lock state"),
+                            P_("Whether the keyboard caps lock is on"),
+                            FALSE,
+                            G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+  device_props[PROP_NUM_LOCK_STATE] =
+      g_param_spec_boolean ("num-lock-state",
+                            P_("Num lock state"),
+                            P_("Whether the keyboard num lock is on"),
+                            FALSE,
+                            G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+  device_props[PROP_SCROLL_LOCK_STATE] =
+      g_param_spec_boolean ("scroll-lock-state",
+                            P_("Scroll lock state"),
+                            P_("Whether the keyboard scroll lock is on"),
+                            FALSE,
+                            G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+  device_props[PROP_MODIFIER_STATE] =
+      g_param_spec_flags ("modifier-state",
+                          P_("Modifier state"),
+                          P_("The modifier state of the keyboard"),
+                          GDK_TYPE_MODIFIER_TYPE, 0,
+                          G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
  g_object_class_install_properties (object_class, LAST_PROP, device_props);

  /**
@@ -473,6 +522,24 @@ gdk_device_get_property (GObject    *object,
    case PROP_TOOL:
      g_value_set_object (value, device->last_tool);
      break;
+    case PROP_DIRECTION:
+      g_value_set_enum (value, gdk_device_get_direction (device));
+      break;
+    case PROP_HAS_BIDI_LAYOUTS:
+      g_value_set_boolean (value, gdk_device_has_bidi_layouts (device));
+      break;
+    case PROP_CAPS_LOCK_STATE:
+      g_value_set_boolean (value, gdk_device_get_caps_lock_state (device));
+      break;
+    case PROP_NUM_LOCK_STATE:
+      g_value_set_boolean (value, gdk_device_get_num_lock_state (device));
+      break;
+    case PROP_SCROLL_LOCK_STATE:
+      g_value_set_boolean (value, gdk_device_get_scroll_lock_state (device));
+      break;
+    case PROP_MODIFIER_STATE:
+      g_value_set_flags (value, gdk_device_get_modifier_state (device));
+      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
@@ -1712,3 +1779,69 @@ gdk_device_get_device_tool (GdkDevice *device)

  return device->last_tool;
 }
+
+gboolean
+gdk_device_get_caps_lock_state (GdkDevice *device)
+{
+  GdkKeymap *keymap = gdk_display_get_keymap (device->display);
+
+  if (device->source == GDK_SOURCE_KEYBOARD)
+    return gdk_keymap_get_caps_lock_state (keymap);
+
+  return FALSE;
+}
+
+gboolean
+gdk_device_get_num_lock_state (GdkDevice *device)
+{
+  GdkKeymap *keymap = gdk_display_get_keymap (device->display);
+
+  if (device->source == GDK_SOURCE_KEYBOARD)
+    return gdk_keymap_get_num_lock_state (keymap);
+
+  return FALSE;
+}
+
+gboolean
+gdk_device_get_scroll_lock_state (GdkDevice *device)
+{
+  GdkKeymap *keymap = gdk_display_get_keymap (device->display);
+
+  if (device->source == GDK_SOURCE_KEYBOARD)
+    return gdk_keymap_get_scroll_lock_state (keymap);
+
+  return FALSE;
+}
+
+GdkModifierType
+gdk_device_get_modifier_state (GdkDevice *device)
+{
+  GdkKeymap *keymap = gdk_display_get_keymap (device->display);
+
+  if (device->source == GDK_SOURCE_KEYBOARD)
+    return gdk_keymap_get_modifier_state (keymap);
+
+  return 0;
+}
+
+PangoDirection
+gdk_device_get_direction (GdkDevice *device)
+{
+  GdkKeymap *keymap = gdk_display_get_keymap (device->display);
+
+  if (device->source == GDK_SOURCE_KEYBOARD)
+    return gdk_keymap_get_direction (keymap);
+
+  return PANGO_DIRECTION_NEUTRAL;
+}
+
+gboolean
+gdk_device_has_bidi_layouts (GdkDevice *device)
+{
+  GdkKeymap *keymap = gdk_display_get_keymap (device->display);
+
+  if (device->source == GDK_SOURCE_KEYBOARD)
+    return gdk_keymap_have_bidi_layouts (keymap);
+
+  return FALSE;
+}
@@ -203,6 +203,24 @@ guint           gdk_device_get_num_touches  (GdkDevice *device);
 GDK_AVAILABLE_IN_ALL
 GdkDeviceTool * gdk_device_get_device_tool  (GdkDevice *device);

+GDK_AVAILABLE_IN_ALL
+gboolean        gdk_device_get_caps_lock_state (GdkDevice *device);
+
+GDK_AVAILABLE_IN_ALL
+gboolean        gdk_device_get_num_lock_state (GdkDevice *device);
+
+GDK_AVAILABLE_IN_ALL
+gboolean        gdk_device_get_scroll_lock_state (GdkDevice *device);
+
+GDK_AVAILABLE_IN_ALL
+GdkModifierType gdk_device_get_modifier_state (GdkDevice *device);
+
+GDK_AVAILABLE_IN_ALL
+PangoDirection  gdk_device_get_direction (GdkDevice *device);
+
+GDK_AVAILABLE_IN_ALL
+gboolean        gdk_device_has_bidi_layouts (GdkDevice *device);
+
 G_END_DECLS

 #endif /* __GDK_DEVICE_H__ */
@@ -1711,3 +1711,10 @@ gdk_display_set_cursor_theme (GdkDisplay *display,
  if (GDK_DISPLAY_GET_CLASS (display)->set_cursor_theme)
    GDK_DISPLAY_GET_CLASS (display)->set_cursor_theme (display, name, size);
 }
+
+GdkModifierType
+gdk_display_get_modifier_mask (GdkDisplay        *display,
+                               GdkModifierIntent  intent)
+{
+  return gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display), intent);  
+}
@@ -118,6 +118,10 @@ GdkMonitor * gdk_display_get_monitor_at_surface (GdkDisplay *display,
 GDK_AVAILABLE_IN_ALL
 GdkKeymap *  gdk_display_get_keymap  (GdkDisplay *display);

+GDK_AVAILABLE_IN_ALL
+GdkModifierType gdk_display_get_modifier_mask (GdkDisplay        *display,
+                                               GdkModifierIntent  intent);
+
 GDK_AVAILABLE_IN_ALL
 gboolean     gdk_display_get_setting (GdkDisplay *display,
                                      const char *name,
@@ -2110,3 +2110,234 @@ gdk_grab_broken_event_get_grab_surface (GdkEvent *event)

  return event->grab_broken.grab_surface;
 }
+
+static gboolean
+translate_keyboard_accel_state (GdkKeymap       *keymap,
+                                guint            hardware_keycode,
+                                GdkModifierType  state,
+                                gint             group,
+                                guint           *keyval,
+                                gint            *effective_group,
+                                gint            *level,
+                                GdkModifierType *consumed_modifiers)
+{
+  GdkModifierType mask;
+  GdkModifierType shift_group_mask;
+  gboolean group_mask_disabled = FALSE;
+  gboolean retval;
+
+  mask = gdk_keymap_get_modifier_mask (keymap,
+                                       GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK);
+
+  /* if the group-toggling modifier is part of the accel mod mask, and
+   * it is active, disable it for matching
+   */
+  shift_group_mask = gdk_keymap_get_modifier_mask (keymap,
+                                                   GDK_MODIFIER_INTENT_SHIFT_GROUP);
+  if (mask & state & shift_group_mask)
+    {
+      state &= ~shift_group_mask;
+      group = 0;
+      group_mask_disabled = TRUE;
+    }
+
+  retval = gdk_keymap_translate_keyboard_state (keymap,
+                                                hardware_keycode, state, group,
+                                                keyval,
+                                                effective_group, level,
+                                                consumed_modifiers);
+
+  /* add back the group mask, we want to match against the modifier,
+   * but not against the keyval from its group
+   */
+  if (group_mask_disabled)
+    {
+      if (effective_group)
+        *effective_group = 1;
+
+      if (consumed_modifiers)
+        *consumed_modifiers &= ~shift_group_mask;
+    }
+
+  return retval;
+}
+
+/**
+ * gdk_event_matches:
+ * @event: the #GdkEvent
+ * @keyval: the keyval to match
+ * @modifiers: the modifiers to match
+ *
+ * Matches an event against a keyboard shortcut that is specified
+ * as a keyval and modifiers. Note that partial matches are possible
+ * where the combination matches if the currently active group is
+ * ignored.
+ *
+ * Returns: a GdkEventMatch value describing whether @event matches
+ */
+GdkEventMatch
+gdk_event_matches (GdkEvent        *event,
+                   guint            keyval,
+                   GdkModifierType  modifiers)
+{
+  guint keycode;
+  GdkModifierType state;
+  GdkModifierType mask;
+  int group;
+  GdkKeymap *keymap;
+  guint ev_keyval;
+  int effective_group;
+  int level;
+  GdkModifierType consumed_modifiers;
+  GdkModifierType shift_group_mask;
+  gboolean group_mod_is_accel_mod = FALSE;
+
+  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
+    return GDK_EVENT_MATCH_NONE;
+
+  keycode = gdk_key_event_get_keycode (event);
+  state = gdk_event_get_modifier_state (event);
+  group = gdk_key_event_get_group (event);
+  keymap = gdk_display_get_keymap (gdk_event_get_display (event));
+
+  mask = gdk_keymap_get_modifier_mask (keymap,
+                                       GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK);
+
+  /* We don't want Caps_Lock to affect keybinding lookups.
+   */
+  state &= ~GDK_LOCK_MASK;
+
+  translate_keyboard_accel_state (keymap,
+                                  keycode, state, group,
+                                  &ev_keyval,
+                                  &effective_group, &level,
+                                  &consumed_modifiers);
+
+  /* if the group-toggling modifier is part of the default accel mod
+   * mask, and it is active, disable it for matching
+   */
+  shift_group_mask = gdk_keymap_get_modifier_mask (keymap,
+                                                   GDK_MODIFIER_INTENT_SHIFT_GROUP);
+  if (mask & shift_group_mask)
+    group_mod_is_accel_mod = TRUE;
+
+  if ((modifiers & ~consumed_modifiers & mask) == (state & ~consumed_modifiers & mask))
+    {
+      /* modifier match */
+      GdkKeymapKey *keys;
+      int n_keys;
+      int i;
+      guint key;
+
+      /* Shift gets consumed and applied for the event,
+       * so apply it to our keyval to match
+       */
+      key = keyval;
+      if (modifiers & GDK_SHIFT_MASK)
+        {
+          if (key == GDK_KEY_Tab)
+            key = GDK_KEY_ISO_Left_Tab;
+          else
+            key = gdk_keyval_to_upper (key);
+        }
+
+      if (ev_keyval == key && /* exact match */
+          (!group_mod_is_accel_mod ||
+           (state & shift_group_mask) == (modifiers & shift_group_mask)))
+        return GDK_EVENT_MATCH_EXACT;
+
+      gdk_keymap_get_entries_for_keyval (keymap, keyval, &keys, &n_keys);
+
+      for (i = 0; i < n_keys; i++)
+        {
+          if (keys[i].keycode == keycode &&
+              keys[i].level == level &&
+              /* Only match for group if it's an accel mod */
+              (!group_mod_is_accel_mod ||
+               keys[i].group == effective_group))
+            {
+              /* partial match */
+              g_free (keys);
+
+              return GDK_EVENT_MATCH_PARTIAL;
+            }
+        }
+
+      g_free (keys);
+    }
+
+
+  return GDK_EVENT_MATCH_NONE;
+}
+
+/**
+ * gdk_event_get_match:
+ * @event: a #GdkEvent
+ * @keyval: (out): return location for a keyval
+ * @modifiers: (out): return location for modifiers
+ *
+ * Gets a keyval and modifier combination that will cause
+ * gdk_event_match() to successfully match the given event.
+ *
+ * Returns: %TRUE on success
+ */
+gboolean
+gdk_event_get_match (GdkEvent        *event,
+                     guint           *keyval,
+                     GdkModifierType *modifiers)
+{
+  GdkKeymap *keymap;
+  GdkModifierType mask;
+  guint keycode;
+  guint group;
+  guint key;
+  guint accel_key;
+  GdkModifierType accel_mods;
+  GdkModifierType consumed_modifiers;
+
+  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
+    return FALSE;
+
+  keymap = gdk_display_get_keymap (gdk_event_get_display (event));
+
+  mask = gdk_keymap_get_modifier_mask (keymap,
+                                       GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK);
+
+  keycode = gdk_key_event_get_keycode (event);
+  group = gdk_key_event_get_group (event);
+  accel_key = gdk_key_event_get_keyval (event);
+  accel_mods = gdk_event_get_modifier_state (event);
+
+  if (accel_key == GDK_KEY_Sys_Req &&
+      (accel_mods & GDK_ALT_MASK) != 0)
+    {
+      /* HACK: we don't want to use SysRq as a keybinding (but we do
+       * want Alt+Print), so we avoid translation from Alt+Print to SysRq
+       */
+      *keyval = GDK_KEY_Print;
+      *modifiers = accel_mods & mask;
+      return TRUE;
+    }
+
+  translate_keyboard_accel_state (keymap,
+                                  keycode,
+                                  accel_mods,
+                                  group,
+                                  &key, NULL, NULL, &consumed_modifiers);
+
+  accel_key = gdk_keyval_to_lower (key);
+
+  if (accel_key == GDK_KEY_ISO_Left_Tab)
+    accel_key = GDK_KEY_Tab;
+
+  accel_mods &= mask & ~consumed_modifiers;
+
+  /* Put shift back if it changed the case of the key, not otherwise. */
+  if (accel_key != key)
+    accel_mods |= GDK_SHIFT_MASK;
+
+  *keyval = accel_key;
+  *modifiers = accel_mods;
+
+  return TRUE;
+}
@@ -428,6 +428,32 @@ gboolean                gdk_events_get_center           (GdkEvent *event1,
                                                         double   *x,
                                                         double   *y);

+/**
+ * GdkEventMatch:
+ * @GDK_EVENT_MATCH_NONE: The key event does not match
+ * @GDK_EVENT_MATCH_PARTIAL: The key event matches if keyboard state
+ *     (specifically, the currently active group) is ignored
+ * @GDK_EVENT_MATCH_EXACT: The key event matches
+ *
+ * The possible return values from gdk_event_matches()
+ * describe how well an event matches a given keyval and modifiers.
+ */
+typedef enum {
+  GDK_EVENT_MATCH_NONE,
+  GDK_EVENT_MATCH_PARTIAL,
+  GDK_EVENT_MATCH_EXACT
+} GdkEventMatch;
+
+GDK_AVAILABLE_IN_ALL
+GdkEventMatch          gdk_event_matches (GdkEvent        *event,
+                                          guint            keyval,
+                                          GdkModifierType  modifiers);
+
+GDK_AVAILABLE_IN_ALL
+gboolean               gdk_event_get_match (GdkEvent        *event,
+                                            guint           *keyval,
+                                            GdkModifierType *modifiers);
+
 G_END_DECLS

 #endif /* __GDK_EVENTS_H__ */
@@ -558,7 +558,7 @@ gdk_keymap_lookup_key (GdkKeymap          *keymap,
 *
 * |[<!-- language="C" -->
 * // We want to ignore irrelevant modifiers like ScrollLock
- * #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK)
+ * #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_ALT_MASK)
 * state = gdk_event_get_modifier_state (event);
 * gdk_keymap_translate_keyboard_state (keymap,
 *                                      gdk_key_event_get_keycode (event),
@@ -685,13 +685,13 @@ gdk_keymap_real_get_modifier_mask (GdkKeymap         *keymap,
      return GDK_CONTROL_MASK;

    case GDK_MODIFIER_INTENT_NO_TEXT_INPUT:
-      return GDK_MOD1_MASK | GDK_CONTROL_MASK;
+      return GDK_ALT_MASK | GDK_CONTROL_MASK;

    case GDK_MODIFIER_INTENT_SHIFT_GROUP:
      return 0;

    case GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK:
-      return (GDK_SHIFT_MASK   | GDK_CONTROL_MASK | GDK_MOD1_MASK    |
+      return (GDK_SHIFT_MASK   | GDK_CONTROL_MASK | GDK_ALT_MASK    |
 	      GDK_SUPER_MASK   | GDK_HYPER_MASK   | GDK_META_MASK);

    default:
@@ -708,7 +708,7 @@ gdk_keymap_real_get_modifier_mask (GdkKeymap         *keymap,
 * uses for a particular purpose.
 *
 * Note that this function always returns real hardware modifiers, not
- * virtual ones (e.g. it will return #GDK_MOD1_MASK rather than
+ * virtual ones (e.g. it will return #GDK_ALT_MASK rather than
 * #GDK_META_MASK if the backend maps MOD1 to META), so there are use
 * cases where the return value of this function has to be transformed
 * by gdk_keymap_add_virtual_modifiers() in order to contain the
@@ -199,7 +199,7 @@ typedef enum
 * @GDK_LOCK_MASK: a Lock key (depending on the modifier mapping of the
 *  X server this may either be CapsLock or ShiftLock).
 * @GDK_CONTROL_MASK: the Control key.
- * @GDK_MOD1_MASK: the fourth modifier key (it depends on the modifier
+ * @GDK_ALT_MASK: the fourth modifier key (it depends on the modifier
 *  mapping of the X server which key is interpreted as this modifier, but
 *  normally it is the Alt key).
 * @GDK_MOD2_MASK: the fifth modifier key (it depends on the modifier
@@ -259,47 +259,25 @@ typedef enum
  GDK_SHIFT_MASK    = 1 << 0,
  GDK_LOCK_MASK     = 1 << 1,
  GDK_CONTROL_MASK  = 1 << 2,
-  GDK_MOD1_MASK     = 1 << 3,
-  GDK_MOD2_MASK     = 1 << 4,
-  GDK_MOD3_MASK     = 1 << 5,
-  GDK_MOD4_MASK     = 1 << 6,
-  GDK_MOD5_MASK     = 1 << 7,
+  GDK_ALT_MASK      = 1 << 3,
+
  GDK_BUTTON1_MASK  = 1 << 8,
  GDK_BUTTON2_MASK  = 1 << 9,
  GDK_BUTTON3_MASK  = 1 << 10,
  GDK_BUTTON4_MASK  = 1 << 11,
  GDK_BUTTON5_MASK  = 1 << 12,

-  GDK_MODIFIER_RESERVED_13_MASK  = 1 << 13,
-  GDK_MODIFIER_RESERVED_14_MASK  = 1 << 14,
-  GDK_MODIFIER_RESERVED_15_MASK  = 1 << 15,
-  GDK_MODIFIER_RESERVED_16_MASK  = 1 << 16,
-  GDK_MODIFIER_RESERVED_17_MASK  = 1 << 17,
-  GDK_MODIFIER_RESERVED_18_MASK  = 1 << 18,
-  GDK_MODIFIER_RESERVED_19_MASK  = 1 << 19,
-  GDK_MODIFIER_RESERVED_20_MASK  = 1 << 20,
-  GDK_MODIFIER_RESERVED_21_MASK  = 1 << 21,
-  GDK_MODIFIER_RESERVED_22_MASK  = 1 << 22,
-  GDK_MODIFIER_RESERVED_23_MASK  = 1 << 23,
-  GDK_MODIFIER_RESERVED_24_MASK  = 1 << 24,
-  GDK_MODIFIER_RESERVED_25_MASK  = 1 << 25,
-
-  /* The next few modifiers are used by XKB, so we skip to the end.
-   * Bits 15 - 25 are currently unused. Bit 29 is used internally.
-   */
-  
  GDK_SUPER_MASK    = 1 << 26,
  GDK_HYPER_MASK    = 1 << 27,
  GDK_META_MASK     = 1 << 28,
  
-  GDK_MODIFIER_RESERVED_29_MASK  = 1 << 29,
-  GDK_MODIFIER_RESERVED_30_MASK  = 1 << 30,
-
-  /* Combination of GDK_SHIFT_MASK..GDK_BUTTON5_MASK + GDK_SUPER_MASK
-     + GDK_HYPER_MASK + GDK_META_MASK */
-  GDK_MODIFIER_MASK = 0x1c001fff
 } GdkModifierType;

+
+#define GDK_MODIFIER_MASK (GDK_SHIFT_MASK|GDK_LOCK_MASK|GDK_CONTROL_MASK| \
+                           GDK_SUPER_MASK|GDK_HYPER_MASK|GDK_META_MASK| \
+                           GDK_BUTTON1_MASK|GDK_BUTTON2_MASK|GDK_BUTTON3_MASK| \
+                           GDK_BUTTON4_MASK|GDK_BUTTON5_MASK)
 /**
 * GdkModifierIntent:
 * @GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR: the primary modifier used to invoke
@@ -288,7 +288,7 @@ get_keyboard_modifiers_from_ns_flags (NSUInteger nsflags)
  if (nsflags & NSControlKeyMask)
    modifiers |= GDK_CONTROL_MASK;
  if (nsflags & NSAlternateKeyMask)
-    modifiers |= GDK_MOD1_MASK;
+    modifiers |= GDK_ALT_MASK;
  if (nsflags & NSCommandKeyMask)
    modifiers |= GDK_MOD2_MASK;

@@ -1162,7 +1162,7 @@ fill_key_event (GdkSurface    *window,
          break;
        case GDK_KEY_Alt_R:
        case GDK_KEY_Alt_L:
-          mask = GDK_MOD1_MASK;
+          mask = GDK_ALT_MASK;
          break;
        case GDK_KEY_Control_R:
        case GDK_KEY_Control_L:
@@ -1280,7 +1280,7 @@ _gdk_quartz_events_get_current_keyboard_modifiers (void)
      if (carbon_modifiers & controlKey)
        modifiers |= GDK_CONTROL_MASK;
      if (carbon_modifiers & optionKey)
-        modifiers |= GDK_MOD1_MASK;
+        modifiers |= GDK_ALT_MASK;
      if (carbon_modifiers & cmdKey)
        modifiers |= GDK_MOD2_MASK;

@@ -757,10 +757,10 @@ gdk_quartz_keymap_get_modifier_mask (GdkKeymap         *keymap,
      return GDK_MOD2_MASK | GDK_CONTROL_MASK;

    case GDK_MODIFIER_INTENT_SHIFT_GROUP:
-      return GDK_MOD1_MASK;
+      return GDK_ALT_MASK;

    case GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK:
-      return (GDK_SHIFT_MASK   | GDK_CONTROL_MASK | GDK_MOD1_MASK    |
+      return (GDK_SHIFT_MASK   | GDK_CONTROL_MASK | GDK_ALT_MASK    |
 	      GDK_MOD2_MASK    | GDK_SUPER_MASK   | GDK_HYPER_MASK   |
 	      GDK_META_MASK);

@@ -1856,16 +1856,38 @@ keyboard_handle_keymap (void               *data,
 {
  GdkWaylandSeat *seat = data;
  PangoDirection direction;
+  gboolean bidi;
+  gboolean caps_lock;
+  gboolean num_lock;
+  gboolean scroll_lock;
+  GdkModifierType modifiers;

  direction = gdk_keymap_get_direction (seat->keymap);
+  bidi = gdk_keymap_have_bidi_layouts (seat->keymap);
+  caps_lock = gdk_keymap_get_caps_lock_state (seat->keymap);
+  num_lock = gdk_keymap_get_num_lock_state (seat->keymap);
+  scroll_lock = gdk_keymap_get_scroll_lock_state (seat->keymap);
+  modifiers = gdk_keymap_get_modifier_state (seat->keymap);

  _gdk_wayland_keymap_update_from_fd (seat->keymap, format, fd, size);

  g_signal_emit_by_name (seat->keymap, "keys-changed");
  g_signal_emit_by_name (seat->keymap, "state-changed");
-
  if (direction != gdk_keymap_get_direction (seat->keymap))
    g_signal_emit_by_name (seat->keymap, "direction-changed");
+
+  if (direction != gdk_keymap_get_direction (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "direction");
+  if (bidi != gdk_keymap_have_bidi_layouts (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "has-bidi-layouts");
+  if (caps_lock != gdk_keymap_get_caps_lock_state (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "caps-lock-state");
+  if (num_lock != gdk_keymap_get_num_lock_state (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "num-lock-state");
+  if (scroll_lock != gdk_keymap_get_scroll_lock_state (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "scroll-lock-state");
+  if (modifiers != gdk_keymap_get_modifier_state (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "modifier-state");
 }

 static void
@@ -2155,11 +2177,23 @@ keyboard_handle_modifiers (void               *data,
  GdkKeymap *keymap;
  struct xkb_state *xkb_state;
  PangoDirection direction;
+  gboolean bidi;
+  gboolean caps_lock;
+  gboolean num_lock;
+  gboolean scroll_lock;
+  GdkModifierType modifiers;

  keymap = seat->keymap;
-  direction = gdk_keymap_get_direction (keymap);
  xkb_state = _gdk_wayland_keymap_get_xkb_state (keymap);

+  direction = gdk_keymap_get_direction (seat->keymap);
+  bidi = gdk_keymap_have_bidi_layouts (seat->keymap);
+  caps_lock = gdk_keymap_get_caps_lock_state (seat->keymap);
+  num_lock = gdk_keymap_get_num_lock_state (seat->keymap);
+  scroll_lock = gdk_keymap_get_scroll_lock_state (seat->keymap);
+  modifiers = gdk_keymap_get_modifier_state (seat->keymap);
+
+
  /* Note: the docs for xkb_state_update mask state that all parameters
   * must be passed, or we may end up with an 'incoherent' state. But the
   * Wayland modifiers event only includes a single group field, so we
@@ -2182,6 +2216,19 @@ keyboard_handle_modifiers (void               *data,
  g_signal_emit_by_name (keymap, "state-changed");
  if (direction != gdk_keymap_get_direction (keymap))
    g_signal_emit_by_name (keymap, "direction-changed");
+
+  if (direction != gdk_keymap_get_direction (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "direction");
+  if (bidi != gdk_keymap_have_bidi_layouts (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "has-bidi-layouts");
+  if (caps_lock != gdk_keymap_get_caps_lock_state (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "caps-lock-state");
+  if (num_lock != gdk_keymap_get_num_lock_state (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "num-lock-state");
+  if (scroll_lock != gdk_keymap_get_scroll_lock_state (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "scroll-lock-state");
+  if (modifiers != gdk_keymap_get_modifier_state (seat->keymap))
+    g_object_notify (G_OBJECT (seat->master_keyboard), "modifier-state");
 }

 static void
@@ -258,16 +258,8 @@ get_xkb_modifiers (struct xkb_keymap *xkb_keymap,
    mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CAPS);
  if (state & GDK_CONTROL_MASK)
    mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CTRL);
-  if (state & GDK_MOD1_MASK)
+  if (state & GDK_ALT_MASK)
    mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_ALT);
-  if (state & GDK_MOD2_MASK)
-    mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_NUM);
-  if (state & GDK_MOD3_MASK)
-    mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod3");
-  if (state & GDK_MOD4_MASK)
-    mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_LOGO);
-  if (state & GDK_MOD5_MASK)
-    mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod5");
  if (state & GDK_SUPER_MASK)
    mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, "Super");
  if (state & GDK_HYPER_MASK)
@@ -291,15 +283,7 @@ get_gdk_modifiers (struct xkb_keymap *xkb_keymap,
  if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CTRL)))
    state |= GDK_CONTROL_MASK;
  if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_ALT)))
-    state |= GDK_MOD1_MASK;
-  if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_NUM)))
-    state |= GDK_MOD2_MASK;
-  if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod3")))
-    state |= GDK_MOD3_MASK;
-  if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_LOGO)))
-    state |= GDK_MOD4_MASK;
-  if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod5")))
-    state |= GDK_MOD5_MASK;
+    state |= GDK_ALT_MASK;
  if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Super")))
    state |= GDK_SUPER_MASK;
  if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Hyper")))
@@ -310,7 +294,7 @@ get_gdk_modifiers (struct xkb_keymap *xkb_keymap,
   * rely on that behavior.
   */
  if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Meta")) &&
-      (state & GDK_MOD1_MASK) == 0)
+      (state & GDK_ALT_MASK) == 0)
    state |= GDK_META_MASK;

  return state;
@@ -79,7 +79,7 @@ get_current_mask (void)
  if (kbd[VK_CONTROL] & 0x80)
    mask |= GDK_CONTROL_MASK;
  if (kbd[VK_MENU] & 0x80)
-    mask |= GDK_MOD1_MASK;
+    mask |= GDK_ALT_MASK;
  if (kbd[VK_LBUTTON] & 0x80)
    mask |= GDK_BUTTON1_MASK;
  if (kbd[VK_MBUTTON] & 0x80)
@@ -54,7 +54,7 @@ get_current_mask (void)
  if (kbd[VK_CONTROL] & 0x80)
    mask |= GDK_CONTROL_MASK;
  if (kbd[VK_MENU] & 0x80)
-    mask |= GDK_MOD1_MASK;
+    mask |= GDK_ALT_MASK;
  if (kbd[VK_LBUTTON] & 0x80)
    mask |= GDK_BUTTON1_MASK;
  if (kbd[VK_MBUTTON] & 0x80)
@@ -844,7 +844,7 @@ get_modifier_key_state (void)
  if (GetKeyState (VK_SHIFT) < 0)
    state |= GDK_SHIFT_MASK;
  if (GetKeyState (VK_MENU) < 0)
-    state |= GDK_MOD1_MASK;
+    state |= GDK_ALT_MASK;
  if (GetKeyState (VK_CAPITAL) & 0x1)
    state |= GDK_LOCK_MASK;

@@ -1869,7 +1869,7 @@ manufacture_keystate_from_GMT (GdkModifierType state)
 {
  DWORD key_state = 0;

-  if (state & GDK_MOD1_MASK)
+  if (state & GDK_ALT_MASK)
    key_state |= MK_ALT;
  if (state & GDK_CONTROL_MASK)
    key_state |= MK_CONTROL;
@@ -2415,22 +2415,22 @@ gdk_dnd_handle_key_event (GdkDrag  *drag,

        case GDK_KEY_Up:
        case GDK_KEY_KP_Up:
-          dy = (state & GDK_MOD1_MASK) ? -BIG_STEP : -SMALL_STEP;
+          dy = (state & GDK_ALT_MASK) ? -BIG_STEP : -SMALL_STEP;
          break;

        case GDK_KEY_Down:
        case GDK_KEY_KP_Down:
-          dy = (state & GDK_MOD1_MASK) ? BIG_STEP : SMALL_STEP;
+          dy = (state & GDK_ALT_MASK) ? BIG_STEP : SMALL_STEP;
          break;

        case GDK_KEY_Left:
        case GDK_KEY_KP_Left:
-          dx = (state & GDK_MOD1_MASK) ? -BIG_STEP : -SMALL_STEP;
+          dx = (state & GDK_ALT_MASK) ? -BIG_STEP : -SMALL_STEP;
          break;

        case GDK_KEY_Right:
        case GDK_KEY_KP_Right:
-          dx = (state & GDK_MOD1_MASK) ? BIG_STEP : SMALL_STEP;
+          dx = (state & GDK_ALT_MASK) ? BIG_STEP : SMALL_STEP;
          break;
        }
    }
@@ -662,14 +662,14 @@ build_key_event_state (BYTE *key_state)
      if (key_state[VK_RCONTROL] & 0x80)
 	state |= GDK_CONTROL_MASK;
      if (key_state[VK_LMENU] & 0x80)
-	state |= GDK_MOD1_MASK;
+	state |= GDK_ALT_MASK;
    }
  else
    {
      if (key_state[VK_CONTROL] & 0x80)
 	state |= GDK_CONTROL_MASK;
      if (key_state[VK_MENU] & 0x80)
-	state |= GDK_MOD1_MASK;
+	state |= GDK_ALT_MASK;
    }

  return state;
@@ -724,7 +724,7 @@ build_pointer_event_state (MSG *msg)
    state |= GDK_SHIFT_MASK;

  if (GetKeyState (VK_MENU) < 0)
-    state |= GDK_MOD1_MASK;
+    state |= GDK_ALT_MASK;

  if (GetKeyState (VK_CAPITAL) & 0x1)
    state |= GDK_LOCK_MASK;
@@ -741,11 +741,7 @@ print_event_state (guint state)
  CASE (SHIFT);
  CASE (LOCK);
  CASE (CONTROL);
-  CASE (MOD1);
-  CASE (MOD2);
-  CASE (MOD3);
-  CASE (MOD4);
-  CASE (MOD5);
+  CASE (ALT);
  CASE (BUTTON1);
  CASE (BUTTON2);
  CASE (BUTTON3);
@@ -2326,9 +2322,9 @@ gdk_event_translate (MSG  *msg,
      both_shift_pressed[0] = both_shift_pressed[1] = 0;
    }

-      /* Reset MOD1_MASK if it is the Alt key itself */
+      /* Reset ALT_MASK if it is the Alt key itself */
      if (msg->wParam == VK_MENU)
-	state &= ~GDK_MOD1_MASK;
+	state &= ~GDK_ALT_MASK;

      event = gdk_event_key_new ((msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
                                   ? GDK_KEY_PRESS
@@ -2148,7 +2148,7 @@ gdk_drag_get_current_actions (GdkModifierType  state,
    {
      *possible_actions = actions;

-      if ((state & (GDK_MOD1_MASK)) && (actions & GDK_ACTION_ASK))
+      if ((state & (GDK_ALT_MASK)) && (actions & GDK_ACTION_ASK))
        *suggested_action = GDK_ACTION_ASK;
      else if (actions & GDK_ACTION_COPY)
        *suggested_action =  GDK_ACTION_COPY;
@@ -2237,22 +2237,22 @@ gdk_dnd_handle_key_event (GdkDrag           *drag,

        case GDK_KEY_Up:
        case GDK_KEY_KP_Up:
-          dy = (state & GDK_MOD1_MASK) ? -BIG_STEP : -SMALL_STEP;
+          dy = (state & GDK_ALT_MASK) ? -BIG_STEP : -SMALL_STEP;
          break;

        case GDK_KEY_Down:
        case GDK_KEY_KP_Down:
-          dy = (state & GDK_MOD1_MASK) ? BIG_STEP : SMALL_STEP;
+          dy = (state & GDK_ALT_MASK) ? BIG_STEP : SMALL_STEP;
          break;

        case GDK_KEY_Left:
        case GDK_KEY_KP_Left:
-          dx = (state & GDK_MOD1_MASK) ? -BIG_STEP : -SMALL_STEP;
+          dx = (state & GDK_ALT_MASK) ? -BIG_STEP : -SMALL_STEP;
          break;

        case GDK_KEY_Right:
        case GDK_KEY_KP_Right:
-          dx = (state & GDK_MOD1_MASK) ? BIG_STEP : SMALL_STEP;
+          dx = (state & GDK_ALT_MASK) ? BIG_STEP : SMALL_STEP;
          break;

        default:
@@ -401,7 +401,7 @@ update_keymaps (GdkX11Keymap *keymap_x11)

          keymap_x11->modmap[i / keymap_x11->mod_keymap->max_keypermod] |= mask;

-          /* The fourth modifier, GDK_MOD1_MASK is 1 << 3.
+          /* The fourth modifier, GDK_ALT_MASK is 1 << 3.
           * Each group of max_keypermod entries refers to the same modifier.
           */
          mask = 1 << (i / keymap_x11->mod_keymap->max_keypermod);
@@ -427,7 +427,7 @@ update_keymaps (GdkX11Keymap *keymap_x11)

            case GDK_CONTROL_MASK:
            case GDK_SHIFT_MASK:
-            case GDK_MOD1_MASK:
+            case GDK_ALT_MASK:
              /* Some keyboard maps are known to map Mode_Switch as an
               * extra Mod1 key. In circumstances like that, it won't be
               * used to switch groups.
@@ -581,6 +581,7 @@ get_num_groups (GdkKeymap *keymap,

 static gboolean
 update_direction (GdkX11Keymap *keymap_x11,
+                  GdkDevice    *keyboard,
                  gint          group)
 {
  XkbDescPtr xkb = get_xkb (keymap_x11);
@@ -601,11 +602,18 @@ update_direction (GdkX11Keymap *keymap_x11,
      keymap_x11->have_direction = TRUE;
    }

-  return !had_direction || old_direction != keymap_x11->current_direction;
+  if (!had_direction || old_direction != keymap_x11->current_direction)
+    {
+      g_object_notify (G_OBJECT (keyboard), "direction");
+      return TRUE;
+    }
+
+  return FALSE;
 }

 static gboolean
 update_lock_state (GdkX11Keymap *keymap_x11,
+                   GdkDevice    *keyboard,
                   gint          locked_mods,
                   gint          effective_mods)
 {
@@ -632,6 +640,15 @@ update_lock_state (GdkX11Keymap *keymap_x11,
  /* FIXME: sanitize this */
  keymap_x11->modifier_state = (guint)effective_mods;

+  if (caps_lock_state != keymap_x11->caps_lock_state)
+    g_object_notify (G_OBJECT (keyboard), "caps-lock-state");
+  if (num_lock_state != keymap_x11->num_lock_state)
+    g_object_notify (G_OBJECT (keyboard), "num-lock-state");
+  if (scroll_lock_state != keymap_x11->scroll_lock_state)
+    g_object_notify (G_OBJECT (keyboard), "scroll-lock-state");
+  if (modifier_state != keymap_x11->modifier_state)
+    g_object_notify (G_OBJECT (keyboard), "modifier-state");
+
  return !have_lock_state
         || (caps_lock_state != keymap_x11->caps_lock_state)
         || (num_lock_state != keymap_x11->num_lock_state)
@@ -652,11 +669,15 @@ _gdk_x11_keymap_state_changed (GdkDisplay   *display,
  if (display_x11->keymap)
    {
      GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (display_x11->keymap);
+      GdkDevice *keyboard;

-      if (update_direction (keymap_x11, XkbStateGroup (&xkb_event->state)))
+      keyboard = gdk_seat_get_keyboard (gdk_display_get_default_seat (display));
+
+      if (update_direction (keymap_x11, keyboard, XkbStateGroup (&xkb_event->state)))
        g_signal_emit_by_name (keymap_x11, "direction-changed");

      if (update_lock_state (keymap_x11,
+                             keyboard,
                             xkb_event->state.locked_mods,
                             xkb_event->state.mods))
        g_signal_emit_by_name (keymap_x11, "state-changed");
@@ -672,6 +693,9 @@ ensure_lock_state (GdkKeymap *keymap)
  if (KEYMAP_USE_XKB (keymap))
    {
      GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (keymap);
+      GdkDevice *keyboard;
+
+      keyboard = gdk_seat_get_keyboard (gdk_display_get_default_seat (keymap->display));

      if (!keymap_x11->have_lock_state)
        {
@@ -679,7 +703,7 @@ ensure_lock_state (GdkKeymap *keymap)
          XkbStateRec state_rec;

          XkbGetState (GDK_DISPLAY_XDISPLAY (display), XkbUseCoreKbd, &state_rec);
-          update_lock_state (keymap_x11, state_rec.locked_mods, state_rec.mods);
+          update_lock_state (keymap_x11, keyboard, state_rec.locked_mods, state_rec.mods);
        }
    }
 #endif /* HAVE_XKB */
@@ -707,11 +731,14 @@ gdk_x11_keymap_get_direction (GdkKeymap *keymap)
      if (!keymap_x11->have_direction)
        {
          GdkDisplay *display = keymap->display;
+          GdkDevice *keyboard;
          XkbStateRec state_rec;

+          keyboard = gdk_seat_get_keyboard (gdk_display_get_default_seat (display));
+
          XkbGetState (GDK_DISPLAY_XDISPLAY (display), XkbUseCoreKbd,
                       &state_rec);
-          update_direction (keymap_x11, XkbStateGroup (&state_rec));
+          update_direction (keymap_x11, keyboard, XkbStateGroup (&state_rec));
        }

      return keymap_x11->current_direction;
@@ -267,7 +267,7 @@ gtk_button_accessible_get_keybinding (AtkAction *action,
    {
      key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (label));
      if (key_val != GDK_KEY_VoidSymbol)
-        return_value = gtk_accelerator_name (key_val, GDK_MOD1_MASK);
+        return_value = gtk_accelerator_name (key_val, GDK_ALT_MASK);
    }
  if (return_value == NULL)
    {
@@ -294,7 +294,7 @@ gtk_button_accessible_get_keybinding (AtkAction *action,
        {
          key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (label));
          if (key_val != GDK_KEY_VoidSymbol)
-            return_value = gtk_accelerator_name (key_val, GDK_MOD1_MASK);
+            return_value = gtk_accelerator_name (key_val, GDK_ALT_MASK);
        }
    }
  return return_value;
@@ -287,7 +287,7 @@ gtk_combo_box_accessible_get_keybinding (AtkAction *action,
    {
      key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (label));
      if (key_val != GDK_KEY_VoidSymbol)
-        return_value = gtk_accelerator_name (key_val, GDK_MOD1_MASK);
+        return_value = gtk_accelerator_name (key_val, GDK_ALT_MASK);
    }

  return return_value;
@@ -1533,7 +1533,7 @@ gtk_entry_accessible_get_keybinding (AtkAction *action,
    {
      key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (label));
      if (key_val != GDK_KEY_VoidSymbol)
-        return gtk_accelerator_name (key_val, GDK_MOD1_MASK);
+        return gtk_accelerator_name (key_val, GDK_ALT_MASK);
    }

  return NULL;
@@ -258,7 +258,7 @@ gtk_expander_accessible_get_keybinding (AtkAction *action,

      key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (label));
      if (key_val != GDK_KEY_VoidSymbol)
-        return_value = gtk_accelerator_name (key_val, GDK_MOD1_MASK);
+        return_value = gtk_accelerator_name (key_val, GDK_ALT_MASK);
    }

  return return_value;
@@ -963,7 +963,7 @@ gtk_text_accessible_get_keybinding (AtkAction *action,
    {
      key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (label));
      if (key_val != GDK_KEY_VoidSymbol)
-        return gtk_accelerator_name (key_val, GDK_MOD1_MASK);
+        return gtk_accelerator_name (key_val, GDK_ALT_MASK);
    }

  return NULL;
@@ -132,17 +132,6 @@ is_ctl (const gchar *string)
          (string[4] == '>'));
 }

-static inline gboolean
-is_modx (const gchar *string)
-{
-  return ((string[0] == '<') &&
-          (string[1] == 'm' || string[1] == 'M') &&
-          (string[2] == 'o' || string[2] == 'O') &&
-          (string[3] == 'd' || string[3] == 'D') &&
-          (string[4] >= '1' && string[4] <= '5') &&
-          (string[5] == '>'));
-}
-
 static inline gboolean
 is_ctrl (const gchar *string)
 {
@@ -287,6 +276,7 @@ gtk_accelerator_parse_with_keycode (const gchar     *accelerator,
  GdkModifierType mods;
  gint len;
  gboolean error;
+  GdkModifierType primary;

  if (accelerator_key)
    *accelerator_key = 0;
@@ -297,6 +287,9 @@ gtk_accelerator_parse_with_keycode (const gchar     *accelerator,

  g_return_val_if_fail (accelerator != NULL, FALSE);

+  primary = gdk_display_get_modifier_mask (display,
+                                           GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
+
  error = FALSE;
  keyval = 0;
  mods = 0;
@@ -309,7 +302,7 @@ gtk_accelerator_parse_with_keycode (const gchar     *accelerator,
            {
              accelerator += 9;
              len -= 9;
-              mods |= _gtk_get_primary_accel_mod ();
+              mods |= primary;
            }
          else if (len >= 9 && is_control (accelerator))
            {
@@ -335,18 +328,6 @@ gtk_accelerator_parse_with_keycode (const gchar     *accelerator,
              len -= 6;
              mods |= GDK_CONTROL_MASK;
            }
-          else if (len >= 6 && is_modx (accelerator))
-            {
-              static const guint mod_vals[] = {
-                GDK_MOD1_MASK, GDK_MOD2_MASK, GDK_MOD3_MASK,
-                GDK_MOD4_MASK, GDK_MOD5_MASK
-              };
-
-              len -= 6;
-              accelerator += 4;
-              mods |= mod_vals[*accelerator - '1'];
-              accelerator += 2;
-            }
          else if (len >= 5 && is_ctl (accelerator))
            {
              accelerator += 5;
@@ -357,7 +338,7 @@ gtk_accelerator_parse_with_keycode (const gchar     *accelerator,
            {
              accelerator += 5;
              len -= 5;
-              mods |= GDK_MOD1_MASK;
+              mods |= GDK_ALT_MASK;
            }
          else if (len >= 6 && is_meta (accelerator))
            {
@@ -564,7 +545,6 @@ gtk_accelerator_name_with_keycode (GdkDisplay      *display,
  if (display == NULL)
    display = gdk_display_manager_get_default_display (gdk_display_manager_get ());

-  gdk_keymap_add_virtual_modifiers (gdk_display_get_keymap (display), &accelerator_mods);
  gtk_name = gtk_accelerator_name (accelerator_key, accelerator_mods);

  if (!accelerator_key)
@@ -599,11 +579,7 @@ gtk_accelerator_name (guint           accelerator_key,
  static const gchar text_primary[] = "<Primary>";
  static const gchar text_shift[] = "<Shift>";
  static const gchar text_control[] = "<Control>";
-  static const gchar text_mod1[] = "<Alt>";
-  static const gchar text_mod2[] = "<Mod2>";
-  static const gchar text_mod3[] = "<Mod3>";
-  static const gchar text_mod4[] = "<Mod4>";
-  static const gchar text_mod5[] = "<Mod5>";
+  static const gchar text_alt[] = "<Alt>";
  static const gchar text_meta[] = "<Meta>";
  static const gchar text_super[] = "<Super>";
  static const gchar text_hyper[] = "<Hyper>";
@@ -611,6 +587,10 @@ gtk_accelerator_name (guint           accelerator_key,
  guint l;
  const char *keyval_name;
  gchar *accelerator;
+  GdkModifierType primary;
+
+  primary = gdk_display_get_modifier_mask (gdk_display_get_default (),
+                                           GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);

  accelerator_mods &= GDK_MODIFIER_MASK;

@@ -620,26 +600,17 @@ gtk_accelerator_name (guint           accelerator_key,

  saved_mods = accelerator_mods;
  l = 0;
-  if (accelerator_mods & _gtk_get_primary_accel_mod ())
+  if (accelerator_mods & primary)
    {
      l += sizeof (text_primary) - 1;
-      accelerator_mods &= ~_gtk_get_primary_accel_mod (); /* consume the default accel */
+      accelerator_mods &= ~primary; /* consume the default accel */
    }
  if (accelerator_mods & GDK_SHIFT_MASK)
    l += sizeof (text_shift) - 1;
  if (accelerator_mods & GDK_CONTROL_MASK)
    l += sizeof (text_control) - 1;
-  if (accelerator_mods & GDK_MOD1_MASK)
-    l += sizeof (text_mod1) - 1;
-  if (accelerator_mods & GDK_MOD2_MASK)
-    l += sizeof (text_mod2) - 1;
-  if (accelerator_mods & GDK_MOD3_MASK)
-    l += sizeof (text_mod3) - 1;
-  if (accelerator_mods & GDK_MOD4_MASK)
-    l += sizeof (text_mod4) - 1;
-  if (accelerator_mods & GDK_MOD5_MASK)
-    l += sizeof (text_mod5) - 1;
-  l += strlen (keyval_name);
+  if (accelerator_mods & GDK_ALT_MASK)
+    l += sizeof (text_alt) - 1;
  if (accelerator_mods & GDK_META_MASK)
    l += sizeof (text_meta) - 1;
  if (accelerator_mods & GDK_HYPER_MASK)
@@ -652,11 +623,11 @@ gtk_accelerator_name (guint           accelerator_key,
  accelerator_mods = saved_mods;
  l = 0;
  accelerator[l] = 0;
-  if (accelerator_mods & _gtk_get_primary_accel_mod ())
+  if (accelerator_mods & primary)
    {
      strcpy (accelerator + l, text_primary);
      l += sizeof (text_primary) - 1;
-      accelerator_mods &= ~_gtk_get_primary_accel_mod (); /* consume the default accel */
+      accelerator_mods &= ~primary; /* consume the default accel */
    }
  if (accelerator_mods & GDK_SHIFT_MASK)
    {
@@ -668,30 +639,10 @@ gtk_accelerator_name (guint           accelerator_key,
      strcpy (accelerator + l, text_control);
      l += sizeof (text_control) - 1;
    }
-  if (accelerator_mods & GDK_MOD1_MASK)
+  if (accelerator_mods & GDK_ALT_MASK)
    {
-      strcpy (accelerator + l, text_mod1);
-      l += sizeof (text_mod1) - 1;
-    }
-  if (accelerator_mods & GDK_MOD2_MASK)
-    {
-      strcpy (accelerator + l, text_mod2);
-      l += sizeof (text_mod2) - 1;
-    }
-  if (accelerator_mods & GDK_MOD3_MASK)
-    {
-      strcpy (accelerator + l, text_mod3);
-      l += sizeof (text_mod3) - 1;
-    }
-  if (accelerator_mods & GDK_MOD4_MASK)
-    {
-      strcpy (accelerator + l, text_mod4);
-      l += sizeof (text_mod4) - 1;
-    }
-  if (accelerator_mods & GDK_MOD5_MASK)
-    {
-      strcpy (accelerator + l, text_mod5);
-      l += sizeof (text_mod5) - 1;
+      strcpy (accelerator + l, text_alt);
+      l += sizeof (text_alt) - 1;
    }
  if (accelerator_mods & GDK_META_MASK)
    {
@@ -741,7 +692,6 @@ gtk_accelerator_get_label_with_keycode (GdkDisplay      *display,
  if (display == NULL)
    display = gdk_display_manager_get_default_display (gdk_display_manager_get ());

-  gdk_keymap_add_virtual_modifiers (gdk_display_get_keymap (display), &accelerator_mods);
  gtk_label = gtk_accelerator_get_label (accelerator_key, accelerator_mods);

  if (!accelerator_key)
@@ -946,7 +896,7 @@ gtk_accelerator_print_label (GString        *gstring,
      seen_mod = TRUE;
    }

-  if (accelerator_mods & GDK_MOD1_MASK)
+  if (accelerator_mods & GDK_ALT_MASK)
    {
      if (seen_mod)
        append_separator (gstring);
@@ -965,42 +915,6 @@ gtk_accelerator_print_label (GString        *gstring,
      seen_mod = TRUE;
    }

-  if (accelerator_mods & GDK_MOD2_MASK)
-    {
-      if (seen_mod)
-        append_separator (gstring);
-
-      g_string_append (gstring, "Mod2");
-      seen_mod = TRUE;
-    }
-
-  if (accelerator_mods & GDK_MOD3_MASK)
-    {
-      if (seen_mod)
-        append_separator (gstring);
-
-      g_string_append (gstring, "Mod3");
-      seen_mod = TRUE;
-    }
-
-  if (accelerator_mods & GDK_MOD4_MASK)
-    {
-      if (seen_mod)
-        append_separator (gstring);
-
-      g_string_append (gstring, "Mod4");
-      seen_mod = TRUE;
-    }
-
-  if (accelerator_mods & GDK_MOD5_MASK)
-    {
-      if (seen_mod)
-        append_separator (gstring);
-
-      g_string_append (gstring, "Mod5");
-      seen_mod = TRUE;
-    }
-
  if (accelerator_mods & GDK_SUPER_MASK)
    {
      if (seen_mod)
@@ -1099,7 +1013,7 @@ gtk_accelerator_print_label (GString        *gstring,
 * Sets the modifiers that will be considered significant for keyboard
 * accelerators. The default mod mask depends on the GDK backend in use,
 * but will typically include #GDK_CONTROL_MASK | #GDK_SHIFT_MASK |
- * #GDK_MOD1_MASK | #GDK_SUPER_MASK | #GDK_HYPER_MASK | #GDK_META_MASK.
+ * #GDK_ALT_MASK | #GDK_SUPER_MASK | #GDK_HYPER_MASK | #GDK_META_MASK.
 * In other words, Control, Shift, Alt, Super, Hyper and Meta. Other
 * modifiers will by default be ignored by #GtkAccelGroup.
 *
@@ -1113,7 +1027,7 @@ void
 gtk_accelerator_set_default_mod_mask (GdkModifierType default_mod_mask)
 {
  default_accel_mod_mask = (default_mod_mask & GDK_MODIFIER_MASK) |
-    (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK);
+    (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_ALT_MASK);
 }

 /**
@@ -1136,11 +1050,11 @@ gtk_accelerator_get_default_mod_mask (void)
      display = gdk_display_get_default ();

      if (!display)
-        return GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK;
+        return GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_ALT_MASK;

      default_accel_mod_mask =
-          gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-				        GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK);
+          gdk_display_get_modifier_mask (display,
+                                         GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK);
    }

  return default_accel_mod_mask;
@@ -346,7 +346,7 @@ icon_loaded (GObject      *object,
        modifiers |= NSShiftKeyMask;
      if (mask & GDK_CONTROL_MASK)
        modifiers |= NSControlKeyMask;
-      if (mask & GDK_MOD1_MASK)
+      if (mask & GDK_ALT_MASK)
        modifiers |= NSAlternateKeyMask;
      if (mask & GDK_META_MASK)
        modifiers |= NSCommandKeyMask;
@@ -535,55 +535,14 @@ key_controller_key_pressed (GtkEventControllerKey *key,
                            GtkWidget             *widget)
 {
  GtkCellEditableWidget *box = (GtkCellEditableWidget*)widget;
+  gboolean edited = FALSE;
+  gboolean cleared = FALSE;
  GdkModifierType accel_mods = 0;
  guint accel_key;
-  gboolean edited;
-  gboolean cleared;
-  GdkModifierType consumed_modifiers;
-  GdkDisplay *display;
-  guint group = 0;
-
-  display = gtk_widget_get_display (widget);
-  group = gtk_event_controller_key_get_group (key);
-
-  edited = FALSE;
-  cleared = FALSE;
-
-  accel_mods = state;
-
-  if (keyval == GDK_KEY_Sys_Req &&
-      (accel_mods & GDK_MOD1_MASK) != 0)
-    {
-      /* HACK: we don't want to use SysRq as a keybinding (but we do
-       * want Alt+Print), so we avoid translation from Alt+Print to SysRq
-       */
-      keyval = GDK_KEY_Print;
-      consumed_modifiers = 0;
-    }
-  else
-    {
-      _gtk_translate_keyboard_accel_state (gdk_display_get_keymap (display),
-                                           keycode,
-                                           state,
-                                           gtk_accelerator_get_default_mod_mask (),
-                                           group,
-                                           &keyval, NULL, NULL, &consumed_modifiers);
-    }
-
-  accel_key = gdk_keyval_to_lower (keyval);
-  if (accel_key == GDK_KEY_ISO_Left_Tab)
-    accel_key = GDK_KEY_Tab;
-
-  accel_mods &= gtk_accelerator_get_default_mod_mask ();
-
-  /* Filter consumed modifiers */
-  if (box->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK)
-    accel_mods &= ~consumed_modifiers;
-
-  /* Put shift back if it changed the case of the key, not otherwise. */
-  if (accel_key != keyval)
-    accel_mods |= GDK_SHIFT_MASK;

+  if (!gdk_event_get_match (gtk_get_current_event (), &accel_key, &accel_mods))
+    return FALSE;
+    
  if (accel_mods == 0)
    {
      switch (keyval)
@@ -321,7 +321,7 @@ key_controller_key_pressed (GtkEventControllerKey *controller,
  GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
  gdouble step;

-  if ((state & GDK_MOD1_MASK) != 0)
+  if ((state & GDK_ALT_MASK) != 0)
    step = 0.1;
  else
    step = 0.01;
@@ -561,20 +561,20 @@ gtk_combo_box_class_init (GtkComboBoxClass *klass)

  /* key bindings */
  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_Down, GDK_MOD1_MASK,
+                                       GDK_KEY_Down, GDK_ALT_MASK,
                                       "popup",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_KP_Down, GDK_MOD1_MASK,
+                                       GDK_KEY_KP_Down, GDK_ALT_MASK,
                                       "popup",
                                       NULL);

  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_Up, GDK_MOD1_MASK,
+                                       GDK_KEY_Up, GDK_ALT_MASK,
                                       "popdown",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_KP_Up, GDK_MOD1_MASK,
+                                       GDK_KEY_KP_Up, GDK_ALT_MASK,
                                       "popdown",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
@@ -7500,29 +7500,29 @@ gtk_file_chooser_widget_class_init (GtkFileChooserWidgetClass *class)
                                       NULL);

  add_normal_and_shifted_binding (widget_class,
-                                  GDK_KEY_Up, GDK_MOD1_MASK,
+                                  GDK_KEY_Up, GDK_ALT_MASK,
                                  "up-folder");
  add_normal_and_shifted_binding (widget_class,
-                                  GDK_KEY_KP_Up, GDK_MOD1_MASK,
+                                  GDK_KEY_KP_Up, GDK_ALT_MASK,
                                  "up-folder");

  add_normal_and_shifted_binding (widget_class,
-                                  GDK_KEY_Down, GDK_MOD1_MASK,
+                                  GDK_KEY_Down, GDK_ALT_MASK,
                                  "down-folder");
  add_normal_and_shifted_binding (widget_class,
-                                  GDK_KEY_KP_Down, GDK_MOD1_MASK,
+                                  GDK_KEY_KP_Down, GDK_ALT_MASK,
                                  "down-folder");

  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_Home, GDK_MOD1_MASK,
+                                       GDK_KEY_Home, GDK_ALT_MASK,
                                       "home-folder",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_KP_Home, GDK_MOD1_MASK,
+                                       GDK_KEY_KP_Home, GDK_ALT_MASK,
                                       "home-folder",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_d, GDK_MOD1_MASK,
+                                       GDK_KEY_d, GDK_ALT_MASK,
                                       "desktop-folder",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
@@ -7530,7 +7530,7 @@ gtk_file_chooser_widget_class_init (GtkFileChooserWidgetClass *class)
                                       "show-hidden",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_s, GDK_MOD1_MASK,
+                                       GDK_KEY_s, GDK_ALT_MASK,
                                       "search-shortcut",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
@@ -7538,11 +7538,11 @@ gtk_file_chooser_widget_class_init (GtkFileChooserWidgetClass *class)
                                       "search-shortcut",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_r, GDK_MOD1_MASK,
+                                       GDK_KEY_r, GDK_ALT_MASK,
                                       "recent-shortcut",
                                       NULL);
  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_p, GDK_MOD1_MASK,
+                                       GDK_KEY_p, GDK_ALT_MASK,
                                       "places-shortcut",
                                       NULL);
  gtk_widget_class_add_binding (widget_class,
@@ -7564,7 +7564,7 @@ gtk_file_chooser_widget_class_init (GtkFileChooserWidgetClass *class)

  for (i = 0; i < G_N_ELEMENTS (quick_bookmark_keyvals); i++)
    gtk_widget_class_add_binding_signal (widget_class,
-                                         quick_bookmark_keyvals[i], GDK_MOD1_MASK,
+                                         quick_bookmark_keyvals[i], GDK_ALT_MASK,
                                         "quick-bookmark",
                                         "(i)", i);

@@ -2999,10 +2999,10 @@ gtk_flow_box_add_move_binding (GtkWidgetClass  *widget_class,
  display = gdk_display_get_default ();
  if (display != NULL)
    {
-      extend_mod_mask = gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-                                                      GDK_MODIFIER_INTENT_EXTEND_SELECTION);
-      modify_mod_mask = gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-                                                      GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+      extend_mod_mask = gdk_display_get_modifier_mask (display,
+                                                        GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+      modify_mod_mask = gdk_display_get_modifier_mask (display,
+                                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
    }

  gtk_widget_class_add_binding_signal (widget_class,
@@ -1034,7 +1034,6 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
  GtkIMContextSimplePrivate *priv = context_simple->priv;
  GdkSurface *surface = gdk_event_get_surface ((GdkEvent *) event);
  GdkDisplay *display = gdk_surface_get_display (surface);
-  GdkKeymap *keymap = gdk_display_get_keymap (display);
  GSList *tmp_list;
  int n_compose = 0;
  GdkModifierType hex_mod_mask;
@@ -1053,10 +1052,10 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
  while (priv->compose_buffer[n_compose] != 0)
    n_compose++;

-  keyval = gdk_key_event_get_keyval ((GdkEvent *)event);
-  state = gdk_event_get_modifier_state ((GdkEvent *)event);
+  keyval = gdk_key_event_get_keyval (event);
+  state = gdk_event_get_modifier_state (event);

-  if (gdk_event_get_event_type ((GdkEvent *) event) == GDK_KEY_RELEASE)
+  if (gdk_event_get_event_type (event) == GDK_KEY_RELEASE)
    {
      if (priv->in_hex_sequence &&
          (keyval == GDK_KEY_Control_L || keyval == GDK_KEY_Control_R ||
@@ -1100,7 +1099,7 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
    if (keyval == gtk_compose_ignore[i])
      return FALSE;

-  hex_mod_mask = gdk_keymap_get_modifier_mask (keymap, GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
+  hex_mod_mask = gdk_display_get_modifier_mask (display, GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
  hex_mod_mask |= GDK_SHIFT_MASK;

  if (priv->in_hex_sequence && priv->modifiers_dropped)
@@ -1132,7 +1131,7 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
    {
      GdkModifierType no_text_input_mask;

-      no_text_input_mask = gdk_keymap_get_modifier_mask (keymap, GDK_MODIFIER_INTENT_NO_TEXT_INPUT);
+      no_text_input_mask = gdk_display_get_modifier_mask (display, GDK_MODIFIER_INTENT_NO_TEXT_INPUT);

      if (state & no_text_input_mask ||
 	  (priv->in_hex_sequence && priv->modifiers_dropped &&
@@ -369,8 +369,8 @@ gtk_im_multicontext_filter_keypress (GtkIMContext *context,
      display = gdk_event_get_display (event);

      no_text_input_mask =
-        gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-                                      GDK_MODIFIER_INTENT_NO_TEXT_INPUT);
+        gdk_display_get_modifier_mask (display,
+                                       GDK_MODIFIER_INTENT_NO_TEXT_INPUT);

      if (gdk_event_get_event_type (event) == GDK_KEY_PRESS &&
          (state & no_text_input_mask) == 0)
@@ -1090,10 +1090,10 @@ gtk_label_class_init (GtkLabelClass *class)
 				       "move-cursor",
                                       "(iib)", GTK_MOVEMENT_PARAGRAPH_ENDS, 0, FALSE);

-  add_move_binding (widget_class, GDK_KEY_f, GDK_MOD1_MASK,
+  add_move_binding (widget_class, GDK_KEY_f, GDK_ALT_MASK,
 		    GTK_MOVEMENT_WORDS, 1);

-  add_move_binding (widget_class, GDK_KEY_b, GDK_MOD1_MASK,
+  add_move_binding (widget_class, GDK_KEY_b, GDK_ALT_MASK,
 		    GTK_MOVEMENT_WORDS, -1);

  add_move_binding (widget_class, GDK_KEY_Home, 0,
@@ -5540,8 +5540,9 @@ get_better_cursor (GtkLabel *label,
 		   gint      *y)
 {
  GtkLabelPrivate *priv = gtk_label_get_instance_private (label);
-  GdkKeymap *keymap = gdk_display_get_keymap (gtk_widget_get_display (GTK_WIDGET (label)));
-  PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
+  GdkSeat *seat = gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET (label)));
+  GdkDevice *device = gdk_seat_get_keyboard (seat);
+  PangoDirection keymap_direction = gdk_device_get_direction (device);
  PangoDirection cursor_direction = get_cursor_direction (label);
  gboolean split_cursor;
  PangoRectangle strong_pos, weak_pos;
@@ -5644,8 +5645,9 @@ gtk_label_move_visually (GtkLabel *label,
 	strong = TRUE;
      else
 	{
-	  GdkKeymap *keymap = gdk_display_get_keymap (gtk_widget_get_display (GTK_WIDGET (label)));
-	  PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
+	  GdkSeat *seat = gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET (label)));
+          GdkDevice *device = gdk_seat_get_keyboard (seat);
+	  PangoDirection keymap_direction = gdk_device_get_direction (device);

 	  strong = keymap_direction == get_cursor_direction (label);
 	}
@@ -1432,10 +1432,10 @@ gtk_list_box_add_move_binding (GtkWidgetClass  *widget_class,
  display = gdk_display_get_default ();
  if (display)
    {
-      extend_mod_mask = gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-                                                      GDK_MODIFIER_INTENT_EXTEND_SELECTION);
-      modify_mod_mask = gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-                                                      GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+      extend_mod_mask = gdk_display_get_modifier_mask (display,
+                                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+      modify_mod_mask = gdk_display_get_modifier_mask (display,
+                                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
    }

  gtk_widget_class_add_binding_signal (widget_class,
@@ -968,11 +968,11 @@ add_reorder_bindings (GtkWidgetClass   *widget_class,
  guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;

  gtk_widget_class_add_binding_signal (widget_class,
-                                       keysym, GDK_MOD1_MASK,
+                                       keysym, GDK_ALT_MASK,
                                       "reorder_tab",
                                       "(ib)", direction, move_to_last);
  gtk_widget_class_add_binding_signal (widget_class,
-                                       keypad_keysym, GDK_MOD1_MASK,
+                                       keypad_keysym, GDK_ALT_MASK,
                                       "reorder_tab",
                                       "(ib)", direction, move_to_last);
 }
@@ -1349,11 +1349,11 @@ gtk_notebook_class_init (GtkNotebookClass *class)
                                       "(i)", 1);

  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_Page_Up, GDK_CONTROL_MASK | GDK_MOD1_MASK,
+                                       GDK_KEY_Page_Up, GDK_CONTROL_MASK | GDK_ALT_MASK,
                                       "change-current-page",
                                       "(i)", -1);
  gtk_widget_class_add_binding_signal (widget_class,
-                                       GDK_KEY_Page_Down, GDK_CONTROL_MASK | GDK_MOD1_MASK,
+                                       GDK_KEY_Page_Down, GDK_CONTROL_MASK | GDK_ALT_MASK,
                                       "change-current-page",
                                       "(i)", 1);

@@ -55,7 +55,7 @@ typedef struct {
  GtkWidget *entry;
  GtkWidget *icon;
  GtkWidget *peek_icon;
-  GdkKeymap *keymap;
+  GdkDevice *keyboard;
  GMenuModel *extra_menu;
 } GtkPasswordEntryPrivate;

@@ -81,16 +81,17 @@ G_DEFINE_TYPE_WITH_CODE (GtkPasswordEntry, gtk_password_entry, GTK_TYPE_WIDGET,
                         G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE, gtk_password_entry_editable_init))

 static void
-keymap_state_changed (GdkKeymap *keymap,
-                      GtkWidget *widget)
+caps_lock_state_changed (GdkDevice  *device,
+                         GParamSpec *pspec,
+                        GtkWidget   *widget)
 {
  GtkPasswordEntry *entry = GTK_PASSWORD_ENTRY (widget);
  GtkPasswordEntryPrivate *priv = gtk_password_entry_get_instance_private (entry);

  if (gtk_editable_get_editable (GTK_EDITABLE (entry)) &&
      gtk_widget_has_focus (priv->entry) &&
-      gdk_keymap_get_caps_lock_state (priv->keymap) &&
-      !priv->peek_icon)
+      !gtk_text_get_visibility (GTK_TEXT (priv->entry)) &&
+      gdk_device_get_caps_lock_state (device))
    gtk_widget_show (priv->icon);
  else
    gtk_widget_hide (priv->icon);
@@ -102,8 +103,8 @@ focus_changed (GtkWidget *widget)
  GtkPasswordEntry *entry = GTK_PASSWORD_ENTRY (widget);
  GtkPasswordEntryPrivate *priv = gtk_password_entry_get_instance_private (entry);

-  if (priv->keymap)
-    keymap_state_changed (priv->keymap, widget);
+  if (priv->keyboard)
+    caps_lock_state_changed (priv->keyboard, NULL, widget);
 }
 
 static void
@@ -133,6 +134,9 @@ visibility_toggled (GObject          *object,
      gtk_image_set_from_icon_name (GTK_IMAGE (priv->peek_icon), "eye-not-looking-symbolic");
      gtk_widget_set_tooltip_text (priv->peek_icon, _("Show text"));
    }
+
+  if (priv->keyboard)
+    caps_lock_state_changed (priv->keyboard, NULL, GTK_WIDGET (entry));
 }

 static void
@@ -165,9 +169,9 @@ gtk_password_entry_realize (GtkWidget *widget)

  GTK_WIDGET_CLASS (gtk_password_entry_parent_class)->realize (widget);

-  priv->keymap = gdk_display_get_keymap (gtk_widget_get_display (widget));
-  g_signal_connect (priv->keymap, "state-changed", G_CALLBACK (keymap_state_changed), entry);
-  keymap_state_changed (priv->keymap, widget);
+  priv->keyboard = gdk_seat_get_keyboard (gdk_display_get_default_seat (gtk_widget_get_display (widget)));
+  g_signal_connect (priv->keyboard, "notify::caps-lock-state", G_CALLBACK (caps_lock_state_changed), entry);
+  caps_lock_state_changed (priv->keyboard, NULL, widget);
 }

 static void
@@ -176,8 +180,8 @@ gtk_password_entry_dispose (GObject *object)
  GtkPasswordEntry *entry = GTK_PASSWORD_ENTRY (object);
  GtkPasswordEntryPrivate *priv = gtk_password_entry_get_instance_private (entry);

-  if (priv->keymap)
-    g_signal_handlers_disconnect_by_func (priv->keymap, keymap_state_changed, entry);
+  if (priv->keyboard)
+    g_signal_handlers_disconnect_by_func (priv->keyboard, caps_lock_state_changed, entry);

  if (priv->entry)
    gtk_editable_finish_delegate (GTK_EDITABLE (entry));
@@ -499,7 +503,7 @@ gtk_password_entry_set_show_peek_icon (GtkPasswordEntry *entry,
                                            entry);
    }

-  keymap_state_changed (priv->keymap, GTK_WIDGET (entry));
+  caps_lock_state_changed (priv->keyboard, NULL, GTK_WIDGET (entry));

  g_object_notify_by_pspec (G_OBJECT (entry), props[PROP_SHOW_PEEK_ICON]);
 }
@@ -3061,7 +3061,7 @@ on_key_pressed (GtkEventControllerKey *controller,
        }

      if (keyval == GDK_KEY_Down &&
-          (state & modifiers) == GDK_MOD1_MASK)
+          (state & modifiers) == GDK_ALT_MASK)
        return eject_or_unmount_selection (sidebar);

      if ((keyval == GDK_KEY_Delete ||
@@ -600,7 +600,7 @@ gtk_popover_has_mnemonic_modifier_pressed (GtkPopover *popover)
      GdkModifierType mask;

      gdk_device_get_state (dev, priv->surface, NULL, &mask);
-      if ((mask & gtk_accelerator_get_default_mod_mask ()) == GDK_MOD1_MASK)
+      if ((mask & gtk_accelerator_get_default_mod_mask ()) == GDK_ALT_MASK)
        {
          retval = TRUE;
          break;
@@ -678,7 +678,7 @@ update_mnemonics_visible (GtkPopover      *popover,
    return;

  if ((keyval == GDK_KEY_Alt_L || keyval == GDK_KEY_Alt_R) &&
-      ((state & (gtk_accelerator_get_default_mod_mask ()) & ~(GDK_MOD1_MASK)) == 0))
+      ((state & (gtk_accelerator_get_default_mod_mask ()) & ~(GDK_ALT_MASK)) == 0))
    {
      if (visible)
        gtk_popover_schedule_mnemonics_visible (popover);
@@ -158,35 +158,6 @@ _gtk_single_string_accumulator (GSignalInvocationHint *ihint,
  return continue_emission;
 }

-GdkModifierType
-_gtk_replace_virtual_modifiers (GdkKeymap       *keymap,
-                                GdkModifierType  modifiers)
-{
-  GdkModifierType result = 0;
-  gint            i;
-
-  g_return_val_if_fail (GDK_IS_KEYMAP (keymap), 0);
-
-  for (i = 0; i < 8; i++) /* SHIFT...MOD5 */
-    {
-      GdkModifierType real = 1 << i;
-
-      if (modifiers & real)
-        {
-          GdkModifierType virtual = real;
-
-          gdk_keymap_add_virtual_modifiers (keymap, &virtual);
-
-          if (virtual == real)
-            result |= virtual;
-          else
-            result |= virtual & ~real;
-        }
-    }
-
-  return result;
-}
-
 GdkModifierType
 _gtk_get_primary_accel_mod (void)
 {
@@ -196,63 +167,13 @@ _gtk_get_primary_accel_mod (void)
    {
      GdkDisplay *display = gdk_display_get_default ();

-      primary = gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-                                              GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
-      primary = _gtk_replace_virtual_modifiers (gdk_display_get_keymap (display),
-                                                primary);
+      primary = gdk_display_get_modifier_mask (display,
+                                               GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
    }

  return primary;
 }

-gboolean
-_gtk_translate_keyboard_accel_state (GdkKeymap       *keymap,
-                                     guint            hardware_keycode,
-                                     GdkModifierType  state,
-                                     GdkModifierType  accel_mask,
-                                     gint             group,
-                                     guint           *keyval,
-                                     gint            *effective_group,
-                                     gint            *level,
-                                     GdkModifierType *consumed_modifiers)
-{
-  GdkModifierType shift_group_mask;
-  gboolean group_mask_disabled = FALSE;
-  gboolean retval;
-
-  /* if the group-toggling modifier is part of the accel mod mask, and
-   * it is active, disable it for matching
-   */
-  shift_group_mask = gdk_keymap_get_modifier_mask (keymap,
-                                                   GDK_MODIFIER_INTENT_SHIFT_GROUP);
-  if (accel_mask & state & shift_group_mask)
-    {
-      state &= ~shift_group_mask;
-      group = 0;
-      group_mask_disabled = TRUE;
-    }
-
-  retval = gdk_keymap_translate_keyboard_state (keymap,
-                                                hardware_keycode, state, group,
-                                                keyval,
-                                                effective_group, level,
-                                                consumed_modifiers);
-
-  /* add back the group mask, we want to match against the modifier,
-   * but not against the keyval from its group
-   */
-  if (group_mask_disabled)
-    {
-      if (effective_group)
-        *effective_group = 1;
-
-      if (consumed_modifiers)
-        *consumed_modifiers &= ~shift_group_mask;
-    }
-
-  return retval;
-}
-
 static gpointer
 register_resources (gpointer data)
 {
@@ -82,20 +82,8 @@ gboolean _gtk_single_string_accumulator   (GSignalInvocationHint *ihint,
                                           const GValue          *handler_return,
                                           gpointer               dummy);

-GdkModifierType _gtk_replace_virtual_modifiers (GdkKeymap       *keymap,
-                                                GdkModifierType  modifiers);
 GdkModifierType _gtk_get_primary_accel_mod     (void);

-gboolean _gtk_translate_keyboard_accel_state   (GdkKeymap       *keymap,
-                                                guint            hardware_keycode,
-                                                GdkModifierType  state,
-                                                GdkModifierType  accel_mask,
-                                                gint             group,
-                                                guint           *keyval,
-                                                gint            *effective_group,
-                                                gint            *level,
-                                                GdkModifierType *consumed_modifiers);
-
 gboolean         gtk_propagate_event_internal  (GtkWidget       *widget,
                                                GdkEvent        *event,
                                                GtkWidget       *topmost);
@@ -550,7 +550,7 @@ gtk_search_entry_is_keynav (guint           keyval,
      keyval == GDK_KEY_End       || keyval == GDK_KEY_KP_End ||
      keyval == GDK_KEY_Page_Up   || keyval == GDK_KEY_KP_Page_Up ||
      keyval == GDK_KEY_Page_Down || keyval == GDK_KEY_KP_Page_Down ||
-      ((state & (GDK_CONTROL_MASK | GDK_MOD1_MASK)) != 0))
+      ((state & (GDK_CONTROL_MASK | GDK_ALT_MASK)) != 0))
        return TRUE;

  /* Other navigation events should get automatically
@@ -313,16 +313,16 @@ gtk_shortcut_controller_run_controllers (GtkEventController *controller,

      switch (gtk_shortcut_trigger_trigger (gtk_shortcut_get_trigger (shortcut), event, enable_mnemonics))
        {
-        case GTK_SHORTCUT_TRIGGER_MATCH_PARTIAL:
+        case GDK_EVENT_MATCH_PARTIAL:
          if (!has_exact)
            break;
          G_GNUC_FALLTHROUGH;

-        case GTK_SHORTCUT_TRIGGER_MATCH_NONE:
+        case GDK_EVENT_MATCH_NONE:
          g_object_unref (shortcut);
          continue;

-        case GTK_SHORTCUT_TRIGGER_MATCH_EXACT:
+        case GDK_EVENT_MATCH_EXACT:
          if (!has_exact)
            {
              g_slist_free_full (shortcuts, shortcut_data_free);
@@ -513,7 +513,7 @@ gtk_shortcut_controller_class_init (GtkShortcutControllerClass *klass)
                          P_("Mnemonic modifers"),
                          P_("The modifiers to be pressed to allow mnemonics activation"),
                          GDK_TYPE_MODIFIER_TYPE,
-                          GDK_MOD1_MASK,
+                          GDK_ALT_MASK,
                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);

  /**
@@ -547,7 +547,7 @@ gtk_shortcut_controller_class_init (GtkShortcutControllerClass *klass)
 static void
 gtk_shortcut_controller_init (GtkShortcutController *self)
 {
-  self->mnemonics_modifiers = GDK_MOD1_MASK;
+  self->mnemonics_modifiers = GDK_ALT_MASK;
 }

 void
@@ -137,16 +137,8 @@ get_labels (guint key, GdkModifierType modifier, guint *n_mods)
    labels[i++] = C_("keyboard label", "Shift");
  if (modifier & GDK_CONTROL_MASK)
    labels[i++] = C_("keyboard label", "Ctrl");
-  if (modifier & GDK_MOD1_MASK)
+  if (modifier & GDK_ALT_MASK)
    labels[i++] = C_("keyboard label", "Alt");
-  if (modifier & GDK_MOD2_MASK)
-    labels[i++] = "Mod2";
-  if (modifier & GDK_MOD3_MASK)
-    labels[i++] = "Mod3";
-  if (modifier & GDK_MOD4_MASK)
-    labels[i++] = "Mod4";
-  if (modifier & GDK_MOD5_MASK)
-    labels[i++] = "Mod5";
  if (modifier & GDK_SUPER_MASK)
    labels[i++] = C_("keyboard label", "Super");
  if (modifier & GDK_HYPER_MASK)
@@ -59,8 +59,7 @@ struct _GtkShortcutTriggerClass
 {
  GObjectClass parent_class;

-  GtkShortcutTriggerMatch
-                  (* trigger)     (GtkShortcutTrigger  *trigger,
+  GdkEventMatch   (* trigger)     (GtkShortcutTrigger  *trigger,
                                   GdkEvent            *event,
                                   gboolean             enable_mnemonics);
  guint           (* hash)        (GtkShortcutTrigger  *trigger);
@@ -97,12 +96,12 @@ gtk_shortcut_trigger_init (GtkShortcutTrigger *self)
 *
 * Returns: Whether the event triggered the shortcut
 **/
-GtkShortcutTriggerMatch
+GdkEventMatch
 gtk_shortcut_trigger_trigger (GtkShortcutTrigger *self,
                              GdkEvent           *event,
                              gboolean            enable_mnemonics)
 {
-  g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), GTK_SHORTCUT_TRIGGER_MATCH_NONE);
+  g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), GDK_EVENT_MATCH_NONE);

  return GTK_SHORTCUT_TRIGGER_GET_CLASS (self)->trigger (self, event, enable_mnemonics);
 }
@@ -410,12 +409,12 @@ gtk_never_trigger_finalize (GObject *gobject)
  G_OBJECT_CLASS (gtk_never_trigger_parent_class)->finalize (gobject);
 }

-static GtkShortcutTriggerMatch
+static GdkEventMatch
 gtk_never_trigger_trigger (GtkShortcutTrigger *trigger,
                           GdkEvent           *event,
                           gboolean            enable_mnemonics)
 {
-  return GTK_SHORTCUT_TRIGGER_MATCH_NONE;
+  return GDK_EVENT_MATCH_NONE;
 }

 static guint
@@ -510,110 +509,14 @@ enum

 static GParamSpec *keyval_props[KEYVAL_N_PROPS];

-static GtkShortcutTriggerMatch
+static GdkEventMatch
 gtk_keyval_trigger_trigger (GtkShortcutTrigger *trigger,
                            GdkEvent           *event,
                            gboolean            enable_mnemonics)
 {
  GtkKeyvalTrigger *self = GTK_KEYVAL_TRIGGER (trigger);
-  guint keycode;
-  GdkModifierType state;
-  GdkModifierType mask;
-  int group;
-  GdkKeymap *keymap;
-  guint keyval;
-  int effective_group;
-  int level;
-  GdkModifierType consumed_modifiers;
-  GdkModifierType shift_group_mask;
-  gboolean group_mod_is_accel_mod = FALSE;
-  const GdkModifierType xmods = GDK_MOD2_MASK|GDK_MOD3_MASK|GDK_MOD4_MASK|GDK_MOD5_MASK;
-  const GdkModifierType vmods = GDK_SUPER_MASK|GDK_HYPER_MASK|GDK_META_MASK;
-  GdkModifierType modifiers;

-  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
-    return GTK_SHORTCUT_TRIGGER_MATCH_NONE;
-
-  mask = gtk_accelerator_get_default_mod_mask ();
-
-  keycode = gdk_key_event_get_keycode (event);
-  state = gdk_event_get_modifier_state (event);
-  group = gdk_key_event_get_group (event);
-  keymap = gdk_display_get_keymap (gdk_event_get_display (event));
-
-  /* We don't want Caps_Lock to affect keybinding lookups.
-   */
-  state &= ~GDK_LOCK_MASK;
-
-  _gtk_translate_keyboard_accel_state (keymap,
-                                       keycode, state, mask, group,
-                                       &keyval,
-                                       &effective_group, &level,
-                                       &consumed_modifiers);
-
-  /* if the group-toggling modifier is part of the default accel mod
-   * mask, and it is active, disable it for matching
-   */
-  shift_group_mask = gdk_keymap_get_modifier_mask (keymap,
-                                                   GDK_MODIFIER_INTENT_SHIFT_GROUP);
-  if (mask & shift_group_mask)
-    group_mod_is_accel_mod = TRUE;
-
-  gdk_keymap_map_virtual_modifiers (keymap, &mask);
-  gdk_keymap_add_virtual_modifiers (keymap, &state);
-
-  modifiers = self->modifiers;
-  if (gdk_keymap_map_virtual_modifiers (keymap, &modifiers) &&
-      ((modifiers & ~consumed_modifiers & mask & ~vmods) == (state & ~consumed_modifiers & mask & ~vmods) ||
-       (modifiers & ~consumed_modifiers & mask & ~xmods) == (state & ~consumed_modifiers & mask & ~xmods)))
-    {
-      /* modifier match */
-      GdkKeymapKey *keys;
-      int n_keys;
-      int i;
-      guint key;
-
-      /* Shift gets consumed and applied for the event,
-       * so apply it to our keyval to match
-       */
-      key = self->keyval;
-      if (self->modifiers & GDK_SHIFT_MASK)
-        {
-          if (key == GDK_KEY_Tab)
-            key = GDK_KEY_ISO_Left_Tab;
-          else
-            key = gdk_keyval_to_upper (key);
-        }
-
-      if (keyval == key && /* exact match */
-          (!group_mod_is_accel_mod ||
-           (state & shift_group_mask) == (self->modifiers & shift_group_mask)))
-        return GTK_SHORTCUT_TRIGGER_MATCH_EXACT;
-
-      gdk_keymap_get_entries_for_keyval (keymap,
-                                         self->keyval,
-                                         &keys, &n_keys);
-
-      for (i = 0; i < n_keys; i++)
-        {
-          if (keys[i].keycode == keycode &&
-              keys[i].level == level &&
-              /* Only match for group if it's an accel mod */
-              (!group_mod_is_accel_mod ||
-               keys[i].group == effective_group))
-            {
-              /* partial match */
-              g_free (keys);
-
-              return GTK_SHORTCUT_TRIGGER_MATCH_PARTIAL;
-            }
-        }
- 
-      g_free (keys);
-    }
-
-
-  return GTK_SHORTCUT_TRIGGER_MATCH_NONE;
+  return gdk_event_matches (event, self->keyval, self->modifiers);
 }

 static guint
@@ -849,7 +752,7 @@ enum

 static GParamSpec *mnemonic_props[MNEMONIC_N_PROPS];

-static GtkShortcutTriggerMatch
+static GdkEventMatch
 gtk_mnemonic_trigger_trigger (GtkShortcutTrigger *trigger,
                              GdkEvent           *event,
                              gboolean            enable_mnemonics)
@@ -858,10 +761,10 @@ gtk_mnemonic_trigger_trigger (GtkShortcutTrigger *trigger,
  guint keyval;

  if (!enable_mnemonics)
-    return GTK_SHORTCUT_TRIGGER_MATCH_NONE;
+    return GDK_EVENT_MATCH_NONE;

  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
-    return GTK_SHORTCUT_TRIGGER_MATCH_NONE;
+    return GDK_EVENT_MATCH_NONE;

  /* XXX: This needs to deal with groups */
  keyval = gdk_key_event_get_keyval (event);
@@ -872,9 +775,9 @@ gtk_mnemonic_trigger_trigger (GtkShortcutTrigger *trigger,
    keyval = gdk_keyval_to_lower (keyval);

  if (keyval != self->keyval)
-    return GTK_SHORTCUT_TRIGGER_MATCH_NONE;
+    return GDK_EVENT_MATCH_NONE;

-  return GTK_SHORTCUT_TRIGGER_MATCH_EXACT;
+  return GDK_EVENT_MATCH_EXACT;
 }

 static guint
@@ -1085,7 +988,7 @@ gtk_alternative_trigger_dispose (GObject *gobject)
  G_OBJECT_CLASS (gtk_alternative_trigger_parent_class)->dispose (gobject);
 }

-static GtkShortcutTriggerMatch
+static GdkEventMatch
 gtk_alternative_trigger_trigger (GtkShortcutTrigger *trigger,
                                 GdkEvent           *event,
                                 gboolean            enable_mnemonics)
@@ -36,25 +36,6 @@ G_BEGIN_DECLS
 * A trigger for a key shortcut.
 */

-/**
- * GtkShortcutTriggerMatch:
- * @GTK_SHORTCUT_TRIGGER_MATCH_NONE: The key event does not
- *     match the trigger
- * @GTK_SHORTCUT_TRIGGER_MATCH_PARTIAL: The key event matches
- *     the trigger if keyboard state (specifically, the currently
- *     active group) is ignored
- * @GTK_SHORTCUT_TRIGGER_MATCH_EXACT: The key event matches
- *     the trigger
- *
- * The possible return values from gtk_shortcut_trigger_trigger()
- * describe if a key event triggers a shortcut.
- */
-typedef enum {
-  GTK_SHORTCUT_TRIGGER_MATCH_NONE,
-  GTK_SHORTCUT_TRIGGER_MATCH_PARTIAL,
-  GTK_SHORTCUT_TRIGGER_MATCH_EXACT,
-} GtkShortcutTriggerMatch;
-
 GDK_AVAILABLE_IN_ALL
 GDK_DECLARE_INTERNAL_TYPE (GtkShortcutTrigger, gtk_shortcut_trigger, GTK, SHORTCUT_TRIGGER, GObject)

@@ -84,7 +65,7 @@ gint                    gtk_shortcut_trigger_compare            (gconstpointer
                                                                 gconstpointer       trigger2);

 GDK_AVAILABLE_IN_ALL
-GtkShortcutTriggerMatch gtk_shortcut_trigger_trigger            (GtkShortcutTrigger *self,
+GdkEventMatch           gtk_shortcut_trigger_trigger            (GtkShortcutTrigger *self,
                                                                 GdkEvent           *event,
                                                                 gboolean            enable_mnemonics);

@@ -1253,7 +1253,8 @@ gtk_render_insertion_cursor (GtkStyleContext *context,
  gboolean split_cursor;
  PangoRectangle strong_pos, weak_pos;
  PangoRectangle *cursor1, *cursor2;
-  PangoDirection keymap_direction;
+  GdkDevice *keyboard;
+  PangoDirection keyboard_direction;
  PangoDirection direction2;

  g_return_if_fail (GTK_IS_STYLE_CONTEXT (context));
@@ -1265,7 +1266,8 @@ gtk_render_insertion_cursor (GtkStyleContext *context,
                "gtk-split-cursor", &split_cursor,
                NULL);

-  keymap_direction = gdk_keymap_get_direction (gdk_display_get_keymap (priv->display));
+  keyboard = gdk_seat_get_keyboard (gdk_display_get_default_seat (priv->display));
+  keyboard_direction = gdk_device_get_direction (keyboard);

  pango_layout_get_cursor_pos (layout, index, &strong_pos, &weak_pos);

@@ -1283,7 +1285,7 @@ gtk_render_insertion_cursor (GtkStyleContext *context,
    }
  else
    {
-      if (keymap_direction == direction)
+      if (keyboard_direction == direction)
        cursor1 = &strong_pos;
      else
        cursor1 = &weak_pos;
@@ -1339,7 +1341,8 @@ gtk_snapshot_render_insertion_cursor (GtkSnapshot     *snapshot,
  float aspect_ratio;
  PangoRectangle strong_pos, weak_pos;
  PangoRectangle *cursor1, *cursor2;
-  PangoDirection keymap_direction;
+  GdkDevice *keyboard;
+  PangoDirection keyboard_direction;
  PangoDirection direction2;

  g_return_if_fail (snapshot != NULL);
@@ -1352,7 +1355,8 @@ gtk_snapshot_render_insertion_cursor (GtkSnapshot     *snapshot,
                "gtk-cursor-aspect-ratio", &aspect_ratio,
                NULL);

-  keymap_direction = gdk_keymap_get_direction (gdk_display_get_keymap (priv->display));
+  keyboard = gdk_seat_get_keyboard (gdk_display_get_default_seat (priv->display));
+  keyboard_direction = gdk_device_get_direction (keyboard);

  pango_layout_get_cursor_pos (layout, index, &strong_pos, &weak_pos);

@@ -1370,7 +1374,7 @@ gtk_snapshot_render_insertion_cursor (GtkSnapshot     *snapshot,
    }
  else
    {
-      if (keymap_direction == direction)
+      if (keyboard_direction == direction)
        cursor1 = &strong_pos;
      else
        cursor1 = &weak_pos;
@@ -410,7 +410,8 @@ static void     gtk_text_insert_emoji       (GtkText         *self);
 static void     gtk_text_select_all         (GtkText         *self);
 static void     gtk_text_real_activate      (GtkText         *self);
 
-static void     keymap_direction_changed    (GdkKeymap       *keymap,
+static void     direction_changed           (GdkDevice       *keyboard,
+                                             GParamSpec      *pspec,
                                             GtkText         *self);

 /* IM Context Callbacks
@@ -1880,7 +1881,8 @@ gtk_text_dispose (GObject *object)
 {
  GtkText *self = GTK_TEXT (object);
  GtkTextPrivate *priv = gtk_text_get_instance_private (self);
-  GdkKeymap *keymap;
+  GdkSeat *seat;
+  GdkDevice *keyboard;
  GtkWidget *chooser;

  priv->current_pos = 0;
@@ -1897,8 +1899,9 @@ gtk_text_dispose (GObject *object)
  if (chooser)
    gtk_widget_unparent (chooser);

-  keymap = gdk_display_get_keymap (gtk_widget_get_display (GTK_WIDGET (object)));
-  g_signal_handlers_disconnect_by_func (keymap, keymap_direction_changed, self);
+  seat = gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET (object)));
+  keyboard = gdk_seat_get_keyboard (seat);
+  g_signal_handlers_disconnect_by_func (keyboard, direction_changed, self);

  g_clear_pointer (&priv->selection_bubble, gtk_widget_unparent);
  g_clear_pointer (&priv->popup_menu, gtk_widget_unparent);
@@ -3081,11 +3084,13 @@ gtk_text_focus_in (GtkWidget *widget)
 {
  GtkText *self = GTK_TEXT (widget);
  GtkTextPrivate *priv = gtk_text_get_instance_private (self);
-  GdkKeymap *keymap;
+  GdkSeat *seat;
+  GdkDevice *keyboard;

  gtk_widget_queue_draw (widget);

-  keymap = gdk_display_get_keymap (gtk_widget_get_display (widget));
+  seat = gdk_display_get_default_seat (gtk_widget_get_display (widget));
+  keyboard = gdk_seat_get_keyboard (seat);

  if (priv->editable)
    {
@@ -3093,8 +3098,8 @@ gtk_text_focus_in (GtkWidget *widget)
      gtk_im_context_focus_in (priv->im_context);
    }

-  g_signal_connect (keymap, "direction-changed",
-                    G_CALLBACK (keymap_direction_changed), self);
+  g_signal_connect (keyboard, "notify::direction",
+                    G_CALLBACK (direction_changed), self);

  gtk_text_reset_blink_time (self);
  gtk_text_check_cursor_blink (self);
@@ -3105,7 +3110,8 @@ gtk_text_focus_out (GtkWidget *widget)
 {
  GtkText *self = GTK_TEXT (widget);
  GtkTextPrivate *priv = gtk_text_get_instance_private (self);
-  GdkKeymap *keymap;
+  GdkSeat *seat;
+  GdkDevice *keyboard;

  gtk_text_selection_bubble_popup_unset (self);

@@ -3114,7 +3120,8 @@ gtk_text_focus_out (GtkWidget *widget)

  gtk_widget_queue_draw (widget);

-  keymap = gdk_display_get_keymap (gtk_widget_get_display (widget));
+  seat = gdk_display_get_default_seat (gtk_widget_get_display (widget));
+  keyboard = gdk_seat_get_keyboard (seat);

  if (priv->editable)
    {
@@ -3124,7 +3131,7 @@ gtk_text_focus_out (GtkWidget *widget)

  gtk_text_check_cursor_blink (self);

-  g_signal_handlers_disconnect_by_func (keymap, keymap_direction_changed, self);
+  g_signal_handlers_disconnect_by_func (keyboard, direction_changed, self);
 }

 static gboolean
@@ -3604,8 +3611,9 @@ get_better_cursor_x (GtkText *self,
                     int      offset)
 {
  GtkTextPrivate *priv = gtk_text_get_instance_private (self);
-  GdkKeymap *keymap = gdk_display_get_keymap (gtk_widget_get_display (GTK_WIDGET (self)));
-  PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
+  GdkSeat *seat = gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET (self)));
+  GdkDevice *keyboard = gdk_seat_get_keyboard (seat);
+  PangoDirection direction = gdk_device_get_direction (keyboard);
  gboolean split_cursor;
  PangoLayout *layout = gtk_text_ensure_layout (self, TRUE);
  const char *text = pango_layout_get_text (layout);
@@ -3621,7 +3629,7 @@ get_better_cursor_x (GtkText *self,
  if (split_cursor)
    return strong_pos.x / PANGO_SCALE;
  else
-    return (keymap_direction == priv->resolved_dir) ? strong_pos.x / PANGO_SCALE : weak_pos.x / PANGO_SCALE;
+    return (direction == priv->resolved_dir) ? strong_pos.x / PANGO_SCALE : weak_pos.x / PANGO_SCALE;
 }

 static void
@@ -4060,8 +4068,9 @@ gtk_text_real_activate (GtkText *self)
 }

 static void
-keymap_direction_changed (GdkKeymap *keymap,
-                          GtkText   *self)
+direction_changed (GdkDevice  *device,
+                   GParamSpec *pspec,
+                   GtkText    *self)
 {
  gtk_text_recompute (self);
 }
@@ -4326,9 +4335,10 @@ gtk_text_create_layout (GtkText  *self,
          if (gtk_widget_has_focus (widget))
            {
              GdkDisplay *display = gtk_widget_get_display (widget);
-              GdkKeymap *keymap = gdk_display_get_keymap (display);
+              GdkSeat *seat = gdk_display_get_default_seat (display);
+              GdkDevice *keyboard = gdk_seat_get_keyboard (seat);

-              if (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_RTL)
+              if (gdk_device_get_direction (keyboard) == PANGO_DIRECTION_RTL)
                pango_dir = PANGO_DIRECTION_RTL;
              else
                pango_dir = PANGO_DIRECTION_LTR;
@@ -4888,10 +4898,12 @@ gtk_text_move_visually (GtkText *self,
        strong = TRUE;
      else
        {
-          GdkKeymap *keymap = gdk_display_get_keymap (gtk_widget_get_display (GTK_WIDGET (self)));
-          PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
+          GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (self));
+          GdkSeat *seat = gdk_display_get_default_seat (display);
+          GdkDevice *keyboard = gdk_seat_get_keyboard (seat);
+          PangoDirection direction = gdk_device_get_direction (keyboard);

-          strong = keymap_direction == priv->resolved_dir;
+          strong = direction == priv->resolved_dir;
        }
      
      if (count > 0)
@@ -7534,7 +7534,8 @@ gtk_text_view_check_keymap_direction (GtkTextView *text_view)
  if (priv->layout)
    {
      GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
-      GdkKeymap *keymap = gdk_display_get_keymap (gtk_widget_get_display (GTK_WIDGET (text_view)));
+      GdkSeat *seat = gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET (text_view)));
+      GdkDevice *keyboard = gdk_seat_get_keyboard (seat);
      GtkTextDirection new_cursor_dir;
      GtkTextDirection new_keyboard_dir;
      gboolean split_cursor;
@@ -7543,7 +7544,7 @@ gtk_text_view_check_keymap_direction (GtkTextView *text_view)
 		    "gtk-split-cursor", &split_cursor,
 		    NULL);
      
-      if (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_RTL)
+      if (gdk_device_get_direction (keyboard) == PANGO_DIRECTION_RTL)
 	new_keyboard_dir = GTK_TEXT_DIR_RTL;
      else
 	new_keyboard_dir  = GTK_TEXT_DIR_LTR;
@@ -5348,7 +5348,7 @@ gtk_tree_view_key_controller_key_pressed (GtkEventControllerKey *key,
        }

      if (focus_column &&
-          (state & GDK_SHIFT_MASK) && (state & GDK_MOD1_MASK) &&
+          (state & GDK_SHIFT_MASK) && (state & GDK_ALT_MASK) &&
          (keyval == GDK_KEY_Left || keyval == GDK_KEY_KP_Left
           || keyval == GDK_KEY_Right || keyval == GDK_KEY_KP_Right))
        {
@@ -5380,7 +5380,7 @@ gtk_tree_view_key_controller_key_pressed (GtkEventControllerKey *key,
        }

      if (focus_column &&
-          (state & GDK_MOD1_MASK) &&
+          (state & GDK_ALT_MASK) &&
          (keyval == GDK_KEY_Left || keyval == GDK_KEY_KP_Left
           || keyval == GDK_KEY_Right || keyval == GDK_KEY_KP_Right
           || keyval == GDK_KEY_Home || keyval == GDK_KEY_KP_Home
@@ -10670,7 +10670,7 @@ gtk_widget_get_style_context (GtkWidget *widget)
 * Returns the modifier mask the @widget’s windowing system backend
 * uses for a particular purpose.
 *
- * See gdk_keymap_get_modifier_mask().
+ * See gdk_display_get_modifier_mask().
 *
 * Returns: the modifier mask used for @intent.
 **/
@@ -10678,14 +10678,9 @@ GdkModifierType
 gtk_widget_get_modifier_mask (GtkWidget         *widget,
                              GdkModifierIntent  intent)
 {
-  GdkDisplay *display;
-
  g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);

-  display = _gtk_widget_get_display (widget);
-
-  return gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-                                       intent);
+  return gdk_display_get_modifier_mask (_gtk_widget_get_display (widget), intent);
 }

 static GtkActionMuxer *
@@ -5238,7 +5238,7 @@ gtk_window_has_mnemonic_modifier_pressed (GtkWindow *window)
      GdkModifierType mask;

      gdk_device_get_state (dev, priv->surface, NULL, &mask);
-      if ((mask & gtk_accelerator_get_default_mod_mask ()) == GDK_MOD1_MASK)
+      if ((mask & gtk_accelerator_get_default_mod_mask ()) == GDK_ALT_MASK)
        {
          retval = TRUE;
          break;
@@ -5287,7 +5287,7 @@ update_mnemonics_visible (GtkWindow       *window,
                          gboolean         visible)
 {
  if ((keyval == GDK_KEY_Alt_L || keyval == GDK_KEY_Alt_R) &&
-      ((state & (gtk_accelerator_get_default_mod_mask ()) & ~(GDK_MOD1_MASK)) == 0))
+      ((state & (gtk_accelerator_get_default_mod_mask ()) & ~(GDK_ALT_MASK)) == 0))
    {
      if (visible)
        _gtk_window_schedule_mnemonics_visible (window);
@@ -6272,11 +6272,10 @@ main (int argc, char *argv[])

  gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
 					GDK_CONTROL_MASK |
-					GDK_MOD1_MASK | 
+					GDK_ALT_MASK | 
 					GDK_META_MASK |
 					GDK_SUPER_MASK |
-					GDK_HYPER_MASK |
-					GDK_MOD4_MASK);
+					GDK_HYPER_MASK);
  /*  benchmarking
   */
  for (i = 1; i < argc; i++)
@@ -171,7 +171,7 @@ test_trigger_parse_keyval (void)
    guint keyval;
    int trigger_type;
  } tests[] = {
-    { "<Primary><Alt>z", GDK_CONTROL_MASK | GDK_MOD1_MASK, 'z' },
+    { "<Primary><Alt>z", GDK_CONTROL_MASK | GDK_ALT_MASK, 'z' },
    { "<Control>U", GDK_CONTROL_MASK, 'u' },
    { "<Hyper>x", GDK_HYPER_MASK, 'x' },
    { "<Meta>y", GDK_META_MASK, 'y' },
@@ -340,14 +340,14 @@ test_trigger_trigger (void)
    guint keyval;
    GdkModifierType state;
    gboolean mnemonic;
-    GtkShortcutTriggerMatch result[4];
+    GdkEventMatch result[4];
  } tests[] = {
-    { GDK_KEY_a, GDK_CONTROL_MASK, FALSE, { GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_EXACT, GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_EXACT } }, 
-    { GDK_KEY_a, GDK_CONTROL_MASK, TRUE,  { GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_EXACT, GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_EXACT } }, 
-    { GDK_KEY_a, GDK_SHIFT_MASK,   FALSE, { GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE } }, 
-    { GDK_KEY_a, GDK_SHIFT_MASK,   TRUE,  { GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE } }, 
-    { GDK_KEY_u, GDK_SHIFT_MASK,   FALSE, { GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE } }, 
-    { GDK_KEY_u, GDK_SHIFT_MASK,   TRUE,  { GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_NONE, GTK_SHORTCUT_TRIGGER_MATCH_EXACT, GTK_SHORTCUT_TRIGGER_MATCH_EXACT } }, 
+    { GDK_KEY_a, GDK_CONTROL_MASK, FALSE, { GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_EXACT, GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_EXACT } }, 
+    { GDK_KEY_a, GDK_CONTROL_MASK, TRUE,  { GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_EXACT, GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_EXACT } }, 
+    { GDK_KEY_a, GDK_SHIFT_MASK,   FALSE, { GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE } }, 
+    { GDK_KEY_a, GDK_SHIFT_MASK,   TRUE,  { GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE } }, 
+    { GDK_KEY_u, GDK_SHIFT_MASK,   FALSE, { GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE } }, 
+    { GDK_KEY_u, GDK_SHIFT_MASK,   TRUE,  { GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_NONE, GDK_EVENT_MATCH_EXACT, GDK_EVENT_MATCH_EXACT } }, 
  };
  int i, j;
Author	SHA1	Message	Date
Matthias Clasen	40a4824b14	gtk: Remove handling of virtual modifiers These are going away. We expect to just have named modifiers in modifier masks now, so we longer juggle 'real' and 'virtual' modifiers.	2020-04-05 10:26:39 -04:00
Matthias Clasen	38fb231a05	gdk: Clean up GdkModifierType Remove MOD2..MOD5. Backends are expected to just set the named modifiers.	2020-04-05 10:24:07 -04:00
Matthias Clasen	e39190c5d2	events: Stop doing elaborate virtual modifier handling These are going away in the GdkModifierType cleanup. Just compare the modifiers we got.	2020-04-05 10:23:18 -04:00
Matthias Clasen	a91e94a18e	broadway: Stop using MOD2..MOD5 These are going away in the GdkModifierType cleanup.	2020-04-05 10:08:01 -04:00
Matthias Clasen	06e6af7641	win32: Stop using MOD2..MOD5 These are going away in the GdkModifierType cleanup.	2020-04-05 10:07:32 -04:00
Matthias Clasen	a7cc504bc2	wayland: Stop setting MOD2..MOD5 These are going away in the GdkModifierType cleanup.	2020-04-05 10:06:51 -04:00
Matthias Clasen	48e0075140	gdk: Remove reserved bit from GdkModifierType This really has no purpose and obscures the header.	2020-04-05 10:04:47 -04:00
Matthias Clasen	d71c7bc324	tests: Stop using GDK_MODx_MASK These are going away.	2020-04-05 09:54:02 -04:00
Matthias Clasen	be0acd1bea	gtk: Stop using GDK_MODx_MASK These are never used in practice, and we never want to see them in the UI, so stop supporting them. This is in preparation for cleaning up GdkModifierType.	2020-04-05 09:53:02 -04:00
Matthias Clasen	a044d2841c	Rename GDK_MOD1_MASK to GDK_ALT_MASK We've hardcoded Mod1 = Alt for a long time, there is no need to keep the confusing naming around anymore.	2020-04-05 09:48:19 -04:00
Matthias Clasen	85e65cdb12	gtk: Stop using keymap apis Stop using most keymap apis in GTK. Only a few calls related to virtual modifiers are left.	2020-04-05 08:54:07 -04:00
Matthias Clasen	d3e5072aea	x11: Notify new device properties	2020-04-05 00:48:02 -04:00
Matthias Clasen	5b4e5c3da8	wayland: Notify new device properties	2020-04-05 00:37:51 -04:00
Matthias Clasen	976f1ad0af	gdk: Move modifier mask api to GdkDisplay GdkKeymap is on the way out.	2020-04-05 00:37:23 -04:00
Matthias Clasen	cbc543e1ca	gdk: Add keymap properties to GdkDevice GdkKeymap is on the way out.	2020-04-05 00:36:42 -04:00
Matthias Clasen	4e44574bc6	passwordentry: Show caps lock warning more Show the caps lock warning regardless of whether we have the peek icon or not.	2020-04-05 00:30:23 -04:00
Matthias Clasen	61df2373b6	Drop some no longer used code	2020-04-04 20:04:42 -04:00
Matthias Clasen	78b9380d5b	cell renderer accel: Use gdk_event_get_match	2020-04-04 20:03:44 -04:00
Matthias Clasen	69b0596607	fixup gdk_event_matches	2020-04-04 20:03:19 -04:00
Matthias Clasen	d2087a23fc	Add gdk_event_get_match This is a counterpart to gdk_event_matches() that can be used to obtain a shortcut matching an event.	2020-04-04 20:02:20 -04:00
Matthias Clasen	c9da5e9043	Add gdk_event_matches Move the elaborate key event matching code from GtkShortcutTrigger to GdkEvent, which greatly reduces the amount of keymap api use outside of GDK.	2020-04-04 17:51:32 -04:00