GI.Atk.Callbacks

Signals

EventListener

type C_EventListener = Ptr Object -> IO ()

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

type EventListener

Arguments

 = Object

obj: An Object instance for whom the callback will be called when the specified event (e.g. 'focus:') takes place.

-> IO ()

A function which is called when an object emits a matching event, as used in atk_add_focus_tracker. Currently the only events for which object-specific handlers are supported are events of type "focus:". Most clients of ATK will prefer to attach signal handlers for the various ATK signals instead.

see atk_add_focus_tracker.

dynamic_EventListener

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_EventListener

-> a

obj: An Object instance for whom the callback will be called when the specified event (e.g. 'focus:') takes place.

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_EventListener :: MonadIO m => EventListener -> m (GClosure C_EventListener)

Wrap the callback into a GClosure.

mk_EventListener :: C_EventListener -> IO (FunPtr C_EventListener)

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

noEventListener :: Maybe EventListener

A convenience synonym for Nothing :: Maybe EventListener.

wrap_EventListener :: Maybe (Ptr (FunPtr C_EventListener)) -> EventListener -> C_EventListener

Wrap a EventListener into a C_EventListener.

EventListenerInit

type C_EventListenerInit = IO ()

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

type EventListenerInit = IO ()

An EventListenerInit function is a special function that is called in order to initialize the per-object event registration system used by EventListener, if any preparation is required.

see atk_focus_tracker_init.

dynamic_EventListenerInit :: (HasCallStack, MonadIO m) => FunPtr C_EventListenerInit -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_EventListenerInit :: MonadIO m => EventListenerInit -> m (GClosure C_EventListenerInit)

Wrap the callback into a GClosure.

mk_EventListenerInit :: C_EventListenerInit -> IO (FunPtr C_EventListenerInit)

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

noEventListenerInit :: Maybe EventListenerInit

A convenience synonym for Nothing :: Maybe EventListenerInit.

wrap_EventListenerInit :: Maybe (Ptr (FunPtr C_EventListenerInit)) -> EventListenerInit -> C_EventListenerInit

Wrap a EventListenerInit into a C_EventListenerInit.

FocusHandler

type C_FocusHandler = Ptr Object -> CInt -> IO ()

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

type FocusHandler

Arguments

 = Object

object: the Object that receives/lose the focus

-> Bool

focusIn: TRUE if the object receives the focus

-> IO ()

Deprecated: (Since version 2.9.4)Deprecated with atk_component_add_focus_handler()and componentRemoveFocusHandler. See thosemethods for more information.

The type of callback function used for atk_component_add_focus_handler() and componentRemoveFocusHandler

dynamic_FocusHandler

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_FocusHandler

-> a

object: the Object that receives/lose the focus

-> Bool

focusIn: TRUE if the object receives the focus

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_FocusHandler :: MonadIO m => FocusHandler -> m (GClosure C_FocusHandler)

Wrap the callback into a GClosure.

mk_FocusHandler :: C_FocusHandler -> IO (FunPtr C_FocusHandler)

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

noFocusHandler :: Maybe FocusHandler

A convenience synonym for Nothing :: Maybe FocusHandler.

wrap_FocusHandler :: Maybe (Ptr (FunPtr C_FocusHandler)) -> FocusHandler -> C_FocusHandler

Wrap a FocusHandler into a C_FocusHandler.

Function

type C_Function = Ptr () -> IO CInt

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

type Function

Arguments

 = IO Bool

Returns: not used

An AtkFunction is a function definition used for padding which has been added to class and interface structures to allow for expansion in the future.

type Function_WithClosures

Arguments

 = Ptr ()

userData: custom data defined by the user

-> IO Bool

Returns: not used

An AtkFunction is a function definition used for padding which has been added to class and interface structures to allow for expansion in the future.

drop_closures_Function :: Function -> Function_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_Function

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_Function

-> Ptr ()

userData: custom data defined by the user

-> m Bool

Returns: not used

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_Function :: MonadIO m => Function -> m (GClosure C_Function)

Wrap the callback into a GClosure.

mk_Function :: C_Function -> IO (FunPtr C_Function)

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

noFunction :: Maybe Function

A convenience synonym for Nothing :: Maybe Function.

noFunction_WithClosures :: Maybe Function_WithClosures

A convenience synonym for Nothing :: Maybe Function_WithClosures.

wrap_Function :: Maybe (Ptr (FunPtr C_Function)) -> Function_WithClosures -> C_Function

Wrap a Function into a C_Function.

KeySnoopFunc

type C_KeySnoopFunc = Ptr KeyEventStruct -> Ptr () -> IO Int32

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

type KeySnoopFunc

Arguments

 = KeyEventStruct

event: an AtkKeyEventStruct containing information about the key event for which notification is being given.

-> IO Int32

Returns: TRUE (nonzero) if the event emission should be stopped and the event discarded without being passed to the normal GUI recipient; FALSE (zero) if the event dispatch to the client application should proceed as normal.

see atk_add_key_event_listener.

An KeySnoopFunc is a type of callback which is called whenever a key event occurs, if registered via atk_add_key_event_listener. It allows for pre-emptive interception of key events via the return code as described below.

type KeySnoopFunc_WithClosures

Arguments

 = KeyEventStruct

event: an AtkKeyEventStruct containing information about the key event for which notification is being given.

-> Ptr ()

userData: a block of data which will be passed to the event listener, on notification.

-> IO Int32

Returns: TRUE (nonzero) if the event emission should be stopped and the event discarded without being passed to the normal GUI recipient; FALSE (zero) if the event dispatch to the client application should proceed as normal.

see atk_add_key_event_listener.

An KeySnoopFunc is a type of callback which is called whenever a key event occurs, if registered via atk_add_key_event_listener. It allows for pre-emptive interception of key events via the return code as described below.

drop_closures_KeySnoopFunc :: KeySnoopFunc -> KeySnoopFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_KeySnoopFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_KeySnoopFunc

-> KeyEventStruct

event: an AtkKeyEventStruct containing information about the key event for which notification is being given.

-> Ptr ()

userData: a block of data which will be passed to the event listener, on notification.

-> m Int32

Returns: TRUE (nonzero) if the event emission should be stopped and the event discarded without being passed to the normal GUI recipient; FALSE (zero) if the event dispatch to the client application should proceed as normal.

see atk_add_key_event_listener.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_KeySnoopFunc :: MonadIO m => KeySnoopFunc -> m (GClosure C_KeySnoopFunc)

Wrap the callback into a GClosure.

mk_KeySnoopFunc :: C_KeySnoopFunc -> IO (FunPtr C_KeySnoopFunc)

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

noKeySnoopFunc :: Maybe KeySnoopFunc

A convenience synonym for Nothing :: Maybe KeySnoopFunc.

noKeySnoopFunc_WithClosures :: Maybe KeySnoopFunc_WithClosures

A convenience synonym for Nothing :: Maybe KeySnoopFunc_WithClosures.

wrap_KeySnoopFunc :: Maybe (Ptr (FunPtr C_KeySnoopFunc)) -> KeySnoopFunc_WithClosures -> C_KeySnoopFunc

Wrap a KeySnoopFunc into a C_KeySnoopFunc.

PropertyChangeHandler

type C_PropertyChangeHandler = Ptr Object -> Ptr PropertyValues -> IO ()

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

type PropertyChangeHandler

Arguments

 = Object

obj: atkobject which property changes

-> PropertyValues

vals: values changed

-> IO ()

Deprecated: Since 2.12.

An AtkPropertyChangeHandler is a function which is executed when an AtkObject's property changes value. It is specified in a call to atk_object_connect_property_change_handler().

dynamic_PropertyChangeHandler

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_PropertyChangeHandler

-> a

obj: atkobject which property changes

-> PropertyValues

vals: values changed

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PropertyChangeHandler :: MonadIO m => PropertyChangeHandler -> m (GClosure C_PropertyChangeHandler)

Wrap the callback into a GClosure.

mk_PropertyChangeHandler :: C_PropertyChangeHandler -> IO (FunPtr C_PropertyChangeHandler)

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

noPropertyChangeHandler :: Maybe PropertyChangeHandler

A convenience synonym for Nothing :: Maybe PropertyChangeHandler.

wrap_PropertyChangeHandler :: Maybe (Ptr (FunPtr C_PropertyChangeHandler)) -> PropertyChangeHandler -> C_PropertyChangeHandler

Wrap a PropertyChangeHandler into a C_PropertyChangeHandler.