GI.Vips.Callbacks

Signals

ArgumentClassMapFn

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

No description available in the introspection data.

type ArgumentClassMapFn_WithClosures = 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.

drop_closures_ArgumentClassMapFn :: ArgumentClassMapFn -> ArgumentClassMapFn_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noArgumentClassMapFn_WithClosures :: Maybe ArgumentClassMapFn_WithClosures

A convenience synonym for Nothing :: Maybe ArgumentClassMapFn_WithClosures.

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

Wrap a ArgumentClassMapFn into a C_ArgumentClassMapFn.

ArgumentMapFn

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

No description available in the introspection data.

type ArgumentMapFn_WithClosures = 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.

drop_closures_ArgumentMapFn :: ArgumentMapFn -> ArgumentMapFn_WithClosures

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

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.

noArgumentMapFn_WithClosures :: Maybe ArgumentMapFn_WithClosures

A convenience synonym for Nothing :: Maybe ArgumentMapFn_WithClosures.

wrap_ArgumentMapFn :: Maybe (Ptr (FunPtr C_ArgumentMapFn)) -> ArgumentMapFn_WithClosures -> 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 () -> IO Int32

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_CallbackFn :: CallbackFn -> CallbackFn_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noCallbackFn_WithClosures :: Maybe CallbackFn_WithClosures

A convenience synonym for Nothing :: Maybe CallbackFn_WithClosures.

wrap_CallbackFn :: Maybe (Ptr (FunPtr C_CallbackFn)) -> CallbackFn_WithClosures -> 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 -> IO (Ptr ())

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_ClassMapFn :: ClassMapFn -> ClassMapFn_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noClassMapFn_WithClosures :: Maybe ClassMapFn_WithClosures

A convenience synonym for Nothing :: Maybe ClassMapFn_WithClosures.

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

Wrap a ClassMapFn into a C_ClassMapFn.

GenerateFn

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

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

type GenerateFn

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

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)

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 -> IO (Ptr ())

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_ImageMapFn :: ImageMapFn -> ImageMapFn_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noImageMapFn_WithClosures :: Maybe ImageMapFn_WithClosures

A convenience synonym for Nothing :: Maybe ImageMapFn_WithClosures.

wrap_ImageMapFn :: Maybe (Ptr (FunPtr C_ImageMapFn)) -> ImageMapFn_WithClosures -> 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.

ObjectClassDumpFieldCallback

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

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

type ObjectClassDumpFieldCallback

Arguments

 = Object

object: object to dump

-> Buf

buf: write dump here

-> IO ()

No description available in the introspection data.

dynamic_ObjectClassDumpFieldCallback

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.

genClosure_ObjectClassDumpFieldCallback :: MonadIO m => ObjectClassDumpFieldCallback -> m (GClosure C_ObjectClassDumpFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassDumpFieldCallback :: C_ObjectClassDumpFieldCallback -> IO (FunPtr C_ObjectClassDumpFieldCallback)

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

noObjectClassDumpFieldCallback :: Maybe ObjectClassDumpFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassDumpFieldCallback.

wrap_ObjectClassDumpFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassDumpFieldCallback)) -> ObjectClassDumpFieldCallback -> C_ObjectClassDumpFieldCallback

Wrap a ObjectClassDumpFieldCallback into a C_ObjectClassDumpFieldCallback.

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 -> Ptr () -> IO Int32

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

type ObjectClassPostbuildFieldCallback = Object -> IO Int32

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_ObjectClassPostbuildFieldCallback :: ObjectClassPostbuildFieldCallback -> ObjectClassPostbuildFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ObjectClassPostbuildFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassPostbuildFieldCallback -> a -> Ptr () -> 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.

noObjectClassPostbuildFieldCallback_WithClosures :: Maybe ObjectClassPostbuildFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe ObjectClassPostbuildFieldCallback_WithClosures.

wrap_ObjectClassPostbuildFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)) -> ObjectClassPostbuildFieldCallback_WithClosures -> 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.

ObjectClassSanityFieldCallback

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

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

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

No description available in the introspection data.

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

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

genClosure_ObjectClassSanityFieldCallback :: MonadIO m => ObjectClassSanityFieldCallback -> m (GClosure C_ObjectClassSanityFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassSanityFieldCallback :: C_ObjectClassSanityFieldCallback -> IO (FunPtr C_ObjectClassSanityFieldCallback)

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

noObjectClassSanityFieldCallback :: Maybe ObjectClassSanityFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassSanityFieldCallback.

wrap_ObjectClassSanityFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassSanityFieldCallback)) -> ObjectClassSanityFieldCallback -> C_ObjectClassSanityFieldCallback

Wrap a ObjectClassSanityFieldCallback into a C_ObjectClassSanityFieldCallback.

ObjectClassSummaryClassFieldCallback

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

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

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

No description available in the introspection data.

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

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

genClosure_ObjectClassSummaryClassFieldCallback :: MonadIO m => ObjectClassSummaryClassFieldCallback -> m (GClosure C_ObjectClassSummaryClassFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassSummaryClassFieldCallback :: C_ObjectClassSummaryClassFieldCallback -> IO (FunPtr C_ObjectClassSummaryClassFieldCallback)

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

noObjectClassSummaryClassFieldCallback :: Maybe ObjectClassSummaryClassFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassSummaryClassFieldCallback.

wrap_ObjectClassSummaryClassFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassSummaryClassFieldCallback)) -> ObjectClassSummaryClassFieldCallback -> C_ObjectClassSummaryClassFieldCallback

Wrap a ObjectClassSummaryClassFieldCallback into a C_ObjectClassSummaryClassFieldCallback.

ObjectClassSummaryFieldCallback

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

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

type ObjectClassSummaryFieldCallback

Arguments

 = Object

object: object to summarise

-> Buf

buf: write summary here

-> IO ()

No description available in the introspection data.

dynamic_ObjectClassSummaryFieldCallback

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.

genClosure_ObjectClassSummaryFieldCallback :: MonadIO m => ObjectClassSummaryFieldCallback -> m (GClosure C_ObjectClassSummaryFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassSummaryFieldCallback :: C_ObjectClassSummaryFieldCallback -> IO (FunPtr C_ObjectClassSummaryFieldCallback)

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

noObjectClassSummaryFieldCallback :: Maybe ObjectClassSummaryFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassSummaryFieldCallback.

wrap_ObjectClassSummaryFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassSummaryFieldCallback)) -> ObjectClassSummaryFieldCallback -> C_ObjectClassSummaryFieldCallback

Wrap a ObjectClassSummaryFieldCallback into a C_ObjectClassSummaryFieldCallback.

ObjectClassToStringFieldCallback

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

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

type ObjectClassToStringFieldCallback

Arguments

 = Object

object: object to stringify

-> Buf

buf: write string here

-> IO ()

No description available in the introspection data.

dynamic_ObjectClassToStringFieldCallback

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.

genClosure_ObjectClassToStringFieldCallback :: MonadIO m => ObjectClassToStringFieldCallback -> m (GClosure C_ObjectClassToStringFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassToStringFieldCallback :: C_ObjectClassToStringFieldCallback -> IO (FunPtr C_ObjectClassToStringFieldCallback)

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

noObjectClassToStringFieldCallback :: Maybe ObjectClassToStringFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassToStringFieldCallback.

wrap_ObjectClassToStringFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassToStringFieldCallback)) -> ObjectClassToStringFieldCallback -> C_ObjectClassToStringFieldCallback

Wrap a ObjectClassToStringFieldCallback into a C_ObjectClassToStringFieldCallback.

ObjectSetArguments

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_ObjectSetArguments :: ObjectSetArguments -> ObjectSetArguments_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noObjectSetArguments_WithClosures :: Maybe ObjectSetArguments_WithClosures

A convenience synonym for Nothing :: Maybe ObjectSetArguments_WithClosures.

wrap_ObjectSetArguments :: Maybe (Ptr (FunPtr C_ObjectSetArguments)) -> ObjectSetArguments_WithClosures -> 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 () -> IO (Ptr ())

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_SListFold2Fn :: SListFold2Fn -> SListFold2Fn_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noSListFold2Fn_WithClosures :: Maybe SListFold2Fn_WithClosures

A convenience synonym for Nothing :: Maybe SListFold2Fn_WithClosures.

wrap_SListFold2Fn :: Maybe (Ptr (FunPtr C_SListFold2Fn)) -> SListFold2Fn_WithClosures -> 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 () -> IO (Ptr ())

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_SListMap2Fn :: SListMap2Fn -> SListMap2Fn_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noSListMap2Fn_WithClosures :: Maybe SListMap2Fn_WithClosures

A convenience synonym for Nothing :: Maybe SListMap2Fn_WithClosures.

wrap_SListMap2Fn :: Maybe (Ptr (FunPtr C_SListMap2Fn)) -> SListMap2Fn_WithClosures -> 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 () -> IO (Ptr ())

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_SListMap4Fn :: SListMap4Fn -> SListMap4Fn_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noSListMap4Fn_WithClosures :: Maybe SListMap4Fn_WithClosures

A convenience synonym for Nothing :: Maybe SListMap4Fn_WithClosures.

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

Wrap a SListMap4Fn into a C_SListMap4Fn.

StartFn

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

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

type StartFn

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

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

A simple wrapper that ignores the closure arguments.

dynamic_StartFn

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)

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.

noStartFn_WithClosures :: Maybe StartFn_WithClosures

A convenience synonym for Nothing :: Maybe StartFn_WithClosures.

wrap_StartFn :: Maybe (Ptr (FunPtr C_StartFn)) -> StartFn_WithClosures -> 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

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

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

A simple wrapper that ignores the closure arguments.

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.

noStopFn_WithClosures :: Maybe StopFn_WithClosures

A convenience synonym for Nothing :: Maybe StopFn_WithClosures.

wrap_StopFn :: Maybe (Ptr (FunPtr C_StopFn)) -> StopFn_WithClosures -> 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 () -> IO (Ptr ())

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_TypeMap2Fn :: TypeMap2Fn -> TypeMap2Fn_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noTypeMap2Fn_WithClosures :: Maybe TypeMap2Fn_WithClosures

A convenience synonym for Nothing :: Maybe TypeMap2Fn_WithClosures.

wrap_TypeMap2Fn :: Maybe (Ptr (FunPtr C_TypeMap2Fn)) -> TypeMap2Fn_WithClosures -> 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 -> IO (Ptr ())

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_TypeMapFn :: TypeMapFn -> TypeMapFn_WithClosures

A simple wrapper that ignores the closure arguments.

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.

noTypeMapFn_WithClosures :: Maybe TypeMapFn_WithClosures

A convenience synonym for Nothing :: Maybe TypeMapFn_WithClosures.

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

Wrap a TypeMapFn into a C_TypeMapFn.