Merge branch 'keymap-rework-2' into 'master'

Keymap rework 2

See merge request GNOME/gtk!1635

85 files changed, 1279 insertions, 1567 deletions

diff --git a/docs/reference/gdk/gdk4-sections.txt b/docs/reference/gdk/gdk4-sections.txt
index fb0341f9b8..dff48e9e1a 100644
--- a/docs/reference/gdk/gdk4-sections.txt
+++ b/docs/reference/gdk/gdk4-sections.txt
@@ -98,7 +98,10 @@ gdk_display_get_monitor_at_surface
 gdk_display_get_clipboard
 gdk_display_get_primary_clipboard
 gdk_display_get_setting
-gdk_display_get_keymap
+
+<SUBSECTION>
+gdk_display_map_keyval
+gdk_display_map_keycode
 
 <SUBSECTION Standard>
 GDK_DISPLAY
@@ -212,7 +215,7 @@ gdk_surface_get_height
 gdk_surface_set_shadow_width
 gdk_surface_get_device_position
 GdkModifierType
-GdkModifierIntent
+GDK_MODIFIER_MASK
 
 <SUBSECTION>
 gdk_surface_get_support_multidevice
@@ -337,49 +340,16 @@ gdk_rectangle_get_type
 <SECTION>
 <TITLE>Keyboard Handling</TITLE>
 <FILE>keys</FILE>
-GdkKeymap
-GdkKeymapKey
-gdk_keymap_lookup_key
-gdk_keymap_translate_keyboard_state
-gdk_keymap_get_entries_for_keyval
-gdk_keymap_get_entries_for_keycode
-gdk_keymap_get_direction
-gdk_keymap_have_bidi_layouts
-gdk_keymap_get_caps_lock_state
-gdk_keymap_get_num_lock_state
-gdk_keymap_get_scroll_lock_state
-gdk_keymap_get_modifier_state
-gdk_keymap_add_virtual_modifiers
-gdk_keymap_map_virtual_modifiers
-gdk_keymap_get_modifier_mask
-gdk_keymap_get_display
-
-<SUBSECTION>
 gdk_keyval_name
 gdk_keyval_from_name
-
-<SUBSECTION>
 gdk_keyval_convert_case
 gdk_keyval_to_upper
 gdk_keyval_to_lower
 gdk_keyval_is_upper
 gdk_keyval_is_lower
-
-<SUBSECTION>
 gdk_keyval_to_unicode
 gdk_unicode_to_keyval
 
-<SUBSECTION Standard>
-GDK_KEYMAP
-GDK_IS_KEYMAP
-GDK_TYPE_KEYMAP
-GDK_KEYMAP_CLASS
-GDK_IS_KEYMAP_CLASS
-GDK_KEYMAP_GET_CLASS
-
-<SUBSECTION Private>
-GdkKeymapClass
-gdk_keymap_get_type
 </SECTION>
 
 <SECTION>
@@ -541,8 +511,9 @@ gdk_scroll_event_get_deltas
 gdk_scroll_event_is_stop
 gdk_key_event_get_keyval
 gdk_key_event_get_keycode
-gdk_key_event_get_scancode
-gdk_key_event_get_group
+gdk_key_event_get_consumed_modifiers
+gdk_key_event_get_layout
+gdk_key_event_get_level
 gdk_key_event_is_modifier
 gdk_focus_event_get_in
 gdk_touch_event_get_emulating_pointer
@@ -566,6 +537,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
diff --git a/docs/reference/gdk/gdk4.types b/docs/reference/gdk/gdk4.types
index 7a7eb76026..3127e63a5c 100644
--- a/docs/reference/gdk/gdk4.types
+++ b/docs/reference/gdk/gdk4.types
@@ -17,7 +17,6 @@ gdk_event_get_type
 gdk_frame_clock_get_type
 gdk_gl_context_get_type
 gdk_gl_texture_get_type
-gdk_keymap_get_type
 gdk_memory_texture_get_type
 gdk_monitor_get_type
 gdk_paintable_get_type
diff --git a/docs/reference/gtk/gtk4-sections.txt b/docs/reference/gtk/gtk4-sections.txt
index e944c9256f..f5462d9d5d 100644
--- a/docs/reference/gtk/gtk4-sections.txt
+++ b/docs/reference/gtk/gtk4-sections.txt
@@ -60,7 +60,6 @@ gtk_accelerator_get_label
 gtk_accelerator_parse_with_keycode
 gtk_accelerator_name_with_keycode
 gtk_accelerator_get_label_with_keycode
-gtk_accelerator_set_default_mod_mask
 gtk_accelerator_get_default_mod_mask
 </SECTION>
 
@@ -4063,7 +4062,6 @@ gtk_widget_get_support_multidevice
 gtk_widget_get_realized
 gtk_widget_get_mapped
 gtk_widget_device_is_shadowed
-gtk_widget_get_modifier_mask
 gtk_widget_get_opacity
 gtk_widget_set_opacity
 gtk_widget_get_overflow
@@ -5960,7 +5958,6 @@ gtk_event_controller_motion_get_type
 GtkShortcutTrigger
 GtkNeverTrigger
 
-GtkShortcutTriggerMatch
 gtk_shortcut_trigger_trigger
 gtk_shortcut_trigger_hash
 gtk_shortcut_trigger_equal
diff --git a/docs/reference/gtk/migrating-3to4.xml b/docs/reference/gtk/migrating-3to4.xml
index b97b8f128b..634fcbe71d 100644
--- a/docs/reference/gtk/migrating-3to4.xml
+++ b/docs/reference/gtk/migrating-3to4.xml
@@ -397,8 +397,29 @@
     <section>
       <title>Adapt to GdkKeymap API changes</title>
       <para>
-        The way to get a keymap has changed slightly. gdk_keymap_get_for_display() has
-        been renamed to gdk_display_get_keymap().
+        GdkKeymap no longer exists as an independent object.
+      </para>
+      <para>
+        If you need access to keymap state, it is now exposed as properties
+        on the #GdkDevice representing the keyboard: #GdkDevice:direction,
+        #GdkDevice:has-bidi-layouts, #GdkDevice:caps-lock-state,
+        #GdkDevice:num-lock-state, #GdkDevice:scroll-lock-state and
+        #GdkDevice:modifier-state.
+        To obtain the keyboard device, you can use
+        <literal>gdk_seat_get_keyboard (gdk_display_get_default_seat (display))</literal>.
+      </para>
+      <para>
+        If you need access to translated keys for event handling, #GdkEvent
+        now includes all of the translated key state, including consumed
+        modifiers, group and shift level, so there should be no need to
+        do manually call gdk_keymap_translate_keyboard_state() (which has
+        been removed).
+      </para>
+      <para>
+        If you need to do forward or backward mapping between key codes
+        and key values, use gdk_display_map_keycode() and gdk_display_map_keyval(),
+        which is the replacement for gdk_keymap_get_entries_for_keycode()
+        and gdk_keymap_get_entries_for_keycode().
       </para>
     </section>
 
@@ -418,6 +439,38 @@
     </section>
 
     <section>
+      <title>Adapt to changes in keyboard modifier handling</title>
+      <para>
+        GTK 3 has the idea that use of modifiers may differ between different
+        platforms, and has a #GdkModifierIntent api to let platforms provide
+        hint about how modifiers are expected to be used. It also promoted
+        the use of &lt;Primary&gt; instead of &lt;Control&gt; to specify
+        accelerators that adapt to platform conventions.
+      </para>
+      <para>
+        In GTK 4, the meaning of modifiers has been fixed, and backends are
+        expected to map the platform conventions to the existing modifiers.
+        The expected use of modifiers in GTK 4 is:
+        <simplelist>
+          <member>GDK_CONTROL_MASK - Primary accelerators</member>
+          <member>GDK_ALT_MASK - Mnemonics</member>
+          <member>GDK_SHIFT_MASK - Extending selections</member>
+          <member>GDK_CONTROL_MASK - Modifying selections</member>
+          <member>GDK_CONTROL_MASK|GDK_ALT_MASK - Prevent text input</member>
+        </simplelist>
+      </para>
+      <para>
+        Consequently, #GdkModifierIntent and related APIs have been removed,
+        and &lt;Control&gt; is preferred over &lt;Primary&gt; in accelerators.
+      </para>
+      <para>
+        A related change is that GTK 4 no longer supports the use of archaic
+        X11 'real' modifiers with the names Mod1,..., Mod5, and %GDK_MOD1_MASK
+        has been renamed to %GDK_ALT_MASK.
+      </para>
+    </section>
+
+    <section>
       <title>Stop using GtkEventBox</title>
       <para>
         GtkEventBox is no longer needed and has been removed.
@@ -809,15 +862,6 @@
     </section>
 
     <section>
-      <title>Stop using tabular menus</title>
-      <para>
-        Tabular menus were rarely used and complicated the menu code,
-        so they have been removed. If you need complex layout in menu-like
-        popups, consider using a #GtkPopover instead.
-      </para>
-    </section>
-
-    <section>
       <title>Stop using gtk_menu_set_display()</title>
       <para>
         This function has been removed. Menus should always be
@@ -944,6 +988,13 @@
         switching to menu models and actions.
       </para>
       <para>
+        Tabular menus were rarely used and complicated the menu code,
+        so they have not been brought over to #GtkPopoverMenu. If you need
+        complex layout in menu-like popups, consider directly using a
+        #GtkPopover instead.
+      </para>
+
+      <para>
         Since menus are gone, GtkMenuButton also lost its ability to show menus,
         and needs to be used with popovers in GTK 4.
       </para>
diff --git a/gdk/broadway/broadway.js b/gdk/broadway/broadway.js
index 6cb576d40c..21554546c2 100644
--- a/gdk/broadway/broadway.js
+++ b/gdk/broadway/broadway.js
@@ -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;
 }
diff --git a/gdk/broadway/gdkeventsource.c b/gdk/broadway/gdkeventsource.c
index 0f83b8b6f6..86e19af155 100644
--- a/gdk/broadway/gdkeventsource.c
+++ b/gdk/broadway/gdkeventsource.c
@@ -266,6 +266,11 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
                                   GINT_TO_POINTER (message->key.surface_id));
     if (surface)
       {
+        GdkTranslatedKey translated;
+        translated.keyval = message->key.key;
+        translated.consumed = 0;
+        translated.layout = 0;
+        translated.level = 0;
         event = gdk_event_key_new (message->base.type == BROADWAY_EVENT_KEY_PRESS
                                      ? GDK_KEY_PRESS
                                      : GDK_KEY_RELEASE,
@@ -273,12 +278,11 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
                                    gdk_seat_get_keyboard (seat),
                                    gdk_seat_get_keyboard (seat),
                                    message->base.time,
-                                   message->key.state,
-                                   message->key.key,
                                    message->key.key,
-                                   message->key.key,
-                                   0,
-                                   FALSE);
+                                   message->key.state,
+                                   FALSE,
+                                   &translated,
+                                   &translated);
 
         node = _gdk_event_queue_append (display, event);
         _gdk_windowing_got_event (display, node, event, message->base.serial);
diff --git a/gdk/broadway/gdkkeys-broadway.c b/gdk/broadway/gdkkeys-broadway.c
index 47a16a54d1..f58f332dc6 100644
--- a/gdk/broadway/gdkkeys-broadway.c
+++ b/gdk/broadway/gdkkeys-broadway.c
@@ -188,19 +188,6 @@ gdk_broadway_keymap_translate_keyboard_state (GdkKeymap       *keymap,
 }
 
 static void
-gdk_broadway_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
-					   GdkModifierType *state)
-{
-}
-
-static gboolean
-gdk_broadway_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
-					   GdkModifierType *state)
-{
-  return TRUE;
-}
-
-static void
 gdk_broadway_keymap_class_init (GdkBroadwayKeymapClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
@@ -217,7 +204,5 @@ gdk_broadway_keymap_class_init (GdkBroadwayKeymapClass *klass)
   keymap_class->get_entries_for_keycode = gdk_broadway_keymap_get_entries_for_keycode;
   keymap_class->lookup_key = gdk_broadway_keymap_lookup_key;
   keymap_class->translate_keyboard_state = gdk_broadway_keymap_translate_keyboard_state;
-  keymap_class->add_virtual_modifiers = gdk_broadway_keymap_add_virtual_modifiers;
-  keymap_class->map_virtual_modifiers = gdk_broadway_keymap_map_virtual_modifiers;
 }
 
diff --git a/gdk/gdk-autocleanup.h b/gdk/gdk-autocleanup.h
index d566986a45..a7c8586962 100644
--- a/gdk/gdk-autocleanup.h
+++ b/gdk/gdk-autocleanup.h
@@ -32,7 +32,6 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDrag, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDrawContext, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkFrameClock, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkGLContext, g_object_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkKeymap, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkMonitor, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkSeat, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkPopupLayout, gdk_popup_layout_unref)
diff --git a/gdk/gdkdevice.c b/gdk/gdkdevice.c
index 2123dc1dd7..907c53ce62 100644
--- a/gdk/gdkdevice.c
+++ b/gdk/gdkdevice.c
@@ -24,6 +24,7 @@
 #include "gdkdisplayprivate.h"
 #include "gdkinternals.h"
 #include "gdkintl.h"
+#include "gdkkeysprivate.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;
+}
diff --git a/gdk/gdkdevice.h b/gdk/gdkdevice.h
index 3229a0b5af..b1cdf583a4 100644
--- a/gdk/gdkdevice.h
+++ b/gdk/gdkdevice.h
@@ -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__ */
diff --git a/gdk/gdkdisplay.c b/gdk/gdkdisplay.c
index e402a929d1..4e209672fc 100644
--- a/gdk/gdkdisplay.c
+++ b/gdk/gdkdisplay.c
@@ -1711,3 +1711,75 @@ 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);
 }
+
+/**
+ * gdk_display_map_keyval:
+ * @display: a #GdkDisplay
+ * @keyval: a keyval, such as %GDK_KEY_a, %GDK_KEY_Up, %GDK_KEY_Return, etc.
+ * @keys: (out) (array length=n_keys) (transfer full): return location
+ *     for an array of #GdkKeymapKey
+ * @n_keys: return location for number of elements in returned array
+ *
+ * Obtains a list of keycode/group/level combinations that will
+ * generate @keyval. Groups and levels are two kinds of keyboard mode;
+ * in general, the level determines whether the top or bottom symbol
+ * on a key is used, and the group determines whether the left or
+ * right symbol is used.
+ *
+ * On US keyboards, the shift key changes the keyboard level, and there
+ * are no groups. A group switch key might convert a keyboard between
+ * Hebrew to English modes, for example.
+ *
+ * #GdkEventKey contains a %group field that indicates the active
+ * keyboard group. The level is computed from the modifier mask.
+ *
+ * The returned array should be freed with g_free().
+ *
+ * Returns: %TRUE if keys were found and returned
+ */
+gboolean
+gdk_display_map_keyval (GdkDisplay    *display,
+                        guint          keyval,
+                        GdkKeymapKey **keys,
+                        int           *n_keys)
+{
+  return gdk_keymap_get_entries_for_keyval (gdk_display_get_keymap (display),
+                                            keyval,
+                                            keys,
+                                            n_keys);
+}
+
+/**
+ * gdk_display_map_keycode:
+ * @display: a #GdkDisplay
+ * @keycode: a keycode
+ * @keys: (out) (array length=n_entries) (transfer full) (optional): return
+ *     location for array of #GdkKeymapKey, or %NULL
+ * @keyvals: (out) (array length=n_entries) (transfer full) (optional): return
+ *     location for array of keyvals, or %NULL
+ * @n_entries: length of @keys and @keyvals
+ *
+ * Returns the keyvals bound to @keycode. The Nth #GdkKeymapKey
+ * in @keys is bound to the Nth keyval in @keyvals.
+ *
+ * When a keycode is pressed by the user, the keyval from
+ * this list of entries is selected by considering the effective
+ * keyboard group and level.
+ *
+ * Free the returned arrays with g_free().
+ *
+ * Returns: %TRUE if there were any entries
+ */
+gboolean
+gdk_display_map_keycode (GdkDisplay    *display,
+                         guint          keycode,
+                         GdkKeymapKey **keys,
+                         guint        **keyvals,
+                         int           *n_entries)
+{
+  return gdk_keymap_get_entries_for_keycode (gdk_display_get_keymap (display),
+                                             keycode,
+                                             keys,
+                                             keyvals,
+                                             n_entries);
+}
diff --git a/gdk/gdkdisplay.h b/gdk/gdkdisplay.h
index bdd6c985cb..bb421f405d 100644
--- a/gdk/gdkdisplay.h
+++ b/gdk/gdkdisplay.h
@@ -116,7 +116,17 @@ GdkMonitor * gdk_display_get_monitor_at_surface (GdkDisplay *display,
                                                 GdkSurface  *surface);
 
 GDK_AVAILABLE_IN_ALL
-GdkKeymap *  gdk_display_get_keymap  (GdkDisplay *display);
+gboolean       gdk_display_map_keyval  (GdkDisplay    *display,
+                                        guint          keyval,
+                                        GdkKeymapKey **keys,
+                                        int           *n_keys);
+
+GDK_AVAILABLE_IN_ALL
+gboolean       gdk_display_map_keycode (GdkDisplay    *display,
+                                        guint          keycode,
+                                        GdkKeymapKey **keys,
+                                        guint        **keyvals,
+                                        int           *n_entries);
 
 GDK_AVAILABLE_IN_ALL
 gboolean     gdk_display_get_setting (GdkDisplay *display,
diff --git a/gdk/gdkevents.c b/gdk/gdkevents.c
index 097198ef29..e99b95a3cd 100644
--- a/gdk/gdkevents.c
+++ b/gdk/gdkevents.c
@@ -30,6 +30,7 @@
 #include "gdkdisplayprivate.h"
 #include "gdkdragprivate.h"
 #include "gdkdropprivate.h"
+#include "gdkkeysprivate.h"
 #include "gdk-private.h"
 
 #include <string.h>
@@ -551,10 +552,7 @@ gdk_event_get_axis (GdkEvent   *event,
  *
  * This function returns whether a #GdkEventButton should trigger a
  * context menu, according to platform conventions. The right mouse
- * button always triggers context menus. Additionally, if
- * gdk_keymap_get_modifier_mask() returns a non-0 mask for
- * %GDK_MODIFIER_INTENT_CONTEXT_MENU, then the left mouse button will
- * also trigger a context menu if this modifier is pressed.
+ * button always triggers context menus.
  *
  * This function should always be used instead of simply checking for
  * event->button == %GDK_BUTTON_SECONDARY.
@@ -569,25 +567,12 @@ gdk_event_triggers_context_menu (GdkEvent *event)
   if (event->any.type == GDK_BUTTON_PRESS)
     {
       GdkEventButton *bevent = (GdkEventButton *) event;
-      GdkDisplay *display;
-      GdkModifierType modifier;
 
       g_return_val_if_fail (GDK_IS_SURFACE (bevent->any.surface), FALSE);
 
       if (bevent->button == GDK_BUTTON_SECONDARY &&
           ! (bevent->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK)))
         return TRUE;
-
-      display = gdk_surface_get_display (bevent->any.surface);
-
-      modifier = gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-                                               GDK_MODIFIER_INTENT_CONTEXT_MENU);
-
-      if (modifier != 0 &&
-          bevent->button == GDK_BUTTON_PRIMARY &&
-          ! (bevent->state & (GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) &&
-          (bevent->state & modifier))
-        return TRUE;
     }
 
   return FALSE;
@@ -931,17 +916,16 @@ gdk_event_proximity_new (GdkEventType   type,
 }
 
 GdkEvent *
-gdk_event_key_new (GdkEventType     type,
-                   GdkSurface      *surface,
-                   GdkDevice       *device,
-                   GdkDevice       *source_device,
-                   guint32          time,
-                   GdkModifierType  state,
-                   guint            keyval,
-                   guint16          keycode,
-                   guint16          scancode,
-                   guint8           group,
-                   gboolean         is_modifier)
+gdk_event_key_new (GdkEventType      type,
+                   GdkSurface       *surface,
+                   GdkDevice        *device,
+                   GdkDevice        *source_device,
+                   guint32           time,
+                   guint             keycode,
+                   GdkModifierType   state,
+                   gboolean          is_modifier,
+                   GdkTranslatedKey *translated,
+                   GdkTranslatedKey *no_lock)
 {
   GdkEventKey *event;
 
@@ -956,12 +940,11 @@ gdk_event_key_new (GdkEventType     type,
   event->any.surface = g_object_ref (surface);
   event->any.device = g_object_ref (device);
   event->any.source_device = g_object_ref (source_device);
+  event->keycode = keycode;
   event->state = state;
-  event->keyval = keyval;
-  event->hardware_keycode = keycode;
-  event->key_scancode = scancode;
-  event->group = group;
   event->any.key_is_modifier = is_modifier;
+  event->translated[0] = *translated;
+  event->translated[1] = *no_lock;
 
   return (GdkEvent *)event;
 }
@@ -1669,7 +1652,7 @@ gdk_key_event_get_keyval (GdkEvent *event)
   g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
                         event->any.type == GDK_KEY_RELEASE, 0);
 
-  return event->key.keyval;
+  return event->key.translated[0].keyval;
 }
 
 /**
@@ -1686,41 +1669,58 @@ gdk_key_event_get_keycode (GdkEvent *event)
   g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
                         event->any.type == GDK_KEY_RELEASE, 0);
 
-  return event->key.hardware_keycode;
+  return event->key.keycode;
 }
 
 /**
- * gdk_key_event_get_scancode:
+ * gdk_key_event_get_level:
  * @event: a key event
  *
- * Extracts the scancode from a key event.
+ * Extracts the shift level from a key event.
  *
- * Returns: the scancode of @event
+ * Returns: the shift level of @event
  */
 guint
-gdk_key_event_get_scancode (GdkEvent *event)
+gdk_key_event_get_level (GdkEvent *event)
 {
   g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
                         event->any.type == GDK_KEY_RELEASE, 0);
 
-  return event->key.key_scancode;
+  return event->key.translated[0].level;
 }
 
 /**
- * gdk_key_event_get_group:
+ * gdk_key_event_get_layout:
  * @event: a key event
  *
- * Extracts the group from a key event.
+ * Extracts the layout from a key event.
  *
- * Returns: the group of @event
+ * Returns: the layout of @event
  */
 guint
-gdk_key_event_get_group (GdkEvent *event)
+gdk_key_event_get_layout (GdkEvent *event)
+{
+  g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
+                        event->any.type == GDK_KEY_RELEASE, 0);
+
+  return event->key.translated[0].layout;
+}
+
+/**
+ * gdk_key_event_get_consumed_modifiers:
+ * @event: a key event
+ *
+ * Extracts the consumed modifiers from a key event.
+ *
+ * Returns: the consumed modifiers or @event
+ */
+GdkModifierType
+gdk_key_event_get_consumed_modifiers (GdkEvent *event)
 {
   g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
                         event->any.type == GDK_KEY_RELEASE, 0);
 
-  return event->key.group;
+  return event->key.translated[0].consumed;
 }
 
 /**
@@ -2110,3 +2110,164 @@ gdk_grab_broken_event_get_grab_surface (GdkEvent *event)
 
   return event->grab_broken.grab_surface;
 }
+
+/**
+ * gdk_key_event_matches:
+ * @event: a key #GdkEvent
+ * @keyval: the keyval to match
+ * @modifiers: the modifiers to match
+ *
+ * Matches a key event against a keyboard shortcut that is specified
+ * as a keyval and modifiers. Partial matches are possible where the
+ * combination matches if the currently active group is ignored.
+ *
+ * Note that we ignore Caps Lock for matching.
+ *
+ * Returns: a GdkKeyMatch value describing whether @event matches
+ */
+GdkKeyMatch
+gdk_key_event_matches (GdkEvent        *event,
+                       guint            keyval,
+                       GdkModifierType  modifiers)
+{
+  guint keycode;
+  GdkModifierType state;
+  GdkModifierType mask;
+  guint ev_keyval;
+  int layout;
+  int level;
+  GdkModifierType consumed_modifiers;
+  GdkModifierType shift_group_mask;
+  gboolean group_mod_is_accel_mod = FALSE;
+
+  g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
+                        event->any.type == GDK_KEY_RELEASE, GDK_KEY_MATCH_NONE);
+
+  keycode = event->key.keycode;
+  state = event->key.state & ~GDK_LOCK_MASK;
+  ev_keyval = event->key.translated[1].keyval;
+  layout = event->key.translated[1].layout;
+  level = event->key.translated[1].level;
+  consumed_modifiers = event->key.translated[1].consumed;
+
+  mask = GDK_CONTROL_MASK|GDK_SHIFT_MASK|GDK_ALT_MASK|
+         GDK_SUPER_MASK|GDK_HYPER_MASK|GDK_META_MASK;
+
+  /* if the group-toggling modifier is part of the default accel mod
+   * mask, and it is active, disable it for matching
+   *
+   * FIXME: get shift group mask from backends
+   */
+  shift_group_mask = 0;
+
+  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_KEY_MATCH_EXACT;
+        }
+
+      gdk_display_map_keyval (gdk_event_get_display (event), 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 == layout))
+            {
+              /* partial match */
+              g_free (keys);
+
+              return GDK_KEY_MATCH_PARTIAL;
+            }
+        }
+
+      g_free (keys);
+    }
+
+
+  return GDK_KEY_MATCH_NONE;
+}
+
+/**
+ * gdk_key_event_get_match:
+ * @event: a key #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_key_event_get_match (GdkEvent        *event,
+                         guint           *keyval,
+                         GdkModifierType *modifiers)
+{
+  GdkModifierType mask;
+  guint key;
+  guint accel_key;
+  GdkModifierType accel_mods;
+  GdkModifierType consumed_modifiers;
+
+  g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
+                        event->any.type == GDK_KEY_RELEASE, FALSE);
+
+  mask = GDK_CONTROL_MASK|GDK_SHIFT_MASK|GDK_ALT_MASK|
+         GDK_SUPER_MASK|GDK_HYPER_MASK|GDK_META_MASK;
+
+  accel_key = event->key.translated[1].keyval;
+  accel_mods = event->key.state;
+  consumed_modifiers = event->key.translated[1].consumed;
+
+  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;
+    }
+
+  key = gdk_keyval_to_lower (accel_key);
+
+  if (key == GDK_KEY_ISO_Left_Tab)
+    key = GDK_KEY_Tab;
+
+  accel_mods &= mask & ~consumed_modifiers;
+
+  if (accel_key != key)
+    accel_mods |= GDK_SHIFT_MASK;
+
+  *keyval = key;
+  *modifiers = accel_mods;
+
+  return TRUE;
+}
diff --git a/gdk/gdkevents.h b/gdk/gdkevents.h
index 888ca9e5c5..d697cb8c20 100644
--- a/gdk/gdkevents.h
+++ b/gdk/gdkevents.h
@@ -363,9 +363,11 @@ guint                   gdk_key_event_get_keyval        (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
 guint                   gdk_key_event_get_keycode       (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-guint                   gdk_key_event_get_scancode      (GdkEvent *event);
+GdkModifierType         gdk_key_event_get_consumed_modifiers (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-guint                   gdk_key_event_get_group         (GdkEvent *event);
+guint                   gdk_key_event_get_layout        (GdkEvent *event);
+GDK_AVAILABLE_IN_ALL
+guint                   gdk_key_event_get_level         (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
 gboolean                gdk_key_event_is_modifier       (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
@@ -428,6 +430,32 @@ gboolean                gdk_events_get_center           (GdkEvent *event1,
                                                          double   *x,
                                                          double   *y);
 
+/**
+ * GdkKeyMatch:
+ * @GDK_KEY_MATCH_NONE: The key event does not match
+ * @GDK_KEY_MATCH_PARTIAL: The key event matches if keyboard state
+ *     (specifically, the currently active group) is ignored
+ * @GDK_KEY_MATCH_EXACT: The key event matches
+ *
+ * The possible return values from gdk_key_event_matches()
+ * describe how well an event matches a given keyval and modifiers.
+ */
+typedef enum {
+  GDK_KEY_MATCH_NONE,
+  GDK_KEY_MATCH_PARTIAL,
+  GDK_KEY_MATCH_EXACT
+} GdkKeyMatch;
+
+GDK_AVAILABLE_IN_ALL
+GdkKeyMatch            gdk_key_event_matches (GdkEvent        *event,
+                                              guint            keyval,
+                                              GdkModifierType  modifiers);
+
+GDK_AVAILABLE_IN_ALL
+gboolean               gdk_key_event_get_match (GdkEvent        *event,
+                                                guint           *keyval,
+                                                GdkModifierType *modifiers);
+
 G_END_DECLS
 
 #endif /* __GDK_EVENTS_H__ */
diff --git a/gdk/gdkeventsprivate.h b/gdk/gdkeventsprivate.h
index 6cc2aadcba..3977be170a 100644
--- a/gdk/gdkeventsprivate.h
+++ b/gdk/gdkeventsprivate.h
@@ -223,6 +223,13 @@ struct _GdkEventScroll
   GdkDeviceTool *tool;
 };
 
+typedef struct {
+  guint keyval;
+  GdkModifierType consumed;
+  guint layout;
+  guint level;
+} GdkTranslatedKey;
+
 /*
  * GdkEventKey:
  * @type: the type of the event (%GDK_KEY_PRESS or %GDK_KEY_RELEASE).
@@ -232,13 +239,9 @@ struct _GdkEventScroll
  * @state: (type GdkModifierType): a bit-mask representing the state of
  *   the modifier keys (e.g. Control, Shift and Alt) and the pointer
  *   buttons. See #GdkModifierType.
- * @keyval: the key that was pressed or released. See the
- *   `gdk/gdkkeysyms.h` header file for a
- *   complete list of GDK key codes.
- * @hardware_keycode: the raw code of the key that was pressed or released.
- * @group: the keyboard group.
- * @is_modifier: a flag that indicates if @hardware_keycode is mapped to a
- *   modifier
+ * @keycode: the raw code of the key that was pressed or released.
+ * @translated: the result of translating @keycode. First with the full
+ *   @state, then while ignoring Caps Lock.
  *
  * Describes a key press or key release event.
  */
@@ -246,10 +249,8 @@ struct _GdkEventKey
 {
   GdkEventAny any;
   GdkModifierType state;
-  guint keyval;
-  guint16 hardware_keycode;
-  guint16 key_scancode;
-  guint8 group;
+  guint32 keycode;
+  GdkTranslatedKey translated[2];
 };
 
 /*
@@ -594,17 +595,16 @@ GdkEvent * gdk_event_proximity_new      (GdkEventType     type,
                                          GdkDeviceTool   *tool,
                                          guint32          time);
 
-GdkEvent * gdk_event_key_new            (GdkEventType     type,
-                                         GdkSurface      *surface,
-                                         GdkDevice       *device,
-                                         GdkDevice       *source_device,
-                                         guint32          time,
-                                         GdkModifierType  state,
-                                         guint            keyval,
-                                         guint16          keycode,
-                                         guint16          scancode,
-                                         guint8           group,
-                                         gboolean         is_modifier);
+GdkEvent * gdk_event_key_new            (GdkEventType      type,
+                                         GdkSurface       *surface,
+                                         GdkDevice        *device,
+                                         GdkDevice        *source_device,
+                                         guint32           time,
+                                         guint             keycode,
+                                         GdkModifierType   modifiers,
+                                         gboolean          is_modifier,
+                                         GdkTranslatedKey *translated,
+                                         GdkTranslatedKey *no_lock);
 
 GdkEvent * gdk_event_focus_new          (GdkSurface      *surface,
                                          GdkDevice       *device,
diff --git a/gdk/gdkinternals.h b/gdk/gdkinternals.h
index 73e356170c..30715af56e 100644
--- a/gdk/gdkinternals.h
+++ b/gdk/gdkinternals.h
@@ -33,6 +33,7 @@
 #include "gdksurfaceprivate.h"
 #include "gdkenumtypes.h"
 #include "gdkdragprivate.h"
+#include "gdkkeysprivate.h"
 
 G_BEGIN_DECLS
 
@@ -322,6 +323,7 @@ void           gdk_seat_ungrab           (GdkSeat                *seat);
 GdkSurface *   gdk_surface_new_temp             (GdkDisplay    *display,
                                                  const GdkRectangle *position);
 
+GdkKeymap *  gdk_display_get_keymap  (GdkDisplay *display);
 
 G_END_DECLS
 
diff --git a/gdk/gdkkeys.c b/gdk/gdkkeys.c
index 25e9284e3c..469d204e0b 100644
--- a/gdk/gdkkeys.c
+++ b/gdk/gdkkeys.c
@@ -36,8 +36,9 @@
  * @Title: Key Values
  *
  * Key values are the codes which are sent whenever a key is pressed or released.
- * They appear in the #GdkEventKey.keyval field of the #GdkEventKey structure.
- * The complete list of key values can be found in the `gdk/gdkkeysyms.h` header file.
+ * They are included in the data contained in a key press or release #GdkEvent.
+ * The complete list of key values can be found in the `gdk/gdkkeysyms.h` header
+ * file.
  *
  * Key values are regularly updated from the upstream X.org X11 implementation,
  * so new values are added regularly. They will be prefixed with GDK_KEY_ rather
@@ -56,43 +57,87 @@
  *
  * # Groups # {#key-group-explanation}
  *
- * One #GdkKeymap object exists for each user display. To obtain keymaps for
- * a display, use gdk_display_get_keymap(). A keymap is a mapping from
- * #GdkKeymapKey to key values. You can think of a #GdkKeymapKey as a
- * representation of a symbol printed on a physical keyboard key. That is, it
- * contains three pieces of information. First, it contains the hardware keycode;
- * this is an identifying number for a physical key. Second, it contains the
- * “level” of the key. The level indicates which symbol on the
- * key will be used, in a vertical direction. So on a standard US keyboard, the key
- * with the number “1“ on it also has the exclamation point (”!”) character on
- * it. The level indicates whether to use the “1” or the “!” symbol.  The letter
- * keys are considered to have a lowercase letter at level 0, and an uppercase
- * letter at level 1, though only the uppercase letter is printed.  Third, the
- * #GdkKeymapKey contains a group; groups are not used on standard US keyboards,
- * but are used in many other countries. On a keyboard with groups, there can be 3
- * or 4 symbols printed on a single key. The group indicates movement in a
- * horizontal direction. Usually groups are used for two different languages.  In
- * group 0, a key might have two English characters, and in group 1 it might have
- * two Hebrew characters. The Hebrew characters will be printed on the key next to
- * the English characters.
- *
- * In order to use a keymap to interpret a key event, it’s necessary to first
- * convert the keyboard state into an effective group and level. This is done via a
- * set of rules that varies widely according to type of keyboard and user
- * configuration. The function gdk_keymap_translate_keyboard_state() accepts a
- * keyboard state -- consisting of hardware keycode pressed, active modifiers, and
- * active group -- applies the appropriate rules, and returns the group/level to be
- * used to index the keymap, along with the modifiers which did not affect the
- * group and level. i.e. it returns “unconsumed modifiers.” The keyboard group may
- * differ from the effective group used for keymap lookups because some keys don't
- * have multiple groups - e.g. the Enter key is always in group 0 regardless of
- * keyboard state.
- *
- * Note that gdk_keymap_translate_keyboard_state() also returns the keyval, i.e. it
- * goes ahead and performs the keymap lookup in addition to telling you which
- * effective group/level values were used for the lookup. #GdkEventKey already
- * contains this keyval, however, so you don’t normally need to call
- * gdk_keymap_translate_keyboard_state() just to get the keyval.
+ * At the lowest level, physical keys on the keyboard are represented by
+ * numeric keycodes, and GDK knows how to translate these keycodes into
+ * key values according to the configured keyboard layout and the current
+ * state of the keyboard. In the GDK api, the mapping from keycodes to key
+ * values is available via gdk_display_map_keycode(), and the reverse mapping
+ * is available via gdk_display_map_keyval(). The results of these functions
+ * are returned in #GdkKeymapKey structs.
+ *
+ * You can think of a #GdkKeymapKey as a representation of a symbol printed on
+ * a physical keyboard key. That is, it contains three pieces of information.
+ * First, it contains the hardware keycode; this is an identifying number for
+ * a physical key. Second, it contains the “level” of the key. The level indicates
+ * which symbol on the key will be used, in a vertical direction. So on a standard
+ * US keyboard, the key with the number “1“ on it also has the exclamation point
+ * (”!”) character on it. The level indicates whether to use the “1” or the “!”
+ * symbol. The letter keys are considered to have a lowercase letter at level 0,
+ * and an uppercase letter at level 1, though normally only the uppercase letter
+ * is printed on the key. Third, the #GdkKeymapKey contains a group; groups are
+ * not used on standard US keyboards, but are used in many other countries. On a
+ * keyboard with groups, there can be 3 or 4 symbols printed on a single key.
+ * The group indicates movement in a horizontal direction. Usually groups are
+ * used for two different languages. In group 0, a key might have two English
+ * characters, and in group 1 it might have two Hebrew characters. The Hebrew
+ * characters will be printed on the key next to the English characters.
+ *
+ * When GDK creates a key event in order to deliver a key press or release,
+ * it first converts the current keyboard state into an effective group and
+ * level. This is done via a set of rules that varies widely according to
+ * type of keyboard and user configuration. The input to this translation
+ * consists of the hardware keycode pressed, the active modifiers, and the
+ * active group. It then applies the appropriate rules, and returns the
+ * group/level to be used to index the keymap, along with the modifiers
+ * which did not affect the group and level. i.e. it returns “unconsumed
+ * modifiers.” The keyboard group may differ from the effective group used
+ * for lookups because some keys don't have multiple groups - e.g. the Enter
+ * key is always in group 0 regardless of keyboard state.
+ *
+ * The results of the translation, including the keyval, are all included
+ * in the key event and can be obtained via #GdkEvent getters.
+ *
+ * # Consumed modifiers
+ *
+ * The @consumed_modifiers in a key event are modifiers that should be masked
+ * out from @state when comparing this key press to a hot key. For instance,
+ * on a US keyboard, the `plus` symbol is shifted, so when comparing a key
+ * press to a `<Control>plus` accelerator `<Shift>` should be masked out.
+ *
+ * |[<!-- language="C" -->
+ * // We want to ignore irrelevant modifiers like ScrollLock
+ * #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),
+ *                                      state,
+ *                                      gdk_key_event_get_group (event),
+ *                                      &keyval, NULL, NULL, &consumed);
+ * if (keyval == GDK_PLUS &&
+ *     (state & ~consumed & ALL_ACCELS_MASK) == GDK_CONTROL_MASK)
+ *   // Control was pressed
+ * ]|
+ *
+ * An older interpretation @consumed_modifiers was that it contained
+ * all modifiers that might affect the translation of the key;
+ * this allowed accelerators to be stored with irrelevant consumed
+ * modifiers, by doing:
+ * |[<!-- language="C" -->
+ * // XXX Don’t do this XXX
+ * if (keyval == accel_keyval &&
+ *     (state & ~consumed & ALL_ACCELS_MASK) == (accel_mods & ~consumed))
+ *   // Accelerator was pressed
+ * ]|
+ *
+ * However, this did not work if multi-modifier combinations were
+ * used in the keymap, since, for instance, `<Control>` would be
+ * masked out even if only `<Control><Alt>` was used in the keymap.
+ * To support this usage as well as well as possible, all single
+ * modifier combinations that could affect the key for any combination
+ * of modifiers will be returned in @consumed_modifiers; multi-modifier
+ * combinations are returned only when actually found in @state. When
+ * you store accelerators, you should always store them with consumed
+ * modifiers removed. Store `<Control>plus`, not `<Control><Shift>plus`.
  */
 
 enum {
@@ -111,9 +156,6 @@ enum {
 static GParamSpec *props[LAST_PROP] = { NULL, };
 static guint signals[LAST_SIGNAL] = { 0 };
 
-static GdkModifierType gdk_keymap_real_get_modifier_mask (GdkKeymap         *keymap,
-                                                          GdkModifierIntent  intent);
-
 G_DEFINE_TYPE (GdkKeymap, gdk_keymap, G_TYPE_OBJECT)
 
 static void
@@ -161,8 +203,6 @@ gdk_keymap_class_init (GdkKeymapClass *klass)
   object_class->get_property = gdk_keymap_get_property;
   object_class->set_property = gdk_keymap_set_property;
 
-  klass->get_modifier_mask = gdk_keymap_real_get_modifier_mask;
-
   props[PROP_DISPLAY] =
     g_param_spec_object ("display",
                          "Display",
@@ -558,7 +598,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),
@@ -615,116 +655,6 @@ gdk_keymap_translate_keyboard_state (GdkKeymap       *keymap,
 								  consumed_modifiers);
 }
 
-/**
- * gdk_keymap_add_virtual_modifiers:
- * @keymap: a #GdkKeymap
- * @state: (inout): pointer to the modifier mask to change
- *
- * Maps the non-virtual modifiers (i.e Mod2, Mod3, ...) which are set
- * in @state to the virtual modifiers (i.e. Super, Hyper and Meta) and
- * set the corresponding bits in @state.
- *
- * GDK already does this before delivering key events, but for
- * compatibility reasons, it only sets the first virtual modifier
- * it finds, whereas this function sets all matching virtual modifiers.
- *
- * This function is useful when matching key events against
- * accelerators.
- */
-void
-gdk_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
-			          GdkModifierType *state)
-{
-  g_return_if_fail (GDK_IS_KEYMAP (keymap));
-
-  GDK_KEYMAP_GET_CLASS (keymap)->add_virtual_modifiers (keymap, state);
-}
-
-/**
- * gdk_keymap_map_virtual_modifiers:
- * @keymap: a #GdkKeymap
- * @state: (inout): pointer to the modifier state to map
- *
- * Maps the virtual modifiers (i.e. Super, Hyper and Meta) which
- * are set in @state to their non-virtual counterparts (i.e. Mod2,
- * Mod3,...) and set the corresponding bits in @state.
- *
- * This function is useful when matching key events against
- * accelerators.
- *
- * Returns: %FALSE if two virtual modifiers were mapped to the
- *     same non-virtual modifier. Note that %FALSE is also returned
- *     if a virtual modifier is mapped to a non-virtual modifier that
- *     was already set in @state.
- */
-gboolean
-gdk_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
-                                  GdkModifierType *state)
-{
-  g_return_val_if_fail (GDK_IS_KEYMAP (keymap), FALSE);
-
-  return GDK_KEYMAP_GET_CLASS(keymap)->map_virtual_modifiers (keymap, state);
-}
-
-static GdkModifierType
-gdk_keymap_real_get_modifier_mask (GdkKeymap         *keymap,
-                                   GdkModifierIntent  intent)
-{
-  switch (intent)
-    {
-    case GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR:
-      return GDK_CONTROL_MASK;
-
-    case GDK_MODIFIER_INTENT_CONTEXT_MENU:
-      return 0;
-
-    case GDK_MODIFIER_INTENT_EXTEND_SELECTION:
-      return GDK_SHIFT_MASK;
-
-    case GDK_MODIFIER_INTENT_MODIFY_SELECTION:
-      return GDK_CONTROL_MASK;
-
-    case GDK_MODIFIER_INTENT_NO_TEXT_INPUT:
-      return GDK_MOD1_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    |
-	      GDK_SUPER_MASK   | GDK_HYPER_MASK   | GDK_META_MASK);
-
-    default:
-      g_return_val_if_reached (0);
-    }
-}
-
-/**
- * gdk_keymap_get_modifier_mask:
- * @keymap: a #GdkKeymap
- * @intent: the use case for the modifier mask
- *
- * Returns the modifier mask the @keymap’s windowing system backend
- * 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
- * #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
- * expected result.
- *
- * Returns: the modifier mask used for @intent.
- **/
-GdkModifierType
-gdk_keymap_get_modifier_mask (GdkKeymap         *keymap,
-                              GdkModifierIntent  intent)
-{
-  g_return_val_if_fail (GDK_IS_KEYMAP (keymap), 0);
-
-  return GDK_KEYMAP_GET_CLASS (keymap)->get_modifier_mask (keymap, intent);
-}
-
 #include "gdkkeynames.c"
 
 /**
diff --git a/gdk/gdkkeys.h b/gdk/gdkkeys.h
index 5189bc54c7..8baef542c6 100644
--- a/gdk/gdkkeys.h
+++ b/gdk/gdkkeys.h
@@ -34,104 +34,6 @@
 
 G_BEGIN_DECLS
 
-
-typedef struct _GdkKeymapKey GdkKeymapKey;
-
-/**
- * GdkKeymapKey:
- * @keycode: the hardware keycode. This is an identifying number for a
- *   physical key.
- * @group: indicates movement in a horizontal direction. Usually groups are used
- *   for two different languages. In group 0, a key might have two English
- *   characters, and in group 1 it might have two Hebrew characters. The Hebrew
- *   characters will be printed on the key next to the English characters.
- * @level: indicates which symbol on the key will be used, in a vertical direction.
- *   So on a standard US keyboard, the key with the number “1” on it also has the
- *   exclamation point ("!") character on it. The level indicates whether to use
- *   the “1” or the “!” symbol. The letter keys are considered to have a lowercase
- *   letter at level 0, and an uppercase letter at level 1, though only the
- *   uppercase letter is printed.
- *
- * A #GdkKeymapKey is a hardware key that can be mapped to a keyval.
- */
-struct _GdkKeymapKey
-{
-  guint keycode;
-  gint  group;
-  gint  level;
-};
-
-
-#define GDK_TYPE_KEYMAP              (gdk_keymap_get_type ())
-#define GDK_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_KEYMAP, GdkKeymap))
-#define GDK_IS_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_KEYMAP))
-
-/**
- * GdkKeymap:
- *
- * A #GdkKeymap defines the translation from keyboard state
- * (including a hardware key, a modifier mask, and active keyboard group)
- * to a keyval. This translation has two phases. The first phase is
- * to determine the effective keyboard group and level for the keyboard
- * state; the second phase is to look up the keycode/group/level triplet
- * in the keymap and see what keyval it corresponds to.
- */
-
-GDK_AVAILABLE_IN_ALL
-GType gdk_keymap_get_type (void) G_GNUC_CONST;
-
-GDK_AVAILABLE_IN_ALL
-GdkDisplay *   gdk_keymap_get_display              (GdkKeymap           *keymap);
-
-GDK_AVAILABLE_IN_ALL
-guint          gdk_keymap_lookup_key               (GdkKeymap           *keymap,
-						    const GdkKeymapKey  *key);
-GDK_AVAILABLE_IN_ALL
-gboolean       gdk_keymap_translate_keyboard_state (GdkKeymap           *keymap,
-						    guint                hardware_keycode,
-						    GdkModifierType      state,
-						    gint                 group,
-						    guint               *keyval,
-						    gint                *effective_group,
-						    gint                *level,
-						    GdkModifierType     *consumed_modifiers);
-GDK_AVAILABLE_IN_ALL
-gboolean       gdk_keymap_get_entries_for_keyval   (GdkKeymap           *keymap,
-						    guint                keyval,
-						    GdkKeymapKey       **keys,
-						    gint                *n_keys);
-GDK_AVAILABLE_IN_ALL
-gboolean       gdk_keymap_get_entries_for_keycode  (GdkKeymap           *keymap,
-						    guint                hardware_keycode,
-						    GdkKeymapKey       **keys,
-						    guint              **keyvals,
-						    gint                *n_entries);
-
-GDK_AVAILABLE_IN_ALL
-PangoDirection gdk_keymap_get_direction            (GdkKeymap           *keymap);
-GDK_AVAILABLE_IN_ALL
-gboolean       gdk_keymap_have_bidi_layouts        (GdkKeymap           *keymap);
-GDK_AVAILABLE_IN_ALL
-gboolean       gdk_keymap_get_caps_lock_state      (GdkKeymap           *keymap);
-GDK_AVAILABLE_IN_ALL
-gboolean       gdk_keymap_get_num_lock_state       (GdkKeymap           *keymap);
-GDK_AVAILABLE_IN_ALL
-gboolean       gdk_keymap_get_scroll_lock_state    (GdkKeymap           *keymap);
-GDK_AVAILABLE_IN_ALL
-guint          gdk_keymap_get_modifier_state       (GdkKeymap           *keymap);
-GDK_AVAILABLE_IN_ALL
-void           gdk_keymap_add_virtual_modifiers    (GdkKeymap           *keymap,
-                                                    GdkModifierType     *state);
-GDK_AVAILABLE_IN_ALL
-gboolean       gdk_keymap_map_virtual_modifiers    (GdkKeymap           *keymap,
-                                                    GdkModifierType     *state);
-GDK_AVAILABLE_IN_ALL
-GdkModifierType gdk_keymap_get_modifier_mask       (GdkKeymap           *keymap,
-                                                    GdkModifierIntent    intent);
-
-
-/* Key values
- */
 GDK_AVAILABLE_IN_ALL
 const char *gdk_keyval_name      (guint        keyval) G_GNUC_CONST;
 
diff --git a/gdk/gdkkeysprivate.h b/gdk/gdkkeysprivate.h
index 96f67b1519..c7cf7424b6 100644
--- a/gdk/gdkkeysprivate.h
+++ b/gdk/gdkkeysprivate.h
@@ -22,10 +22,14 @@
 
 G_BEGIN_DECLS
 
+#define GDK_TYPE_KEYMAP              (gdk_keymap_get_type ())
+#define GDK_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_KEYMAP, GdkKeymap))
+#define GDK_IS_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_KEYMAP))
 #define GDK_KEYMAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_KEYMAP, GdkKeymapClass))
 #define GDK_IS_KEYMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_KEYMAP))
 #define GDK_KEYMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_KEYMAP, GdkKeymapClass))
 
+typedef struct _GdkKeymap             GdkKeymap;
 typedef struct _GdkKeymapClass GdkKeymapClass;
 
 struct _GdkKeymapClass
@@ -56,12 +60,6 @@ struct _GdkKeymapClass
                                          gint            *effective_group,
                                          gint            *level,
                                          GdkModifierType *consumed_modifiers);
-  void (* add_virtual_modifiers)        (GdkKeymap       *keymap,
-                                         GdkModifierType *state);
-  gboolean (* map_virtual_modifiers)    (GdkKeymap       *keymap,
-                                         GdkModifierType *state);
-  GdkModifierType (*get_modifier_mask)  (GdkKeymap         *keymap,
-                                         GdkModifierIntent  intent);
   guint (* get_modifier_state)          (GdkKeymap *keymap);
 
 
@@ -77,6 +75,37 @@ struct _GdkKeymap
   GdkDisplay *display;
 };
 
+GType gdk_keymap_get_type (void) G_GNUC_CONST;
+
+GdkDisplay *   gdk_keymap_get_display              (GdkKeymap           *keymap);
+
+guint          gdk_keymap_lookup_key               (GdkKeymap           *keymap,
+                                                    const GdkKeymapKey  *key);
+gboolean       gdk_keymap_translate_keyboard_state (GdkKeymap           *keymap,
+                                                    guint                hardware_keycode,
+                                                    GdkModifierType      state,
+                                                    gint                 group,
+                                                    guint               *keyval,
+                                                    gint                *effective_group,
+                                                    gint                *level,
+                                                    GdkModifierType     *consumed_modifiers);
+gboolean       gdk_keymap_get_entries_for_keyval   (GdkKeymap           *keymap,
+                                                    guint                keyval,
+                                                    GdkKeymapKey       **keys,
+                                                    gint                *n_keys);
+gboolean       gdk_keymap_get_entries_for_keycode  (GdkKeymap           *keymap,
+                                                    guint                hardware_keycode,
+                                                    GdkKeymapKey       **keys,
+                                                    guint              **keyvals,
+                                                    gint                *n_entries);
+
+PangoDirection gdk_keymap_get_direction            (GdkKeymap           *keymap);
+gboolean       gdk_keymap_have_bidi_layouts        (GdkKeymap           *keymap);
+gboolean       gdk_keymap_get_caps_lock_state      (GdkKeymap           *keymap);
+gboolean       gdk_keymap_get_num_lock_state       (GdkKeymap           *keymap);
+gboolean       gdk_keymap_get_scroll_lock_state    (GdkKeymap           *keymap);
+guint          gdk_keymap_get_modifier_state       (GdkKeymap           *keymap);
+
 G_END_DECLS
 
 #endif
diff --git a/gdk/gdksurface.c b/gdk/gdksurface.c
index 7432a9b348..9dae9a93b5 100644
--- a/gdk/gdksurface.c
+++ b/gdk/gdksurface.c
@@ -2815,17 +2815,18 @@ rewrite_event_for_toplevel (GdkEvent *event)
                                 gdk_event_get_source_device (event),
                                 gdk_focus_event_get_in (event));
   else
-    return gdk_event_key_new (gdk_event_get_event_type (event),
-                              surface,
-                              gdk_event_get_device (event),
-                              gdk_event_get_source_device (event),
-                              gdk_event_get_time (event),
-                              gdk_event_get_modifier_state (event),
-                              gdk_key_event_get_keyval (event),
-                              gdk_key_event_get_keycode (event),
-                              gdk_key_event_get_scancode (event),
-                              gdk_key_event_get_group (event),
-                              gdk_key_event_is_modifier (event));
+    {
+      return gdk_event_key_new (gdk_event_get_event_type (event),
+                                surface,
+                                gdk_event_get_device (event),
+                                gdk_event_get_source_device (event),
+                                gdk_event_get_time (event),
+                                gdk_key_event_get_keycode (event),
+                                gdk_event_get_modifier_state (event),
+                                gdk_key_event_is_modifier (event),
+                                &event->key.translated[0],
+                                &event->key.translated[1]);
+    }
 }
 
 static void
@@ -2874,13 +2875,13 @@ add_event_mark (GdkEvent *event,
     case GDK_KEY_PRESS:
     case GDK_KEY_RELEASE:
       {
-        message = g_strdup_printf ("%s {keyval=%u, state=0x%x, hardware_keycode=%u key_scancode=%u group=%u is_modifier=%u}",
+        message = g_strdup_printf ("%s {keyval=%u, state=0x%x, keycode=%u layout=%u level=%u is_modifier=%u}",
                                    kind,
                                    gdk_key_event_get_keyval (event),
                                    gdk_event_get_modifier_state (event),
                                    gdk_key_event_get_keycode (event),
-                                   gdk_key_event_get_scancode (event),
-                                   gdk_key_event_get_group (event),
+                                   gdk_key_event_get_layout (event),
+                                   gdk_key_event_get_level (event),
                                    gdk_key_event_is_modifier (event));
         break;
       }
diff --git a/gdk/gdktypes.h b/gdk/gdktypes.h
index 39f38788a0..9e8a7997fa 100644
--- a/gdk/gdktypes.h
+++ b/gdk/gdktypes.h
@@ -122,7 +122,6 @@ typedef struct _GdkClipboard          GdkClipboard;
 typedef struct _GdkDisplayManager     GdkDisplayManager;
 typedef struct _GdkDisplay            GdkDisplay;
 typedef struct _GdkSurface             GdkSurface;
-typedef struct _GdkKeymap             GdkKeymap;
 typedef struct _GdkAppLaunchContext   GdkAppLaunchContext;
 typedef struct _GdkSeat               GdkSeat;
 typedef struct _GdkSnapshot           GdkSnapshot;
@@ -199,147 +198,54 @@ 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
- *  mapping of the X server which key is interpreted as this modifier).
- * @GDK_MOD3_MASK: the sixth modifier key (it depends on the modifier
- *  mapping of the X server which key is interpreted as this modifier).
- * @GDK_MOD4_MASK: the seventh modifier key (it depends on the modifier
- *  mapping of the X server which key is interpreted as this modifier).
- * @GDK_MOD5_MASK: the eighth modifier key (it depends on the modifier
- *  mapping of the X server which key is interpreted as this modifier).
  * @GDK_BUTTON1_MASK: the first mouse button.
  * @GDK_BUTTON2_MASK: the second mouse button.
  * @GDK_BUTTON3_MASK: the third mouse button.
  * @GDK_BUTTON4_MASK: the fourth mouse button.
  * @GDK_BUTTON5_MASK: the fifth mouse button.
- * @GDK_MODIFIER_RESERVED_13_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_14_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_15_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_16_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_17_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_18_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_19_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_20_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_21_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_22_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_23_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_24_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_25_MASK: A reserved bit flag; do not use in your own code
  * @GDK_SUPER_MASK: the Super modifier
  * @GDK_HYPER_MASK: the Hyper modifier
  * @GDK_META_MASK: the Meta modifier
- * @GDK_MODIFIER_RESERVED_29_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_RESERVED_30_MASK: A reserved bit flag; do not use in your own code
- * @GDK_MODIFIER_MASK: a mask covering all modifier types.
  *
  * A set of bit-flags to indicate the state of modifier keys and mouse buttons
  * in various event types. Typical modifier keys are Shift, Control, Meta,
  * Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock.
  *
- * Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons.
- *
- * GDK recognizes which of the Meta, Super or Hyper keys are mapped
- * to Mod2 - Mod5, and indicates this by setting %GDK_SUPER_MASK,
- * %GDK_HYPER_MASK or %GDK_META_MASK in the state field of key events.
- *
- * Note that GDK may add internal values to events which include
- * reserved values such as %GDK_MODIFIER_RESERVED_13_MASK.  Your code
- * should preserve and ignore them.  You can use %GDK_MODIFIER_MASK to
- * remove all reserved values.
- *
- * Also note that the GDK X backend interprets button press events for button
- * 4-7 as scroll events, so %GDK_BUTTON4_MASK and %GDK_BUTTON5_MASK will never
- * be set.
+ * Note that GDK may add internal values to events which include values outside
+ * of this enumeration. Your code should preserve and ignore them.  You can use
+ * %GDK_MODIFIER_MASK to remove all private values.
  */
 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;
 
+
 /**
- * GdkModifierIntent:
- * @GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR: the primary modifier used to invoke
- *  menu accelerators.
- * @GDK_MODIFIER_INTENT_CONTEXT_MENU: the modifier used to invoke context menus.
- *  Note that mouse button 3 always triggers context menus. When this modifier
- *  is not 0, it additionally triggers context menus when used with mouse button 1.
- * @GDK_MODIFIER_INTENT_EXTEND_SELECTION: the modifier used to extend selections
- *  using `modifier`-click or `modifier`-cursor-key
- * @GDK_MODIFIER_INTENT_MODIFY_SELECTION: the modifier used to modify selections,
- *  which in most cases means toggling the clicked item into or out of the selection.
- * @GDK_MODIFIER_INTENT_NO_TEXT_INPUT: when any of these modifiers is pressed, the
- *  key event cannot produce a symbol directly. This is meant to be used for
- *  input methods, and for use cases like typeahead search.
- * @GDK_MODIFIER_INTENT_SHIFT_GROUP: the modifier that switches between keyboard
- *  groups (AltGr on X11/Windows and Option/Alt on OS X).
- * @GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK: The set of modifier masks accepted
- * as modifiers in accelerators. Needed because Command is mapped to MOD2 on
- * OSX, which is widely used, but on X11 MOD2 is NumLock and using that for a
- * mod key is problematic at best.
- * Ref: https://bugzilla.gnome.org/show_bug.cgi?id=736125.
+ * GDK_MODIFIER_MASK:
  *
- * This enum is used with gdk_keymap_get_modifier_mask()
- * in order to determine what modifiers the
- * currently used windowing system backend uses for particular
- * purposes. For example, on X11/Windows, the Control key is used for
- * invoking menu shortcuts (accelerators), whereas on Apple computers
- * it’s the Command key (which correspond to %GDK_CONTROL_MASK and
- * %GDK_MOD2_MASK, respectively).
- **/
-typedef enum
-{
-  GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR,
-  GDK_MODIFIER_INTENT_CONTEXT_MENU,
-  GDK_MODIFIER_INTENT_EXTEND_SELECTION,
-  GDK_MODIFIER_INTENT_MODIFY_SELECTION,
-  GDK_MODIFIER_INTENT_NO_TEXT_INPUT,
-  GDK_MODIFIER_INTENT_SHIFT_GROUP,
-  GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK,
-} GdkModifierIntent;
+ * A mask covering all entries in #GdkModifierType.
+ */
+#define GDK_MODIFIER_MASK (GDK_SHIFT_MASK|GDK_LOCK_MASK|GDK_CONTROL_MASK| \
+                           GDK_ALT_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)
 
 /**
  * GdkEventMask:
@@ -622,6 +528,33 @@ typedef enum
     return G_TYPE_INSTANCE_GET_CLASS (ptr, module_obj_name##_get_type (), ModuleObjName##Class); }       \
   G_GNUC_END_IGNORE_DEPRECATIONS
 
+typedef struct _GdkKeymapKey GdkKeymapKey;
+
+/**
+ * GdkKeymapKey:
+ * @keycode: the hardware keycode. This is an identifying number for a
+ *   physical key.
+ * @group: indicates movement in a horizontal direction. Usually groups are used
+ *   for two different languages. In group 0, a key might have two English
+ *   characters, and in group 1 it might have two Hebrew characters. The Hebrew
+ *   characters will be printed on the key next to the English characters.
+ * @level: indicates which symbol on the key will be used, in a vertical direction.
+ *   So on a standard US keyboard, the key with the number “1” on it also has the
+ *   exclamation point ("!") character on it. The level indicates whether to use
+ *   the “1” or the “!” symbol. The letter keys are considered to have a lowercase
+ *   letter at level 0, and an uppercase letter at level 1, though only the
+ *   uppercase letter is printed.
+ *
+ * A #GdkKeymapKey is a hardware key that can be mapped to a keyval.
+ */
+struct _GdkKeymapKey
+{
+  guint keycode;
+  gint  group;
+  gint  level;
+};
+
+
 G_END_DECLS
 
 #endif /* __GDK_TYPES_H__ */
diff --git a/gdk/quartz/gdkevents-quartz.c b/gdk/quartz/gdkevents-quartz.c
index 775e14ba90..49d5cc6aa0 100644
--- a/gdk/quartz/gdkevents-quartz.c
+++ b/gdk/quartz/gdkevents-quartz.c
@@ -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;
 
diff --git a/gdk/quartz/gdkkeys-quartz.c b/gdk/quartz/gdkkeys-quartz.c
index 6ded6b1a34..baa86144cd 100644
--- a/gdk/quartz/gdkkeys-quartz.c
+++ b/gdk/quartz/gdkkeys-quartz.c
@@ -735,40 +735,6 @@ gdk_quartz_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
   return TRUE;
 }
 
-static GdkModifierType
-gdk_quartz_keymap_get_modifier_mask (GdkKeymap         *keymap,
-                                     GdkModifierIntent  intent)
-{
-  switch (intent)
-    {
-    case GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR:
-      return GDK_MOD2_MASK;
-
-    case GDK_MODIFIER_INTENT_CONTEXT_MENU:
-      return GDK_CONTROL_MASK;
-
-    case GDK_MODIFIER_INTENT_EXTEND_SELECTION:
-      return GDK_SHIFT_MASK;
-
-    case GDK_MODIFIER_INTENT_MODIFY_SELECTION:
-      return GDK_MOD2_MASK;
-
-    case GDK_MODIFIER_INTENT_NO_TEXT_INPUT:
-      return GDK_MOD2_MASK | GDK_CONTROL_MASK;
-
-    case GDK_MODIFIER_INTENT_SHIFT_GROUP:
-      return GDK_MOD1_MASK;
-
-    case GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK:
-      return (GDK_SHIFT_MASK   | GDK_CONTROL_MASK | GDK_MOD1_MASK    |
-	      GDK_MOD2_MASK    | GDK_SUPER_MASK   | GDK_HYPER_MASK   |
-	      GDK_META_MASK);
-
-    default:
-      g_return_val_if_reached (0);
-    }
-}
-
 /* What sort of key event is this? Returns one of
  * GDK_KEY_PRESS, GDK_KEY_RELEASE, GDK_NOTHING (should be ignored)
  */
@@ -881,5 +847,4 @@ gdk_quartz_keymap_class_init (GdkQuartzKeymapClass *klass)
   keymap_class->translate_keyboard_state = gdk_quartz_keymap_translate_keyboard_state;
   keymap_class->add_virtual_modifiers = gdk_quartz_keymap_add_virtual_modifiers;
   keymap_class->map_virtual_modifiers = gdk_quartz_keymap_map_virtual_modifiers;
-  keymap_class->get_modifier_mask = gdk_quartz_keymap_get_modifier_mask;
 }
diff --git a/gdk/wayland/gdkdevice-wayland.c b/gdk/wayland/gdkdevice-wayland.c
index dcb38c2953..e29541c108 100644
--- a/gdk/wayland/gdkdevice-wayland.c
+++ b/gdk/wayland/gdkdevice-wayland.c
@@ -30,6 +30,7 @@
 #include "gdkseat-wayland.h"
 #include "gdkwayland.h"
 #include "gdkkeysyms.h"
+#include "gdkkeysprivate.h"
 #include "gdkcursorprivate.h"
 #include "gdkdeviceprivate.h"
 #include "gdkdevicepadprivate.h"
@@ -1856,16 +1857,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
@@ -1998,9 +2021,13 @@ deliver_key_event (GdkWaylandSeat *seat,
   struct xkb_state *xkb_state;
   struct xkb_keymap *xkb_keymap;
   GdkKeymap *keymap;
-  xkb_keysym_t sym;
   guint delay, interval, timeout;
   gint64 begin_time, now;
+  xkb_mod_mask_t consumed;
+  GdkTranslatedKey translated;
+  GdkTranslatedKey no_lock;
+  xkb_mod_mask_t modifiers;
+  xkb_mod_index_t caps_lock;
 
   begin_time = g_get_monotonic_time ();
 
@@ -2010,36 +2037,69 @@ deliver_key_event (GdkWaylandSeat *seat,
   xkb_state = _gdk_wayland_keymap_get_xkb_state (keymap);
   xkb_keymap = _gdk_wayland_keymap_get_xkb_keymap (keymap);
 
-  sym = xkb_state_key_get_one_sym (xkb_state, key);
-  if (sym == XKB_KEY_NoSymbol)
+  translated.keyval = xkb_state_key_get_one_sym (xkb_state, key);
+  modifiers = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_EFFECTIVE);
+  consumed = modifiers & ~xkb_state_mod_mask_remove_consumed (xkb_state, key, modifiers);
+  translated.consumed = gdk_wayland_keymap_get_gdk_modifiers (keymap, consumed);
+  translated.layout = xkb_state_key_get_layout (xkb_state, key);
+  translated.level = xkb_state_key_get_level (xkb_state, key, translated.layout);
+
+  if (translated.keyval == XKB_KEY_NoSymbol)
     return;
 
   seat->pointer_info.time = time_;
   seat->key_modifiers = gdk_keymap_get_modifier_state (keymap);
 
+
+  modifiers = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_EFFECTIVE);
+  caps_lock = xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CAPS);
+  if (modifiers & (1 << caps_lock))
+    {
+      struct xkb_state *tmp_state = xkb_state_new (xkb_keymap);
+      xkb_layout_index_t layout;
+
+      modifiers &= ~(1 << caps_lock);
+      layout = xkb_state_serialize_layout (xkb_state, XKB_STATE_LAYOUT_EFFECTIVE);
+      xkb_state_update_mask (tmp_state, modifiers, 0, 0, layout, 0, 0);
+
+      no_lock.keyval = xkb_state_key_get_one_sym (tmp_state, key);
+      consumed = modifiers & ~xkb_state_mod_mask_remove_consumed (tmp_state, key, modifiers);
+      no_lock.consumed = gdk_wayland_keymap_get_gdk_modifiers (keymap, consumed);
+      no_lock.layout = xkb_state_key_get_layout (tmp_state, key);
+      no_lock.level = xkb_state_key_get_level (tmp_state, key, no_lock.layout);
+
+      xkb_state_unref (tmp_state);
+    }
+  else
+    {
+      no_lock = translated;
+    }
+
   event = gdk_event_key_new (state ? GDK_KEY_PRESS : GDK_KEY_RELEASE,
                              seat->keyboard_focus,
                              seat->master_keyboard,
                              seat->keyboard,
                              time_,
-                             device_get_modifiers (seat->master_pointer),
-                             sym,
                              key,
-                             key,
-                             0,
-                             _gdk_wayland_keymap_key_is_modifier (keymap, key));
+                             device_get_modifiers (seat->master_pointer),
+                             _gdk_wayland_keymap_key_is_modifier (keymap, key),
+                             &translated, 
+                             &no_lock);
 
   _gdk_wayland_display_deliver_event (seat->display, event);
 
   GDK_SEAT_NOTE (seat, EVENTS,
             g_message ("keyboard %s event%s, surface %p, code %d, sym %d, "
-                       "mods 0x%x",
+                       "mods 0x%x, consumed 0x%x, layout %d level %d",
                        (state ? "press" : "release"),
                        (from_key_repeat ? " (repeat)" : ""),
                        gdk_event_get_surface (event),
                        gdk_key_event_get_keycode (event),
                        gdk_key_event_get_keyval (event),
-                       gdk_event_get_modifier_state (event)));
+                       gdk_event_get_modifier_state (event),
+                       gdk_key_event_get_consumed_modifiers (event),
+                       gdk_key_event_get_layout (event),
+                       gdk_key_event_get_level (event)));
 
   if (!xkb_keymap_key_repeats (xkb_keymap, key))
     return;
@@ -2155,11 +2215,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 +2254,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
diff --git a/gdk/wayland/gdkkeys-wayland.c b/gdk/wayland/gdkkeys-wayland.c
index b1992057a0..1b98c73e85 100644
--- a/gdk/wayland/gdkkeys-wayland.c
+++ b/gdk/wayland/gdkkeys-wayland.c
@@ -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,12 +294,21 @@ 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;
 }
 
+GdkModifierType
+gdk_wayland_keymap_get_gdk_modifiers (GdkKeymap *keymap,
+                                      guint32    mods)
+{
+  struct xkb_keymap *xkb_keymap = GDK_WAYLAND_KEYMAP (keymap)->xkb_keymap;
+
+  return get_gdk_modifiers (xkb_keymap, mods);
+}
+
 static gboolean
 gdk_wayland_keymap_translate_keyboard_state (GdkKeymap       *keymap,
 					     guint            hardware_keycode,
@@ -377,68 +370,6 @@ gdk_wayland_keymap_get_modifier_state (GdkKeymap *keymap)
 }
 
 static void
-gdk_wayland_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
-					  GdkModifierType *state)
-{
-  struct xkb_keymap *xkb_keymap;
-  struct xkb_state *xkb_state;
-  xkb_mod_index_t idx;
-  uint32_t mods, real;
-  struct { const char *name; GdkModifierType mask; } vmods[] = {
-    { "Super", GDK_SUPER_MASK },
-    { "Hyper", GDK_HYPER_MASK },
-    { "Meta", GDK_META_MASK },
-    { NULL, 0 }
-  };
-  int i;
-
-  xkb_keymap = GDK_WAYLAND_KEYMAP (keymap)->xkb_keymap;
-  mods = get_xkb_modifiers (xkb_keymap, *state);
-
-  xkb_state = xkb_state_new (xkb_keymap);
-
-  for (i = 0; vmods[i].name; i++)
-    {
-      idx = xkb_keymap_mod_get_index (xkb_keymap, vmods[i].name);
-      if (idx == XKB_MOD_INVALID)
-        continue;
-
-      xkb_state_update_mask (xkb_state, 1 << idx, 0, 0, 0, 0, 0);
-      real = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_EFFECTIVE);
-      real &= 0xf0; /* ignore mapping to Lock, Shift, Control, Mod1 */
-      if (mods & real)
-        *state |= vmods[i].mask;
-      xkb_state_update_mask (xkb_state, 0, 0, 0, 0, 0, 0);
-    }
-
-  xkb_state_unref (xkb_state);
-}
-
-static gboolean
-gdk_wayland_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
-					  GdkModifierType *state)
-{
-  struct xkb_keymap *xkb_keymap;
-  struct xkb_state *xkb_state;
-  uint32_t mods, mapped;
-  gboolean ret = TRUE;
-
-  xkb_keymap = GDK_WAYLAND_KEYMAP (keymap)->xkb_keymap;
-  mods = get_xkb_modifiers (xkb_keymap, *state);
-
-  xkb_state = xkb_state_new (xkb_keymap);
-  xkb_state_update_mask (xkb_state, mods & ~0xff, 0, 0, 0, 0, 0);
-  mapped = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_EFFECTIVE);
-  if ((mapped & mods & 0xff) != 0)
-    ret = FALSE;
-  *state |= get_gdk_modifiers (xkb_keymap, mapped);
-
-  xkb_state_unref (xkb_state);
-
-  return ret;
-}
-
-static void
 _gdk_wayland_keymap_class_init (GdkWaylandKeymapClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
@@ -456,8 +387,6 @@ _gdk_wayland_keymap_class_init (GdkWaylandKeymapClass *klass)
   keymap_class->lookup_key = gdk_wayland_keymap_lookup_key;
   keymap_class->translate_keyboard_state = gdk_wayland_keymap_translate_keyboard_state;
   keymap_class->get_modifier_state = gdk_wayland_keymap_get_modifier_state;
-  keymap_class->add_virtual_modifiers = gdk_wayland_keymap_add_virtual_modifiers;
-  keymap_class->map_virtual_modifiers = gdk_wayland_keymap_map_virtual_modifiers;
 }
 
 static void
diff --git a/gdk/wayland/gdkprivate-wayland.h b/gdk/wayland/gdkprivate-wayland.h
index 6ea1a1ae6e..13dbd221e0 100644
--- a/gdk/wayland/gdkprivate-wayland.h
+++ b/gdk/wayland/gdkprivate-wayland.h
@@ -201,5 +201,7 @@ void gdk_wayland_surface_update_scale (GdkSurface *surface);
 
 GdkSurface * create_dnd_surface (GdkDisplay *display);
 
+GdkModifierType gdk_wayland_keymap_get_gdk_modifiers (GdkKeymap *keymap,
+                                                      guint32    mods);
 
 #endif /* __GDK_PRIVATE_WAYLAND_H__ */
diff --git a/gdk/win32/gdkdevice-win32.c b/gdk/win32/gdkdevice-win32.c
index 569e31f499..dffb8d8c7d 100644
--- a/gdk/win32/gdkdevice-win32.c
+++ b/gdk/win32/gdkdevice-win32.c
@@ -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)
diff --git a/gdk/win32/gdkdevice-wintab.c b/gdk/win32/gdkdevice-wintab.c
index 2823a16406..5aed3e053a 100644
--- a/gdk/win32/gdkdevice-wintab.c
+++ b/gdk/win32/gdkdevice-wintab.c
@@ -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)
diff --git a/gdk/win32/gdkdevicemanager-win32.c b/gdk/win32/gdkdevicemanager-win32.c
index 393fe6d7c1..592b52a8d4 100644
--- a/gdk/win32/gdkdevicemanager-win32.c
+++ b/gdk/win32/gdkdevicemanager-win32.c
@@ -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;
 
diff --git a/gdk/win32/gdkdrag-win32.c b/gdk/win32/gdkdrag-win32.c
index e16ca9643e..a42a497152 100644
--- a/gdk/win32/gdkdrag-win32.c
+++ b/gdk/win32/gdkdrag-win32.c
@@ -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;
         }
     }
diff --git a/gdk/win32/gdkevents-win32.c b/gdk/win32/gdkevents-win32.c
index b163667a77..86e3ccec0f 100644
--- a/gdk/win32/gdkevents-win32.c
+++ b/gdk/win32/gdkevents-win32.c
@@ -72,6 +72,8 @@
 
 #include <imm.h>
 
+#define GDK_MOD2_MASK (1 << 4)
+
 #ifndef XBUTTON1
 #define XBUTTON1 1
 #define XBUTTON2 2
@@ -662,14 +664,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 +726,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 +743,8 @@ print_event_state (guint state)
   CASE (SHIFT);
   CASE (LOCK);
   CASE (CONTROL);
-  CASE (MOD1);
+  CASE (ALT);
   CASE (MOD2);
-  CASE (MOD3);
-  CASE (MOD4);
-  CASE (MOD5);
   CASE (BUTTON1);
   CASE (BUTTON2);
   CASE (BUTTON3);
@@ -810,7 +809,7 @@ _gdk_win32_print_event (GdkEvent *event)
       kvname = gdk_keyval_name (gdk_key_event_get_keyval (event));
       g_print ("%#.02x group:%d %s",
                gdk_key_event_get_keycode (event),
-               gdk_key_event_get_group (event),
+               gdk_key_event_get_layout (event),
 	       (kvname ? kvname : "??"));
       print_event_state (gdk_event_get_modifier_state (event));
       break;
@@ -2051,12 +2050,12 @@ gdk_event_translate (MSG  *msg,
   GdkModifierType state;
   guint keyval;
   guint16 keycode;
-  guint16 scancode;
   guint8 group;
   gboolean is_modifier;
 
   double delta_x, delta_y;
   GdkScrollDirection direction;
+  GdkTranslatedKey translated;
 
   display = gdk_display_get_default ();
   win32_display = GDK_WIN32_DISPLAY (display);
@@ -2130,17 +2129,20 @@ gdk_event_translate (MSG  *msg,
       gdk_display_setting_changed (display, "gtk-im-module");
 
       /* Generate a dummy key event to "nudge" IMContext */
+      translated.keyval = GDK_KEY_VoidSymbol;
+      translated.consumed = 0;
+      translated.layout = 0;
+      translated.level = 0;
       event = gdk_event_key_new (GDK_KEY_PRESS,
                                  window,
                                  device_manager_win32->core_keyboard,
                                  device_manager_win32->system_keyboard,
                                  _gdk_win32_get_next_tick (msg->time),
                                  0,
-                                 GDK_KEY_VoidSymbol,
-                                 0,
                                  0,
-                                 0,
-                                 FALSE);
+                                 FALSE,
+                                 &translated,
+                                 &translated);
       _gdk_win32_append_event (event);
       break;
 
@@ -2226,7 +2228,6 @@ gdk_event_translate (MSG  *msg,
 
       keyval = GDK_KEY_VoidSymbol;
       keycode = msg->wParam;
-      scancode = msg->lParam >> 16;
 
       if (HIWORD (msg->lParam) & KF_EXTENDED)
 	{
@@ -2326,10 +2327,15 @@ 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;
 
+      /* FIXME do proper translation */
+      translated.keyval = keyval;
+      translated.consumed = 0;
+      translated.layout = group;
+      translated.level = 0;
       event = gdk_event_key_new ((msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
                                    ? GDK_KEY_PRESS
                                    : GDK_KEY_RELEASE,
@@ -2338,11 +2344,10 @@ gdk_event_translate (MSG  *msg,
                                  device_manager_win32->system_keyboard,
                                  _gdk_win32_get_next_tick (msg->time),
                                  state,
-                                 keyval,
                                  keycode,
-                                 scancode,
-                                 group,
-                                 is_modifier);
+                                 is_modifier,
+                                 &translated,
+                                 &translated);
 
       _gdk_win32_append_event (event);
 
@@ -2404,17 +2409,20 @@ gdk_event_translate (MSG  *msg,
       for (i = 0; i < ccount; i++)
 	{
           /* Build a key press event */
+          translated.keyval = gdk_unicode_to_keyval (wbuf[i]);
+          translated.consumed = 0;
+          translated.layout = get_active_group ();
+          translated.level = 0;
           event = gdk_event_key_new (GDK_KEY_PRESS,
                                      window,
                                      device_manager_win32->core_keyboard,
                                      device_manager_win32->system_keyboard,
                                      _gdk_win32_get_next_tick (msg->time),
                                      build_key_event_state (key_state),
-                                     gdk_unicode_to_keyval (wbuf[i]),               
-                                     0,
                                      0,
-                                     get_active_group (),
-                                     FALSE);
+                                     FALSE,
+                                     &translated,
+                                     &translated);
 
           _gdk_win32_append_event (event);
 
@@ -2425,11 +2433,10 @@ gdk_event_translate (MSG  *msg,
                                      device_manager_win32->system_keyboard,
                                      _gdk_win32_get_next_tick (msg->time),
                                      build_key_event_state (key_state),
-                                     gdk_unicode_to_keyval (wbuf[i]),               
-                                     0,
                                      0,
-                                     get_active_group (),
-                                     FALSE);
+                                     FALSE,
+                                     &translated,
+                                     &translated);
 
           _gdk_win32_append_event (event);
 	}
diff --git a/gdk/win32/gdkkeys-win32.c b/gdk/win32/gdkkeys-win32.c
index 9350c121f5..bae9a8e24d 100644
--- a/gdk/win32/gdkkeys-win32.c
+++ b/gdk/win32/gdkkeys-win32.c
@@ -38,6 +38,8 @@
 #include "gdkkeysprivate.h"
 #include "gdkwin32keys.h"
 
+#define GDK_MOD2_MASK (1 << 4)
+
 enum _GdkWin32KeyLevelState
 {
   GDK_WIN32_LEVEL_NONE = 0,
@@ -1672,20 +1674,6 @@ gdk_win32_keymap_translate_keyboard_state (GdkKeymap       *gdk_keymap,
 }
 
 static void
-gdk_win32_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
-                                        GdkModifierType *state)
-{
-}
-
-static gboolean
-gdk_win32_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
-                                        GdkModifierType *state)
-{
-  /* FIXME: Is this the right thing to do? */
-  return TRUE;
-}
-
-static void
 gdk_win32_keymap_class_init (GdkWin32KeymapClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
@@ -1702,6 +1690,4 @@ gdk_win32_keymap_class_init (GdkWin32KeymapClass *klass)
   keymap_class->get_entries_for_keycode = gdk_win32_keymap_get_entries_for_keycode;
   keymap_class->lookup_key = gdk_win32_keymap_lookup_key;
   keymap_class->translate_keyboard_state = gdk_win32_keymap_translate_keyboard_state;
-  keymap_class->add_virtual_modifiers = gdk_win32_keymap_add_virtual_modifiers;
-  keymap_class->map_virtual_modifiers = gdk_win32_keymap_map_virtual_modifiers;
 }
diff --git a/gdk/win32/gdkwin32.h b/gdk/win32/gdkwin32.h
index f4001dabb5..739624d84c 100644
--- a/gdk/win32/gdkwin32.h
+++ b/gdk/win32/gdkwin32.h
@@ -31,7 +31,6 @@
 #include <gdk/win32/gdkwin32display.h>
 #include <gdk/win32/gdkwin32displaymanager.h>
 #include <gdk/win32/gdkwin32dnd.h>
-#include <gdk/win32/gdkwin32keys.h>
 #include <gdk/win32/gdkwin32screen.h>
 #include <gdk/win32/gdkwin32surface.h>
 #include <gdk/win32/gdkwin32misc.h>
diff --git a/gdk/win32/gdkwin32keys.h b/gdk/win32/gdkwin32keys.h
index 5dcef11fa1..a35cd74f33 100644
--- a/gdk/win32/gdkwin32keys.h
+++ b/gdk/win32/gdkwin32keys.h
@@ -23,6 +23,7 @@
 #endif
 
 #include <gdk/gdk.h>
+#include "gdkkeysprivate.h"
 
 G_BEGIN_DECLS
 
@@ -58,10 +59,8 @@ typedef struct _GdkWin32KeymapClass GdkWin32KeymapClass;
 #define GDK_IS_WIN32_KEYMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WIN32_KEYMAP))
 #define GDK_WIN32_KEYMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WIN32_KEYMAP, GdkWin32KeymapClass))
 
-GDK_AVAILABLE_IN_ALL
 GType gdk_win32_keymap_get_type (void);
 
-GDK_AVAILABLE_IN_ALL
 GdkWin32KeymapMatch gdk_win32_keymap_check_compose (GdkWin32Keymap *keymap,
                                                     guint16        *compose_buffer,
                                                     gsize           compose_buffer_len,
diff --git a/gdk/x11/gdkdevicemanager-xi2.c b/gdk/x11/gdkdevicemanager-xi2.c
index 6e6ba54c93..d3c690bb19 100644
--- a/gdk/x11/gdkdevicemanager-xi2.c
+++ b/gdk/x11/gdkdevicemanager-xi2.c
@@ -19,6 +19,7 @@
 
 #include "gdkx11devicemanager-xi2.h"
 #include "gdkx11device-xi2.h"
+#include "gdkx11keys.h"
 
 #include "gdkdeviceprivate.h"
 #include "gdkdevicetoolprivate.h"
@@ -1521,7 +1522,10 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
         XIDeviceEvent *xev = (XIDeviceEvent *) ev;
         GdkKeymap *keymap = gdk_display_get_keymap (display);
         GdkModifierType consumed, state, orig_state;
+        int layout, level;
         guint keyval;
+        GdkTranslatedKey translated;
+        GdkTranslatedKey no_lock;
 
         GDK_DISPLAY_NOTE (display, EVENTS,
                   g_message ("key %s:\twindow %ld\n"
@@ -1549,12 +1553,37 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
                                              state,
                                              xev->group.effective,
                                              &keyval,
-                                             NULL, NULL, &consumed);
+                                             &layout, &level, &consumed);
         orig_state = state;
         state &= ~consumed;
         _gdk_x11_keymap_add_virt_mods (keymap, &state);
         state |= orig_state;
 
+        translated.keyval = keyval;
+        translated.consumed = consumed;
+        translated.layout = layout;
+        translated.level = level;
+
+        if (orig_state & GDK_LOCK_MASK)
+          {
+            orig_state &= ~GDK_LOCK_MASK;
+
+            gdk_keymap_translate_keyboard_state (keymap,
+                                                 xev->detail,
+                                                 orig_state,
+                                                 xev->group.effective,
+                                                 &keyval,
+                                                 &layout, &level, &consumed);
+
+            no_lock.keyval = keyval;
+            no_lock.consumed = consumed;
+            no_lock.layout = layout;
+            no_lock.level = level;
+          }
+        else
+          {
+            no_lock = translated;
+          }
         event = gdk_event_key_new (xev->evtype == XI_KeyPress
                                      ? GDK_KEY_PRESS
                                      : GDK_KEY_RELEASE,
@@ -1562,12 +1591,11 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
                                    device,
                                    source_device,
                                    xev->time,
-                                   state,
-                                   keyval,
                                    xev->detail,
-                                   xev->detail,
-                                   xev->group.effective,
-                                   gdk_x11_keymap_key_is_modifier (keymap, xev->detail));
+                                   state,
+                                   gdk_x11_keymap_key_is_modifier (keymap, xev->detail),
+                                   &translated,
+                                   &no_lock);
 
         if (ev->evtype == XI_KeyPress)
           set_user_time (event);
diff --git a/gdk/x11/gdkdisplay-x11.c b/gdk/x11/gdkdisplay-x11.c
index 2d34eb314a..97dfcae5e9 100644
--- a/gdk/x11/gdkdisplay-x11.c
+++ b/gdk/x11/gdkdisplay-x11.c
@@ -26,6 +26,7 @@
 
 #include "gdkdisplay-x11.h"
 #include "gdkdisplayprivate.h"
+#include "gdkx11keys.h"
 
 #include "gdkasync.h"
 #include "gdkdisplay.h"
diff --git a/gdk/x11/gdkdrag-x11.c b/gdk/x11/gdkdrag-x11.c
index f2856b891b..da0c516796 100644
--- a/gdk/x11/gdkdrag-x11.c
+++ b/gdk/x11/gdkdrag-x11.c
@@ -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;
@@ -2214,7 +2214,7 @@ gdk_dnd_handle_key_event (GdkDrag           *drag,
 
   if (event->any.type == GDK_KEY_PRESS)
     {
-      switch (event->keyval)
+      switch (event->translated[0].keyval)
         {
         case GDK_KEY_Escape:
           gdk_drag_cancel (drag, GDK_DRAG_CANCEL_USER_CANCELLED);
@@ -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:
diff --git a/gdk/x11/gdkkeys-x11.c b/gdk/x11/gdkkeys-x11.c
index 4c27ac3472..1276c00eb7 100644
--- a/gdk/x11/gdkkeys-x11.c
+++ b/gdk/x11/gdkkeys-x11.c
@@ -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;
+
+      keyboard = gdk_seat_get_keyboard (gdk_display_get_default_seat (display));
 
-      if (update_direction (keymap_x11, XkbStateGroup (&xkb_event->state)))
+      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;
@@ -1428,28 +1455,6 @@ _gdk_x11_keymap_add_virt_mods (GdkKeymap       *keymap,
   GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (keymap);
   int i;
 
-  /* See comment in add_virtual_modifiers() */
-  for (i = 4; i < 8; i++)
-    {
-      if ((1 << i) & *modifiers)
-        {
-          if (keymap_x11->modmap[i] & GDK_SUPER_MASK)
-            *modifiers |= GDK_SUPER_MASK;
-          else if (keymap_x11->modmap[i] & GDK_HYPER_MASK)
-            *modifiers |= GDK_HYPER_MASK;
-          else if (keymap_x11->modmap[i] & GDK_META_MASK)
-            *modifiers |= GDK_META_MASK;
-        }
-    }
-}
-
-static void
-gdk_x11_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
-                                      GdkModifierType *state)
-{
-  GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (keymap);
-  int i;
-
   /*  This loop used to start at 3, which included MOD1 in the
    *  virtual mapping. However, all of GTK+ treats MOD1 as a
    *  synonym for Alt, and does not expect it to be mapped around,
@@ -1458,14 +1463,14 @@ gdk_x11_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
    */
   for (i = 4; i < 8; i++)
     {
-      if ((1 << i) & *state)
+      if ((1 << i) & *modifiers)
         {
           if (keymap_x11->modmap[i] & GDK_SUPER_MASK)
-            *state |= GDK_SUPER_MASK;
-          if (keymap_x11->modmap[i] & GDK_HYPER_MASK)
-            *state |= GDK_HYPER_MASK;
-          if (keymap_x11->modmap[i] & GDK_META_MASK)
-            *state |= GDK_META_MASK;
+            *modifiers |= GDK_SUPER_MASK;
+          else if (keymap_x11->modmap[i] & GDK_HYPER_MASK)
+            *modifiers |= GDK_HYPER_MASK;
+          else if (keymap_x11->modmap[i] & GDK_META_MASK)
+            *modifiers |= GDK_META_MASK;
         }
     }
 }
@@ -1519,56 +1524,6 @@ gdk_x11_keymap_key_is_modifier (GdkKeymap *keymap,
   return FALSE;
 }
 
-static gboolean
-gdk_x11_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
-                                      GdkModifierType *state)
-{
-  GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (keymap);
-  const guint vmods[] = { GDK_SUPER_MASK, GDK_HYPER_MASK, GDK_META_MASK };
-  int i, j;
-  gboolean retval;
-
-#ifdef HAVE_XKB
-  if (KEYMAP_USE_XKB (keymap))
-    get_xkb (keymap_x11);
-#endif
-
-  retval = TRUE;
-
-  for (j = 0; j < 3; j++)
-    {
-      if (*state & vmods[j])
-        {
-          /* See comment in add_virtual_modifiers() */
-          for (i = 4; i < 8; i++)
-            {
-              if (keymap_x11->modmap[i] & vmods[j])
-                {
-                  if (*state & (1 << i))
-                    retval = FALSE;
-                  else
-                    *state |= 1 << i;
-                }
-            }
-        }
-    }
-
-  return retval;
-}
-
-static GdkModifierType
-gdk_x11_keymap_get_modifier_mask (GdkKeymap         *keymap,
-                                  GdkModifierIntent  intent)
-{
-  GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (keymap);
-
-  if (intent == GDK_MODIFIER_INTENT_SHIFT_GROUP)
-    return keymap_x11->group_switch_mask;
-
-  return GDK_KEYMAP_CLASS (gdk_x11_keymap_parent_class)->get_modifier_mask (keymap,
-                                                                            intent);
-}
-
 static void
 gdk_x11_keymap_class_init (GdkX11KeymapClass *klass)
 {
@@ -1587,7 +1542,4 @@ gdk_x11_keymap_class_init (GdkX11KeymapClass *klass)
   keymap_class->get_entries_for_keycode = gdk_x11_keymap_get_entries_for_keycode;
   keymap_class->lookup_key = gdk_x11_keymap_lookup_key;
   keymap_class->translate_keyboard_state = gdk_x11_keymap_translate_keyboard_state;
-  keymap_class->add_virtual_modifiers = gdk_x11_keymap_add_virtual_modifiers;
-  keymap_class->map_virtual_modifiers = gdk_x11_keymap_map_virtual_modifiers;
-  keymap_class->get_modifier_mask = gdk_x11_keymap_get_modifier_mask;
 }
diff --git a/gdk/x11/gdkx-autocleanups.h b/gdk/x11/gdkx-autocleanups.h
index 123f77e811..465b412727 100644
--- a/gdk/x11/gdkx-autocleanups.h
+++ b/gdk/x11/gdkx-autocleanups.h
@@ -27,7 +27,6 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11DeviceXI2, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Display, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Drag, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11GLContext, g_object_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Keymap, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Screen, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Surface, g_object_unref)
 
diff --git a/gdk/x11/gdkx.h b/gdk/x11/gdkx.h
index 2705305964..c94f52fbb8 100644
--- a/gdk/x11/gdkx.h
+++ b/gdk/x11/gdkx.h
@@ -40,7 +40,6 @@
 #include <gdk/x11/gdkx11display.h>
 #include <gdk/x11/gdkx11dnd.h>
 #include <gdk/x11/gdkx11glcontext.h>
-#include <gdk/x11/gdkx11keys.h>
 #include <gdk/x11/gdkx11monitor.h>
 #include <gdk/x11/gdkx11property.h>
 #include <gdk/x11/gdkx11screen.h>
diff --git a/gdk/x11/gdkx11keys.h b/gdk/x11/gdkx11keys.h
index b33d4cddf0..65d3531b5b 100644
--- a/gdk/x11/gdkx11keys.h
+++ b/gdk/x11/gdkx11keys.h
@@ -23,6 +23,7 @@
 #endif
 
 #include <gdk/gdk.h>
+#include <gdk/gdkkeysprivate.h>
 
 G_BEGIN_DECLS
 
@@ -43,11 +44,9 @@ typedef struct _GdkX11KeymapClass GdkX11KeymapClass;
 GDK_AVAILABLE_IN_ALL
 GType gdk_x11_keymap_get_type (void);
 
-GDK_AVAILABLE_IN_ALL
 gint gdk_x11_keymap_get_group_for_state (GdkKeymap *keymap,
                                          guint      state);
 
-GDK_AVAILABLE_IN_ALL
 gboolean gdk_x11_keymap_key_is_modifier (GdkKeymap *keymap,
                                          guint      keycode);
 G_END_DECLS
diff --git a/gdk/x11/meson.build b/gdk/x11/meson.build
index bfc6243978..6db7e695b3 100644
--- a/gdk/x11/meson.build
+++ b/gdk/x11/meson.build
@@ -41,7 +41,6 @@ gdk_x11_public_headers = files([
   'gdkx11display.h',
   'gdkx11dnd.h',
   'gdkx11glcontext.h',
-  'gdkx11keys.h',
   'gdkx11monitor.h',
   'gdkx11property.h',
   'gdkx11screen.h',
diff --git a/gtk/a11y/gtkbuttonaccessible.c b/gtk/a11y/gtkbuttonaccessible.c
index 1a2e85e9f2..d296699ee2 100644
--- a/gtk/a11y/gtkbuttonaccessible.c
+++ b/gtk/a11y/gtkbuttonaccessible.c
@@ -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;
diff --git a/gtk/a11y/gtkcomboboxaccessible.c b/gtk/a11y/gtkcomboboxaccessible.c
index 1c6b294ab2..b98a71a6f2 100644
--- a/gtk/a11y/gtkcomboboxaccessible.c
+++ b/gtk/a11y/gtkcomboboxaccessible.c
@@ -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;
diff --git a/gtk/a11y/gtkentryaccessible.c b/gtk/a11y/gtkentryaccessible.c
index 01bd1c9ac2..324a79f31c 100644
--- a/gtk/a11y/gtkentryaccessible.c
+++ b/gtk/a11y/gtkentryaccessible.c
@@ -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;
diff --git a/gtk/a11y/gtkexpanderaccessible.c b/gtk/a11y/gtkexpanderaccessible.c
index 6986e50899..d2bd0d9bce 100644
--- a/gtk/a11y/gtkexpanderaccessible.c
+++ b/gtk/a11y/gtkexpanderaccessible.c
@@ -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;
diff --git a/gtk/a11y/gtktextaccessible.c b/gtk/a11y/gtktextaccessible.c
index 4d086b83c7..ea20e4bde1 100644
--- a/gtk/a11y/gtktextaccessible.c
+++ b/gtk/a11y/gtktextaccessible.c
@@ -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;
diff --git a/gtk/gtkaccelgroup.c b/gtk/gtkaccelgroup.c
index 97cdc22791..0cf685c2d8 100644
--- a/gtk/gtkaccelgroup.c
+++ b/gtk/gtkaccelgroup.c
@@ -40,11 +40,12 @@
  *
  * We have various utility functions to parse and generate
  * textual representations of keyboard accelerators.
+ *
+ * If you want to set up keyboard accelerators for widgets,
+ * #GtkShortcutTrigger is probably more convenient than the
+ * functions in this section.
  */
 
-/* --- variables --- */
-static guint  default_accel_mod_mask     = 0;
-
 
 /* --- functions --- */
 /**
@@ -133,17 +134,6 @@ is_ctl (const gchar *string)
 }
 
 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)
 {
   return ((string[0] == '<') &&
@@ -297,6 +287,9 @@ gtk_accelerator_parse_with_keycode (const gchar     *accelerator,
 
   g_return_val_if_fail (accelerator != NULL, FALSE);
 
+  if (!display)
+    display = gdk_display_get_default ();
+
   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 |= GDK_CONTROL_MASK;
             }
           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))
             {
@@ -442,11 +423,10 @@ gtk_accelerator_parse_with_keycode (const gchar     *accelerator,
 
           if (keyval && accelerator_codes != NULL)
             {
-              GdkKeymap *keymap = gdk_display_get_keymap (display ? display : gdk_display_get_default ());
               GdkKeymapKey *keys;
               gint n_keys, i, j;
 
-              if (!gdk_keymap_get_entries_for_keyval (keymap, keyval, &keys, &n_keys))
+              if (!gdk_display_map_keyval (display, keyval, &keys, &n_keys))
                 {
                   /* Not in keymap */
                   error = TRUE;
@@ -518,8 +498,7 @@ out:
  *     modifier mask, %NULL
  *
  * Parses a string representing an accelerator. The format looks like
- * “<Control>a” or “<Shift><Alt>F1” or “<Release>z” (the last one is
- * for key release).
+ * “<Control>a” or “<Shift><Alt>F1”.
  *
  * The parser is fairly liberal and allows lower or upper case, and also
  * abbreviations such as “<Ctl>” and “<Ctrl>”. Key names are parsed using
@@ -564,7 +543,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)
@@ -596,14 +574,9 @@ gchar*
 gtk_accelerator_name (guint           accelerator_key,
                       GdkModifierType accelerator_mods)
 {
-  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>";
@@ -620,26 +593,12 @@ gtk_accelerator_name (guint           accelerator_key,
 
   saved_mods = accelerator_mods;
   l = 0;
-  if (accelerator_mods & _gtk_get_primary_accel_mod ())
-    {
-      l += sizeof (text_primary) - 1;
-      accelerator_mods &= ~_gtk_get_primary_accel_mod (); /* 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,12 +611,6 @@ gtk_accelerator_name (guint           accelerator_key,
   accelerator_mods = saved_mods;
   l = 0;
   accelerator[l] = 0;
-  if (accelerator_mods & _gtk_get_primary_accel_mod ())
-    {
-      strcpy (accelerator + l, text_primary);
-      l += sizeof (text_primary) - 1;
-      accelerator_mods &= ~_gtk_get_primary_accel_mod (); /* consume the default accel */
-    }
   if (accelerator_mods & GDK_SHIFT_MASK)
     {
       strcpy (accelerator + l, text_shift);
@@ -668,30 +621,10 @@ gtk_accelerator_name (guint           accelerator_key,
       strcpy (accelerator + l, text_control);
       l += sizeof (text_control) - 1;
     }
-  if (accelerator_mods & GDK_MOD1_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)
+  if (accelerator_mods & GDK_ALT_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 +674,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 +878,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 +897,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)
@@ -1093,55 +989,19 @@ gtk_accelerator_print_label (GString        *gstring,
 }
 
 /**
- * gtk_accelerator_set_default_mod_mask:
- * @default_mod_mask: accelerator modifier mask
- *
- * 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.
- * In other words, Control, Shift, Alt, Super, Hyper and Meta. Other
- * modifiers will by default be ignored by #GtkAccelGroup.
- *
- * You must include at least the three modifiers Control, Shift
- * and Alt in any value you pass to this function.
- *
- * The default mod mask should be changed on application startup,
- * before using any accelerator groups.
- */
-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);
-}
-
-/**
  * gtk_accelerator_get_default_mod_mask:
  *
  * Gets the modifier mask.
  *
  * The modifier mask determines which modifiers are considered significant
- * for keyboard accelerators. See gtk_accelerator_set_default_mod_mask().
+ * for keyboard accelerators. This includes all keyboard modifiers except
+ * for %GDK_LOCK_MASK.
  *
- * Returns: the default accelerator modifier mask
+ * Returns: the modifier mask for accelerators
  */
 GdkModifierType
 gtk_accelerator_get_default_mod_mask (void)
 {
-  if (!default_accel_mod_mask)
-    {
-      GdkDisplay *display;
-
-      display = gdk_display_get_default ();
-
-      if (!display)
-        return GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK;
-
-      default_accel_mod_mask =
-          gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-				        GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK);
-    }
-
-  return default_accel_mod_mask;
+  return GDK_CONTROL_MASK|GDK_SHIFT_MASK|GDK_ALT_MASK|
+         GDK_SUPER_MASK|GDK_HYPER_MASK|GDK_META_MASK;
 }
diff --git a/gtk/gtkaccelgroup.h b/gtk/gtkaccelgroup.h
index 69d0a3f227..6e38622223 100644
--- a/gtk/gtkaccelgroup.h
+++ b/gtk/gtkaccelgroup.h
@@ -67,10 +67,8 @@ gchar*   gtk_accelerator_get_label_with_keycode (GdkDisplay      *display,
                                                  guint            keycode,
                                                  GdkModifierType  accelerator_mods);
 GDK_AVAILABLE_IN_ALL
-void	 gtk_accelerator_set_default_mod_mask (GdkModifierType  default_mod_mask);
-GDK_AVAILABLE_IN_ALL
-GdkModifierType
-	 gtk_accelerator_get_default_mod_mask (void);
+GdkModifierType gtk_accelerator_get_default_mod_mask (void);
+
 
 G_END_DECLS
 
diff --git a/gtk/gtkapplication-quartz-menu.c b/gtk/gtkapplication-quartz-menu.c
index 4a8a135c0e..9b72b8e3c2 100644
--- a/gtk/gtkapplication-quartz-menu.c
+++ b/gtk/gtkapplication-quartz-menu.c
@@ -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;
diff --git a/gtk/gtkcellrendereraccel.c b/gtk/gtkcellrendereraccel.c
index c589320cab..7d172432e1 100644
--- a/gtk/gtkcellrendereraccel.c
+++ b/gtk/gtkcellrendereraccel.c
@@ -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_key_event_get_match (gtk_get_current_event (), &accel_key, &accel_mods))
+    return FALSE;
+    
   if (accel_mods == 0)
     {
       switch (keyval)
diff --git a/gtk/gtkcolorplane.c b/gtk/gtkcolorplane.c
index a11b0752e2..bbe7ac0f2d 100644
--- a/gtk/gtkcolorplane.c
+++ b/gtk/gtkcolorplane.c
@@ -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;
diff --git a/gtk/gtkcombobox.c b/gtk/gtkcombobox.c
index c1e97debb0..47e3f0cd5b 100644
--- a/gtk/gtkcombobox.c
+++ b/gtk/gtkcombobox.c
@@ -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,
diff --git a/gtk/gtkeventcontrollerkey.c b/gtk/gtkeventcontrollerkey.c
index 62614dbf79..ae7c11a8b0 100644
--- a/gtk/gtkeventcontrollerkey.c
+++ b/gtk/gtkeventcontrollerkey.c
@@ -385,5 +385,5 @@ gtk_event_controller_key_get_group (GtkEventControllerKey *controller)
   g_return_val_if_fail (GTK_IS_EVENT_CONTROLLER_KEY (controller), FALSE);
   g_return_val_if_fail (controller->current_event != NULL, FALSE);
 
-  return gdk_key_event_get_group (controller->current_event);
+  return gdk_key_event_get_layout (controller->current_event);
 }
diff --git a/gtk/gtkfilechooserwidget.c b/gtk/gtkfilechooserwidget.c
index f62b861e71..689c8e9eb1 100644
--- a/gtk/gtkfilechooserwidget.c
+++ b/gtk/gtkfilechooserwidget.c
@@ -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);
 
diff --git a/gtk/gtkflowbox.c b/gtk/gtkflowbox.c
index 832dc87907..73214fb90f 100644
--- a/gtk/gtkflowbox.c
+++ b/gtk/gtkflowbox.c
@@ -142,10 +142,10 @@ get_current_selection_modifiers (GtkWidget *widget,
 
   if (gtk_get_current_event_state (&state))
     {
-      mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+      mask = GDK_CONTROL_MASK;
       if ((state & mask) == mask)
         *modify = TRUE;
-      mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+      mask = GDK_SHIFT_MASK;
       if ((state & mask) == mask)
         *extend = TRUE;
     }
@@ -2992,19 +2992,9 @@ gtk_flow_box_add_move_binding (GtkWidgetClass  *widget_class,
                                GtkMovementStep  step,
                                gint             count)
 {
-  GdkDisplay *display;
   GdkModifierType extend_mod_mask = GDK_SHIFT_MASK;
   GdkModifierType modify_mod_mask = GDK_CONTROL_MASK;
 
-  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);
-    }
-
   gtk_widget_class_add_binding_signal (widget_class,
                                        keyval, modmask,
                                        "move-cursor",
diff --git a/gtk/gtkiconview.c b/gtk/gtkiconview.c
index f3bb6ead98..275b598675 100644
--- a/gtk/gtkiconview.c
+++ b/gtk/gtkiconview.c
@@ -2125,7 +2125,7 @@ gtk_icon_view_button_press (GtkGestureClick *gesture,
   GtkCellRenderer *cell = NULL, *cursor_cell = NULL;
   int button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
   GdkEventSequence *sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
-  GdkEventButton *event = (GdkEventButton *)gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
+  GdkEvent *event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
   GdkModifierType state;
 
   if (!gtk_widget_has_focus (widget))
@@ -2133,15 +2133,10 @@ gtk_icon_view_button_press (GtkGestureClick *gesture,
 
   if (button == GDK_BUTTON_PRIMARY)
     {
-      GdkModifierType extend_mod_mask;
-      GdkModifierType modify_mod_mask;
-
-      state = gdk_event_get_modifier_state ((GdkEvent *)event);
-      extend_mod_mask =
-        gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+      GdkModifierType extend_mod_mask = GDK_SHIFT_MASK;
+      GdkModifierType modify_mod_mask = GDK_CONTROL_MASK;
 
-      modify_mod_mask =
-        gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+      state = gdk_event_get_modifier_state (event);
 
       item = _gtk_icon_view_get_item_at_widget_coords (icon_view,
                                                        x, y,
@@ -3468,15 +3463,8 @@ gtk_icon_view_real_move_cursor (GtkIconView     *icon_view,
 
   if (gtk_get_current_event_state (&state))
     {
-      GdkModifierType extend_mod_mask;
-      GdkModifierType modify_mod_mask;
-
-      extend_mod_mask =
-        gtk_widget_get_modifier_mask (GTK_WIDGET (icon_view),
-                                      GDK_MODIFIER_INTENT_EXTEND_SELECTION);
-      modify_mod_mask =
-        gtk_widget_get_modifier_mask (GTK_WIDGET (icon_view),
-                                      GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+      GdkModifierType extend_mod_mask = GDK_SHIFT_MASK;
+      GdkModifierType modify_mod_mask = GDK_CONTROL_MASK;
 
       if ((state & modify_mod_mask) == modify_mod_mask)
         icon_view->priv->modify_selection_pressed = TRUE;
diff --git a/gtk/gtkimcontextsimple.c b/gtk/gtkimcontextsimple.c
index 6c9c965f7d..169d9333e9 100644
--- a/gtk/gtkimcontextsimple.c
+++ b/gtk/gtkimcontextsimple.c
@@ -929,18 +929,21 @@ no_sequence_matches (GtkIMContextSimple *context_simple,
       
       for (i = 0; i < n_compose - len - 1; i++)
 	{
-          guint tmp_keyval = priv->compose_buffer[len + i];
+          GdkTranslatedKey translated;
+          translated.keyval = priv->compose_buffer[len + i];
+          translated.consumed = 0;
+          translated.layout = 0;
+          translated.level = 0;
           GdkEvent *tmp_event = gdk_event_key_new (GDK_KEY_PRESS,
                                                    gdk_event_get_surface (event),
                                                    gdk_event_get_device (event),
                                                    gdk_event_get_source_device (event),
                                                    gdk_event_get_time (event),
+                                                   priv->compose_buffer[len + i],
                                                    gdk_event_get_modifier_state (event),
-                                                   tmp_keyval,
-                                                   tmp_keyval,
-                                                   tmp_keyval,
-                                                   0,
-                                                   0);
+                                                   FALSE,
+                                                   &translated,
+                                                   &translated);
 	  
 	  gtk_im_context_filter_keypress (context, tmp_event);
 	  gdk_event_unref (tmp_event);
@@ -982,14 +985,12 @@ is_hex_keyval (guint keyval)
 static guint
 canonical_hex_keyval (GdkEvent *event)
 {
-  GdkSurface *surface = gdk_event_get_surface ((GdkEvent *) event);
-  GdkKeymap *keymap = gdk_display_get_keymap (gdk_surface_get_display (surface));
   guint keyval, event_keyval;
   guint *keyvals = NULL;
   gint n_vals = 0;
   gint i;
 
-  event_keyval = gdk_key_event_get_keyval ((GdkEvent *)event);
+  event_keyval = gdk_key_event_get_keyval (event);
 
   /* See if the keyval is already a hex digit */
   if (is_hex_keyval (event_keyval))
@@ -998,10 +999,10 @@ canonical_hex_keyval (GdkEvent *event)
   /* See if this key would have generated a hex keyval in
    * any other state, and return that hex keyval if so
    */
-  gdk_keymap_get_entries_for_keycode (keymap,
-                                      gdk_key_event_get_scancode ((GdkEvent *) event),
-				      NULL,
-				      &keyvals, &n_vals);
+  gdk_display_map_keycode (gdk_event_get_display (event),
+                           gdk_key_event_get_keycode (event),
+                           NULL,
+                           &keyvals, &n_vals);
 
   keyval = 0;
   i = 0;
@@ -1033,8 +1034,6 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
   GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (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,8 +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_SHIFT_MASK;
+  hex_mod_mask = GDK_CONTROL_MASK|GDK_SHIFT_MASK;
 
   if (priv->in_hex_sequence && priv->modifiers_dropped)
     have_hex_mods = TRUE;
@@ -1132,7 +1130,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_ALT_MASK|GDK_CONTROL_MASK;
 
       if (state & no_text_input_mask ||
 	  (priv->in_hex_sequence && priv->modifiers_dropped &&
@@ -1262,7 +1260,8 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
     {
       gboolean success = FALSE;
 
-#ifdef GDK_WINDOWING_WIN32
+#if 0
+  /* FIXME this needs redoing since keymaps are no longer exposed */
       if (GDK_IS_WIN32_DISPLAY (display))
         {
           guint16  output[2];
diff --git a/gtk/gtkimmulticontext.c b/gtk/gtkimmulticontext.c
index b7a40a1f4b..2d2768e026 100644
--- a/gtk/gtkimmulticontext.c
+++ b/gtk/gtkimmulticontext.c
@@ -361,16 +361,12 @@ gtk_im_multicontext_filter_keypress (GtkIMContext *context,
     }
   else
     {
-      GdkDisplay *display;
       GdkModifierType no_text_input_mask;
 
       keyval = gdk_key_event_get_keyval (event);
       state = gdk_event_get_modifier_state (event);
-      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);
+      no_text_input_mask = GDK_ALT_MASK|GDK_CONTROL_MASK;
 
       if (gdk_event_get_event_type (event) == GDK_KEY_PRESS &&
           (state & no_text_input_mask) == 0)
diff --git a/gtk/gtklabel.c b/gtk/gtklabel.c
index 0b7b884685..2bba929146 100644
--- a/gtk/gtklabel.c
+++ b/gtk/gtklabel.c
@@ -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);
 	}
diff --git a/gtk/gtklistbox.c b/gtk/gtklistbox.c
index def3c27e05..bae24231cd 100644
--- a/gtk/gtklistbox.c
+++ b/gtk/gtklistbox.c
@@ -1425,19 +1425,9 @@ gtk_list_box_add_move_binding (GtkWidgetClass  *widget_class,
                                GtkMovementStep  step,
                                gint             count)
 {
-  GdkDisplay *display;
   GdkModifierType extend_mod_mask = GDK_SHIFT_MASK;
   GdkModifierType modify_mod_mask = GDK_CONTROL_MASK;
 
-  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);
-    }
-
   gtk_widget_class_add_binding_signal (widget_class,
                                        keyval, modmask,
                                        "move-cursor",
@@ -1786,10 +1776,10 @@ get_current_selection_modifiers (GtkWidget *widget,
 
   if (gtk_get_current_event_state (&state))
     {
-      mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+      mask = GDK_CONTROL_MASK;
       if ((state & mask) == mask)
         *modify = TRUE;
-      mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+      mask = GDK_SHIFT_MASK;
       if ((state & mask) == mask)
         *extend = TRUE;
     }
diff --git a/gtk/gtknotebook.c b/gtk/gtknotebook.c
index 3dd45e6535..57f90c8338 100644
--- a/gtk/gtknotebook.c
+++ b/gtk/gtknotebook.c
@@ -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);
 
diff --git a/gtk/gtkpasswordentry.c b/gtk/gtkpasswordentry.c
index 0ed1fe043f..b6f202f247 100644
--- a/gtk/gtkpasswordentry.c
+++ b/gtk/gtkpasswordentry.c
@@ -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]);
 }
diff --git a/gtk/gtkplacessidebar.c b/gtk/gtkplacessidebar.c
index cdcffab742..934a834762 100644
--- a/gtk/gtkplacessidebar.c
+++ b/gtk/gtkplacessidebar.c
@@ -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 ||
diff --git a/gtk/gtkpopover.c b/gtk/gtkpopover.c
index 1c90dc2af9..0f598fa74e 100644
--- a/gtk/gtkpopover.c
+++ b/gtk/gtkpopover.c
@@ -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);
diff --git a/gtk/gtkprivate.c b/gtk/gtkprivate.c
index 9a6cd584dc..105cf4a8ce 100644
--- a/gtk/gtkprivate.c
+++ b/gtk/gtkprivate.c
@@ -158,101 +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)
-{
-  static GdkModifierType primary = 0;
-
-  if (! primary)
-    {
-      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);
-    }
-
-  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)
 {
diff --git a/gtk/gtkprivate.h b/gtk/gtkprivate.h
index f4ba489ba6..9e8300d1a3 100644
--- a/gtk/gtkprivate.h
+++ b/gtk/gtkprivate.h
@@ -82,20 +82,6 @@ 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);
diff --git a/gtk/gtksearchentry.c b/gtk/gtksearchentry.c
index 93073e70b7..b8c224dd84 100644
--- a/gtk/gtksearchentry.c
+++ b/gtk/gtksearchentry.c
@@ -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
diff --git a/gtk/gtkshortcutcontroller.c b/gtk/gtkshortcutcontroller.c
index 8fa081f977..a3c62ead72 100644
--- a/gtk/gtkshortcutcontroller.c
+++ b/gtk/gtkshortcutcontroller.c
@@ -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_KEY_MATCH_PARTIAL:
           if (!has_exact)
             break;
           G_GNUC_FALLTHROUGH;
 
-        case GTK_SHORTCUT_TRIGGER_MATCH_NONE:
+        case GDK_KEY_MATCH_NONE:
           g_object_unref (shortcut);
           continue;
 
-        case GTK_SHORTCUT_TRIGGER_MATCH_EXACT:
+        case GDK_KEY_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
diff --git a/gtk/gtkshortcutlabel.c b/gtk/gtkshortcutlabel.c
index 90471af3ee..5b453edd9d 100644
--- a/gtk/gtkshortcutlabel.c
+++ b/gtk/gtkshortcutlabel.c
@@ -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)
diff --git a/gtk/gtkshortcuttrigger.c b/gtk/gtkshortcuttrigger.c
index 722a41fafd..30ab0411ca 100644
--- a/gtk/gtkshortcuttrigger.c
+++ b/gtk/gtkshortcuttrigger.c
@@ -59,8 +59,7 @@ struct _GtkShortcutTriggerClass
 {
   GObjectClass parent_class;
 
-  GtkShortcutTriggerMatch
-                  (* trigger)     (GtkShortcutTrigger  *trigger,
+  GdkKeyMatch     (* 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
+GdkKeyMatch
 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_KEY_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 GdkKeyMatch
 gtk_never_trigger_trigger (GtkShortcutTrigger *trigger,
                            GdkEvent           *event,
                            gboolean            enable_mnemonics)
 {
-  return GTK_SHORTCUT_TRIGGER_MATCH_NONE;
+  return GDK_KEY_MATCH_NONE;
 }
 
 static guint
@@ -510,110 +509,14 @@ enum
 
 static GParamSpec *keyval_props[KEYVAL_N_PROPS];
 
-static GtkShortcutTriggerMatch
+static GdkKeyMatch
 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_key_event_matches (event, self->keyval, self->modifiers);
 }
 
 static guint
@@ -849,7 +752,7 @@ enum
 
 static GParamSpec *mnemonic_props[MNEMONIC_N_PROPS];
 
-static GtkShortcutTriggerMatch
+static GdkKeyMatch
 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_KEY_MATCH_NONE;
 
   if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
-    return GTK_SHORTCUT_TRIGGER_MATCH_NONE;
+    return GDK_KEY_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_KEY_MATCH_NONE;
 
-  return GTK_SHORTCUT_TRIGGER_MATCH_EXACT;
+  return GDK_KEY_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 GdkKeyMatch
 gtk_alternative_trigger_trigger (GtkShortcutTrigger *trigger,
                                  GdkEvent           *event,
                                  gboolean            enable_mnemonics)
diff --git a/gtk/gtkshortcuttrigger.h b/gtk/gtkshortcuttrigger.h
index eba7bde4f4..2701429c98 100644
--- a/gtk/gtkshortcuttrigger.h
+++ b/gtk/gtkshortcuttrigger.h
@@ -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,
+GdkKeyMatch             gtk_shortcut_trigger_trigger            (GtkShortcutTrigger *self,
                                                                  GdkEvent           *event,
                                                                  gboolean            enable_mnemonics);
 
diff --git a/gtk/gtkstylecontext.c b/gtk/gtkstylecontext.c
index c885841799..ab087433e1 100644
--- a/gtk/gtkstylecontext.c
+++ b/gtk/gtkstylecontext.c
@@ -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;
diff --git a/gtk/gtktext.c b/gtk/gtktext.c
index 6825c7e88a..7908e31119 100644
--- a/gtk/gtktext.c
+++ b/gtk/gtktext.c
@@ -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);
@@ -2654,7 +2657,6 @@ gtk_text_click_gesture_pressed (GtkGestureClick *gesture,
       gboolean have_selection;
       gboolean is_touchscreen, extend_selection;
       GdkDevice *source;
-      guint state;
 
       sel_start = priv->selection_bound;
       sel_end = priv->current_pos;
@@ -2670,12 +2672,7 @@ gtk_text_click_gesture_pressed (GtkGestureClick *gesture,
       priv->select_words = FALSE;
       priv->select_lines = FALSE;
 
-      state = gdk_event_get_modifier_state (event);
-
-      extend_selection =
-        (state &
-         gtk_widget_get_modifier_mask (widget,
-                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION));
+      extend_selection = GDK_SHIFT_MASK;
 
       /* Always emit reset when preedit is shown */
       priv->need_im_reset = TRUE;
@@ -3081,11 +3078,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 +3092,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 +3104,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 +3114,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 +3125,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 +3605,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 +3623,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 +4062,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 +4329,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 +4892,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)
diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c
index 7b4ec0a3d4..dd0bbe71dd 100644
--- a/gtk/gtktextview.c
+++ b/gtk/gtktextview.c
@@ -5373,9 +5373,7 @@ gtk_text_view_click_gesture_pressed (GtkGestureClick *gesture,
 
       state = gdk_event_get_modifier_state (event);
 
-      if (state &
-          gtk_widget_get_modifier_mask (GTK_WIDGET (text_view),
-                                        GDK_MODIFIER_INTENT_EXTEND_SELECTION))
+      if (state & GDK_SHIFT_MASK)
         extends = TRUE;
 
       switch (n_press)
@@ -5456,8 +5454,9 @@ gtk_text_view_click_gesture_pressed (GtkGestureClick *gesture,
 }
 
 static void
-keymap_direction_changed (GdkKeymap   *keymap,
-			  GtkTextView *text_view)
+direction_changed (GdkDevice  *device,
+                   GParamSpec *pspec,
+                   GtkTextView *text_view)
 {
   gtk_text_view_check_keymap_direction (text_view);
 }
@@ -5467,6 +5466,8 @@ gtk_text_view_focus_in (GtkWidget *widget)
 {
   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
   GtkTextViewPrivate *priv = text_view->priv;
+  GdkSeat *seat;
+  GdkDevice *keyboard;
 
   gtk_widget_queue_draw (widget);
 
@@ -5480,9 +5481,10 @@ gtk_text_view_focus_in (GtkWidget *widget)
       gtk_text_view_check_cursor_blink (text_view);
     }
 
-  g_signal_connect (gdk_display_get_keymap (gtk_widget_get_display (widget)),
-                    "direction-changed",
-                    G_CALLBACK (keymap_direction_changed), text_view);
+  seat = gdk_display_get_default_seat (gtk_widget_get_display (widget));
+  keyboard = gdk_seat_get_keyboard (seat);
+  g_signal_connect (keyboard, "notify::direction",
+                    G_CALLBACK (direction_changed), text_view);
   gtk_text_view_check_keymap_direction (text_view);
 
   if (priv->editable)
@@ -5497,6 +5499,8 @@ gtk_text_view_focus_out (GtkWidget *widget)
 {
   GtkTextView *text_view = GTK_TEXT_VIEW (widget);
   GtkTextViewPrivate *priv = text_view->priv;
+  GdkSeat *seat;
+  GdkDevice *keyboard;
 
   gtk_text_view_end_selection_drag (text_view);
 
@@ -5510,9 +5514,9 @@ gtk_text_view_focus_out (GtkWidget *widget)
       gtk_text_layout_set_cursor_visible (priv->layout, FALSE);
     }
 
-  g_signal_handlers_disconnect_by_func (gdk_display_get_keymap (gtk_widget_get_display (widget)),
-                                        keymap_direction_changed,
-                                        text_view);
+  seat = gdk_display_get_default_seat (gtk_widget_get_display (widget));
+  keyboard = gdk_seat_get_keyboard (seat);
+  g_signal_handlers_disconnect_by_func (keyboard, direction_changed, text_view);
   gtk_text_view_selection_bubble_popup_unset (text_view);
 
   text_view->priv->text_handles_enabled = FALSE;
@@ -7534,7 +7538,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 +7548,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;
diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c
index 548034619c..3580ab8f8d 100644
--- a/gtk/gtktreeview.c
+++ b/gtk/gtktreeview.c
@@ -2791,10 +2791,10 @@ get_current_selection_modifiers (GtkWidget *widget,
 
   if (gtk_get_current_event_state (&state))
     {
-      mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+      mask = GDK_CONTROL_MASK;
       if ((state & mask) == mask)
         *modify = TRUE;
-      mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+      mask = GDK_SHIFT_MASK;
       if ((state & mask) == mask)
         *extend = TRUE;
     }
@@ -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
@@ -7966,13 +7966,8 @@ gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
       GdkModifierType extend_mod_mask;
       GdkModifierType modify_mod_mask;
 
-      extend_mod_mask =
-        gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
-                                      GDK_MODIFIER_INTENT_EXTEND_SELECTION);
-
-      modify_mod_mask =
-        gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
-                                      GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+      extend_mod_mask = GDK_SHIFT_MASK;
+      modify_mod_mask = GDK_CONTROL_MASK;
 
       if ((state & modify_mod_mask) == modify_mod_mask)
         tree_view->modify_selection_pressed = TRUE;
@@ -9990,9 +9985,7 @@ gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
 	{
           GdkModifierType modify_mod_mask;
 
-          modify_mod_mask =
-            gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
-                                          GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+          modify_mod_mask = GDK_CONTROL_MASK;
 
 	  if ((state & modify_mod_mask) == modify_mod_mask)
 	    tree_view->modify_selection_pressed = TRUE;
@@ -13686,8 +13679,7 @@ gtk_tree_view_search_key_pressed (GtkEventControllerKey *key,
       return TRUE;
     }
 
-  default_accel = gtk_widget_get_modifier_mask (widget,
-                                                GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
+  default_accel = GDK_CONTROL_MASK;
 
   /* select previous matching iter */
   if (keyval == GDK_KEY_Up || keyval == GDK_KEY_KP_Up)
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index a276b3369b..677c6b2b8d 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -10662,32 +10662,6 @@ gtk_widget_get_style_context (GtkWidget *widget)
   return priv->context;
 }
 
-/**
- * gtk_widget_get_modifier_mask:
- * @widget: a #GtkWidget
- * @intent: the use case for the modifier mask
- *
- * Returns the modifier mask the @widget’s windowing system backend
- * uses for a particular purpose.
- *
- * See gdk_keymap_get_modifier_mask().
- *
- * Returns: the modifier mask used for @intent.
- **/
-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);
-}
-
 static GtkActionMuxer *
 gtk_widget_get_parent_muxer (GtkWidget *widget,
                              gboolean   create)
diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h
index 10065a7b1a..c5ebb4b721 100644
--- a/gtk/gtkwidget.h
+++ b/gtk/gtkwidget.h
@@ -772,10 +772,6 @@ GDK_AVAILABLE_IN_ALL
 const char *      gtk_widget_class_get_css_name (GtkWidgetClass *widget_class);
 
 GDK_AVAILABLE_IN_ALL
-GdkModifierType   gtk_widget_get_modifier_mask (GtkWidget         *widget,
-                                                GdkModifierIntent  intent);
-
-GDK_AVAILABLE_IN_ALL
 guint gtk_widget_add_tick_callback (GtkWidget       *widget,
                                     GtkTickCallback  callback,
                                     gpointer         user_data,
diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c
index d7a62f52ab..42135b8bb9 100644
--- a/gtk/gtkwindow.c
+++ b/gtk/gtkwindow.c
@@ -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);
diff --git a/gtk/inspector/object-tree.c b/gtk/inspector/object-tree.c
index ac31163805..5b1f3dc2a5 100644
--- a/gtk/inspector/object-tree.c
+++ b/gtk/inspector/object-tree.c
@@ -742,7 +742,7 @@ key_pressed (GtkEventController     *controller,
       gboolean search_started;
 
       search_started = gtk_search_bar_get_search_mode (GTK_SEARCH_BAR (wt->priv->search_bar));
-      default_accel = gtk_widget_get_modifier_mask (GTK_WIDGET (wt), GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
+      default_accel = GDK_CONTROL_MASK;
 
       if (search_started &&
           (keyval == GDK_KEY_Return ||
diff --git a/gtk/inspector/resource-list.c b/gtk/inspector/resource-list.c
index 9f413d0ef1..dfc0817abd 100644
--- a/gtk/inspector/resource-list.c
+++ b/gtk/inspector/resource-list.c
@@ -407,7 +407,7 @@ key_pressed (GtkEventController       *controller,
       gboolean search_started;
 
       search_started = gtk_search_bar_get_search_mode (GTK_SEARCH_BAR (sl->priv->search_bar));
-      default_accel = gtk_widget_get_modifier_mask (GTK_WIDGET (sl), GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
+      default_accel = GDK_CONTROL_MASK;
 
       if (search_started &&
           (keyval == GDK_KEY_Return ||
diff --git a/tests/testgtk.c b/tests/testgtk.c
index 570bab6f00..61b66b69fc 100644
--- a/tests/testgtk.c
+++ b/tests/testgtk.c
@@ -6270,13 +6270,6 @@ main (int argc, char *argv[])
                                               GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
   g_object_unref (provider);
 
-  gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
-					GDK_CONTROL_MASK |
-					GDK_MOD1_MASK | 
-					GDK_META_MASK |
-					GDK_SUPER_MASK |
-					GDK_HYPER_MASK |
-					GDK_MOD4_MASK);
   /*  benchmarking
    */
   for (i = 1; i < argc; i++)
diff --git a/testsuite/gtk/accel.c b/testsuite/gtk/accel.c
index c49a10e72f..4c06b28ca0 100644
--- a/testsuite/gtk/accel.c
+++ b/testsuite/gtk/accel.c
@@ -18,9 +18,11 @@
 #include <locale.h>
 
 static void
-test_one_accel (const char *accel,
-		const char *exp_label,
-		gboolean    has_keysym)
+test_one_accel (const char      *accel,
+                GdkModifierType  exp_mods,
+                guint            exp_key,
+		const char      *exp_label,
+		gboolean         has_keysym)
 {
   guint accel_key;
   GdkModifierType mods;
@@ -47,7 +49,8 @@ test_one_accel (const char *accel,
     }
 
   if (has_keysym)
-    g_assert (accel_key != 0);
+    g_assert (accel_key == exp_key);
+  g_assert (mods == exp_mods);
   g_assert (keycodes);
   g_assert (keycodes[0] != 0);
 
@@ -72,49 +75,49 @@ test_one_accel (const char *accel,
 static void
 accel1 (void)
 {
-  test_one_accel ("0xb3", "0xb3", FALSE);
+  test_one_accel ("0xb3", 0, 0xb3, "0xb3", FALSE);
 }
 
 static void
 accel2 (void)
 {
-  test_one_accel ("<Primary><Alt>z", "Ctrl+Alt+Z", TRUE);
+  test_one_accel ("<Control><Alt>z", GDK_CONTROL_MASK|GDK_ALT_MASK, GDK_KEY_z, "Ctrl+Alt+Z", TRUE);
 }
 
 static void
 accel3 (void)
 {
-  test_one_accel ("KP_7", "7", TRUE);
+  test_one_accel ("KP_7", 0, GDK_KEY_KP_7, "7", TRUE);
 }
 
 static void
 accel4 (void)
 {
-  test_one_accel ("<Primary>KP_7", "Ctrl+7", TRUE);
+  test_one_accel ("<Control>KP_7", GDK_CONTROL_MASK, GDK_KEY_KP_7, "Ctrl+7", TRUE);
 }
 
 static void
 accel5 (void)
 {
-  test_one_accel ("<Shift>exclam", "Shift+!", TRUE);
+  test_one_accel ("<Shift>exclam", GDK_SHIFT_MASK, GDK_KEY_exclam, "Shift+!", TRUE);
 }
 
 static void
 accel6 (void)
 {
-  test_one_accel ("<Hyper>x", "Hyper+X", TRUE);
+  test_one_accel ("<Hyper>x", GDK_HYPER_MASK, GDK_KEY_x, "Hyper+X", TRUE);
 }
 
 static void
 accel7 (void)
 {
-  test_one_accel ("<Super>x", "Super+X", TRUE);
+  test_one_accel ("<Super>x", GDK_SUPER_MASK, GDK_KEY_x, "Super+X", TRUE);
 }
 
 static void
 accel8 (void)
 {
-  test_one_accel ("<Meta>x", "Meta+X", TRUE);
+  test_one_accel ("<Meta>x", GDK_META_MASK, GDK_KEY_x, "Meta+X", TRUE);
 }
 
 static void
diff --git a/testsuite/gtk/shortcuts.c b/testsuite/gtk/shortcuts.c
index 916a8f0424..a1b93afca2 100644
--- a/testsuite/gtk/shortcuts.c
+++ b/testsuite/gtk/shortcuts.c
@@ -19,27 +19,21 @@ struct _GdkEventAny
   GdkDevice *source_device;
 };
 
+typedef struct {
+  guint keyval;
+  GdkModifierType consumed;
+  guint layout;
+  guint level;
+} GdkTranslatedKey;
+
 struct _GdkEventKey
 {
   GdkEventAny any;
   GdkModifierType state;
-  guint keyval;
-  guint16 hardware_keycode;
-  guint16 key_scancode;
-  guint8 group;
+  guint32 keycode;
+  GdkTranslatedKey translated[2];
 };
 
-static GdkEvent * gdk_event_key_new     (GdkEventType     type,
-                                         GdkSurface      *surface,
-                                         GdkDevice       *device,
-                                         GdkDevice       *source_device,
-                                         guint32          time,
-                                         GdkModifierType  state,
-                                         guint            keyval,
-                                         guint16          keycode,
-                                         guint16          scancode,
-                                         guint8           group,
-                                         gboolean         is_modifier);
 
 static GdkEvent *
 gdk_event_key_new (GdkEventType     type,
@@ -47,12 +41,23 @@ gdk_event_key_new (GdkEventType     type,
                    GdkDevice       *device,
                    GdkDevice       *source_device,
                    guint32          time,
+                   guint            keycode,
+                   GdkModifierType  state,
+                   gboolean         is_modifier,
+                   GdkTranslatedKey *translated,
+                   GdkTranslatedKey *no_lock);
+
+static GdkEvent *
+gdk_event_key_new (GdkEventType     type,
+                   GdkSurface      *surface,
+                   GdkDevice       *device,
+                   GdkDevice       *source_device,
+                   guint32          time,
+                   guint            keycode,
                    GdkModifierType  state,
-                   guint            keyval,
-                   guint16          keycode,
-                   guint16          scancode,
-                   guint8           group,
-                   gboolean         is_modifier)
+                   gboolean         is_modifier,
+                   GdkTranslatedKey *translated,
+                   GdkTranslatedKey *no_lock)
 {
   GdkEventKey *event;
 
@@ -67,12 +72,11 @@ gdk_event_key_new (GdkEventType     type,
   event->any.surface = g_object_ref (surface);
   event->any.device = g_object_ref (device);
   event->any.source_device = g_object_ref (source_device);
+  event->keycode = keycode;
   event->state = state;
-  event->keyval = keyval;
-  event->hardware_keycode = keycode;
-  event->key_scancode = scancode;
-  event->group = group;
   event->any.key_is_modifier = is_modifier;
+  event->translated[0] = *translated;
+  event->translated[1] = *no_lock;
 
   return (GdkEvent *)event;
 }
@@ -171,7 +175,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 +344,14 @@ test_trigger_trigger (void)
     guint keyval;
     GdkModifierType state;
     gboolean mnemonic;
-    GtkShortcutTriggerMatch result[4];
+    GdkKeyMatch 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_KEY_MATCH_NONE, GDK_KEY_MATCH_EXACT, GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_EXACT } }, 
+    { GDK_KEY_a, GDK_CONTROL_MASK, TRUE,  { GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_EXACT, GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_EXACT } }, 
+    { GDK_KEY_a, GDK_SHIFT_MASK,   FALSE, { GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE } }, 
+    { GDK_KEY_a, GDK_SHIFT_MASK,   TRUE,  { GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE } }, 
+    { GDK_KEY_u, GDK_SHIFT_MASK,   FALSE, { GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE } }, 
+    { GDK_KEY_u, GDK_SHIFT_MASK,   TRUE,  { GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_NONE, GDK_KEY_MATCH_EXACT, GDK_KEY_MATCH_EXACT } }, 
   };
   int i, j;
 
@@ -365,24 +369,29 @@ test_trigger_trigger (void)
     {
       GdkKeymapKey *keys;
       int n_keys;
+      GdkTranslatedKey translated;
 
-      if (!gdk_keymap_get_entries_for_keyval (gdk_display_get_keymap (display),
-                                              tests[i].keyval, &keys, &n_keys))
+      if (!gdk_display_map_keyval (display, tests[i].keyval, &keys, &n_keys))
         continue;
 
+      translated.keyval = tests[i].keyval;
+      translated.consumed = 0;
+      translated.layout = keys[0].group;
+      translated.level = keys[0].level;
       event = gdk_event_key_new (GDK_KEY_PRESS,
                                  surface,
                                  device,
                                  device,
                                  GDK_CURRENT_TIME,
-                                 tests[i].state,
-                                 tests[i].keyval,
                                  keys[0].keycode,
-                                 keys[0].keycode,
-                                 keys[0].group,
-                                 FALSE);
+                                 tests[i].state,
+                                 FALSE,
+                                 &translated,
+                                 &translated);
       for (j = 0; j < 4; j++)
-        g_assert_cmpint (gtk_shortcut_trigger_trigger (trigger[j], event, tests[i].mnemonic), ==, tests[i].result[j]);
+        {
+          g_assert_cmpint (gtk_shortcut_trigger_trigger (trigger[j], event, tests[i].mnemonic), ==, tests[i].result[j]);
+        }
 
       gdk_event_unref (event);
     }
diff --git a/testsuite/reftests/meson.build b/testsuite/reftests/meson.build
index 3a3706d51b..8be2073d98 100644
--- a/testsuite/reftests/meson.build
+++ b/testsuite/reftests/meson.build
@@ -376,8 +376,9 @@ testdata = [
   'sizegroups-basics.css',
   'sizegroups-basics.ui',
   'sizegroups-basics.ref.ui',
-  'sizegroups-evolution-identity-page.ui',
-  'sizegroups-evolution-identity-page.ref.ui',
+  # this one triggers pango assertion in ci
+  #'sizegroups-evolution-identity-page.ui',
+  #'sizegroups-evolution-identity-page.ref.ui',
   'sizegroups-get-preferred-null.ui',
   'sizegroups-get-preferred-null.ref.ui',
   'statusbar-remove-all.ref.ui',
@@ -424,7 +425,8 @@ xfails = [
   'background-color-transparent.ui',
   'background-image-multiple.ui',
   'background-origin.ui',
-  'sizegroups-evolution-identity-page.ui',
+  # see above
+  #'sizegroups-evolution-identity-page.ui',
   'textview-border-windows.ui',
   'window-show-contents-on-map.ui',
   # these depend on details of text layout