Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria |
Safe Haskell | None |
Language | Haskell2010 |
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.
Synopsis
- newtype Keymap = Keymap (ManagedPtr Keymap)
- class (GObject o, IsDescendantOf Keymap o) => IsKeymap o
- toKeymap :: (MonadIO m, IsKeymap o) => o -> m Keymap
- noKeymap :: Maybe Keymap
- keymapAddVirtualModifiers :: (HasCallStack, MonadIO m, IsKeymap a) => a -> [ModifierType] -> m [ModifierType]
- keymapGetCapsLockState :: (HasCallStack, MonadIO m, IsKeymap a) => a -> m Bool
- keymapGetDirection :: (HasCallStack, MonadIO m, IsKeymap a) => a -> m Direction
- keymapGetDisplay :: (HasCallStack, MonadIO m, IsKeymap a) => a -> m Display
- keymapGetEntriesForKeycode :: (HasCallStack, MonadIO m, IsKeymap a) => a -> Word32 -> m (Bool, [KeymapKey], [Word32])
- keymapGetEntriesForKeyval :: (HasCallStack, MonadIO m, IsKeymap a) => a -> Word32 -> m (Bool, [KeymapKey])
- keymapGetModifierMask :: (HasCallStack, MonadIO m, IsKeymap a) => a -> ModifierIntent -> m [ModifierType]
- keymapGetModifierState :: (HasCallStack, MonadIO m, IsKeymap a) => a -> m Word32
- keymapGetNumLockState :: (HasCallStack, MonadIO m, IsKeymap a) => a -> m Bool
- keymapGetScrollLockState :: (HasCallStack, MonadIO m, IsKeymap a) => a -> m Bool
- keymapHaveBidiLayouts :: (HasCallStack, MonadIO m, IsKeymap a) => a -> m Bool
- keymapLookupKey :: (HasCallStack, MonadIO m, IsKeymap a) => a -> KeymapKey -> m Word32
- keymapMapVirtualModifiers :: (HasCallStack, MonadIO m, IsKeymap a) => a -> [ModifierType] -> m (Bool, [ModifierType])
- keymapTranslateKeyboardState :: (HasCallStack, MonadIO m, IsKeymap a) => a -> Word32 -> [ModifierType] -> Int32 -> m (Bool, Word32, Int32, Int32, [ModifierType])
- constructKeymapDisplay :: (IsKeymap o, IsDisplay a) => a -> IO (GValueConstruct o)
- getKeymapDisplay :: (MonadIO m, IsKeymap o) => o -> m Display
- type C_KeymapDirectionChangedCallback = Ptr () -> Ptr () -> IO ()
- type KeymapDirectionChangedCallback = IO ()
- afterKeymapDirectionChanged :: (IsKeymap a, MonadIO m) => a -> KeymapDirectionChangedCallback -> m SignalHandlerId
- genClosure_KeymapDirectionChanged :: MonadIO m => KeymapDirectionChangedCallback -> m (GClosure C_KeymapDirectionChangedCallback)
- mk_KeymapDirectionChangedCallback :: C_KeymapDirectionChangedCallback -> IO (FunPtr C_KeymapDirectionChangedCallback)
- noKeymapDirectionChangedCallback :: Maybe KeymapDirectionChangedCallback
- onKeymapDirectionChanged :: (IsKeymap a, MonadIO m) => a -> KeymapDirectionChangedCallback -> m SignalHandlerId
- wrap_KeymapDirectionChangedCallback :: KeymapDirectionChangedCallback -> C_KeymapDirectionChangedCallback
- type C_KeymapKeysChangedCallback = Ptr () -> Ptr () -> IO ()
- type KeymapKeysChangedCallback = IO ()
- afterKeymapKeysChanged :: (IsKeymap a, MonadIO m) => a -> KeymapKeysChangedCallback -> m SignalHandlerId
- genClosure_KeymapKeysChanged :: MonadIO m => KeymapKeysChangedCallback -> m (GClosure C_KeymapKeysChangedCallback)
- mk_KeymapKeysChangedCallback :: C_KeymapKeysChangedCallback -> IO (FunPtr C_KeymapKeysChangedCallback)
- noKeymapKeysChangedCallback :: Maybe KeymapKeysChangedCallback
- onKeymapKeysChanged :: (IsKeymap a, MonadIO m) => a -> KeymapKeysChangedCallback -> m SignalHandlerId
- wrap_KeymapKeysChangedCallback :: KeymapKeysChangedCallback -> C_KeymapKeysChangedCallback
- type C_KeymapStateChangedCallback = Ptr () -> Ptr () -> IO ()
- type KeymapStateChangedCallback = IO ()
- afterKeymapStateChanged :: (IsKeymap a, MonadIO m) => a -> KeymapStateChangedCallback -> m SignalHandlerId
- genClosure_KeymapStateChanged :: MonadIO m => KeymapStateChangedCallback -> m (GClosure C_KeymapStateChangedCallback)
- mk_KeymapStateChangedCallback :: C_KeymapStateChangedCallback -> IO (FunPtr C_KeymapStateChangedCallback)
- noKeymapStateChangedCallback :: Maybe KeymapStateChangedCallback
- onKeymapStateChanged :: (IsKeymap a, MonadIO m) => a -> KeymapStateChangedCallback -> m SignalHandlerId
- wrap_KeymapStateChangedCallback :: KeymapStateChangedCallback -> C_KeymapStateChangedCallback
Exported types
Memory-managed wrapper type.
Instances
Eq Keymap Source # | |
GObject Keymap Source # | |
Defined in GI.Gdk.Objects.Keymap gobjectType :: IO GType # | |
IsGValue Keymap Source # | Convert |
HasParentTypes Keymap Source # | |
Defined in GI.Gdk.Objects.Keymap | |
type ParentTypes Keymap Source # | |
Defined in GI.Gdk.Objects.Keymap |
class (GObject o, IsDescendantOf Keymap o) => IsKeymap o Source #
Instances
(GObject o, IsDescendantOf Keymap o) => IsKeymap o Source # | |
Defined in GI.Gdk.Objects.Keymap |
Methods
Overloaded methods
addVirtualModifiers
keymapAddVirtualModifiers Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> [ModifierType] |
|
-> m [ModifierType] |
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.
getCapsLockState
keymapGetCapsLockState Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> m Bool | Returns: |
Returns whether the Caps Lock modifer is locked.
getDirection
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> m Direction | Returns: |
Returns the direction of effective layout of the keymap.
The direction of a layout is the direction of the majority of its
symbols. See unicharDirection
.
getDisplay
Retrieves the Display
associated to the keymap
.
getEntriesForKeycode
keymapGetEntriesForKeycode Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> Word32 |
|
-> m (Bool, [KeymapKey], [Word32]) | Returns: |
Returns the keyvals bound to hardwareKeycode
.
The Nth KeymapKey
in keys
is bound to the Nth
keyval in keyvals
. Free the returned arrays with 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 keymapTranslateKeyboardState
.
getEntriesForKeyval
keymapGetEntriesForKeyval Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> Word32 |
|
-> m (Bool, [KeymapKey]) | Returns: |
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 free
.
getModifierMask
keymapGetModifierMask Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> ModifierIntent |
|
-> m [ModifierType] | Returns: the modifier mask used for |
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 keymapAddVirtualModifiers
in order to contain the
expected result.
getModifierState
keymapGetModifierState Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> m Word32 | Returns: the current modifier state. |
Returns the current modifier state.
getNumLockState
keymapGetNumLockState Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> m Bool | Returns: |
Returns whether the Num Lock modifer is locked.
getScrollLockState
keymapGetScrollLockState Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> m Bool | Returns: |
Returns whether the Scroll Lock modifer is locked.
haveBidiLayouts
keymapHaveBidiLayouts Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> m Bool | Returns: |
Determines if keyboard layouts for both right-to-left and left-to-right languages are in use.
lookupKey
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> KeymapKey |
|
-> m Word32 | Returns: a keyval, or 0 if none was mapped to the given |
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 keymapTranslateKeyboardState
instead of
this function, since the effective group/level may not be
the same as the current keyboard state.
mapVirtualModifiers
keymapMapVirtualModifiers Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> [ModifierType] |
|
-> m (Bool, [ModifierType]) | Returns: |
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.
translateKeyboardState
keymapTranslateKeyboardState Source #
:: (HasCallStack, MonadIO m, IsKeymap a) | |
=> a |
|
-> Word32 |
|
-> [ModifierType] |
|
-> Int32 |
|
-> m (Bool, Word32, Int32, Int32, [ModifierType]) | Returns: |
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
consumedModifiers
.
See [Groups][key-group-explanation] for an explanation of
groups and levels. The effectiveGroup
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.
consumedModifiers
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 <Shift>
should be masked out.
C code
// 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 consumedModifiers
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:
C code
// 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 consumedModifiers
; 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
,
Properties
display
No description available in the introspection data.
constructKeymapDisplay :: (IsKeymap o, IsDisplay a) => a -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “display
” property. This is rarely needed directly, but it is used by new
.
getKeymapDisplay :: (MonadIO m, IsKeymap o) => o -> m Display Source #
Get the value of the “display
” property.
When overloading is enabled, this is equivalent to
get
keymap #display
Signals
directionChanged
type C_KeymapDirectionChangedCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type KeymapDirectionChangedCallback = IO () Source #
The directionChanged signal gets emitted when the direction
of the keymap changes. See keymapGetDirection
.
afterKeymapDirectionChanged :: (IsKeymap a, MonadIO m) => a -> KeymapDirectionChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the directionChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to
after
keymap #directionChanged callback
genClosure_KeymapDirectionChanged :: MonadIO m => KeymapDirectionChangedCallback -> m (GClosure C_KeymapDirectionChangedCallback) Source #
Wrap the callback into a GClosure
.
mk_KeymapDirectionChangedCallback :: C_KeymapDirectionChangedCallback -> IO (FunPtr C_KeymapDirectionChangedCallback) Source #
Generate a function pointer callable from C code, from a C_KeymapDirectionChangedCallback
.
noKeymapDirectionChangedCallback :: Maybe KeymapDirectionChangedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
KeymapDirectionChangedCallback
onKeymapDirectionChanged :: (IsKeymap a, MonadIO m) => a -> KeymapDirectionChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the directionChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to
on
keymap #directionChanged callback
wrap_KeymapDirectionChangedCallback :: KeymapDirectionChangedCallback -> C_KeymapDirectionChangedCallback Source #
Wrap a KeymapDirectionChangedCallback
into a C_KeymapDirectionChangedCallback
.
keysChanged
type C_KeymapKeysChangedCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type KeymapKeysChangedCallback = IO () Source #
The keysChanged signal is emitted when the mapping represented by
keymap
changes.
afterKeymapKeysChanged :: (IsKeymap a, MonadIO m) => a -> KeymapKeysChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the keysChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to
after
keymap #keysChanged callback
genClosure_KeymapKeysChanged :: MonadIO m => KeymapKeysChangedCallback -> m (GClosure C_KeymapKeysChangedCallback) Source #
Wrap the callback into a GClosure
.
mk_KeymapKeysChangedCallback :: C_KeymapKeysChangedCallback -> IO (FunPtr C_KeymapKeysChangedCallback) Source #
Generate a function pointer callable from C code, from a C_KeymapKeysChangedCallback
.
noKeymapKeysChangedCallback :: Maybe KeymapKeysChangedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
KeymapKeysChangedCallback
onKeymapKeysChanged :: (IsKeymap a, MonadIO m) => a -> KeymapKeysChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the keysChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to
on
keymap #keysChanged callback
wrap_KeymapKeysChangedCallback :: KeymapKeysChangedCallback -> C_KeymapKeysChangedCallback Source #
Wrap a KeymapKeysChangedCallback
into a C_KeymapKeysChangedCallback
.
stateChanged
type C_KeymapStateChangedCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type KeymapStateChangedCallback = IO () Source #
The stateChanged signal is emitted when the state of the
keyboard changes, e.g when Caps Lock is turned on or off.
See keymapGetCapsLockState
.
afterKeymapStateChanged :: (IsKeymap a, MonadIO m) => a -> KeymapStateChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the stateChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to
after
keymap #stateChanged callback
genClosure_KeymapStateChanged :: MonadIO m => KeymapStateChangedCallback -> m (GClosure C_KeymapStateChangedCallback) Source #
Wrap the callback into a GClosure
.
mk_KeymapStateChangedCallback :: C_KeymapStateChangedCallback -> IO (FunPtr C_KeymapStateChangedCallback) Source #
Generate a function pointer callable from C code, from a C_KeymapStateChangedCallback
.
noKeymapStateChangedCallback :: Maybe KeymapStateChangedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
KeymapStateChangedCallback
onKeymapStateChanged :: (IsKeymap a, MonadIO m) => a -> KeymapStateChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the stateChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to
on
keymap #stateChanged callback