GI.Vips.Callbacks

Signals

ArgumentClassMapFn

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

No description available in the introspection data.

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

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

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

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)

Wrap the callback into a GClosure.

mk_ArgumentClassMapFn :: C_ArgumentClassMapFn -> IO (FunPtr C_ArgumentClassMapFn)

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

noArgumentClassMapFn :: Maybe ArgumentClassMapFn

A convenience synonym for Nothing :: Maybe ArgumentClassMapFn.

wrap_ArgumentClassMapFn :: Maybe (Ptr (FunPtr C_ArgumentClassMapFn)) -> ArgumentClassMapFn -> C_ArgumentClassMapFn

Wrap a ArgumentClassMapFn into a C_ArgumentClassMapFn.

ArgumentMapFn

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

No description available in the introspection data.

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

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

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

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)

Wrap the callback into a GClosure.

mk_ArgumentMapFn :: C_ArgumentMapFn -> IO (FunPtr C_ArgumentMapFn)

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

noArgumentMapFn :: Maybe ArgumentMapFn

A convenience synonym for Nothing :: Maybe ArgumentMapFn.

wrap_ArgumentMapFn :: Maybe (Ptr (FunPtr C_ArgumentMapFn)) -> ArgumentMapFn -> C_ArgumentMapFn

Wrap a ArgumentMapFn into a C_ArgumentMapFn.

CallbackFn

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

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

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

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_CallbackFn :: C_CallbackFn -> IO (FunPtr C_CallbackFn)

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

noCallbackFn :: Maybe CallbackFn

A convenience synonym for Nothing :: Maybe CallbackFn.

wrap_CallbackFn :: Maybe (Ptr (FunPtr C_CallbackFn)) -> CallbackFn -> C_CallbackFn

Wrap a CallbackFn into a C_CallbackFn.

ClassMapFn

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

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

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

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_ClassMapFn :: C_ClassMapFn -> IO (FunPtr C_ClassMapFn)

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

noClassMapFn :: Maybe ClassMapFn

A convenience synonym for Nothing :: Maybe ClassMapFn.

wrap_ClassMapFn :: Maybe (Ptr (FunPtr C_ClassMapFn)) -> ClassMapFn -> C_ClassMapFn

Wrap a ClassMapFn into a C_ClassMapFn.

GenerateFn

type C_GenerateFn = Ptr () -> Ptr () -> Ptr () -> Ptr () -> CInt -> IO Int32

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

type GenerateFn

Arguments

 = Ptr ()

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

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_GenerateFn

-> Ptr ()

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)

Wrap the callback into a GClosure.

mk_GenerateFn :: C_GenerateFn -> IO (FunPtr C_GenerateFn)

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

noGenerateFn :: Maybe GenerateFn

A convenience synonym for Nothing :: Maybe GenerateFn.

wrap_GenerateFn :: Maybe (Ptr (FunPtr C_GenerateFn)) -> GenerateFn -> C_GenerateFn

Wrap a GenerateFn into a C_GenerateFn.

ImageMapFn

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

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

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

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_ImageMapFn :: C_ImageMapFn -> IO (FunPtr C_ImageMapFn)

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

noImageMapFn :: Maybe ImageMapFn

A convenience synonym for Nothing :: Maybe ImageMapFn.

wrap_ImageMapFn :: Maybe (Ptr (FunPtr C_ImageMapFn)) -> ImageMapFn -> C_ImageMapFn

Wrap a ImageMapFn into a C_ImageMapFn.

InterpolateMethod

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

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

type InterpolateMethod

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

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)

Wrap the callback into a GClosure.

mk_InterpolateMethod :: C_InterpolateMethod -> IO (FunPtr C_InterpolateMethod)

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

noInterpolateMethod :: Maybe InterpolateMethod

A convenience synonym for Nothing :: Maybe InterpolateMethod.

wrap_InterpolateMethod :: Maybe (Ptr (FunPtr C_InterpolateMethod)) -> InterpolateMethod -> C_InterpolateMethod

Wrap a InterpolateMethod into a C_InterpolateMethod.

ObjectClassBuildFieldCallback

type C_ObjectClassBuildFieldCallback = Ptr Object -> IO Int32

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

type ObjectClassBuildFieldCallback = Object -> IO Int32

No description available in the introspection data.

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

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

genClosure_ObjectClassBuildFieldCallback :: MonadIO m => ObjectClassBuildFieldCallback -> m (GClosure C_ObjectClassBuildFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassBuildFieldCallback :: C_ObjectClassBuildFieldCallback -> IO (FunPtr C_ObjectClassBuildFieldCallback)

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

noObjectClassBuildFieldCallback :: Maybe ObjectClassBuildFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassBuildFieldCallback.

wrap_ObjectClassBuildFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassBuildFieldCallback)) -> ObjectClassBuildFieldCallback -> C_ObjectClassBuildFieldCallback

Wrap a ObjectClassBuildFieldCallback into a C_ObjectClassBuildFieldCallback.

ObjectClassCloseFieldCallback

type C_ObjectClassCloseFieldCallback = Ptr Object -> IO ()

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

type ObjectClassCloseFieldCallback = Object -> IO ()

No description available in the introspection data.

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

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

genClosure_ObjectClassCloseFieldCallback :: MonadIO m => ObjectClassCloseFieldCallback -> m (GClosure C_ObjectClassCloseFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassCloseFieldCallback :: C_ObjectClassCloseFieldCallback -> IO (FunPtr C_ObjectClassCloseFieldCallback)

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

noObjectClassCloseFieldCallback :: Maybe ObjectClassCloseFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassCloseFieldCallback.

wrap_ObjectClassCloseFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassCloseFieldCallback)) -> ObjectClassCloseFieldCallback -> C_ObjectClassCloseFieldCallback

Wrap a ObjectClassCloseFieldCallback into a C_ObjectClassCloseFieldCallback.

ObjectClassOutputToArgFieldCallback

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

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

type ObjectClassOutputToArgFieldCallback = Object -> Text -> IO Int32

No description available in the introspection data.

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

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

genClosure_ObjectClassOutputToArgFieldCallback :: MonadIO m => ObjectClassOutputToArgFieldCallback -> m (GClosure C_ObjectClassOutputToArgFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassOutputToArgFieldCallback :: C_ObjectClassOutputToArgFieldCallback -> IO (FunPtr C_ObjectClassOutputToArgFieldCallback)

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

noObjectClassOutputToArgFieldCallback :: Maybe ObjectClassOutputToArgFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassOutputToArgFieldCallback.

wrap_ObjectClassOutputToArgFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)) -> ObjectClassOutputToArgFieldCallback -> C_ObjectClassOutputToArgFieldCallback

Wrap a ObjectClassOutputToArgFieldCallback into a C_ObjectClassOutputToArgFieldCallback.

ObjectClassPostbuildFieldCallback

type C_ObjectClassPostbuildFieldCallback = Ptr Object -> IO Int32

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

type ObjectClassPostbuildFieldCallback = Object -> IO Int32

No description available in the introspection data.

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

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

genClosure_ObjectClassPostbuildFieldCallback :: MonadIO m => ObjectClassPostbuildFieldCallback -> m (GClosure C_ObjectClassPostbuildFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassPostbuildFieldCallback :: C_ObjectClassPostbuildFieldCallback -> IO (FunPtr C_ObjectClassPostbuildFieldCallback)

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

noObjectClassPostbuildFieldCallback :: Maybe ObjectClassPostbuildFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassPostbuildFieldCallback.

wrap_ObjectClassPostbuildFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)) -> ObjectClassPostbuildFieldCallback -> C_ObjectClassPostbuildFieldCallback

Wrap a ObjectClassPostbuildFieldCallback into a C_ObjectClassPostbuildFieldCallback.

ObjectClassPostcloseFieldCallback

type C_ObjectClassPostcloseFieldCallback = Ptr Object -> IO ()

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

type ObjectClassPostcloseFieldCallback = Object -> IO ()

No description available in the introspection data.

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

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

genClosure_ObjectClassPostcloseFieldCallback :: MonadIO m => ObjectClassPostcloseFieldCallback -> m (GClosure C_ObjectClassPostcloseFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassPostcloseFieldCallback :: C_ObjectClassPostcloseFieldCallback -> IO (FunPtr C_ObjectClassPostcloseFieldCallback)

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

noObjectClassPostcloseFieldCallback :: Maybe ObjectClassPostcloseFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassPostcloseFieldCallback.

wrap_ObjectClassPostcloseFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassPostcloseFieldCallback)) -> ObjectClassPostcloseFieldCallback -> C_ObjectClassPostcloseFieldCallback

Wrap a ObjectClassPostcloseFieldCallback into a C_ObjectClassPostcloseFieldCallback.

ObjectClassPrecloseFieldCallback

type C_ObjectClassPrecloseFieldCallback = Ptr Object -> IO ()

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

type ObjectClassPrecloseFieldCallback = Object -> IO ()

No description available in the introspection data.

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

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

genClosure_ObjectClassPrecloseFieldCallback :: MonadIO m => ObjectClassPrecloseFieldCallback -> m (GClosure C_ObjectClassPrecloseFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassPrecloseFieldCallback :: C_ObjectClassPrecloseFieldCallback -> IO (FunPtr C_ObjectClassPrecloseFieldCallback)

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

noObjectClassPrecloseFieldCallback :: Maybe ObjectClassPrecloseFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassPrecloseFieldCallback.

wrap_ObjectClassPrecloseFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassPrecloseFieldCallback)) -> ObjectClassPrecloseFieldCallback -> C_ObjectClassPrecloseFieldCallback

Wrap a ObjectClassPrecloseFieldCallback into a C_ObjectClassPrecloseFieldCallback.

ObjectClassRewindFieldCallback

type C_ObjectClassRewindFieldCallback = Ptr Object -> IO ()

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

type ObjectClassRewindFieldCallback = Object -> IO ()

No description available in the introspection data.

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

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

genClosure_ObjectClassRewindFieldCallback :: MonadIO m => ObjectClassRewindFieldCallback -> m (GClosure C_ObjectClassRewindFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassRewindFieldCallback :: C_ObjectClassRewindFieldCallback -> IO (FunPtr C_ObjectClassRewindFieldCallback)

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

noObjectClassRewindFieldCallback :: Maybe ObjectClassRewindFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassRewindFieldCallback.

wrap_ObjectClassRewindFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassRewindFieldCallback)) -> ObjectClassRewindFieldCallback -> C_ObjectClassRewindFieldCallback

Wrap a ObjectClassRewindFieldCallback into a C_ObjectClassRewindFieldCallback.

ObjectSetArguments

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

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

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

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_ObjectSetArguments :: C_ObjectSetArguments -> IO (FunPtr C_ObjectSetArguments)

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

noObjectSetArguments :: Maybe ObjectSetArguments

A convenience synonym for Nothing :: Maybe ObjectSetArguments.

wrap_ObjectSetArguments :: Maybe (Ptr (FunPtr C_ObjectSetArguments)) -> ObjectSetArguments -> C_ObjectSetArguments

Wrap a ObjectSetArguments into a C_ObjectSetArguments.

OperationBuildFn

type C_OperationBuildFn = Ptr Object -> IO CInt

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

type OperationBuildFn = Object -> IO Bool

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_OperationBuildFn :: C_OperationBuildFn -> IO (FunPtr C_OperationBuildFn)

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

noOperationBuildFn :: Maybe OperationBuildFn

A convenience synonym for Nothing :: Maybe OperationBuildFn.

wrap_OperationBuildFn :: Maybe (Ptr (FunPtr C_OperationBuildFn)) -> OperationBuildFn -> C_OperationBuildFn

Wrap a OperationBuildFn into a C_OperationBuildFn.

SListFold2Fn

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

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

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

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_SListFold2Fn :: C_SListFold2Fn -> IO (FunPtr C_SListFold2Fn)

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

noSListFold2Fn :: Maybe SListFold2Fn

A convenience synonym for Nothing :: Maybe SListFold2Fn.

wrap_SListFold2Fn :: Maybe (Ptr (FunPtr C_SListFold2Fn)) -> SListFold2Fn -> C_SListFold2Fn

Wrap a SListFold2Fn into a C_SListFold2Fn.

SListMap2Fn

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

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

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

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_SListMap2Fn :: C_SListMap2Fn -> IO (FunPtr C_SListMap2Fn)

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

noSListMap2Fn :: Maybe SListMap2Fn

A convenience synonym for Nothing :: Maybe SListMap2Fn.

wrap_SListMap2Fn :: Maybe (Ptr (FunPtr C_SListMap2Fn)) -> SListMap2Fn -> C_SListMap2Fn

Wrap a SListMap2Fn into a C_SListMap2Fn.

SListMap4Fn

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

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

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

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_SListMap4Fn :: C_SListMap4Fn -> IO (FunPtr C_SListMap4Fn)

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

noSListMap4Fn :: Maybe SListMap4Fn

A convenience synonym for Nothing :: Maybe SListMap4Fn.

wrap_SListMap4Fn :: Maybe (Ptr (FunPtr C_SListMap4Fn)) -> SListMap4Fn -> C_SListMap4Fn

Wrap a SListMap4Fn into a C_SListMap4Fn.

StartFn

type C_StartFn = Ptr () -> Ptr () -> Ptr () -> IO (Ptr ())

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

type StartFn

Arguments

 = Ptr ()

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().

dynamic_StartFn

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_StartFn

-> Ptr ()

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)

Wrap the callback into a GClosure.

mk_StartFn :: C_StartFn -> IO (FunPtr C_StartFn)

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

noStartFn :: Maybe StartFn

A convenience synonym for Nothing :: Maybe StartFn.

wrap_StartFn :: Maybe (Ptr (FunPtr C_StartFn)) -> StartFn -> C_StartFn

Wrap a StartFn into a C_StartFn.

StopFn

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

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

type StopFn

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().

dynamic_StopFn

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)

Wrap the callback into a GClosure.

mk_StopFn :: C_StopFn -> IO (FunPtr C_StopFn)

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

noStopFn :: Maybe StopFn

A convenience synonym for Nothing :: Maybe StopFn.

wrap_StopFn :: Maybe (Ptr (FunPtr C_StopFn)) -> StopFn -> C_StopFn

Wrap a StopFn into a C_StopFn.

TypeMap2Fn

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

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

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

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_TypeMap2Fn :: C_TypeMap2Fn -> IO (FunPtr C_TypeMap2Fn)

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

noTypeMap2Fn :: Maybe TypeMap2Fn

A convenience synonym for Nothing :: Maybe TypeMap2Fn.

wrap_TypeMap2Fn :: Maybe (Ptr (FunPtr C_TypeMap2Fn)) -> TypeMap2Fn -> C_TypeMap2Fn

Wrap a TypeMap2Fn into a C_TypeMap2Fn.

TypeMapFn

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

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

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

No description available in the introspection data.

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

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)

Wrap the callback into a GClosure.

mk_TypeMapFn :: C_TypeMapFn -> IO (FunPtr C_TypeMapFn)

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

noTypeMapFn :: Maybe TypeMapFn

A convenience synonym for Nothing :: Maybe TypeMapFn.

wrap_TypeMapFn :: Maybe (Ptr (FunPtr C_TypeMapFn)) -> TypeMapFn -> C_TypeMapFn

Wrap a TypeMapFn into a C_TypeMapFn.