GI.Gtk.Objects.EventControllerKey

EventControllerKey is an event controller meant for situations where you need access to key events.

This object was added in 3.24.

Exported types

newtype EventControllerKey

Memory-managed wrapper type.

Constructors

EventControllerKey (ManagedPtr EventControllerKey)

Instances

GObject EventControllerKey

Defined in GI.Gtk.Objects.EventControllerKey

Methods

gobjectType :: IO GType

HasParentTypes EventControllerKey

Defined in GI.Gtk.Objects.EventControllerKey

type ParentTypes EventControllerKey

Defined in GI.Gtk.Objects.EventControllerKey

type ParentTypes EventControllerKey = EventController ': (Object ': ([] :: [Type]))

class (GObject o, IsDescendantOf EventControllerKey o) => IsEventControllerKey o

Type class for types which can be safely cast to EventControllerKey, for instance with toEventControllerKey.

Instances

(GObject o, IsDescendantOf EventControllerKey o) => IsEventControllerKey o

Defined in GI.Gtk.Objects.EventControllerKey

toEventControllerKey :: (MonadIO m, IsEventControllerKey o) => o -> m EventControllerKey

Cast to EventControllerKey, for types for which this is known to be safe. For general casts, use castTo.

noEventControllerKey :: Maybe EventControllerKey

A convenience alias for Nothing :: Maybe EventControllerKey.

Methods

forward

eventControllerKeyForward :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsWidget b) => a -> b -> m Bool

No description available in the introspection data.

getGroup

eventControllerKeyGetGroup :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m Word32

No description available in the introspection data.

getImContext

eventControllerKeyGetImContext

Arguments

:: (HasCallStack, MonadIO m, IsEventControllerKey a)

=> a

controller: a EventControllerKey

-> m IMContext

Returns: the IM context

Gets the IM context of a key controller.

Since: 3.24

new

eventControllerKeyNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m EventControllerKey

No description available in the introspection data.

setImContext

eventControllerKeySetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsIMContext b) => a -> b -> m ()

No description available in the introspection data.

Signals

focusIn

type C_EventControllerKeyFocusInCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type EventControllerKeyFocusInCallback = IO ()

No description available in the introspection data.

afterEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId

Connect a signal handler for the “focus-in” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after eventControllerKey #focusIn callback

genClosure_EventControllerKeyFocusIn :: MonadIO m => EventControllerKeyFocusInCallback -> m (GClosure C_EventControllerKeyFocusInCallback)

Wrap the callback into a GClosure.

mk_EventControllerKeyFocusInCallback :: C_EventControllerKeyFocusInCallback -> IO (FunPtr C_EventControllerKeyFocusInCallback)

Generate a function pointer callable from C code, from a C_EventControllerKeyFocusInCallback.

noEventControllerKeyFocusInCallback :: Maybe EventControllerKeyFocusInCallback

A convenience synonym for Nothing :: Maybe EventControllerKeyFocusInCallback.

onEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId

Connect a signal handler for the “focus-in” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on eventControllerKey #focusIn callback

wrap_EventControllerKeyFocusInCallback :: EventControllerKeyFocusInCallback -> C_EventControllerKeyFocusInCallback

Wrap a EventControllerKeyFocusInCallback into a C_EventControllerKeyFocusInCallback.

focusOut

type C_EventControllerKeyFocusOutCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type EventControllerKeyFocusOutCallback = IO ()

No description available in the introspection data.

afterEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId

Connect a signal handler for the “focus-out” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after eventControllerKey #focusOut callback

genClosure_EventControllerKeyFocusOut :: MonadIO m => EventControllerKeyFocusOutCallback -> m (GClosure C_EventControllerKeyFocusOutCallback)

Wrap the callback into a GClosure.

mk_EventControllerKeyFocusOutCallback :: C_EventControllerKeyFocusOutCallback -> IO (FunPtr C_EventControllerKeyFocusOutCallback)

Generate a function pointer callable from C code, from a C_EventControllerKeyFocusOutCallback.

noEventControllerKeyFocusOutCallback :: Maybe EventControllerKeyFocusOutCallback

A convenience synonym for Nothing :: Maybe EventControllerKeyFocusOutCallback.

onEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId

Connect a signal handler for the “focus-out” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on eventControllerKey #focusOut callback

wrap_EventControllerKeyFocusOutCallback :: EventControllerKeyFocusOutCallback -> C_EventControllerKeyFocusOutCallback

Wrap a EventControllerKeyFocusOutCallback into a C_EventControllerKeyFocusOutCallback.

imUpdate

type C_EventControllerKeyImUpdateCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type EventControllerKeyImUpdateCallback = IO ()

No description available in the introspection data.

afterEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId

Connect a signal handler for the “im-update” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after eventControllerKey #imUpdate callback

genClosure_EventControllerKeyImUpdate :: MonadIO m => EventControllerKeyImUpdateCallback -> m (GClosure C_EventControllerKeyImUpdateCallback)

Wrap the callback into a GClosure.

mk_EventControllerKeyImUpdateCallback :: C_EventControllerKeyImUpdateCallback -> IO (FunPtr C_EventControllerKeyImUpdateCallback)

Generate a function pointer callable from C code, from a C_EventControllerKeyImUpdateCallback.

noEventControllerKeyImUpdateCallback :: Maybe EventControllerKeyImUpdateCallback

A convenience synonym for Nothing :: Maybe EventControllerKeyImUpdateCallback.

onEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId

Connect a signal handler for the “im-update” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on eventControllerKey #imUpdate callback

wrap_EventControllerKeyImUpdateCallback :: EventControllerKeyImUpdateCallback -> C_EventControllerKeyImUpdateCallback

Wrap a EventControllerKeyImUpdateCallback into a C_EventControllerKeyImUpdateCallback.

keyPressed

type C_EventControllerKeyKeyPressedCallback = Ptr () -> Word32 -> Word32 -> CUInt -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type EventControllerKeyKeyPressedCallback

Arguments

 = Word32

keyval: the pressed key.

-> Word32

keycode: the raw code of the pressed key.

-> [ModifierType]

state: the bitmask, representing the state of modifier keys and pointer buttons. See ModifierType.

-> IO Bool

Returns: True if the key press was handled, False otherwise.

This signal is emitted whenever a key is pressed.

Since: 3.24

afterEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId

Connect a signal handler for the “key-pressed” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after eventControllerKey #keyPressed callback

genClosure_EventControllerKeyKeyPressed :: MonadIO m => EventControllerKeyKeyPressedCallback -> m (GClosure C_EventControllerKeyKeyPressedCallback)

Wrap the callback into a GClosure.

mk_EventControllerKeyKeyPressedCallback :: C_EventControllerKeyKeyPressedCallback -> IO (FunPtr C_EventControllerKeyKeyPressedCallback)

Generate a function pointer callable from C code, from a C_EventControllerKeyKeyPressedCallback.

noEventControllerKeyKeyPressedCallback :: Maybe EventControllerKeyKeyPressedCallback

A convenience synonym for Nothing :: Maybe EventControllerKeyKeyPressedCallback.

onEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId

Connect a signal handler for the “key-pressed” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on eventControllerKey #keyPressed callback

wrap_EventControllerKeyKeyPressedCallback :: EventControllerKeyKeyPressedCallback -> C_EventControllerKeyKeyPressedCallback

Wrap a EventControllerKeyKeyPressedCallback into a C_EventControllerKeyKeyPressedCallback.

keyReleased

type C_EventControllerKeyKeyReleasedCallback = Ptr () -> Word32 -> Word32 -> CUInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type EventControllerKeyKeyReleasedCallback

Arguments

 = Word32

keyval: the released key.

-> Word32

keycode: the raw code of the released key.

-> [ModifierType]

state: the bitmask, representing the state of modifier keys and pointer buttons. See ModifierType.

-> IO ()

This signal is emitted whenever a key is released.

Since: 3.24

afterEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId

Connect a signal handler for the “key-released” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after eventControllerKey #keyReleased callback

genClosure_EventControllerKeyKeyReleased :: MonadIO m => EventControllerKeyKeyReleasedCallback -> m (GClosure C_EventControllerKeyKeyReleasedCallback)

Wrap the callback into a GClosure.

mk_EventControllerKeyKeyReleasedCallback :: C_EventControllerKeyKeyReleasedCallback -> IO (FunPtr C_EventControllerKeyKeyReleasedCallback)

Generate a function pointer callable from C code, from a C_EventControllerKeyKeyReleasedCallback.

noEventControllerKeyKeyReleasedCallback :: Maybe EventControllerKeyKeyReleasedCallback

A convenience synonym for Nothing :: Maybe EventControllerKeyKeyReleasedCallback.

onEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId

Connect a signal handler for the “key-released” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on eventControllerKey #keyReleased callback

wrap_EventControllerKeyKeyReleasedCallback :: EventControllerKeyKeyReleasedCallback -> C_EventControllerKeyKeyReleasedCallback

Wrap a EventControllerKeyKeyReleasedCallback into a C_EventControllerKeyKeyReleasedCallback.

modifiers

type C_EventControllerKeyModifiersCallback = Ptr () -> CUInt -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type EventControllerKeyModifiersCallback = [ModifierType] -> IO Bool

No description available in the introspection data.

afterEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId

Connect a signal handler for the “modifiers” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after eventControllerKey #modifiers callback

genClosure_EventControllerKeyModifiers :: MonadIO m => EventControllerKeyModifiersCallback -> m (GClosure C_EventControllerKeyModifiersCallback)

Wrap the callback into a GClosure.

mk_EventControllerKeyModifiersCallback :: C_EventControllerKeyModifiersCallback -> IO (FunPtr C_EventControllerKeyModifiersCallback)

Generate a function pointer callable from C code, from a C_EventControllerKeyModifiersCallback.

noEventControllerKeyModifiersCallback :: Maybe EventControllerKeyModifiersCallback

A convenience synonym for Nothing :: Maybe EventControllerKeyModifiersCallback.

onEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId

Connect a signal handler for the “modifiers” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on eventControllerKey #modifiers callback

wrap_EventControllerKeyModifiersCallback :: EventControllerKeyModifiersCallback -> C_EventControllerKeyModifiersCallback

Wrap a EventControllerKeyModifiersCallback into a C_EventControllerKeyModifiersCallback.