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

GI.Gtk.Objects.EventControllerKey

Contents

Exported types
Methods
Properties
- containsFocus
- isFocus
Signals

Description

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

Synopsis

newtype EventControllerKey = EventControllerKey (ManagedPtr EventControllerKey)
class (GObject o, IsDescendantOf EventControllerKey o) => IsEventControllerKey o
toEventControllerKey :: (MonadIO m, IsEventControllerKey o) => o -> m EventControllerKey
noEventControllerKey :: Maybe EventControllerKey
eventControllerKeyForward :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsWidget b) => a -> b -> m Bool
eventControllerKeyGetFocusOrigin :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m Widget
eventControllerKeyGetFocusTarget :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m Widget
eventControllerKeyGetGroup :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m Word32
eventControllerKeyGetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m IMContext
eventControllerKeyNew :: (HasCallStack, MonadIO m) => m EventControllerKey
eventControllerKeySetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsIMContext b) => a -> b -> m ()
getEventControllerKeyContainsFocus :: (MonadIO m, IsEventControllerKey o) => o -> m Bool
getEventControllerKeyIsFocus :: (MonadIO m, IsEventControllerKey o) => o -> m Bool
type C_EventControllerKeyFocusInCallback = Ptr () -> CUInt -> CUInt -> Ptr () -> IO ()
type EventControllerKeyFocusInCallback = CrossingMode -> NotifyType -> IO ()
afterEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
genClosure_EventControllerKeyFocusIn :: MonadIO m => EventControllerKeyFocusInCallback -> m (GClosure C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyFocusInCallback :: C_EventControllerKeyFocusInCallback -> IO (FunPtr C_EventControllerKeyFocusInCallback)
noEventControllerKeyFocusInCallback :: Maybe EventControllerKeyFocusInCallback
onEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
wrap_EventControllerKeyFocusInCallback :: EventControllerKeyFocusInCallback -> C_EventControllerKeyFocusInCallback
type C_EventControllerKeyFocusOutCallback = Ptr () -> CUInt -> CUInt -> Ptr () -> IO ()
type EventControllerKeyFocusOutCallback = CrossingMode -> NotifyType -> IO ()
afterEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId
genClosure_EventControllerKeyFocusOut :: MonadIO m => EventControllerKeyFocusOutCallback -> m (GClosure C_EventControllerKeyFocusOutCallback)
mk_EventControllerKeyFocusOutCallback :: C_EventControllerKeyFocusOutCallback -> IO (FunPtr C_EventControllerKeyFocusOutCallback)
noEventControllerKeyFocusOutCallback :: Maybe EventControllerKeyFocusOutCallback
onEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId
wrap_EventControllerKeyFocusOutCallback :: EventControllerKeyFocusOutCallback -> C_EventControllerKeyFocusOutCallback
type C_EventControllerKeyImUpdateCallback = Ptr () -> Ptr () -> IO ()
type EventControllerKeyImUpdateCallback = IO ()
afterEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId
genClosure_EventControllerKeyImUpdate :: MonadIO m => EventControllerKeyImUpdateCallback -> m (GClosure C_EventControllerKeyImUpdateCallback)
mk_EventControllerKeyImUpdateCallback :: C_EventControllerKeyImUpdateCallback -> IO (FunPtr C_EventControllerKeyImUpdateCallback)
noEventControllerKeyImUpdateCallback :: Maybe EventControllerKeyImUpdateCallback
onEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId
wrap_EventControllerKeyImUpdateCallback :: EventControllerKeyImUpdateCallback -> C_EventControllerKeyImUpdateCallback
type C_EventControllerKeyKeyPressedCallback = Ptr () -> Word32 -> Word32 -> CUInt -> Ptr () -> IO CInt
type EventControllerKeyKeyPressedCallback = Word32 -> Word32 -> [ModifierType] -> IO Bool
afterEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
genClosure_EventControllerKeyKeyPressed :: MonadIO m => EventControllerKeyKeyPressedCallback -> m (GClosure C_EventControllerKeyKeyPressedCallback)
mk_EventControllerKeyKeyPressedCallback :: C_EventControllerKeyKeyPressedCallback -> IO (FunPtr C_EventControllerKeyKeyPressedCallback)
noEventControllerKeyKeyPressedCallback :: Maybe EventControllerKeyKeyPressedCallback
onEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
wrap_EventControllerKeyKeyPressedCallback :: EventControllerKeyKeyPressedCallback -> C_EventControllerKeyKeyPressedCallback
type C_EventControllerKeyKeyReleasedCallback = Ptr () -> Word32 -> Word32 -> CUInt -> Ptr () -> IO ()
type EventControllerKeyKeyReleasedCallback = Word32 -> Word32 -> [ModifierType] -> IO ()
afterEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
genClosure_EventControllerKeyKeyReleased :: MonadIO m => EventControllerKeyKeyReleasedCallback -> m (GClosure C_EventControllerKeyKeyReleasedCallback)
mk_EventControllerKeyKeyReleasedCallback :: C_EventControllerKeyKeyReleasedCallback -> IO (FunPtr C_EventControllerKeyKeyReleasedCallback)
noEventControllerKeyKeyReleasedCallback :: Maybe EventControllerKeyKeyReleasedCallback
onEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
wrap_EventControllerKeyKeyReleasedCallback :: EventControllerKeyKeyReleasedCallback -> C_EventControllerKeyKeyReleasedCallback
type C_EventControllerKeyModifiersCallback = Ptr () -> CUInt -> Ptr () -> IO CInt
type EventControllerKeyModifiersCallback = [ModifierType] -> IO Bool
afterEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
genClosure_EventControllerKeyModifiers :: MonadIO m => EventControllerKeyModifiersCallback -> m (GClosure C_EventControllerKeyModifiersCallback)
mk_EventControllerKeyModifiersCallback :: C_EventControllerKeyModifiersCallback -> IO (FunPtr C_EventControllerKeyModifiersCallback)
noEventControllerKeyModifiersCallback :: Maybe EventControllerKeyModifiersCallback
onEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
wrap_EventControllerKeyModifiersCallback :: EventControllerKeyModifiersCallback -> C_EventControllerKeyModifiersCallback

Exported types

newtype EventControllerKey Source #

Memory-managed wrapper type.

Constructors

EventControllerKey (ManagedPtr EventControllerKey)

Instances

Instances details

Eq EventControllerKey Source #
Instance details Defined in GI.Gtk.Objects.EventControllerKey Methods (==) :: EventControllerKey -> EventControllerKey -> Bool # (/=) :: EventControllerKey -> EventControllerKey -> Bool #
IsGValue EventControllerKey Source #	Convert `EventControllerKey` to and from `GValue` with `toGValue` and `fromGValue`.
Instance details Defined in GI.Gtk.Objects.EventControllerKey Methods toGValue :: EventControllerKey -> IO GValue # fromGValue :: GValue -> IO EventControllerKey #
GObject EventControllerKey Source #
Instance details Defined in GI.Gtk.Objects.EventControllerKey Methods gobjectType :: IO GType #
HasParentTypes EventControllerKey Source #
Instance details Defined in GI.Gtk.Objects.EventControllerKey
type ParentTypes EventControllerKey Source #
Instance details Defined in GI.Gtk.Objects.EventControllerKey type ParentTypes EventControllerKey = '[EventController, Object]

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

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

Instances

Instances details

(GObject o, IsDescendantOf EventControllerKey o) => IsEventControllerKey o Source #
Instance details Defined in GI.Gtk.Objects.EventControllerKey

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

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

noEventControllerKey :: Maybe EventControllerKey Source #

A convenience alias for Nothing :: Maybe EventControllerKey.

Methods

Overloaded methods

forward

eventControllerKeyForward Source #

Arguments

:: (HasCallStack, MonadIO m, IsEventControllerKey a, IsWidget b)
=> a	`controller`: a `EventControllerKey`
-> b	`widget`: a `Widget`
-> m Bool	Returns: whether the `widget` handled the event

Forwards the current event of this controller to a widget.

This function can only be used in handlers for the keyPressed, keyReleased or modifiers signals.

getFocusOrigin

eventControllerKeyGetFocusOrigin Source #

Arguments

:: (HasCallStack, MonadIO m, IsEventControllerKey a)
=> a	`controller`: a `EventControllerKey`
-> m Widget	Returns: the previous focus

Returns the widget that was holding focus before.

This function can only be used in handlers for the focusIn and focusOut signals.

getFocusTarget

eventControllerKeyGetFocusTarget Source #

Arguments

:: (HasCallStack, MonadIO m, IsEventControllerKey a)
=> a	`controller`: a `EventControllerKey`
-> m Widget	Returns: the next focus

Returns the widget that will be holding focus afterwards.

This function can only be used in handlers for the focusIn and focusOut signals.

getGroup

eventControllerKeyGetGroup Source #

Arguments

:: (HasCallStack, MonadIO m, IsEventControllerKey a)
=> a	`controller`: a `EventControllerKey`
-> m Word32	Returns: the key group

Gets the key group of the current event of this controller. See eventGetKeyGroup.

getImContext

eventControllerKeyGetImContext Source #

Arguments

:: (HasCallStack, MonadIO m, IsEventControllerKey a)
=> a	`controller`: a `EventControllerKey`
-> m IMContext	Returns: the `IMContext`

Gets the input method context of the key controller.

new

eventControllerKeyNew Source #

Arguments

:: (HasCallStack, MonadIO m)
=> m EventControllerKey	Returns: a new `EventControllerKey`

Creates a new event controller that will handle key events.

setImContext

eventControllerKeySetImContext Source #

Arguments

:: (HasCallStack, MonadIO m, IsEventControllerKey a, IsIMContext b)
=> a	`controller`: a `EventControllerKey`
-> b	`imContext`: a `IMContext`
-> m ()

Sets the input method context of the key controller.

Properties

containsFocus

Whether focus is in a descendant of the controllers widget. See EventControllerKey:is-focus.

When handling focus events, this property is updated before focusIn or focusOut are emitted.

getEventControllerKeyContainsFocus :: (MonadIO m, IsEventControllerKey o) => o -> m Bool Source #

Get the value of the “contains-focus” property. When overloading is enabled, this is equivalent to

get eventControllerKey #containsFocus

isFocus

Whether focus is in the controllers widget itself, as opposed to in a descendent widget. See EventControllerKey:contains-focus.

When handling focus events, this property is updated before focusIn or focusOut are emitted.

getEventControllerKeyIsFocus :: (MonadIO m, IsEventControllerKey o) => o -> m Bool Source #

Get the value of the “is-focus” property. When overloading is enabled, this is equivalent to

get eventControllerKey #isFocus

Signals

focusIn

type C_EventControllerKeyFocusInCallback = Ptr () -> CUInt -> CUInt -> Ptr () -> IO () Source #

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

type EventControllerKeyFocusInCallback Source #

Arguments

= CrossingMode	`mode`: crossing mode indicating what caused this change
-> NotifyType	`detail`: detail indication where the focus is coming from
-> IO ()

This signal is emitted whenever the widget controlled by the controller or one of its descendants) is given the keyboard focus.

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

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) Source #

Wrap the callback into a GClosure.

mk_EventControllerKeyFocusInCallback :: C_EventControllerKeyFocusInCallback -> IO (FunPtr C_EventControllerKeyFocusInCallback) Source #

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

noEventControllerKeyFocusInCallback :: Maybe EventControllerKeyFocusInCallback Source #

A convenience synonym for Nothing :: Maybe EventControllerKeyFocusInCallback.

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

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 Source #

Wrap a EventControllerKeyFocusInCallback into a C_EventControllerKeyFocusInCallback.

focusOut

type C_EventControllerKeyFocusOutCallback = Ptr () -> CUInt -> CUInt -> Ptr () -> IO () Source #

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

type EventControllerKeyFocusOutCallback Source #

Arguments

= CrossingMode	`mode`: crossing mode indicating what caused this change
-> NotifyType	`detail`: detail indication where the focus is going
-> IO ()

This signal is emitted whenever the widget controlled by the controller (or one of its descendants) loses the keyboard focus.

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

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) Source #

Wrap the callback into a GClosure.

mk_EventControllerKeyFocusOutCallback :: C_EventControllerKeyFocusOutCallback -> IO (FunPtr C_EventControllerKeyFocusOutCallback) Source #

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

noEventControllerKeyFocusOutCallback :: Maybe EventControllerKeyFocusOutCallback Source #

A convenience synonym for Nothing :: Maybe EventControllerKeyFocusOutCallback.

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

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 Source #

Wrap a EventControllerKeyFocusOutCallback into a C_EventControllerKeyFocusOutCallback.

imUpdate

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

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

type EventControllerKeyImUpdateCallback = IO () Source #

This signal is emitted whenever the input method context filters away a keypress and prevents the controller receiving it. See eventControllerKeySetImContext and iMContextFilterKeypress.

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

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) Source #

Wrap the callback into a GClosure.

mk_EventControllerKeyImUpdateCallback :: C_EventControllerKeyImUpdateCallback -> IO (FunPtr C_EventControllerKeyImUpdateCallback) Source #

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

noEventControllerKeyImUpdateCallback :: Maybe EventControllerKeyImUpdateCallback Source #

A convenience synonym for Nothing :: Maybe EventControllerKeyImUpdateCallback.

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

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 Source #

Wrap a EventControllerKeyImUpdateCallback into a C_EventControllerKeyImUpdateCallback.

keyPressed

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

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

type EventControllerKeyKeyPressedCallback Source #

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.

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

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) Source #

Wrap the callback into a GClosure.

mk_EventControllerKeyKeyPressedCallback :: C_EventControllerKeyKeyPressedCallback -> IO (FunPtr C_EventControllerKeyKeyPressedCallback) Source #

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

noEventControllerKeyKeyPressedCallback :: Maybe EventControllerKeyKeyPressedCallback Source #

A convenience synonym for Nothing :: Maybe EventControllerKeyKeyPressedCallback.

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

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 Source #

Wrap a EventControllerKeyKeyPressedCallback into a C_EventControllerKeyKeyPressedCallback.

keyReleased

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

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

type EventControllerKeyKeyReleasedCallback Source #

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.

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

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) Source #

Wrap the callback into a GClosure.

mk_EventControllerKeyKeyReleasedCallback :: C_EventControllerKeyKeyReleasedCallback -> IO (FunPtr C_EventControllerKeyKeyReleasedCallback) Source #

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

noEventControllerKeyKeyReleasedCallback :: Maybe EventControllerKeyKeyReleasedCallback Source #

A convenience synonym for Nothing :: Maybe EventControllerKeyKeyReleasedCallback.

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

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 Source #

Wrap a EventControllerKeyKeyReleasedCallback into a C_EventControllerKeyKeyReleasedCallback.

modifiers

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

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

type EventControllerKeyModifiersCallback Source #

Arguments

= [ModifierType]	`keyval`: the released key.
-> IO Bool

This signal is emitted whenever the state of modifier keys and pointer buttons change.

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

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) Source #

Wrap the callback into a GClosure.

mk_EventControllerKeyModifiersCallback :: C_EventControllerKeyModifiersCallback -> IO (FunPtr C_EventControllerKeyModifiersCallback) Source #

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

noEventControllerKeyModifiersCallback :: Maybe EventControllerKeyModifiersCallback Source #

A convenience synonym for Nothing :: Maybe EventControllerKeyModifiersCallback.

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

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 Source #

Wrap a EventControllerKeyModifiersCallback into a C_EventControllerKeyModifiersCallback.