From 8c6162b50cd8bb5addf711b444b83024060d6582 Mon Sep 17 00:00:00 2001 From: Alexander Larsson Date: Mon, 6 Dec 2010 20:01:12 +0100 Subject: [PATCH] Convert all gdk_keymap methods to vtable calls --- gdk/gdkinternals.h | 30 +++++ gdk/gdkkeys.c | 281 +++++++++++++++++++++++++++++++++++++++ gdk/x11/gdkkeys-x11.c | 302 ++++++++---------------------------------- 3 files changed, 369 insertions(+), 244 deletions(-) diff --git a/gdk/gdkinternals.h b/gdk/gdkinternals.h index 8a07af3fa9..0be0825790 100644 --- a/gdk/gdkinternals.h +++ b/gdk/gdkinternals.h @@ -315,6 +315,36 @@ struct _GdkKeymapClass { GObjectClass parent_class; + PangoDirection (* get_direction) (GdkKeymap *keymap); + gboolean (* have_bidi_layouts) (GdkKeymap *keymap); + gboolean (* get_caps_lock_state) (GdkKeymap *keymap); + gboolean (* get_num_lock_state) (GdkKeymap *keymap); + gboolean (* get_entries_for_keyval) (GdkKeymap *keymap, + guint keyval, + GdkKeymapKey **keys, + gint *n_keys); + gboolean (* get_entries_for_keycode) (GdkKeymap *keymap, + guint hardware_keycode, + GdkKeymapKey **keys, + guint **keyvals, + gint *n_entries); + guint (* lookup_key) (GdkKeymap *keymap, + const GdkKeymapKey *key); + gboolean (* translate_keyboard_state) (GdkKeymap *keymap, + guint hardware_keycode, + GdkModifierType state, + gint group, + guint *keyval, + gint *effective_group, + gint *level, + GdkModifierType *consumed_modifiers); + void (* add_virtual_modifiers) (GdkKeymap *keymap, + GdkModifierType *state); + gboolean (* map_virtual_modifiers) (GdkKeymap *keymap, + GdkModifierType *state); + + + /* Signals */ void (*direction_changed) (GdkKeymap *keymap); void (*keys_changed) (GdkKeymap *keymap); void (*state_changed) (GdkKeymap *keymap); diff --git a/gdk/gdkkeys.c b/gdk/gdkkeys.c index 09e8bda04c..c52a45e241 100644 --- a/gdk/gdkkeys.c +++ b/gdk/gdkkeys.c @@ -420,3 +420,284 @@ gdk_keymap_get_default (void) { return gdk_keymap_get_for_display (gdk_display_get_default ()); } + +/** + * gdk_keymap_get_direction: + * @keymap: a #GdkKeymap or %NULL to use the default keymap + * + * Returns the direction of effective layout of the keymap. + * + * Returns: %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL + * if it can determine the direction. %PANGO_DIRECTION_NEUTRAL + * otherwise. + **/ +PangoDirection +gdk_keymap_get_direction (GdkKeymap *keymap) +{ + return GDK_KEYMAP_GET_CLASS(keymap)->get_direction (keymap); +} + +/** + * gdk_keymap_have_bidi_layouts: + * @keymap: a #GdkKeymap or %NULL to use the default keymap + * + * Determines if keyboard layouts for both right-to-left and left-to-right + * languages are in use. + * + * Returns: %TRUE if there are layouts in both directions, %FALSE otherwise + * + * Since: 2.12 + **/ +gboolean +gdk_keymap_have_bidi_layouts (GdkKeymap *keymap) +{ + return GDK_KEYMAP_GET_CLASS(keymap)->have_bidi_layouts (keymap); +} + +/** + * gdk_keymap_get_caps_lock_state: + * @keymap: a #GdkKeymap + * + * Returns whether the Caps Lock modifer is locked. + * + * Returns: %TRUE if Caps Lock is on + * + * Since: 2.16 + */ +gboolean +gdk_keymap_get_caps_lock_state (GdkKeymap *keymap) +{ + return GDK_KEYMAP_GET_CLASS(keymap)->get_caps_lock_state (keymap); +} + +/** + * gdk_keymap_get_num_lock_state: + * @keymap: a #GdkKeymap + * + * Returns whether the Num Lock modifer is locked. + * + * Returns: %TRUE if Num Lock is on + * + * Since: 3.0 + */ +gboolean +gdk_keymap_get_num_lock_state (GdkKeymap *keymap) +{ + return GDK_KEYMAP_GET_CLASS(keymap)->get_num_lock_state (keymap); +} + +/** + * gdk_keymap_get_entries_for_keyval: + * @keymap: (allow-none): a #GdkKeymap, or %NULL to use the default keymap + * @keyval: a keyval, such as %GDK_a, %GDK_Up, %GDK_Return, etc. + * @keys: (out): return location for an array of #GdkKeymapKey + * @n_keys: (out): 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(). + * + * Return value: %TRUE if keys were found and returned + **/ +gboolean +gdk_keymap_get_entries_for_keyval (GdkKeymap *keymap, + guint keyval, + GdkKeymapKey **keys, + gint *n_keys) +{ + return GDK_KEYMAP_GET_CLASS(keymap)->get_entries_for_keyval (keymap, keyval, keys, n_keys); +} + +/** + * gdk_keymap_get_entries_for_keycode: + * @keymap: (allow-none): a #GdkKeymap or %NULL to use the default keymap + * @hardware_keycode: a keycode + * @keys: (out): return location for array of #GdkKeymapKey, or %NULL + * @keyvals: (out): return location for array of keyvals, or %NULL + * @n_entries: length of @keys and @keyvals + * + * Returns the keyvals bound to @hardware_keycode. + * The Nth #GdkKeymapKey in @keys is bound to the Nth + * keyval in @keyvals. Free the returned arrays with g_free(). + * 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. See gdk_keymap_translate_keyboard_state(). + * + * Returns: %TRUE if there were any entries + **/ +gboolean +gdk_keymap_get_entries_for_keycode (GdkKeymap *keymap, + guint hardware_keycode, + GdkKeymapKey **keys, + guint **keyvals, + gint *n_entries) +{ + return GDK_KEYMAP_GET_CLASS(keymap)->get_entries_for_keycode (keymap, hardware_keycode, keys, keyvals, n_entries); +} + +/** + * gdk_keymap_lookup_key: + * @keymap: a #GdkKeymap or %NULL to use the default keymap + * @key: a #GdkKeymapKey with keycode, group, and level initialized + * + * Looks up the keyval mapped to a keycode/group/level triplet. + * If no keyval is bound to @key, returns 0. For normal user input, + * you want to use gdk_keymap_translate_keyboard_state() instead of + * this function, since the effective group/level may not be + * the same as the current keyboard state. + * + * Return value: a keyval, or 0 if none was mapped to the given @key + **/ +guint +gdk_keymap_lookup_key (GdkKeymap *keymap, + const GdkKeymapKey *key) +{ + return GDK_KEYMAP_GET_CLASS(keymap)->lookup_key (keymap, key); +} + +/** + * gdk_keymap_translate_keyboard_state: + * @keymap: (allow-none): a #GdkKeymap, or %NULL to use the default + * @hardware_keycode: a keycode + * @state: a modifier state + * @group: active keyboard group + * @keyval: (out) (allow-none): return location for keyval, or %NULL + * @effective_group: (out) (allow-none): return location for effective group, or %NULL + * @level: (out) (allow-none): return location for level, or %NULL + * @consumed_modifiers: (out) (allow-none): return location for modifiers that were used to + * determine the group or level, or %NULL + * + * Translates the contents of a #GdkEventKey into a keyval, effective + * group, and level. Modifiers that affected the translation and + * are thus unavailable for application use are returned in + * @consumed_modifiers. See for an explanation of + * groups and levels. The @effective_group is the group that was + * actually used for the translation; some keys such as Enter are not + * affected by the active keyboard group. The @level is derived from + * @state. For convenience, #GdkEventKey already contains the translated + * keyval, so this function isn't as useful as you might think. + * + * + * @consumed_modifiers gives 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. + * + * + * /* We want to ignore irrelevant modifiers like ScrollLock */ + * #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK) + * gdk_keymap_translate_keyboard_state (keymap, event->hardware_keycode, + * event->state, event->group, + * &keyval, NULL, NULL, &consumed); + * if (keyval == GDK_PLUS && + * (event->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: + * + * /* XXX Don't do this XXX */ + * if (keyval == accel_keyval && + * (event->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, + * + * + * Return value: %TRUE if there was a keyval bound to the keycode/state/group + **/ +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) +{ + return GDK_KEYMAP_GET_CLASS(keymap)->translate_keyboard_state (keymap, + hardware_keycode, + state, + group, + keyval, + effective_group, + level, + consumed_modifiers); +} + +/** + * gdk_keymap_add_virtual_modifiers: + * @keymap: a #GdkKeymap + * @state: pointer to the modifier mask to change + * + * Adds virtual modifiers (i.e. Super, Hyper and Meta) which correspond + * to the real modifiers (i.e Mod2, Mod3, ...) in @modifiers. + * are set in @state to their non-virtual counterparts (i.e. Mod2, + * Mod3,...) 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. + * + * Since: 2.20 + */ +void +gdk_keymap_add_virtual_modifiers (GdkKeymap *keymap, + GdkModifierType *state) +{ + GDK_KEYMAP_GET_CLASS(keymap)->add_virtual_modifiers (keymap, state); +} + +/** + * gdk_keymap_map_virtual_modifiers: + * @keymap: a #GdkKeymap + * @state: 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: %TRUE if no 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. + * + * Since: 2.20 + */ +gboolean +gdk_keymap_map_virtual_modifiers (GdkKeymap *keymap, + GdkModifierType *state) +{ + return GDK_KEYMAP_GET_CLASS(keymap)->map_virtual_modifiers (keymap, state); +} diff --git a/gdk/x11/gdkkeys-x11.c b/gdk/x11/gdkkeys-x11.c index 1de8400fb3..1394b56cd7 100644 --- a/gdk/x11/gdkkeys-x11.c +++ b/gdk/x11/gdkkeys-x11.c @@ -138,16 +138,6 @@ gdk_keymap_x11_get_type (void) return object_type; } -static void -gdk_keymap_x11_class_init (GdkKeymapX11Class *klass) -{ - GObjectClass *object_class = G_OBJECT_CLASS (klass); - - parent_class = g_type_class_peek_parent (klass); - - object_class->finalize = gdk_keymap_x11_finalize; -} - static void gdk_keymap_x11_init (GdkKeymapX11 *keymap) { @@ -736,18 +726,8 @@ _gdk_keymap_keys_changed (GdkDisplay *display) g_signal_emit_by_name (display_x11->keymap, "keys_changed", 0); } -/** - * gdk_keymap_get_direction: - * @keymap: a #GdkKeymap or %NULL to use the default keymap - * - * Returns the direction of effective layout of the keymap. - * - * Returns: %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL - * if it can determine the direction. %PANGO_DIRECTION_NEUTRAL - * otherwise. - **/ -PangoDirection -gdk_keymap_get_direction (GdkKeymap *keymap) +static PangoDirection +gdk_x11_keymap_get_direction (GdkKeymap *keymap) { keymap = GET_EFFECTIVE_KEYMAP (keymap); @@ -773,19 +753,8 @@ gdk_keymap_get_direction (GdkKeymap *keymap) return PANGO_DIRECTION_NEUTRAL; } -/** - * gdk_keymap_have_bidi_layouts: - * @keymap: a #GdkKeymap or %NULL to use the default keymap - * - * Determines if keyboard layouts for both right-to-left and left-to-right - * languages are in use. - * - * Returns: %TRUE if there are layouts in both directions, %FALSE otherwise - * - * Since: 2.12 - **/ -gboolean -gdk_keymap_have_bidi_layouts (GdkKeymap *keymap) +static gboolean +gdk_x11_keymap_have_bidi_layouts (GdkKeymap *keymap) { keymap = GET_EFFECTIVE_KEYMAP (keymap); @@ -815,18 +784,8 @@ gdk_keymap_have_bidi_layouts (GdkKeymap *keymap) return FALSE; } -/** - * gdk_keymap_get_caps_lock_state: - * @keymap: a #GdkKeymap - * - * Returns whether the Caps Lock modifer is locked. - * - * Returns: %TRUE if Caps Lock is on - * - * Since: 2.16 - */ -gboolean -gdk_keymap_get_caps_lock_state (GdkKeymap *keymap) +static gboolean +gdk_x11_keymap_get_caps_lock_state (GdkKeymap *keymap) { GdkKeymapX11 *keymap_x11; @@ -837,18 +796,8 @@ gdk_keymap_get_caps_lock_state (GdkKeymap *keymap) return keymap_x11->caps_lock_state; } -/** - * gdk_keymap_get_num_lock_state: - * @keymap: a #GdkKeymap - * - * Returns whether the Num Lock modifer is locked. - * - * Returns: %TRUE if Num Lock is on - * - * Since: 3.0 - */ -gboolean -gdk_keymap_get_num_lock_state (GdkKeymap *keymap) +static gboolean +gdk_x11_keymap_get_num_lock_state (GdkKeymap *keymap) { GdkKeymapX11 *keymap_x11; @@ -859,32 +808,11 @@ gdk_keymap_get_num_lock_state (GdkKeymap *keymap) return keymap_x11->num_lock_state; } -/** - * gdk_keymap_get_entries_for_keyval: - * @keymap: (allow-none): a #GdkKeymap, or %NULL to use the default keymap - * @keyval: a keyval, such as %GDK_a, %GDK_Up, %GDK_Return, etc. - * @keys: (out): return location for an array of #GdkKeymapKey - * @n_keys: (out): 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(). - * - * Return value: %TRUE if keys were found and returned - **/ -gboolean -gdk_keymap_get_entries_for_keyval (GdkKeymap *keymap, - guint keyval, - GdkKeymapKey **keys, - gint *n_keys) +static gboolean +gdk_x11_keymap_get_entries_for_keyval (GdkKeymap *keymap, + guint keyval, + GdkKeymapKey **keys, + gint *n_keys) { GArray *retval; GdkKeymapX11 *keymap_x11; @@ -1009,29 +937,12 @@ gdk_keymap_get_entries_for_keyval (GdkKeymap *keymap, return *n_keys > 0; } -/** - * gdk_keymap_get_entries_for_keycode: - * @keymap: (allow-none): a #GdkKeymap or %NULL to use the default keymap - * @hardware_keycode: a keycode - * @keys: (out): return location for array of #GdkKeymapKey, or %NULL - * @keyvals: (out): return location for array of keyvals, or %NULL - * @n_entries: length of @keys and @keyvals - * - * Returns the keyvals bound to @hardware_keycode. - * The Nth #GdkKeymapKey in @keys is bound to the Nth - * keyval in @keyvals. Free the returned arrays with g_free(). - * 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. See gdk_keymap_translate_keyboard_state(). - * - * Returns: %TRUE if there were any entries - **/ -gboolean -gdk_keymap_get_entries_for_keycode (GdkKeymap *keymap, - guint hardware_keycode, - GdkKeymapKey **keys, - guint **keyvals, - gint *n_entries) +static gboolean +gdk_x11_keymap_get_entries_for_keycode (GdkKeymap *keymap, + guint hardware_keycode, + GdkKeymapKey **keys, + guint **keyvals, + gint *n_entries) { GdkKeymapX11 *keymap_x11; @@ -1168,23 +1079,9 @@ gdk_keymap_get_entries_for_keycode (GdkKeymap *keymap, return *n_entries > 0; } - -/** - * gdk_keymap_lookup_key: - * @keymap: a #GdkKeymap or %NULL to use the default keymap - * @key: a #GdkKeymapKey with keycode, group, and level initialized - * - * Looks up the keyval mapped to a keycode/group/level triplet. - * If no keyval is bound to @key, returns 0. For normal user input, - * you want to use gdk_keymap_translate_keyboard_state() instead of - * this function, since the effective group/level may not be - * the same as the current keyboard state. - * - * Return value: a keyval, or 0 if none was mapped to the given @key - **/ -guint -gdk_keymap_lookup_key (GdkKeymap *keymap, - const GdkKeymapKey *key) +static guint +gdk_x11_keymap_lookup_key (GdkKeymap *keymap, + const GdkKeymapKey *key) { GdkKeymapX11 *keymap_x11; @@ -1434,82 +1331,15 @@ translate_keysym (GdkKeymapX11 *keymap_x11, #undef SYM } -/** - * gdk_keymap_translate_keyboard_state: - * @keymap: (allow-none): a #GdkKeymap, or %NULL to use the default - * @hardware_keycode: a keycode - * @state: a modifier state - * @group: active keyboard group - * @keyval: (out) (allow-none): return location for keyval, or %NULL - * @effective_group: (out) (allow-none): return location for effective group, or %NULL - * @level: (out) (allow-none): return location for level, or %NULL - * @consumed_modifiers: (out) (allow-none): return location for modifiers that were used to - * determine the group or level, or %NULL - * - * Translates the contents of a #GdkEventKey into a keyval, effective - * group, and level. Modifiers that affected the translation and - * are thus unavailable for application use are returned in - * @consumed_modifiers. See for an explanation of - * groups and levels. The @effective_group is the group that was - * actually used for the translation; some keys such as Enter are not - * affected by the active keyboard group. The @level is derived from - * @state. For convenience, #GdkEventKey already contains the translated - * keyval, so this function isn't as useful as you might think. - * - * - * @consumed_modifiers gives 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. - * - * - * /* We want to ignore irrelevant modifiers like ScrollLock */ - * #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK) - * gdk_keymap_translate_keyboard_state (keymap, event->hardware_keycode, - * event->state, event->group, - * &keyval, NULL, NULL, &consumed); - * if (keyval == GDK_PLUS && - * (event->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: - * - * /* XXX Don't do this XXX */ - * if (keyval == accel_keyval && - * (event->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, - * - * - * Return value: %TRUE if there was a keyval bound to the keycode/state/group - **/ -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) +static gboolean +gdk_x11_keymap_translate_keyboard_state (GdkKeymap *keymap, + guint hardware_keycode, + GdkModifierType state, + gint group, + guint *keyval, + gint *effective_group, + gint *level, + GdkModifierType *consumed_modifiers) { GdkKeymapX11 *keymap_x11; KeySym tmp_keyval = NoSymbol; @@ -1720,27 +1550,8 @@ _gdk_keymap_add_virtual_modifiers_compat (GdkKeymap *keymap, } } -/** - * gdk_keymap_add_virtual_modifiers: - * @keymap: a #GdkKeymap - * @state: pointer to the modifier mask to change - * - * Adds virtual modifiers (i.e. Super, Hyper and Meta) which correspond - * to the real modifiers (i.e Mod2, Mod3, ...) in @modifiers. - * are set in @state to their non-virtual counterparts (i.e. Mod2, - * Mod3,...) 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. - * - * Since: 2.20 - */ -void -gdk_keymap_add_virtual_modifiers (GdkKeymap *keymap, +static void +gdk_x11_keymap_add_virtual_modifiers (GdkKeymap *keymap, GdkModifierType *state) { GdkKeymapX11 *keymap_x11; @@ -1800,28 +1611,9 @@ _gdk_keymap_key_is_modifier (GdkKeymap *keymap, return FALSE; } -/** - * gdk_keymap_map_virtual_modifiers: - * @keymap: a #GdkKeymap - * @state: 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: %TRUE if no 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. - * - * Since: 2.20 - */ -gboolean -gdk_keymap_map_virtual_modifiers (GdkKeymap *keymap, - GdkModifierType *state) +static gboolean +gdk_x11_keymap_map_virtual_modifiers (GdkKeymap *keymap, + GdkModifierType *state) { GdkKeymapX11 *keymap_x11; const guint vmods[] = { @@ -1857,3 +1649,25 @@ gdk_keymap_map_virtual_modifiers (GdkKeymap *keymap, return retval; } + +static void +gdk_keymap_x11_class_init (GdkKeymapX11Class *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GdkKeymapClass *keymap_class = GDK_KEYMAP_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = gdk_keymap_x11_finalize; + + keymap_class->get_direction = gdk_x11_keymap_get_direction; + keymap_class->have_bidi_layouts = gdk_x11_keymap_have_bidi_layouts; + keymap_class->get_caps_lock_state = gdk_x11_keymap_get_caps_lock_state; + keymap_class->get_num_lock_state = gdk_x11_keymap_get_num_lock_state; + keymap_class->get_entries_for_keyval = gdk_x11_keymap_get_entries_for_keyval; + 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; +}