gi-vips-8.0.5: libvips GObject bindings
CopyrightWill Thompson and Iñaki García Etxebarria
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria
Safe HaskellSafe-Inferred
LanguageHaskell2010

GI.Vips.Callbacks

Description

 
Synopsis

Signals

ArgumentClassMapFn

type ArgumentClassMapFn = ObjectClass -> GParamSpec -> ArgumentClass -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

type ArgumentClassMapFn_WithClosures = ObjectClass -> GParamSpec -> ArgumentClass -> Ptr () -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

type C_ArgumentClassMapFn = Ptr ObjectClass -> Ptr GParamSpec -> Ptr ArgumentClass -> Ptr () -> Ptr () -> IO (Ptr ()) Source #

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

drop_closures_ArgumentClassMapFn :: ArgumentClassMapFn -> ArgumentClassMapFn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ArgumentClassMapFn :: (HasCallStack, MonadIO m) => FunPtr C_ArgumentClassMapFn -> ObjectClass -> GParamSpec -> ArgumentClass -> Ptr () -> Ptr () -> m (Ptr ()) Source #

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

genClosure_ArgumentClassMapFn :: MonadIO m => ArgumentClassMapFn -> m (GClosure C_ArgumentClassMapFn) Source #

Wrap the callback into a GClosure.

mk_ArgumentClassMapFn :: C_ArgumentClassMapFn -> IO (FunPtr C_ArgumentClassMapFn) Source #

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

ArgumentMapFn

type ArgumentMapFn = Object -> GParamSpec -> ArgumentClass -> ArgumentInstance -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

type ArgumentMapFn_WithClosures = Object -> GParamSpec -> ArgumentClass -> ArgumentInstance -> Ptr () -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

type C_ArgumentMapFn = Ptr Object -> Ptr GParamSpec -> Ptr ArgumentClass -> Ptr ArgumentInstance -> Ptr () -> Ptr () -> IO (Ptr ()) Source #

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

drop_closures_ArgumentMapFn :: ArgumentMapFn -> ArgumentMapFn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ArgumentMapFn :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ArgumentMapFn -> a -> GParamSpec -> ArgumentClass -> ArgumentInstance -> Ptr () -> Ptr () -> m (Ptr ()) Source #

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

genClosure_ArgumentMapFn :: MonadIO m => ArgumentMapFn -> m (GClosure C_ArgumentMapFn) Source #

Wrap the callback into a GClosure.

mk_ArgumentMapFn :: C_ArgumentMapFn -> IO (FunPtr C_ArgumentMapFn) Source #

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

CallbackFn

type C_CallbackFn = Ptr () -> Ptr () -> IO Int32 Source #

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

type CallbackFn = Ptr () -> IO Int32 Source #

No description available in the introspection data.

type CallbackFn_WithClosures = Ptr () -> Ptr () -> IO Int32 Source #

No description available in the introspection data.

drop_closures_CallbackFn :: CallbackFn -> CallbackFn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CallbackFn :: (HasCallStack, MonadIO m) => FunPtr C_CallbackFn -> Ptr () -> Ptr () -> m Int32 Source #

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

genClosure_CallbackFn :: MonadIO m => CallbackFn -> m (GClosure C_CallbackFn) Source #

Wrap the callback into a GClosure.

mk_CallbackFn :: C_CallbackFn -> IO (FunPtr C_CallbackFn) Source #

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

noCallbackFn :: Maybe CallbackFn Source #

A convenience synonym for Nothing :: Maybe CallbackFn.

ClassMapFn

type C_ClassMapFn = Ptr ObjectClass -> Ptr () -> IO (Ptr ()) Source #

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

type ClassMapFn = ObjectClass -> IO (Ptr ()) Source #

No description available in the introspection data.

type ClassMapFn_WithClosures = ObjectClass -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

drop_closures_ClassMapFn :: ClassMapFn -> ClassMapFn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClassMapFn :: (HasCallStack, MonadIO m) => FunPtr C_ClassMapFn -> ObjectClass -> Ptr () -> m (Ptr ()) Source #

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

genClosure_ClassMapFn :: MonadIO m => ClassMapFn -> m (GClosure C_ClassMapFn) Source #

Wrap the callback into a GClosure.

mk_ClassMapFn :: C_ClassMapFn -> IO (FunPtr C_ClassMapFn) Source #

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

noClassMapFn :: Maybe ClassMapFn Source #

A convenience synonym for Nothing :: Maybe ClassMapFn.

GenerateFn

type C_GenerateFn = Ptr Region -> Ptr () -> Ptr () -> Ptr () -> CInt -> IO Int32 Source #

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

type GenerateFn Source #

Arguments

 = Region

out: Region to fill

-> Ptr ()

seq: sequence value

-> Ptr ()

a: user data

-> Ptr ()

b: user data

-> Bool

stop: set this to stop processing

-> IO Int32

Returns: 0 on success, -1 on error.

Fill out->valid with pixels. seq contains per-thread state, such as the input regions. Set stop to True to stop processing.

See also: vips_image_generate(), vips_stop_many().

dynamic_GenerateFn Source #

Arguments

:: (HasCallStack, MonadIO m, IsRegion a) 
=> FunPtr C_GenerateFn 
-> a

out: Region to fill

-> Ptr ()

seq: sequence value

-> Ptr ()

a: user data

-> Ptr ()

b: user data

-> Bool

stop: set this to stop processing

-> m Int32

Returns: 0 on success, -1 on error.

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

genClosure_GenerateFn :: MonadIO m => GenerateFn -> m (GClosure C_GenerateFn) Source #

Wrap the callback into a GClosure.

mk_GenerateFn :: C_GenerateFn -> IO (FunPtr C_GenerateFn) Source #

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

noGenerateFn :: Maybe GenerateFn Source #

A convenience synonym for Nothing :: Maybe GenerateFn.

ImageMapFn

type C_ImageMapFn = Ptr Image -> CString -> Ptr GValue -> Ptr () -> IO (Ptr ()) Source #

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

type ImageMapFn = Image -> Text -> GValue -> IO (Ptr ()) Source #

No description available in the introspection data.

type ImageMapFn_WithClosures = Image -> Text -> GValue -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

drop_closures_ImageMapFn :: ImageMapFn -> ImageMapFn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ImageMapFn :: (HasCallStack, MonadIO m, IsImage a) => FunPtr C_ImageMapFn -> a -> Text -> GValue -> Ptr () -> m (Ptr ()) Source #

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

genClosure_ImageMapFn :: MonadIO m => ImageMapFn -> m (GClosure C_ImageMapFn) Source #

Wrap the callback into a GClosure.

mk_ImageMapFn :: C_ImageMapFn -> IO (FunPtr C_ImageMapFn) Source #

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

noImageMapFn :: Maybe ImageMapFn Source #

A convenience synonym for Nothing :: Maybe ImageMapFn.

InterpolateMethod

type C_InterpolateMethod = Ptr Interpolate -> Ptr () -> Ptr Region -> CDouble -> CDouble -> IO () Source #

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

type InterpolateMethod Source #

Arguments

 = Interpolate

interpolate: the interpolator

-> Ptr ()

out: write the interpolated pixel here

-> Region

in: read source pixels from here

-> Double

x: interpolate value at this position

-> Double

y: interpolate value at this position

-> IO () 

An interpolation function. It should read source pixels from in with VIPS_REGION_ADDR(), it can look left and up from (x, y) by windowOffset pixels and it can access pixels in a window of size windowSize.

The interpolated value should be written to the pixel pointed to by out.

See also: InterpolateClass.

dynamic_InterpolateMethod Source #

Arguments

:: (HasCallStack, MonadIO m, IsInterpolate a, IsRegion b) 
=> FunPtr C_InterpolateMethod 
-> a

interpolate: the interpolator

-> Ptr ()

out: write the interpolated pixel here

-> b

in: read source pixels from here

-> Double

x: interpolate value at this position

-> Double

y: interpolate value at this position

-> m () 

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

genClosure_InterpolateMethod :: MonadIO m => InterpolateMethod -> m (GClosure C_InterpolateMethod) Source #

Wrap the callback into a GClosure.

mk_InterpolateMethod :: C_InterpolateMethod -> IO (FunPtr C_InterpolateMethod) Source #

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

ObjectClassBuildFieldCallback

type C_ObjectClassBuildFieldCallback = Ptr Object -> IO Int32 Source #

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

type ObjectClassBuildFieldCallback = Object -> IO Int32 Source #

No description available in the introspection data.

dynamic_ObjectClassBuildFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassBuildFieldCallback -> a -> m Int32 Source #

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

ObjectClassCloseFieldCallback

type C_ObjectClassCloseFieldCallback = Ptr Object -> IO () Source #

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

type ObjectClassCloseFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassCloseFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassCloseFieldCallback -> a -> m () Source #

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

ObjectClassDumpFieldCallback

type C_ObjectClassDumpFieldCallback = Ptr Object -> Ptr Buf -> IO () Source #

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

type ObjectClassDumpFieldCallback Source #

Arguments

 = Object

object: object to dump

-> Buf

buf: write dump here

-> IO () 

No description available in the introspection data.

dynamic_ObjectClassDumpFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) 
=> FunPtr C_ObjectClassDumpFieldCallback 
-> a

object: object to dump

-> Buf

buf: write dump here

-> m () 

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

ObjectClassOutputToArgFieldCallback

type C_ObjectClassOutputToArgFieldCallback = Ptr Object -> CString -> IO Int32 Source #

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

type ObjectClassOutputToArgFieldCallback = Object -> Text -> IO Int32 Source #

No description available in the introspection data.

dynamic_ObjectClassOutputToArgFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassOutputToArgFieldCallback -> a -> Text -> m Int32 Source #

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

ObjectClassPostbuildFieldCallback

type C_ObjectClassPostbuildFieldCallback = Ptr Object -> Ptr () -> IO Int32 Source #

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

type ObjectClassPostbuildFieldCallback = Object -> IO Int32 Source #

No description available in the introspection data.

type ObjectClassPostbuildFieldCallback_WithClosures = Object -> Ptr () -> IO Int32 Source #

No description available in the introspection data.

dynamic_ObjectClassPostbuildFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassPostbuildFieldCallback -> a -> Ptr () -> m Int32 Source #

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

ObjectClassPostcloseFieldCallback

type C_ObjectClassPostcloseFieldCallback = Ptr Object -> IO () Source #

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

type ObjectClassPostcloseFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassPostcloseFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassPostcloseFieldCallback -> a -> m () Source #

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

ObjectClassPrecloseFieldCallback

type C_ObjectClassPrecloseFieldCallback = Ptr Object -> IO () Source #

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

type ObjectClassPrecloseFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassPrecloseFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassPrecloseFieldCallback -> a -> m () Source #

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

ObjectClassRewindFieldCallback

type C_ObjectClassRewindFieldCallback = Ptr Object -> IO () Source #

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

type ObjectClassRewindFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassRewindFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassRewindFieldCallback -> a -> m () Source #

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

ObjectClassSanityFieldCallback

type C_ObjectClassSanityFieldCallback = Ptr Object -> Ptr Buf -> IO () Source #

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

type ObjectClassSanityFieldCallback = Object -> Buf -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassSanityFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassSanityFieldCallback -> a -> Buf -> m () Source #

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

ObjectClassSummaryClassFieldCallback

type C_ObjectClassSummaryClassFieldCallback = Ptr () -> Ptr Buf -> IO () Source #

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

type ObjectClassSummaryClassFieldCallback = Ptr () -> Buf -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassSummaryClassFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ObjectClassSummaryClassFieldCallback -> Ptr () -> Buf -> m () Source #

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

ObjectClassSummaryFieldCallback

type C_ObjectClassSummaryFieldCallback = Ptr Object -> Ptr Buf -> IO () Source #

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

type ObjectClassSummaryFieldCallback Source #

Arguments

 = Object

object: object to summarise

-> Buf

buf: write summary here

-> IO () 

No description available in the introspection data.

dynamic_ObjectClassSummaryFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) 
=> FunPtr C_ObjectClassSummaryFieldCallback 
-> a

object: object to summarise

-> Buf

buf: write summary here

-> m () 

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

ObjectClassToStringFieldCallback

type C_ObjectClassToStringFieldCallback = Ptr Object -> Ptr Buf -> IO () Source #

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

type ObjectClassToStringFieldCallback Source #

Arguments

 = Object

object: object to stringify

-> Buf

buf: write string here

-> IO () 

No description available in the introspection data.

dynamic_ObjectClassToStringFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) 
=> FunPtr C_ObjectClassToStringFieldCallback 
-> a

object: object to stringify

-> Buf

buf: write string here

-> m () 

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

ObjectSetArguments

type C_ObjectSetArguments = Ptr Object -> Ptr () -> Ptr () -> IO (Ptr ()) Source #

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

type ObjectSetArguments = Object -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

type ObjectSetArguments_WithClosures = Object -> Ptr () -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

drop_closures_ObjectSetArguments :: ObjectSetArguments -> ObjectSetArguments_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ObjectSetArguments :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectSetArguments -> a -> Ptr () -> Ptr () -> m (Ptr ()) Source #

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

genClosure_ObjectSetArguments :: MonadIO m => ObjectSetArguments -> m (GClosure C_ObjectSetArguments) Source #

Wrap the callback into a GClosure.

mk_ObjectSetArguments :: C_ObjectSetArguments -> IO (FunPtr C_ObjectSetArguments) Source #

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

OperationBuildFn

type C_OperationBuildFn = Ptr Object -> IO CInt Source #

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

type OperationBuildFn = Object -> IO Bool Source #

No description available in the introspection data.

dynamic_OperationBuildFn :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_OperationBuildFn -> a -> m Bool Source #

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

genClosure_OperationBuildFn :: MonadIO m => OperationBuildFn -> m (GClosure C_OperationBuildFn) Source #

Wrap the callback into a GClosure.

mk_OperationBuildFn :: C_OperationBuildFn -> IO (FunPtr C_OperationBuildFn) Source #

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

SListFold2Fn

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_SListFold2Fn :: SListFold2Fn -> SListFold2Fn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SListFold2Fn :: (HasCallStack, MonadIO m) => FunPtr C_SListFold2Fn -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> m (Ptr ()) Source #

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

genClosure_SListFold2Fn :: MonadIO m => SListFold2Fn -> m (GClosure C_SListFold2Fn) Source #

Wrap the callback into a GClosure.

mk_SListFold2Fn :: C_SListFold2Fn -> IO (FunPtr C_SListFold2Fn) Source #

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

SListMap2Fn

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_SListMap2Fn :: SListMap2Fn -> SListMap2Fn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SListMap2Fn :: (HasCallStack, MonadIO m) => FunPtr C_SListMap2Fn -> Ptr () -> Ptr () -> Ptr () -> m (Ptr ()) Source #

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

genClosure_SListMap2Fn :: MonadIO m => SListMap2Fn -> m (GClosure C_SListMap2Fn) Source #

Wrap the callback into a GClosure.

mk_SListMap2Fn :: C_SListMap2Fn -> IO (FunPtr C_SListMap2Fn) Source #

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

SListMap4Fn

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_SListMap4Fn :: SListMap4Fn -> SListMap4Fn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SListMap4Fn :: (HasCallStack, MonadIO m) => FunPtr C_SListMap4Fn -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> m (Ptr ()) Source #

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

genClosure_SListMap4Fn :: MonadIO m => SListMap4Fn -> m (GClosure C_SListMap4Fn) Source #

Wrap the callback into a GClosure.

mk_SListMap4Fn :: C_SListMap4Fn -> IO (FunPtr C_SListMap4Fn) Source #

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

StartFn

type C_StartFn = Ptr Image -> Ptr () -> Ptr () -> IO (Ptr ()) Source #

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

type StartFn Source #

Arguments

 = Image

out: image being calculated

-> Ptr ()

a: user data

-> IO (Ptr ())

Returns: a new sequence value

Start a new processing sequence for this generate function. This allocates per-thread state, such as an input region.

See also: vips_start_one(), vips_start_many().

type StartFn_WithClosures Source #

Arguments

 = Image

out: image being calculated

-> Ptr ()

a: user data

-> Ptr ()

b: user data

-> IO (Ptr ())

Returns: a new sequence value

Start a new processing sequence for this generate function. This allocates per-thread state, such as an input region.

See also: vips_start_one(), vips_start_many().

drop_closures_StartFn :: StartFn -> StartFn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_StartFn Source #

Arguments

:: (HasCallStack, MonadIO m, IsImage a) 
=> FunPtr C_StartFn 
-> a

out: image being calculated

-> Ptr ()

a: user data

-> Ptr ()

b: user data

-> m (Ptr ())

Returns: a new sequence value

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

genClosure_StartFn :: MonadIO m => StartFn -> m (GClosure C_StartFn) Source #

Wrap the callback into a GClosure.

mk_StartFn :: C_StartFn -> IO (FunPtr C_StartFn) Source #

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

noStartFn :: Maybe StartFn Source #

A convenience synonym for Nothing :: Maybe StartFn.

StopFn

type C_StopFn = Ptr () -> Ptr () -> Ptr () -> IO Int32 Source #

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

type StopFn Source #

Arguments

 = Ptr ()

seq: sequence value

-> Ptr ()

a: user data

-> IO Int32

Returns: 0 on success, -1 on error.

Stop a processing sequence. This frees per-thread state, such as an input region.

See also: vips_stop_one(), vips_stop_many().

type StopFn_WithClosures Source #

Arguments

 = Ptr ()

seq: sequence value

-> Ptr ()

a: user data

-> Ptr ()

b: user data

-> IO Int32

Returns: 0 on success, -1 on error.

Stop a processing sequence. This frees per-thread state, such as an input region.

See also: vips_stop_one(), vips_stop_many().

drop_closures_StopFn :: StopFn -> StopFn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_StopFn Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> FunPtr C_StopFn 
-> Ptr ()

seq: sequence value

-> Ptr ()

a: user data

-> Ptr ()

b: user data

-> m Int32

Returns: 0 on success, -1 on error.

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

genClosure_StopFn :: MonadIO m => StopFn -> m (GClosure C_StopFn) Source #

Wrap the callback into a GClosure.

mk_StopFn :: C_StopFn -> IO (FunPtr C_StopFn) Source #

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

noStopFn :: Maybe StopFn Source #

A convenience synonym for Nothing :: Maybe StopFn.

TypeMap2Fn

type C_TypeMap2Fn = CGType -> Ptr () -> Ptr () -> IO (Ptr ()) Source #

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

type TypeMap2Fn = GType -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

type TypeMap2Fn_WithClosures = GType -> Ptr () -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

drop_closures_TypeMap2Fn :: TypeMap2Fn -> TypeMap2Fn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TypeMap2Fn :: (HasCallStack, MonadIO m) => FunPtr C_TypeMap2Fn -> GType -> Ptr () -> Ptr () -> m (Ptr ()) Source #

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

genClosure_TypeMap2Fn :: MonadIO m => TypeMap2Fn -> m (GClosure C_TypeMap2Fn) Source #

Wrap the callback into a GClosure.

mk_TypeMap2Fn :: C_TypeMap2Fn -> IO (FunPtr C_TypeMap2Fn) Source #

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

noTypeMap2Fn :: Maybe TypeMap2Fn Source #

A convenience synonym for Nothing :: Maybe TypeMap2Fn.

TypeMapFn

type C_TypeMapFn = CGType -> Ptr () -> IO (Ptr ()) Source #

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

type TypeMapFn = GType -> IO (Ptr ()) Source #

No description available in the introspection data.

type TypeMapFn_WithClosures = GType -> Ptr () -> IO (Ptr ()) Source #

No description available in the introspection data.

drop_closures_TypeMapFn :: TypeMapFn -> TypeMapFn_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TypeMapFn :: (HasCallStack, MonadIO m) => FunPtr C_TypeMapFn -> GType -> Ptr () -> m (Ptr ()) Source #

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

genClosure_TypeMapFn :: MonadIO m => TypeMapFn -> m (GClosure C_TypeMapFn) Source #

Wrap the callback into a GClosure.

mk_TypeMapFn :: C_TypeMapFn -> IO (FunPtr C_TypeMapFn) Source #

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

noTypeMapFn :: Maybe TypeMapFn Source #

A convenience synonym for Nothing :: Maybe TypeMapFn.