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

Eq EventControllerKey

Defined in GI.Gtk.Objects.EventControllerKey

Methods

(==) :: EventControllerKey -> EventControllerKey -> Bool

(/=) :: EventControllerKey -> EventControllerKey -> Bool

GObject EventControllerKey

Defined in GI.Gtk.Objects.EventControllerKey

ManagedPtrNewtype EventControllerKey

Defined in GI.Gtk.Objects.EventControllerKey

Methods

toManagedPtr :: EventControllerKey -> ManagedPtr EventControllerKey

TypedObject EventControllerKey

Defined in GI.Gtk.Objects.EventControllerKey

Methods

glibType :: IO GType

HasParentTypes EventControllerKey

Defined in GI.Gtk.Objects.EventControllerKey

IsGValue (Maybe EventControllerKey)

Convert EventControllerKey to and from GValue. See toGValue and fromGValue.

Defined in GI.Gtk.Objects.EventControllerKey

Methods

gvalueGType_ :: IO GType

gvalueSet_ :: Ptr GValue -> Maybe EventControllerKey -> IO ()

gvalueGet_ :: Ptr GValue -> IO (Maybe EventControllerKey)

type ParentTypes EventControllerKey

Defined in GI.Gtk.Objects.EventControllerKey

type ParentTypes EventControllerKey = '[EventController, Object]

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.

Methods

Click to display all available methods, including inherited ones

Methods

bindProperty, bindPropertyFull, forceFloating, forward, freezeNotify, getv, handleEvent, isFloating, notify, notifyByPspec, ref, refSink, reset, runDispose, stealData, stealQdata, thawNotify, unref, watchClosure.

Getters

getData, getGroup, getImContext, getPropagationPhase, getProperty, getQdata, getWidget.

Setters

setData, setDataFull, setImContext, setPropagationPhase, setProperty.

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 focusIn 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 focusIn 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 focusOut 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 focusOut 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 imUpdate 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 imUpdate 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 keyPressed 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 keyPressed 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 keyReleased 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 keyReleased 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.