GI.Clutter.Callbacks

Signals

ActorCreateChildFunc

type ActorCreateChildFunc

Arguments

 = Object

item: the item in the model

-> IO Actor

Returns: The newly created child Actor

Creates a Actor using the item in the model.

The usual way to implement this function is to create a Actor instance and then bind the Object properties to the actor properties of interest, using objectBindProperty. This way, when the item in the ListModel changes, the Actor changes as well.

Since: 1.24

type ActorCreateChildFunc_WithClosures

Arguments

 = Object

item: the item in the model

-> Ptr ()

userData: Data passed to actorBindModel

-> IO Actor

Returns: The newly created child Actor

Creates a Actor using the item in the model.

The usual way to implement this function is to create a Actor instance and then bind the Object properties to the actor properties of interest, using objectBindProperty. This way, when the item in the ListModel changes, the Actor changes as well.

Since: 1.24

type C_ActorCreateChildFunc = Ptr Object -> Ptr () -> IO (Ptr Actor)

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

drop_closures_ActorCreateChildFunc :: ActorCreateChildFunc -> ActorCreateChildFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ActorCreateChildFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_ActorCreateChildFunc

-> a

item: the item in the model

-> Ptr ()

userData: Data passed to actorBindModel

-> m Actor

Returns: The newly created child Actor

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

genClosure_ActorCreateChildFunc :: MonadIO m => ActorCreateChildFunc -> m (GClosure C_ActorCreateChildFunc)

Wrap the callback into a GClosure.

mk_ActorCreateChildFunc :: C_ActorCreateChildFunc -> IO (FunPtr C_ActorCreateChildFunc)

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

noActorCreateChildFunc :: Maybe ActorCreateChildFunc

A convenience synonym for Nothing :: Maybe ActorCreateChildFunc.

noActorCreateChildFunc_WithClosures :: Maybe ActorCreateChildFunc_WithClosures

A convenience synonym for Nothing :: Maybe ActorCreateChildFunc_WithClosures.

wrap_ActorCreateChildFunc :: Maybe (Ptr (FunPtr C_ActorCreateChildFunc)) -> ActorCreateChildFunc_WithClosures -> C_ActorCreateChildFunc

Wrap a ActorCreateChildFunc into a C_ActorCreateChildFunc.

AlphaFunc

type AlphaFunc

Arguments

 = Alpha

alpha: a Alpha

-> IO Double

Returns: a floating point value

Deprecated: (Since version 1.12)Use TimelineProgressFunc instead.

A function returning a value depending on the position of the Timeline bound to alpha.

Since: 0.2

type AlphaFunc_WithClosures

Arguments

 = Alpha

alpha: a Alpha

-> Ptr ()

userData: user data passed to the function

-> IO Double

Returns: a floating point value

A function returning a value depending on the position of the Timeline bound to alpha.

Since: 0.2

type C_AlphaFunc = Ptr Alpha -> Ptr () -> IO CDouble

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

drop_closures_AlphaFunc :: AlphaFunc -> AlphaFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_AlphaFunc

Arguments

:: (HasCallStack, MonadIO m, IsAlpha a)

=> FunPtr C_AlphaFunc

-> a

alpha: a Alpha

-> Ptr ()

userData: user data passed to the function

-> m Double

Returns: a floating point value

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

genClosure_AlphaFunc :: MonadIO m => AlphaFunc -> m (GClosure C_AlphaFunc)

Wrap the callback into a GClosure.

mk_AlphaFunc :: C_AlphaFunc -> IO (FunPtr C_AlphaFunc)

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

noAlphaFunc :: Maybe AlphaFunc

A convenience synonym for Nothing :: Maybe AlphaFunc.

noAlphaFunc_WithClosures :: Maybe AlphaFunc_WithClosures

A convenience synonym for Nothing :: Maybe AlphaFunc_WithClosures.

wrap_AlphaFunc :: Maybe (Ptr (FunPtr C_AlphaFunc)) -> AlphaFunc_WithClosures -> C_AlphaFunc

Wrap a AlphaFunc into a C_AlphaFunc.

BehaviourForeachFunc

type BehaviourForeachFunc

Arguments

 = Behaviour

behaviour: the Behaviour

-> Actor

actor: an actor driven by behaviour

-> IO ()

Deprecated: (Since version 1.6)

This function is passed to behaviourActorsForeach and will be called for each actor driven by behaviour.

Since: 0.2

type BehaviourForeachFunc_WithClosures

Arguments

 = Behaviour

behaviour: the Behaviour

-> Actor

actor: an actor driven by behaviour

-> Ptr ()

data: optional data passed to the function

-> IO ()

This function is passed to behaviourActorsForeach and will be called for each actor driven by behaviour.

Since: 0.2

type C_BehaviourForeachFunc = Ptr Behaviour -> Ptr Actor -> Ptr () -> IO ()

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

drop_closures_BehaviourForeachFunc :: BehaviourForeachFunc -> BehaviourForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BehaviourForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsBehaviour a, IsActor b)

=> FunPtr C_BehaviourForeachFunc

-> a

behaviour: the Behaviour

-> b

actor: an actor driven by behaviour

-> Ptr ()

data: optional data passed to the function

-> m ()

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

genClosure_BehaviourForeachFunc :: MonadIO m => BehaviourForeachFunc -> m (GClosure C_BehaviourForeachFunc)

Wrap the callback into a GClosure.

mk_BehaviourForeachFunc :: C_BehaviourForeachFunc -> IO (FunPtr C_BehaviourForeachFunc)

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

noBehaviourForeachFunc :: Maybe BehaviourForeachFunc

A convenience synonym for Nothing :: Maybe BehaviourForeachFunc.

noBehaviourForeachFunc_WithClosures :: Maybe BehaviourForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe BehaviourForeachFunc_WithClosures.

wrap_BehaviourForeachFunc :: Maybe (Ptr (FunPtr C_BehaviourForeachFunc)) -> BehaviourForeachFunc_WithClosures -> C_BehaviourForeachFunc

Wrap a BehaviourForeachFunc into a C_BehaviourForeachFunc.

BindingActionFunc

type BindingActionFunc

Arguments

 = Object

gobject: a Object

-> Text

actionName: the name of the action

-> Word32

keyVal: the key symbol

-> [ModifierType]

modifiers: bitmask of the modifier flags

-> IO Bool

Returns: the function should return True if the key binding has been handled, and return False otherwise

The prototype for the callback function registered with bindingPoolInstallAction and invoked by bindingPoolActivate.

Since: 1.0

type BindingActionFunc_WithClosures

Arguments

 = Object

gobject: a Object

-> Text

actionName: the name of the action

-> Word32

keyVal: the key symbol

-> [ModifierType]

modifiers: bitmask of the modifier flags

-> Ptr ()

userData: data passed to the function

-> IO Bool

Returns: the function should return True if the key binding has been handled, and return False otherwise

The prototype for the callback function registered with bindingPoolInstallAction and invoked by bindingPoolActivate.

Since: 1.0

type C_BindingActionFunc = Ptr Object -> CString -> Word32 -> CUInt -> Ptr () -> IO CInt

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

drop_closures_BindingActionFunc :: BindingActionFunc -> BindingActionFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BindingActionFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_BindingActionFunc

-> a

gobject: a Object

-> Text

actionName: the name of the action

-> Word32

keyVal: the key symbol

-> [ModifierType]

modifiers: bitmask of the modifier flags

-> Ptr ()

userData: data passed to the function

-> m Bool

Returns: the function should return True if the key binding has been handled, and return False otherwise

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

genClosure_BindingActionFunc :: MonadIO m => BindingActionFunc -> m (GClosure C_BindingActionFunc)

Wrap the callback into a GClosure.

mk_BindingActionFunc :: C_BindingActionFunc -> IO (FunPtr C_BindingActionFunc)

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

noBindingActionFunc :: Maybe BindingActionFunc

A convenience synonym for Nothing :: Maybe BindingActionFunc.

noBindingActionFunc_WithClosures :: Maybe BindingActionFunc_WithClosures

A convenience synonym for Nothing :: Maybe BindingActionFunc_WithClosures.

wrap_BindingActionFunc :: Maybe (Ptr (FunPtr C_BindingActionFunc)) -> BindingActionFunc_WithClosures -> C_BindingActionFunc

Wrap a BindingActionFunc into a C_BindingActionFunc.

Callback

type C_Callback = Ptr Actor -> Ptr () -> IO ()

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

type Callback

Arguments

 = Actor

actor: a Actor

-> IO ()

Generic callback

type Callback_WithClosures

Arguments

 = Actor

actor: a Actor

-> Ptr ()

data: user data

-> IO ()

Generic callback

drop_closures_Callback :: Callback -> Callback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_Callback

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> FunPtr C_Callback

-> a

actor: a Actor

-> Ptr ()

data: user data

-> m ()

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

genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback)

Wrap the callback into a GClosure.

mk_Callback :: C_Callback -> IO (FunPtr C_Callback)

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

noCallback :: Maybe Callback

A convenience synonym for Nothing :: Maybe Callback.

noCallback_WithClosures :: Maybe Callback_WithClosures

A convenience synonym for Nothing :: Maybe Callback_WithClosures.

wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback_WithClosures -> C_Callback

Wrap a Callback into a C_Callback.

EventFilterFunc

type C_EventFilterFunc = Ptr Event -> Ptr () -> IO CInt

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

type EventFilterFunc

Arguments

 = Event

event: the event that is going to be emitted

-> IO Bool

Returns: EVENT_STOP to indicate that the event has been handled or EVENT_PROPAGATE otherwise. Returning EVENT_STOP skips any further filter functions and prevents the signal emission for the event.

A function pointer type used by event filters that are added with eventAddFilter.

Since: 1.18

type EventFilterFunc_WithClosures

Arguments

 = Event

event: the event that is going to be emitted

-> Ptr ()

userData: the data pointer passed to eventAddFilter

-> IO Bool

Returns: EVENT_STOP to indicate that the event has been handled or EVENT_PROPAGATE otherwise. Returning EVENT_STOP skips any further filter functions and prevents the signal emission for the event.

A function pointer type used by event filters that are added with eventAddFilter.

Since: 1.18

drop_closures_EventFilterFunc :: EventFilterFunc -> EventFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_EventFilterFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_EventFilterFunc

-> Event

event: the event that is going to be emitted

-> Ptr ()

userData: the data pointer passed to eventAddFilter

-> m Bool

Returns: EVENT_STOP to indicate that the event has been handled or EVENT_PROPAGATE otherwise. Returning EVENT_STOP skips any further filter functions and prevents the signal emission for the event.

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

genClosure_EventFilterFunc :: MonadIO m => EventFilterFunc -> m (GClosure C_EventFilterFunc)

Wrap the callback into a GClosure.

mk_EventFilterFunc :: C_EventFilterFunc -> IO (FunPtr C_EventFilterFunc)

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

noEventFilterFunc :: Maybe EventFilterFunc

A convenience synonym for Nothing :: Maybe EventFilterFunc.

noEventFilterFunc_WithClosures :: Maybe EventFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe EventFilterFunc_WithClosures.

wrap_EventFilterFunc :: Maybe (Ptr (FunPtr C_EventFilterFunc)) -> EventFilterFunc_WithClosures -> C_EventFilterFunc

Wrap a EventFilterFunc into a C_EventFilterFunc.

ModelFilterFunc

type C_ModelFilterFunc = Ptr Model -> Ptr ModelIter -> Ptr () -> IO CInt

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

type ModelFilterFunc

Arguments

 = Model

model: a Model

-> ModelIter

iter: the iterator for the row

-> IO Bool

Returns: If the row should be displayed, return True

Deprecated: (Since version 1.24)Implement filters using a custom ListModel instead

Filters the content of a row in the model.

Since: 0.6

type ModelFilterFunc_WithClosures

Arguments

 = Model

model: a Model

-> ModelIter

iter: the iterator for the row

-> Ptr ()

userData: data passed to modelSetFilter

-> IO Bool

Returns: If the row should be displayed, return True

Filters the content of a row in the model.

Since: 0.6

drop_closures_ModelFilterFunc :: ModelFilterFunc -> ModelFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ModelFilterFunc

Arguments

:: (HasCallStack, MonadIO m, IsModel a, IsModelIter b)

=> FunPtr C_ModelFilterFunc

-> a

model: a Model

-> b

iter: the iterator for the row

-> Ptr ()

userData: data passed to modelSetFilter

-> m Bool

Returns: If the row should be displayed, return True

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

genClosure_ModelFilterFunc :: MonadIO m => ModelFilterFunc -> m (GClosure C_ModelFilterFunc)

Wrap the callback into a GClosure.

mk_ModelFilterFunc :: C_ModelFilterFunc -> IO (FunPtr C_ModelFilterFunc)

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

noModelFilterFunc :: Maybe ModelFilterFunc

A convenience synonym for Nothing :: Maybe ModelFilterFunc.

noModelFilterFunc_WithClosures :: Maybe ModelFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe ModelFilterFunc_WithClosures.

wrap_ModelFilterFunc :: Maybe (Ptr (FunPtr C_ModelFilterFunc)) -> ModelFilterFunc_WithClosures -> C_ModelFilterFunc

Wrap a ModelFilterFunc into a C_ModelFilterFunc.

ModelForeachFunc

type C_ModelForeachFunc = Ptr Model -> Ptr ModelIter -> Ptr () -> IO CInt

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

type ModelForeachFunc

Arguments

 = Model

model: a Model

-> ModelIter

iter: the iterator for the row

-> IO Bool

Returns: True if the iteration should continue, False otherwise

Deprecated: (Since version 1.24)Use ListModel

Iterates on the content of a row in the model

Since: 0.6

type ModelForeachFunc_WithClosures

Arguments

 = Model

model: a Model

-> ModelIter

iter: the iterator for the row

-> Ptr ()

userData: data passed to modelForeach

-> IO Bool

Returns: True if the iteration should continue, False otherwise

Iterates on the content of a row in the model

Since: 0.6

drop_closures_ModelForeachFunc :: ModelForeachFunc -> ModelForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ModelForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsModel a, IsModelIter b)

=> FunPtr C_ModelForeachFunc

-> a

model: a Model

-> b

iter: the iterator for the row

-> Ptr ()

userData: data passed to modelForeach

-> m Bool

Returns: True if the iteration should continue, False otherwise

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

genClosure_ModelForeachFunc :: MonadIO m => ModelForeachFunc -> m (GClosure C_ModelForeachFunc)

Wrap the callback into a GClosure.

mk_ModelForeachFunc :: C_ModelForeachFunc -> IO (FunPtr C_ModelForeachFunc)

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

noModelForeachFunc :: Maybe ModelForeachFunc

A convenience synonym for Nothing :: Maybe ModelForeachFunc.

noModelForeachFunc_WithClosures :: Maybe ModelForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe ModelForeachFunc_WithClosures.

wrap_ModelForeachFunc :: Maybe (Ptr (FunPtr C_ModelForeachFunc)) -> ModelForeachFunc_WithClosures -> C_ModelForeachFunc

Wrap a ModelForeachFunc into a C_ModelForeachFunc.

ModelSortFunc

type C_ModelSortFunc = Ptr Model -> Ptr GValue -> Ptr GValue -> Ptr () -> IO Int32

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

type ModelSortFunc

Arguments

 = Model

model: a Model

-> GValue

a: a Value representing the contents of the row

-> GValue

b: a Value representing the contents of the second row

-> IO Int32

Returns: a positive integer if a is after b, a negative integer if a is before b, or 0 if the rows are the same

Deprecated: (Since version 1.24)Implement sorting using a custom ListModel instead

Compares the content of two rows in the model.

Since: 0.6

type ModelSortFunc_WithClosures

Arguments

 = Model

model: a Model

-> GValue

a: a Value representing the contents of the row

-> GValue

b: a Value representing the contents of the second row

-> Ptr ()

userData: data passed to modelSetSort

-> IO Int32

Returns: a positive integer if a is after b, a negative integer if a is before b, or 0 if the rows are the same

Compares the content of two rows in the model.

Since: 0.6

drop_closures_ModelSortFunc :: ModelSortFunc -> ModelSortFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ModelSortFunc

Arguments

:: (HasCallStack, MonadIO m, IsModel a)

=> FunPtr C_ModelSortFunc

-> a

model: a Model

-> GValue

a: a Value representing the contents of the row

-> GValue

b: a Value representing the contents of the second row

-> Ptr ()

userData: data passed to modelSetSort

-> m Int32

Returns: a positive integer if a is after b, a negative integer if a is before b, or 0 if the rows are the same

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

genClosure_ModelSortFunc :: MonadIO m => ModelSortFunc -> m (GClosure C_ModelSortFunc)

Wrap the callback into a GClosure.

mk_ModelSortFunc :: C_ModelSortFunc -> IO (FunPtr C_ModelSortFunc)

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

noModelSortFunc :: Maybe ModelSortFunc

A convenience synonym for Nothing :: Maybe ModelSortFunc.

noModelSortFunc_WithClosures :: Maybe ModelSortFunc_WithClosures

A convenience synonym for Nothing :: Maybe ModelSortFunc_WithClosures.

wrap_ModelSortFunc :: Maybe (Ptr (FunPtr C_ModelSortFunc)) -> ModelSortFunc_WithClosures -> C_ModelSortFunc

Wrap a ModelSortFunc into a C_ModelSortFunc.

PathCallback

type C_PathCallback = Ptr PathNode -> Ptr () -> IO ()

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

type PathCallback

Arguments

 = PathNode

node: the node

-> IO ()

This function is passed to pathForeach and will be called for each node contained in the path.

Since: 1.0

type PathCallback_WithClosures

Arguments

 = PathNode

node: the node

-> Ptr ()

data: optional data passed to the function

-> IO ()

This function is passed to pathForeach and will be called for each node contained in the path.

Since: 1.0

drop_closures_PathCallback :: PathCallback -> PathCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PathCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_PathCallback

-> PathNode

node: the node

-> Ptr ()

data: optional data passed to the function

-> m ()

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

genClosure_PathCallback :: MonadIO m => PathCallback -> m (GClosure C_PathCallback)

Wrap the callback into a GClosure.

mk_PathCallback :: C_PathCallback -> IO (FunPtr C_PathCallback)

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

noPathCallback :: Maybe PathCallback

A convenience synonym for Nothing :: Maybe PathCallback.

noPathCallback_WithClosures :: Maybe PathCallback_WithClosures

A convenience synonym for Nothing :: Maybe PathCallback_WithClosures.

wrap_PathCallback :: Maybe (Ptr (FunPtr C_PathCallback)) -> PathCallback_WithClosures -> C_PathCallback

Wrap a PathCallback into a C_PathCallback.

ProgressFunc

type C_ProgressFunc = Ptr GValue -> Ptr GValue -> CDouble -> Ptr GValue -> IO CInt

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

type ProgressFunc

Arguments

 = GValue

a: the initial value of an interval

-> GValue

b: the final value of an interval

-> Double

progress: the progress factor, between 0 and 1

-> GValue

retval: the value used to store the progress

-> IO Bool

Returns: True if the function successfully computed the value and stored it inside retval

Prototype of the progress function used to compute the value between the two ends a and b of an interval depending on the value of progress.

The Value in retval is already initialized with the same type as a and b.

This function will be called by Interval if the type of the values of the interval was registered using clutter_interval_register_progress_func().

Since: 1.0

dynamic_ProgressFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ProgressFunc

-> GValue

a: the initial value of an interval

-> GValue

b: the final value of an interval

-> Double

progress: the progress factor, between 0 and 1

-> GValue

retval: the value used to store the progress

-> m Bool

Returns: True if the function successfully computed the value and stored it inside retval

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

genClosure_ProgressFunc :: MonadIO m => ProgressFunc -> m (GClosure C_ProgressFunc)

Wrap the callback into a GClosure.

mk_ProgressFunc :: C_ProgressFunc -> IO (FunPtr C_ProgressFunc)

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

noProgressFunc :: Maybe ProgressFunc

A convenience synonym for Nothing :: Maybe ProgressFunc.

wrap_ProgressFunc :: Maybe (Ptr (FunPtr C_ProgressFunc)) -> ProgressFunc -> C_ProgressFunc

Wrap a ProgressFunc into a C_ProgressFunc.

ScriptConnectFunc

type C_ScriptConnectFunc = Ptr Script -> Ptr Object -> CString -> CString -> Ptr Object -> CUInt -> Ptr () -> IO ()

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

type ScriptConnectFunc

Arguments

 = Script

script: a Script

-> Object

object: the object to connect

-> Text

signalName: the name of the signal

-> Text

handlerName: the name of the signal handler

-> Object

connectObject: the object to connect the signal to, or Nothing

-> [ConnectFlags]

flags: signal connection flags

-> IO ()

This is the signature of a function used to connect signals. It is used by the scriptConnectSignalsFull function. It is mainly intended for interpreted language bindings, but could be useful where the programmer wants more control over the signal connection process.

Since: 0.6

type ScriptConnectFunc_WithClosures

Arguments

 = Script

script: a Script

-> Object

object: the object to connect

-> Text

signalName: the name of the signal

-> Text

handlerName: the name of the signal handler

-> Object

connectObject: the object to connect the signal to, or Nothing

-> [ConnectFlags]

flags: signal connection flags

-> Ptr ()

userData: user data to pass to the signal handler

-> IO ()

This is the signature of a function used to connect signals. It is used by the scriptConnectSignalsFull function. It is mainly intended for interpreted language bindings, but could be useful where the programmer wants more control over the signal connection process.

Since: 0.6

drop_closures_ScriptConnectFunc :: ScriptConnectFunc -> ScriptConnectFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ScriptConnectFunc

Arguments

:: (HasCallStack, MonadIO m, IsScript a, IsObject b, IsObject c)

=> FunPtr C_ScriptConnectFunc

-> a

script: a Script

-> b

object: the object to connect

-> Text

signalName: the name of the signal

-> Text

handlerName: the name of the signal handler

-> c

connectObject: the object to connect the signal to, or Nothing

-> [ConnectFlags]

flags: signal connection flags

-> Ptr ()

userData: user data to pass to the signal handler

-> m ()

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

genClosure_ScriptConnectFunc :: MonadIO m => ScriptConnectFunc -> m (GClosure C_ScriptConnectFunc)

Wrap the callback into a GClosure.

mk_ScriptConnectFunc :: C_ScriptConnectFunc -> IO (FunPtr C_ScriptConnectFunc)

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

noScriptConnectFunc :: Maybe ScriptConnectFunc

A convenience synonym for Nothing :: Maybe ScriptConnectFunc.

noScriptConnectFunc_WithClosures :: Maybe ScriptConnectFunc_WithClosures

A convenience synonym for Nothing :: Maybe ScriptConnectFunc_WithClosures.

wrap_ScriptConnectFunc :: Maybe (Ptr (FunPtr C_ScriptConnectFunc)) -> ScriptConnectFunc_WithClosures -> C_ScriptConnectFunc

Wrap a ScriptConnectFunc into a C_ScriptConnectFunc.

TimelineProgressFunc

type C_TimelineProgressFunc = Ptr Timeline -> CDouble -> CDouble -> Ptr () -> IO CDouble

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

type TimelineProgressFunc

Arguments

 = Timeline

timeline: a Timeline

-> Double

elapsed: the elapsed time, in milliseconds

-> Double

total: the total duration of the timeline, in milliseconds,

-> IO Double

Returns: the progress, as a floating point value between -1.0 and 2.0.

A function for defining a custom progress.

Since: 1.10

type TimelineProgressFunc_WithClosures

Arguments

 = Timeline

timeline: a Timeline

-> Double

elapsed: the elapsed time, in milliseconds

-> Double

total: the total duration of the timeline, in milliseconds,

-> Ptr ()

userData: data passed to the function

-> IO Double

Returns: the progress, as a floating point value between -1.0 and 2.0.

A function for defining a custom progress.

Since: 1.10

drop_closures_TimelineProgressFunc :: TimelineProgressFunc -> TimelineProgressFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TimelineProgressFunc

Arguments

:: (HasCallStack, MonadIO m, IsTimeline a)

=> FunPtr C_TimelineProgressFunc

-> a

timeline: a Timeline

-> Double

elapsed: the elapsed time, in milliseconds

-> Double

total: the total duration of the timeline, in milliseconds,

-> Ptr ()

userData: data passed to the function

-> m Double

Returns: the progress, as a floating point value between -1.0 and 2.0.

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

genClosure_TimelineProgressFunc :: MonadIO m => TimelineProgressFunc -> m (GClosure C_TimelineProgressFunc)

Wrap the callback into a GClosure.

mk_TimelineProgressFunc :: C_TimelineProgressFunc -> IO (FunPtr C_TimelineProgressFunc)

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

noTimelineProgressFunc :: Maybe TimelineProgressFunc

A convenience synonym for Nothing :: Maybe TimelineProgressFunc.

noTimelineProgressFunc_WithClosures :: Maybe TimelineProgressFunc_WithClosures

A convenience synonym for Nothing :: Maybe TimelineProgressFunc_WithClosures.

wrap_TimelineProgressFunc :: Maybe (Ptr (FunPtr C_TimelineProgressFunc)) -> TimelineProgressFunc_WithClosures -> C_TimelineProgressFunc

Wrap a TimelineProgressFunc into a C_TimelineProgressFunc.