Struct gdk::Keymap [−][src]
pub struct Keymap(_);
Expand description
A Keymap 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.
Implementations
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.
Returns the modifier mask the self’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 ModifierType::MOD1_MASK rather than
ModifierType::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 add_virtual_modifiers() in order to contain the
expected result.
intent
the use case for the modifier mask
Returns
the modifier mask used for intent.
pub fn translate_keyboard_state(
&self,
hardware_keycode: u32,
state: ModifierType,
group: i32
) -> Option<(u32, i32, i32, ModifierType)>
pub fn translate_keyboard_state(
&self,
hardware_keycode: u32,
state: ModifierType,
group: i32
) -> Option<(u32, i32, i32, ModifierType)>Translates the contents of a EventKey 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 [Groups][key-group-explanation] 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, EventKey already contains the translated
keyval, so this function isn’t as useful as you might think.
consumed_modifiers gives modifiers that should be masked outfrom 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
⚠️ The following code is in C ⚠️
// 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:
⚠️ The following code is in C ⚠️
// 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>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. Storeplus, not <Control>plus,
hardware_keycode
a keycode
state
a modifier state
group
active keyboard group
Returns
true if there was a keyval bound to the keycode/state/group
keyval
return location for keyval, or None
effective_group
return location for effective
group, or None
level
return location for level, or None
consumed_modifiers
return location for modifiers
that were used to determine the group or level, or None
Returns the Keymap attached to the default display.
Deprecated since 3.22
Use for_display() instead
Returns
the Keymap attached to the default display.
The ::direction-changed signal gets emitted when the direction of the keymap changes.
The ::keys-changed signal is emitted when the mapping represented by
keymap changes.
The ::state-changed signal is emitted when the state of the
keyboard changes, e.g when Caps Lock is turned on or off.
See is_caps_locked().
Returns the keyvals bound to hardware_keycode.
The Nth KeymapKey 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 translate_keyboard_state().
hardware_keycode
a keycode
Returns
true if there were any entries
keys
return
location for array of KeymapKey, or None
keyvals
return
location for array of keyvals, or None
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.
EventKey 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().
keyval
a keyval, such as GDK_KEY_a, GDK_KEY_Up, GDK_KEY_Return, etc.
Returns
true if keys were found and returned
keys
return location
for an array of KeymapKey
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.
state
pointer to the modifier mask to change
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.
state
pointer to the modifier state to map
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.
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 translate_keyboard_state() instead of
this function, since the effective group/level may not be
the same as the current keyboard state.
key
a KeymapKey with keycode, group, and level initialized
Returns
a keyval, or 0 if none was mapped to the given key
Trait Implementations
This method returns an ordering between self and other values if one exists. Read more
This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <=
operator. Read more
This method tests greater than (for self and other) and is used by the > operator. Read more
Returns the type identifier of Self.
Auto Trait Implementations
impl RefUnwindSafe for Keymapimpl UnwindSafe for KeymapBlanket Implementations
Mutably borrows from an owned value. Read more
Upcasts an object to a superclass or interface T. Read more
Upcasts an object to a reference of its superclass or interface T. Read more
Tries to downcast to a subclass or interface implementor T. Read more
Tries to downcast to a reference of its subclass or interface implementor T. Read more
Tries to cast to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Tries to cast to reference to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Casts to T unconditionally. Read more
Casts to &T unconditionally. Read more
Returns true if the object is an instance of (can be cast to) T.
pub fn set_properties_from_value(
&self,
property_values: &[(&str, Value)]
) -> Result<(), BoolError>pub fn set_property<'a, N, V>(
&self,
property_name: N,
value: V
) -> Result<(), BoolError> where
N: Into<&'a str>,
V: ToValue, pub fn set_property_from_value<'a, N>(
&self,
property_name: N,
value: &Value
) -> Result<(), BoolError> where
N: Into<&'a str>, Safety Read more
Safety Read more
Safety Read more
Safety Read more
pub fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec) + Send + Sync, pub fn connect_notify_local<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec), pub unsafe fn connect_notify_unsafe<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec), pub fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>, pub fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>, pub fn connect<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
N: Into<&'a str>, Same as connect but takes a SignalId instead of a signal name.
pub fn connect_local<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + 'static,
N: Into<&'a str>, Same as connect_local but takes a SignalId instead of a signal name.
pub unsafe fn connect_unsafe<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value>,
N: Into<&'a str>, Same as connect_unsafe but takes a SignalId instead of a signal name.
Emit signal by signal id.
Emit signal with details by signal id.
Emit signal by it’s name.
pub fn bind_property<'a, O, N, M>(
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
O: ObjectType,
M: Into<&'a str>,
N: Into<&'a str>, Same as emit but takes Value for the arguments.
Same as emit_by_name but takes Value for the arguments.
Returns a SendValue clone of self.
impl<'a, T, C> FromValueOptional<'a> for T where
C: ValueTypeChecker<Error = ValueTypeMismatchOrNoneError>,
T: FromValue<'a, Checker = C>,