{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Vips.Structs.ObjectClass
(
ObjectClass(..) ,
newZeroObjectClass ,
#if defined(ENABLE_OVERLOADING)
ResolveObjectClassMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ObjectClassInstallArgumentMethodInfo ,
#endif
objectClassInstallArgument ,
clearObjectClassArgumentTable ,
getObjectClassArgumentTable ,
#if defined(ENABLE_OVERLOADING)
objectClass_argumentTable ,
#endif
setObjectClassArgumentTable ,
clearObjectClassArgumentTableTraverse ,
getObjectClassArgumentTableTraverse ,
#if defined(ENABLE_OVERLOADING)
objectClass_argumentTableTraverse ,
#endif
setObjectClassArgumentTableTraverse ,
getObjectClassArgumentTableTraverseGtype,
#if defined(ENABLE_OVERLOADING)
objectClass_argumentTableTraverseGtype ,
#endif
setObjectClassArgumentTableTraverseGtype,
clearObjectClassBuild ,
getObjectClassBuild ,
#if defined(ENABLE_OVERLOADING)
objectClass_build ,
#endif
setObjectClassBuild ,
clearObjectClassClose ,
getObjectClassClose ,
#if defined(ENABLE_OVERLOADING)
objectClass_close ,
#endif
setObjectClassClose ,
getObjectClassDeprecated ,
#if defined(ENABLE_OVERLOADING)
objectClass_deprecated ,
#endif
setObjectClassDeprecated ,
clearObjectClassDescription ,
getObjectClassDescription ,
#if defined(ENABLE_OVERLOADING)
objectClass_description ,
#endif
setObjectClassDescription ,
clearObjectClassNickname ,
getObjectClassNickname ,
#if defined(ENABLE_OVERLOADING)
objectClass_nickname ,
#endif
setObjectClassNickname ,
getObjectClassOutputNeedsArg ,
#if defined(ENABLE_OVERLOADING)
objectClass_outputNeedsArg ,
#endif
setObjectClassOutputNeedsArg ,
clearObjectClassOutputToArg ,
getObjectClassOutputToArg ,
#if defined(ENABLE_OVERLOADING)
objectClass_outputToArg ,
#endif
setObjectClassOutputToArg ,
getObjectClassParentClass ,
#if defined(ENABLE_OVERLOADING)
objectClass_parentClass ,
#endif
clearObjectClassPostbuild ,
getObjectClassPostbuild ,
#if defined(ENABLE_OVERLOADING)
objectClass_postbuild ,
#endif
setObjectClassPostbuild ,
clearObjectClassPostclose ,
getObjectClassPostclose ,
#if defined(ENABLE_OVERLOADING)
objectClass_postclose ,
#endif
setObjectClassPostclose ,
clearObjectClassPreclose ,
getObjectClassPreclose ,
#if defined(ENABLE_OVERLOADING)
objectClass_preclose ,
#endif
setObjectClassPreclose ,
clearObjectClassRewind ,
getObjectClassRewind ,
#if defined(ENABLE_OVERLOADING)
objectClass_rewind ,
#endif
setObjectClassRewind ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
import qualified GI.Vips.Callbacks as Vips.Callbacks
import {-# SOURCE #-} qualified GI.Vips.Flags as Vips.Flags
newtype ObjectClass = ObjectClass (SP.ManagedPtr ObjectClass)
deriving (ObjectClass -> ObjectClass -> Bool
(ObjectClass -> ObjectClass -> Bool)
-> (ObjectClass -> ObjectClass -> Bool) -> Eq ObjectClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectClass -> ObjectClass -> Bool
$c/= :: ObjectClass -> ObjectClass -> Bool
== :: ObjectClass -> ObjectClass -> Bool
$c== :: ObjectClass -> ObjectClass -> Bool
Eq)
instance SP.ManagedPtrNewtype ObjectClass where
toManagedPtr :: ObjectClass -> ManagedPtr ObjectClass
toManagedPtr (ObjectClass ManagedPtr ObjectClass
p) = ManagedPtr ObjectClass
p
instance BoxedPtr ObjectClass where
boxedPtrCopy :: ObjectClass -> IO ObjectClass
boxedPtrCopy = \ObjectClass
p -> ObjectClass
-> (Ptr ObjectClass -> IO ObjectClass) -> IO ObjectClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ObjectClass
p (Int -> Ptr ObjectClass -> IO (Ptr ObjectClass)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
328 (Ptr ObjectClass -> IO (Ptr ObjectClass))
-> (Ptr ObjectClass -> IO ObjectClass)
-> Ptr ObjectClass
-> IO ObjectClass
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ObjectClass -> ObjectClass)
-> Ptr ObjectClass -> IO ObjectClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ObjectClass -> ObjectClass
ObjectClass)
boxedPtrFree :: ObjectClass -> IO ()
boxedPtrFree = \ObjectClass
x -> ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ObjectClass
x Ptr ObjectClass -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ObjectClass where
boxedPtrCalloc :: IO (Ptr ObjectClass)
boxedPtrCalloc = Int -> IO (Ptr ObjectClass)
forall a. Int -> IO (Ptr a)
callocBytes Int
328
newZeroObjectClass :: MonadIO m => m ObjectClass
newZeroObjectClass :: forall (m :: * -> *). MonadIO m => m ObjectClass
newZeroObjectClass = IO ObjectClass -> m ObjectClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ObjectClass -> m ObjectClass)
-> IO ObjectClass -> m ObjectClass
forall a b. (a -> b) -> a -> b
$ IO (Ptr ObjectClass)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ObjectClass)
-> (Ptr ObjectClass -> IO ObjectClass) -> IO ObjectClass
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ObjectClass -> ObjectClass)
-> Ptr ObjectClass -> IO ObjectClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ObjectClass -> ObjectClass
ObjectClass
instance tag ~ 'AttrSet => Constructible ObjectClass tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ObjectClass -> ObjectClass)
-> [AttrOp ObjectClass tag] -> m ObjectClass
new ManagedPtr ObjectClass -> ObjectClass
_ [AttrOp ObjectClass tag]
attrs = do
ObjectClass
o <- m ObjectClass
forall (m :: * -> *). MonadIO m => m ObjectClass
newZeroObjectClass
ObjectClass -> [AttrOp ObjectClass 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ObjectClass
o [AttrOp ObjectClass tag]
[AttrOp ObjectClass 'AttrSet]
attrs
ObjectClass -> m ObjectClass
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClass
o
getObjectClassParentClass :: MonadIO m => ObjectClass -> m GObject.ObjectClass.ObjectClass
getObjectClassParentClass :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ObjectClass
getObjectClassParentClass ObjectClass
s = IO ObjectClass -> m ObjectClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ObjectClass -> m ObjectClass)
-> IO ObjectClass -> m ObjectClass
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO ObjectClass) -> IO ObjectClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ObjectClass) -> IO ObjectClass)
-> (Ptr ObjectClass -> IO ObjectClass) -> IO ObjectClass
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
let val :: Ptr ObjectClass
val = Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr ObjectClass
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr GObject.ObjectClass.ObjectClass)
ObjectClass
val' <- ((ManagedPtr ObjectClass -> ObjectClass)
-> Ptr ObjectClass -> IO ObjectClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ObjectClass -> ObjectClass
GObject.ObjectClass.ObjectClass) Ptr ObjectClass
val
ObjectClass -> IO ObjectClass
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClass
val'
#if defined(ENABLE_OVERLOADING)
data ObjectClassParentClassFieldInfo
instance AttrInfo ObjectClassParentClassFieldInfo where
type AttrBaseTypeConstraint ObjectClassParentClassFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassParentClassFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint ObjectClassParentClassFieldInfo = (~) (Ptr GObject.ObjectClass.ObjectClass)
type AttrTransferTypeConstraint ObjectClassParentClassFieldInfo = (~)(Ptr GObject.ObjectClass.ObjectClass)
type AttrTransferType ObjectClassParentClassFieldInfo = (Ptr GObject.ObjectClass.ObjectClass)
type AttrGetType ObjectClassParentClassFieldInfo = GObject.ObjectClass.ObjectClass
type AttrLabel ObjectClassParentClassFieldInfo = "parent_class"
type AttrOrigin ObjectClassParentClassFieldInfo = ObjectClass
attrGet = getObjectClassParentClass
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.parentClass"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:parentClass"
})
objectClass_parentClass :: AttrLabelProxy "parentClass"
objectClass_parentClass = AttrLabelProxy
#endif
getObjectClassBuild :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassBuildFieldCallback)
getObjectClassBuild :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassBuildFieldCallback)
getObjectClassBuild ObjectClass
s = IO (Maybe ObjectClassBuildFieldCallback)
-> m (Maybe ObjectClassBuildFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassBuildFieldCallback)
-> m (Maybe ObjectClassBuildFieldCallback))
-> IO (Maybe ObjectClassBuildFieldCallback)
-> m (Maybe ObjectClassBuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassBuildFieldCallback))
-> IO (Maybe ObjectClassBuildFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassBuildFieldCallback))
-> IO (Maybe ObjectClassBuildFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassBuildFieldCallback))
-> IO (Maybe ObjectClassBuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassBuildFieldCallback
val <- Ptr (FunPtr C_ObjectClassBuildFieldCallback)
-> IO (FunPtr C_ObjectClassBuildFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassBuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) :: IO (FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)
Maybe ObjectClassBuildFieldCallback
result <- FunPtr C_ObjectClassBuildFieldCallback
-> (FunPtr C_ObjectClassBuildFieldCallback
-> IO ObjectClassBuildFieldCallback)
-> IO (Maybe ObjectClassBuildFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassBuildFieldCallback
val ((FunPtr C_ObjectClassBuildFieldCallback
-> IO ObjectClassBuildFieldCallback)
-> IO (Maybe ObjectClassBuildFieldCallback))
-> (FunPtr C_ObjectClassBuildFieldCallback
-> IO ObjectClassBuildFieldCallback)
-> IO (Maybe ObjectClassBuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassBuildFieldCallback
val' -> do
let val'' :: ObjectClassBuildFieldCallback
val'' = FunPtr C_ObjectClassBuildFieldCallback
-> ObjectClassBuildFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassBuildFieldCallback -> a -> m Int32
Vips.Callbacks.dynamic_ObjectClassBuildFieldCallback FunPtr C_ObjectClassBuildFieldCallback
val'
ObjectClassBuildFieldCallback -> IO ObjectClassBuildFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassBuildFieldCallback
val''
Maybe ObjectClassBuildFieldCallback
-> IO (Maybe ObjectClassBuildFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassBuildFieldCallback
result
setObjectClassBuild :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback -> m ()
setObjectClassBuild :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassBuildFieldCallback -> m ()
setObjectClassBuild ObjectClass
s FunPtr C_ObjectClassBuildFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassBuildFieldCallback)
-> FunPtr C_ObjectClassBuildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassBuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_ObjectClassBuildFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)
clearObjectClassBuild :: MonadIO m => ObjectClass -> m ()
clearObjectClassBuild :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassBuild ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassBuildFieldCallback)
-> FunPtr C_ObjectClassBuildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassBuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_ObjectClassBuildFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassBuildFieldInfo
instance AttrInfo ObjectClassBuildFieldInfo where
type AttrBaseTypeConstraint ObjectClassBuildFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassBuildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassBuildFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)
type AttrTransferTypeConstraint ObjectClassBuildFieldInfo = (~)Vips.Callbacks.ObjectClassBuildFieldCallback
type AttrTransferType ObjectClassBuildFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)
type AttrGetType ObjectClassBuildFieldInfo = Maybe Vips.Callbacks.ObjectClassBuildFieldCallback
type AttrLabel ObjectClassBuildFieldInfo = "build"
type AttrOrigin ObjectClassBuildFieldInfo = ObjectClass
attrGet = getObjectClassBuild
attrSet = setObjectClassBuild
attrConstruct = undefined
attrClear = clearObjectClassBuild
attrTransfer _ v = do
Vips.Callbacks.mk_ObjectClassBuildFieldCallback (Vips.Callbacks.wrap_ObjectClassBuildFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.build"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:build"
})
objectClass_build :: AttrLabelProxy "build"
objectClass_build = AttrLabelProxy
#endif
getObjectClassPostbuild :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassPostbuildFieldCallback)
getObjectClassPostbuild :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassPostbuildFieldCallback)
getObjectClassPostbuild ObjectClass
s = IO (Maybe ObjectClassPostbuildFieldCallback)
-> m (Maybe ObjectClassPostbuildFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassPostbuildFieldCallback)
-> m (Maybe ObjectClassPostbuildFieldCallback))
-> IO (Maybe ObjectClassPostbuildFieldCallback)
-> m (Maybe ObjectClassPostbuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass
-> IO (Maybe ObjectClassPostbuildFieldCallback))
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassPostbuildFieldCallback))
-> IO (Maybe ObjectClassPostbuildFieldCallback))
-> (Ptr ObjectClass
-> IO (Maybe ObjectClassPostbuildFieldCallback))
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassPostbuildFieldCallback
val <- Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
-> IO (FunPtr C_ObjectClassPostbuildFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) :: IO (FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)
Maybe ObjectClassPostbuildFieldCallback
result <- FunPtr C_ObjectClassPostbuildFieldCallback
-> (FunPtr C_ObjectClassPostbuildFieldCallback
-> IO ObjectClassPostbuildFieldCallback)
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassPostbuildFieldCallback
val ((FunPtr C_ObjectClassPostbuildFieldCallback
-> IO ObjectClassPostbuildFieldCallback)
-> IO (Maybe ObjectClassPostbuildFieldCallback))
-> (FunPtr C_ObjectClassPostbuildFieldCallback
-> IO ObjectClassPostbuildFieldCallback)
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassPostbuildFieldCallback
val' -> do
let val'' :: ObjectClassPostbuildFieldCallback
val'' = FunPtr C_ObjectClassPostbuildFieldCallback
-> ObjectClassPostbuildFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassPostbuildFieldCallback
-> a -> Ptr () -> m Int32
Vips.Callbacks.dynamic_ObjectClassPostbuildFieldCallback FunPtr C_ObjectClassPostbuildFieldCallback
val'
ObjectClassPostbuildFieldCallback
-> IO ObjectClassPostbuildFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassPostbuildFieldCallback
val''
Maybe ObjectClassPostbuildFieldCallback
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassPostbuildFieldCallback
result
setObjectClassPostbuild :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback -> m ()
setObjectClassPostbuild :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassPostbuildFieldCallback -> m ()
setObjectClassPostbuild ObjectClass
s FunPtr C_ObjectClassPostbuildFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
-> FunPtr C_ObjectClassPostbuildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_ObjectClassPostbuildFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)
clearObjectClassPostbuild :: MonadIO m => ObjectClass -> m ()
clearObjectClassPostbuild :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassPostbuild ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
-> FunPtr C_ObjectClassPostbuildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_ObjectClassPostbuildFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassPostbuildFieldInfo
instance AttrInfo ObjectClassPostbuildFieldInfo where
type AttrBaseTypeConstraint ObjectClassPostbuildFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassPostbuildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassPostbuildFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)
type AttrTransferTypeConstraint ObjectClassPostbuildFieldInfo = (~)Vips.Callbacks.ObjectClassPostbuildFieldCallback
type AttrTransferType ObjectClassPostbuildFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)
type AttrGetType ObjectClassPostbuildFieldInfo = Maybe Vips.Callbacks.ObjectClassPostbuildFieldCallback
type AttrLabel ObjectClassPostbuildFieldInfo = "postbuild"
type AttrOrigin ObjectClassPostbuildFieldInfo = ObjectClass
attrGet = getObjectClassPostbuild
attrSet = setObjectClassPostbuild
attrConstruct = undefined
attrClear = clearObjectClassPostbuild
attrTransfer _ v = do
Vips.Callbacks.mk_ObjectClassPostbuildFieldCallback (Vips.Callbacks.wrap_ObjectClassPostbuildFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.postbuild"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:postbuild"
})
objectClass_postbuild :: AttrLabelProxy "postbuild"
objectClass_postbuild = AttrLabelProxy
#endif
getObjectClassRewind :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassRewindFieldCallback)
getObjectClassRewind :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassRewindFieldCallback)
getObjectClassRewind ObjectClass
s = IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassRewindFieldCallback
val <- Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> IO (FunPtr C_ObjectClassRewindFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) :: IO (FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)
Maybe ObjectClassRewindFieldCallback
result <- FunPtr C_ObjectClassRewindFieldCallback
-> (FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassRewindFieldCallback
val ((FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback))
-> (FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassRewindFieldCallback
val' -> do
let val'' :: ObjectClassRewindFieldCallback
val'' = FunPtr C_ObjectClassRewindFieldCallback
-> ObjectClassRewindFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassRewindFieldCallback -> a -> m ()
Vips.Callbacks.dynamic_ObjectClassRewindFieldCallback FunPtr C_ObjectClassRewindFieldCallback
val'
ObjectClassRewindFieldCallback -> IO ObjectClassRewindFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassRewindFieldCallback
val''
Maybe ObjectClassRewindFieldCallback
-> IO (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassRewindFieldCallback
result
setObjectClassRewind :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback -> m ()
setObjectClassRewind :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassRewindFieldCallback -> m ()
setObjectClassRewind ObjectClass
s FunPtr C_ObjectClassRewindFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_ObjectClassRewindFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)
clearObjectClassRewind :: MonadIO m => ObjectClass -> m ()
clearObjectClassRewind :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassRewind ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_ObjectClassRewindFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassRewindFieldInfo
instance AttrInfo ObjectClassRewindFieldInfo where
type AttrBaseTypeConstraint ObjectClassRewindFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassRewindFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassRewindFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)
type AttrTransferTypeConstraint ObjectClassRewindFieldInfo = (~)Vips.Callbacks.ObjectClassRewindFieldCallback
type AttrTransferType ObjectClassRewindFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)
type AttrGetType ObjectClassRewindFieldInfo = Maybe Vips.Callbacks.ObjectClassRewindFieldCallback
type AttrLabel ObjectClassRewindFieldInfo = "rewind"
type AttrOrigin ObjectClassRewindFieldInfo = ObjectClass
attrGet = getObjectClassRewind
attrSet = setObjectClassRewind
attrConstruct = undefined
attrClear = clearObjectClassRewind
attrTransfer _ v = do
Vips.Callbacks.mk_ObjectClassRewindFieldCallback (Vips.Callbacks.wrap_ObjectClassRewindFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.rewind"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:rewind"
})
objectClass_rewind :: AttrLabelProxy "rewind"
objectClass_rewind = AttrLabelProxy
#endif
getObjectClassPreclose :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassPrecloseFieldCallback)
getObjectClassPreclose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassRewindFieldCallback)
getObjectClassPreclose ObjectClass
s = IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassRewindFieldCallback
val <- Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> IO (FunPtr C_ObjectClassRewindFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) :: IO (FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)
Maybe ObjectClassRewindFieldCallback
result <- FunPtr C_ObjectClassRewindFieldCallback
-> (FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassRewindFieldCallback
val ((FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback))
-> (FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassRewindFieldCallback
val' -> do
let val'' :: ObjectClassRewindFieldCallback
val'' = FunPtr C_ObjectClassRewindFieldCallback
-> ObjectClassRewindFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassRewindFieldCallback -> a -> m ()
Vips.Callbacks.dynamic_ObjectClassPrecloseFieldCallback FunPtr C_ObjectClassRewindFieldCallback
val'
ObjectClassRewindFieldCallback -> IO ObjectClassRewindFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassRewindFieldCallback
val''
Maybe ObjectClassRewindFieldCallback
-> IO (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassRewindFieldCallback
result
setObjectClassPreclose :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback -> m ()
setObjectClassPreclose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassRewindFieldCallback -> m ()
setObjectClassPreclose ObjectClass
s FunPtr C_ObjectClassRewindFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_ObjectClassRewindFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)
clearObjectClassPreclose :: MonadIO m => ObjectClass -> m ()
clearObjectClassPreclose :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassPreclose ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_ObjectClassRewindFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassPrecloseFieldInfo
instance AttrInfo ObjectClassPrecloseFieldInfo where
type AttrBaseTypeConstraint ObjectClassPrecloseFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassPrecloseFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassPrecloseFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)
type AttrTransferTypeConstraint ObjectClassPrecloseFieldInfo = (~)Vips.Callbacks.ObjectClassPrecloseFieldCallback
type AttrTransferType ObjectClassPrecloseFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)
type AttrGetType ObjectClassPrecloseFieldInfo = Maybe Vips.Callbacks.ObjectClassPrecloseFieldCallback
type AttrLabel ObjectClassPrecloseFieldInfo = "preclose"
type AttrOrigin ObjectClassPrecloseFieldInfo = ObjectClass
attrGet = getObjectClassPreclose
attrSet = setObjectClassPreclose
attrConstruct = undefined
attrClear = clearObjectClassPreclose
attrTransfer _ v = do
Vips.Callbacks.mk_ObjectClassPrecloseFieldCallback (Vips.Callbacks.wrap_ObjectClassPrecloseFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.preclose"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:preclose"
})
objectClass_preclose :: AttrLabelProxy "preclose"
objectClass_preclose = AttrLabelProxy
#endif
getObjectClassClose :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassCloseFieldCallback)
getObjectClassClose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassRewindFieldCallback)
getObjectClassClose ObjectClass
s = IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassRewindFieldCallback
val <- Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> IO (FunPtr C_ObjectClassRewindFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) :: IO (FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)
Maybe ObjectClassRewindFieldCallback
result <- FunPtr C_ObjectClassRewindFieldCallback
-> (FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassRewindFieldCallback
val ((FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback))
-> (FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassRewindFieldCallback
val' -> do
let val'' :: ObjectClassRewindFieldCallback
val'' = FunPtr C_ObjectClassRewindFieldCallback
-> ObjectClassRewindFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassRewindFieldCallback -> a -> m ()
Vips.Callbacks.dynamic_ObjectClassCloseFieldCallback FunPtr C_ObjectClassRewindFieldCallback
val'
ObjectClassRewindFieldCallback -> IO ObjectClassRewindFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassRewindFieldCallback
val''
Maybe ObjectClassRewindFieldCallback
-> IO (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassRewindFieldCallback
result
setObjectClassClose :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback -> m ()
setObjectClassClose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassRewindFieldCallback -> m ()
setObjectClassClose ObjectClass
s FunPtr C_ObjectClassRewindFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_ObjectClassRewindFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)
clearObjectClassClose :: MonadIO m => ObjectClass -> m ()
clearObjectClassClose :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassClose ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_ObjectClassRewindFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassCloseFieldInfo
instance AttrInfo ObjectClassCloseFieldInfo where
type AttrBaseTypeConstraint ObjectClassCloseFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassCloseFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassCloseFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)
type AttrTransferTypeConstraint ObjectClassCloseFieldInfo = (~)Vips.Callbacks.ObjectClassCloseFieldCallback
type AttrTransferType ObjectClassCloseFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)
type AttrGetType ObjectClassCloseFieldInfo = Maybe Vips.Callbacks.ObjectClassCloseFieldCallback
type AttrLabel ObjectClassCloseFieldInfo = "close"
type AttrOrigin ObjectClassCloseFieldInfo = ObjectClass
attrGet = getObjectClassClose
attrSet = setObjectClassClose
attrConstruct = undefined
attrClear = clearObjectClassClose
attrTransfer _ v = do
Vips.Callbacks.mk_ObjectClassCloseFieldCallback (Vips.Callbacks.wrap_ObjectClassCloseFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.close"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:close"
})
objectClass_close :: AttrLabelProxy "close"
objectClass_close = AttrLabelProxy
#endif
getObjectClassPostclose :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassPostcloseFieldCallback)
getObjectClassPostclose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassRewindFieldCallback)
getObjectClassPostclose ObjectClass
s = IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassRewindFieldCallback
val <- Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> IO (FunPtr C_ObjectClassRewindFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) :: IO (FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)
Maybe ObjectClassRewindFieldCallback
result <- FunPtr C_ObjectClassRewindFieldCallback
-> (FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassRewindFieldCallback
val ((FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback))
-> (FunPtr C_ObjectClassRewindFieldCallback
-> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassRewindFieldCallback
val' -> do
let val'' :: ObjectClassRewindFieldCallback
val'' = FunPtr C_ObjectClassRewindFieldCallback
-> ObjectClassRewindFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassRewindFieldCallback -> a -> m ()
Vips.Callbacks.dynamic_ObjectClassPostcloseFieldCallback FunPtr C_ObjectClassRewindFieldCallback
val'
ObjectClassRewindFieldCallback -> IO ObjectClassRewindFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassRewindFieldCallback
val''
Maybe ObjectClassRewindFieldCallback
-> IO (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassRewindFieldCallback
result
setObjectClassPostclose :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback -> m ()
setObjectClassPostclose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassRewindFieldCallback -> m ()
setObjectClassPostclose ObjectClass
s FunPtr C_ObjectClassRewindFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_ObjectClassRewindFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)
clearObjectClassPostclose :: MonadIO m => ObjectClass -> m ()
clearObjectClassPostclose :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassPostclose ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_ObjectClassRewindFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassPostcloseFieldInfo
instance AttrInfo ObjectClassPostcloseFieldInfo where
type AttrBaseTypeConstraint ObjectClassPostcloseFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassPostcloseFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassPostcloseFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)
type AttrTransferTypeConstraint ObjectClassPostcloseFieldInfo = (~)Vips.Callbacks.ObjectClassPostcloseFieldCallback
type AttrTransferType ObjectClassPostcloseFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)
type AttrGetType ObjectClassPostcloseFieldInfo = Maybe Vips.Callbacks.ObjectClassPostcloseFieldCallback
type AttrLabel ObjectClassPostcloseFieldInfo = "postclose"
type AttrOrigin ObjectClassPostcloseFieldInfo = ObjectClass
attrGet = getObjectClassPostclose
attrSet = setObjectClassPostclose
attrConstruct = undefined
attrClear = clearObjectClassPostclose
attrTransfer _ v = do
Vips.Callbacks.mk_ObjectClassPostcloseFieldCallback (Vips.Callbacks.wrap_ObjectClassPostcloseFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.postclose"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:postclose"
})
objectClass_postclose :: AttrLabelProxy "postclose"
objectClass_postclose = AttrLabelProxy
#endif
getObjectClassOutputNeedsArg :: MonadIO m => ObjectClass -> m Bool
getObjectClassOutputNeedsArg :: forall (m :: * -> *). MonadIO m => ObjectClass -> m Bool
getObjectClassOutputNeedsArg ObjectClass
s = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO Bool) -> IO Bool
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO Bool) -> IO Bool)
-> (Ptr ObjectClass -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) :: IO CInt
let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'
setObjectClassOutputNeedsArg :: MonadIO m => ObjectClass -> Bool -> m ()
setObjectClassOutputNeedsArg :: forall (m :: * -> *). MonadIO m => ObjectClass -> Bool -> m ()
setObjectClassOutputNeedsArg ObjectClass
s Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
val
Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) (CInt
val' :: CInt)
#if defined(ENABLE_OVERLOADING)
data ObjectClassOutputNeedsArgFieldInfo
instance AttrInfo ObjectClassOutputNeedsArgFieldInfo where
type AttrBaseTypeConstraint ObjectClassOutputNeedsArgFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassOutputNeedsArgFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ObjectClassOutputNeedsArgFieldInfo = (~) Bool
type AttrTransferTypeConstraint ObjectClassOutputNeedsArgFieldInfo = (~)Bool
type AttrTransferType ObjectClassOutputNeedsArgFieldInfo = Bool
type AttrGetType ObjectClassOutputNeedsArgFieldInfo = Bool
type AttrLabel ObjectClassOutputNeedsArgFieldInfo = "output_needs_arg"
type AttrOrigin ObjectClassOutputNeedsArgFieldInfo = ObjectClass
attrGet = getObjectClassOutputNeedsArg
attrSet = setObjectClassOutputNeedsArg
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.outputNeedsArg"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:outputNeedsArg"
})
objectClass_outputNeedsArg :: AttrLabelProxy "outputNeedsArg"
objectClass_outputNeedsArg = AttrLabelProxy
#endif
getObjectClassOutputToArg :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassOutputToArgFieldCallback)
getObjectClassOutputToArg :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassOutputToArgFieldCallback)
getObjectClassOutputToArg ObjectClass
s = IO (Maybe ObjectClassOutputToArgFieldCallback)
-> m (Maybe ObjectClassOutputToArgFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassOutputToArgFieldCallback)
-> m (Maybe ObjectClassOutputToArgFieldCallback))
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
-> m (Maybe ObjectClassOutputToArgFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass
-> IO (Maybe ObjectClassOutputToArgFieldCallback))
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass
-> IO (Maybe ObjectClassOutputToArgFieldCallback))
-> IO (Maybe ObjectClassOutputToArgFieldCallback))
-> (Ptr ObjectClass
-> IO (Maybe ObjectClassOutputToArgFieldCallback))
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassOutputToArgFieldCallback
val <- Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
-> IO (FunPtr C_ObjectClassOutputToArgFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) :: IO (FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)
Maybe ObjectClassOutputToArgFieldCallback
result <- FunPtr C_ObjectClassOutputToArgFieldCallback
-> (FunPtr C_ObjectClassOutputToArgFieldCallback
-> IO ObjectClassOutputToArgFieldCallback)
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassOutputToArgFieldCallback
val ((FunPtr C_ObjectClassOutputToArgFieldCallback
-> IO ObjectClassOutputToArgFieldCallback)
-> IO (Maybe ObjectClassOutputToArgFieldCallback))
-> (FunPtr C_ObjectClassOutputToArgFieldCallback
-> IO ObjectClassOutputToArgFieldCallback)
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassOutputToArgFieldCallback
val' -> do
let val'' :: ObjectClassOutputToArgFieldCallback
val'' = FunPtr C_ObjectClassOutputToArgFieldCallback
-> ObjectClassOutputToArgFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassOutputToArgFieldCallback
-> a -> Text -> m Int32
Vips.Callbacks.dynamic_ObjectClassOutputToArgFieldCallback FunPtr C_ObjectClassOutputToArgFieldCallback
val'
ObjectClassOutputToArgFieldCallback
-> IO ObjectClassOutputToArgFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassOutputToArgFieldCallback
val''
Maybe ObjectClassOutputToArgFieldCallback
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassOutputToArgFieldCallback
result
setObjectClassOutputToArg :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback -> m ()
setObjectClassOutputToArg :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassOutputToArgFieldCallback -> m ()
setObjectClassOutputToArg ObjectClass
s FunPtr C_ObjectClassOutputToArgFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
-> FunPtr C_ObjectClassOutputToArgFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_ObjectClassOutputToArgFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)
clearObjectClassOutputToArg :: MonadIO m => ObjectClass -> m ()
clearObjectClassOutputToArg :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassOutputToArg ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
-> FunPtr C_ObjectClassOutputToArgFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_ObjectClassOutputToArgFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassOutputToArgFieldInfo
instance AttrInfo ObjectClassOutputToArgFieldInfo where
type AttrBaseTypeConstraint ObjectClassOutputToArgFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassOutputToArgFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassOutputToArgFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)
type AttrTransferTypeConstraint ObjectClassOutputToArgFieldInfo = (~)Vips.Callbacks.ObjectClassOutputToArgFieldCallback
type AttrTransferType ObjectClassOutputToArgFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)
type AttrGetType ObjectClassOutputToArgFieldInfo = Maybe Vips.Callbacks.ObjectClassOutputToArgFieldCallback
type AttrLabel ObjectClassOutputToArgFieldInfo = "output_to_arg"
type AttrOrigin ObjectClassOutputToArgFieldInfo = ObjectClass
attrGet = getObjectClassOutputToArg
attrSet = setObjectClassOutputToArg
attrConstruct = undefined
attrClear = clearObjectClassOutputToArg
attrTransfer _ v = do
Vips.Callbacks.mk_ObjectClassOutputToArgFieldCallback (Vips.Callbacks.wrap_ObjectClassOutputToArgFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.outputToArg"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:outputToArg"
})
objectClass_outputToArg :: AttrLabelProxy "outputToArg"
objectClass_outputToArg = AttrLabelProxy
#endif
getObjectClassNickname :: MonadIO m => ObjectClass -> m (Maybe T.Text)
getObjectClassNickname :: forall (m :: * -> *). MonadIO m => ObjectClass -> m (Maybe Text)
getObjectClassNickname ObjectClass
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setObjectClassNickname :: MonadIO m => ObjectClass -> CString -> m ()
setObjectClassNickname :: forall (m :: * -> *). MonadIO m => ObjectClass -> CString -> m ()
setObjectClassNickname ObjectClass
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (CString
val :: CString)
clearObjectClassNickname :: MonadIO m => ObjectClass -> m ()
clearObjectClassNickname :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassNickname ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data ObjectClassNicknameFieldInfo
instance AttrInfo ObjectClassNicknameFieldInfo where
type AttrBaseTypeConstraint ObjectClassNicknameFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassNicknameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassNicknameFieldInfo = (~) CString
type AttrTransferTypeConstraint ObjectClassNicknameFieldInfo = (~)CString
type AttrTransferType ObjectClassNicknameFieldInfo = CString
type AttrGetType ObjectClassNicknameFieldInfo = Maybe T.Text
type AttrLabel ObjectClassNicknameFieldInfo = "nickname"
type AttrOrigin ObjectClassNicknameFieldInfo = ObjectClass
attrGet = getObjectClassNickname
attrSet = setObjectClassNickname
attrConstruct = undefined
attrClear = clearObjectClassNickname
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.nickname"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:nickname"
})
objectClass_nickname :: AttrLabelProxy "nickname"
objectClass_nickname = AttrLabelProxy
#endif
getObjectClassDescription :: MonadIO m => ObjectClass -> m (Maybe T.Text)
getObjectClassDescription :: forall (m :: * -> *). MonadIO m => ObjectClass -> m (Maybe Text)
getObjectClassDescription ObjectClass
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setObjectClassDescription :: MonadIO m => ObjectClass -> CString -> m ()
setObjectClassDescription :: forall (m :: * -> *). MonadIO m => ObjectClass -> CString -> m ()
setObjectClassDescription ObjectClass
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (CString
val :: CString)
clearObjectClassDescription :: MonadIO m => ObjectClass -> m ()
clearObjectClassDescription :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassDescription ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data ObjectClassDescriptionFieldInfo
instance AttrInfo ObjectClassDescriptionFieldInfo where
type AttrBaseTypeConstraint ObjectClassDescriptionFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassDescriptionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassDescriptionFieldInfo = (~) CString
type AttrTransferTypeConstraint ObjectClassDescriptionFieldInfo = (~)CString
type AttrTransferType ObjectClassDescriptionFieldInfo = CString
type AttrGetType ObjectClassDescriptionFieldInfo = Maybe T.Text
type AttrLabel ObjectClassDescriptionFieldInfo = "description"
type AttrOrigin ObjectClassDescriptionFieldInfo = ObjectClass
attrGet = getObjectClassDescription
attrSet = setObjectClassDescription
attrConstruct = undefined
attrClear = clearObjectClassDescription
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.description"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:description"
})
objectClass_description :: AttrLabelProxy "description"
objectClass_description = AttrLabelProxy
#endif
getObjectClassArgumentTable :: MonadIO m => ObjectClass -> m (Maybe (Map.Map (Ptr ()) (Ptr ())))
getObjectClassArgumentTable :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe (Map (Ptr ()) (Ptr ())))
getObjectClassArgumentTable ObjectClass
s = IO (Maybe (Map (Ptr ()) (Ptr ())))
-> m (Maybe (Map (Ptr ()) (Ptr ())))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Map (Ptr ()) (Ptr ())))
-> m (Maybe (Map (Ptr ()) (Ptr ()))))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
-> m (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> (Ptr ObjectClass -> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (GHashTable (Ptr ()) (Ptr ()))
val <- Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> IO (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) :: IO (Ptr (GHashTable (Ptr ()) (Ptr ())))
Maybe (Map (Ptr ()) (Ptr ()))
result <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> (Ptr (GHashTable (Ptr ()) (Ptr ()))
-> IO (Map (Ptr ()) (Ptr ())))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (GHashTable (Ptr ()) (Ptr ()))
val ((Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO (Map (Ptr ()) (Ptr ())))
-> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> (Ptr (GHashTable (Ptr ()) (Ptr ()))
-> IO (Map (Ptr ()) (Ptr ())))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. (a -> b) -> a -> b
$ \Ptr (GHashTable (Ptr ()) (Ptr ()))
val' -> do
[(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
val'' <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> IO [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
val'
let val''' :: [(Ptr (), PtrWrapped (Ptr ()))]
val''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
-> [(Ptr (), PtrWrapped (Ptr ()))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
ptrUnpackPtr [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
val''
let val'''' :: [(Ptr (), Ptr ())]
val'''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(Ptr (), PtrWrapped (Ptr ()))] -> [(Ptr (), Ptr ())]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
ptrUnpackPtr [(Ptr (), PtrWrapped (Ptr ()))]
val'''
let val''''' :: Map (Ptr ()) (Ptr ())
val''''' = [(Ptr (), Ptr ())] -> Map (Ptr ()) (Ptr ())
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Ptr (), Ptr ())]
val''''
Map (Ptr ()) (Ptr ()) -> IO (Map (Ptr ()) (Ptr ()))
forall (m :: * -> *) a. Monad m => a -> m a
return Map (Ptr ()) (Ptr ())
val'''''
Maybe (Map (Ptr ()) (Ptr ())) -> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Map (Ptr ()) (Ptr ()))
result
setObjectClassArgumentTable :: MonadIO m => ObjectClass -> Ptr (GHashTable (Ptr ()) (Ptr ())) -> m ()
setObjectClassArgumentTable :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> Ptr (GHashTable (Ptr ()) (Ptr ())) -> m ()
setObjectClassArgumentTable ObjectClass
s Ptr (GHashTable (Ptr ()) (Ptr ()))
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (Ptr (GHashTable (Ptr ()) (Ptr ()))
val :: Ptr (GHashTable (Ptr ()) (Ptr ())))
clearObjectClassArgumentTable :: MonadIO m => ObjectClass -> m ()
clearObjectClassArgumentTable :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassArgumentTable ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (Ptr (GHashTable (Ptr ()) (Ptr ()))
forall a. Ptr a
FP.nullPtr :: Ptr (GHashTable (Ptr ()) (Ptr ())))
#if defined(ENABLE_OVERLOADING)
data ObjectClassArgumentTableFieldInfo
instance AttrInfo ObjectClassArgumentTableFieldInfo where
type AttrBaseTypeConstraint ObjectClassArgumentTableFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassArgumentTableFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassArgumentTableFieldInfo = (~) (Ptr (GHashTable (Ptr ()) (Ptr ())))
type AttrTransferTypeConstraint ObjectClassArgumentTableFieldInfo = (~)(Ptr (GHashTable (Ptr ()) (Ptr ())))
type AttrTransferType ObjectClassArgumentTableFieldInfo = (Ptr (GHashTable (Ptr ()) (Ptr ())))
type AttrGetType ObjectClassArgumentTableFieldInfo = Maybe (Map.Map (Ptr ()) (Ptr ()))
type AttrLabel ObjectClassArgumentTableFieldInfo = "argument_table"
type AttrOrigin ObjectClassArgumentTableFieldInfo = ObjectClass
attrGet = getObjectClassArgumentTable
attrSet = setObjectClassArgumentTable
attrConstruct = undefined
attrClear = clearObjectClassArgumentTable
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.argumentTable"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:argumentTable"
})
objectClass_argumentTable :: AttrLabelProxy "argumentTable"
objectClass_argumentTable = AttrLabelProxy
#endif
getObjectClassArgumentTableTraverse :: MonadIO m => ObjectClass -> m ([Ptr ()])
getObjectClassArgumentTableTraverse :: forall (m :: * -> *). MonadIO m => ObjectClass -> m [Ptr ()]
getObjectClassArgumentTableTraverse ObjectClass
s = IO [Ptr ()] -> m [Ptr ()]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Ptr ()] -> m [Ptr ()]) -> IO [Ptr ()] -> m [Ptr ()]
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO [Ptr ()]) -> IO [Ptr ()]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO [Ptr ()]) -> IO [Ptr ()])
-> (Ptr ObjectClass -> IO [Ptr ()]) -> IO [Ptr ()]
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (GSList (Ptr ()))
val <- Ptr (Ptr (GSList (Ptr ()))) -> IO (Ptr (GSList (Ptr ())))
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GSList (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) :: IO (Ptr (GSList (Ptr ())))
[Ptr ()]
val' <- Ptr (GSList (Ptr ())) -> IO [Ptr ()]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr ()))
val
[Ptr ()] -> IO [Ptr ()]
forall (m :: * -> *) a. Monad m => a -> m a
return [Ptr ()]
val'
setObjectClassArgumentTableTraverse :: MonadIO m => ObjectClass -> Ptr (GSList (Ptr ())) -> m ()
setObjectClassArgumentTableTraverse :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> Ptr (GSList (Ptr ())) -> m ()
setObjectClassArgumentTableTraverse ObjectClass
s Ptr (GSList (Ptr ()))
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (Ptr (GSList (Ptr ()))) -> Ptr (GSList (Ptr ())) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GSList (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (Ptr (GSList (Ptr ()))
val :: Ptr (GSList (Ptr ())))
clearObjectClassArgumentTableTraverse :: MonadIO m => ObjectClass -> m ()
clearObjectClassArgumentTableTraverse :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassArgumentTableTraverse ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
Ptr (Ptr (GSList (Ptr ()))) -> Ptr (GSList (Ptr ())) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GSList (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (Ptr (GSList (Ptr ()))
forall a. Ptr a
FP.nullPtr :: Ptr (GSList (Ptr ())))
#if defined(ENABLE_OVERLOADING)
data ObjectClassArgumentTableTraverseFieldInfo
instance AttrInfo ObjectClassArgumentTableTraverseFieldInfo where
type AttrBaseTypeConstraint ObjectClassArgumentTableTraverseFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassArgumentTableTraverseFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassArgumentTableTraverseFieldInfo = (~) (Ptr (GSList (Ptr ())))
type AttrTransferTypeConstraint ObjectClassArgumentTableTraverseFieldInfo = (~)(Ptr (GSList (Ptr ())))
type AttrTransferType ObjectClassArgumentTableTraverseFieldInfo = (Ptr (GSList (Ptr ())))
type AttrGetType ObjectClassArgumentTableTraverseFieldInfo = [Ptr ()]
type AttrLabel ObjectClassArgumentTableTraverseFieldInfo = "argument_table_traverse"
type AttrOrigin ObjectClassArgumentTableTraverseFieldInfo = ObjectClass
attrGet = getObjectClassArgumentTableTraverse
attrSet = setObjectClassArgumentTableTraverse
attrConstruct = undefined
attrClear = clearObjectClassArgumentTableTraverse
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.argumentTableTraverse"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:argumentTableTraverse"
})
objectClass_argumentTableTraverse :: AttrLabelProxy "argumentTableTraverse"
objectClass_argumentTableTraverse = AttrLabelProxy
#endif
getObjectClassArgumentTableTraverseGtype :: MonadIO m => ObjectClass -> m GType
getObjectClassArgumentTableTraverseGtype :: forall (m :: * -> *). MonadIO m => ObjectClass -> m GType
getObjectClassArgumentTableTraverseGtype ObjectClass
s = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO GType) -> IO GType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO GType) -> IO GType)
-> (Ptr ObjectClass -> IO GType) -> IO GType
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
CGType
val <- Ptr CGType -> IO CGType
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CGType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) :: IO CGType
let val' :: GType
val' = CGType -> GType
GType CGType
val
GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
val'
setObjectClassArgumentTableTraverseGtype :: MonadIO m => ObjectClass -> GType -> m ()
setObjectClassArgumentTableTraverseGtype :: forall (m :: * -> *). MonadIO m => ObjectClass -> GType -> m ()
setObjectClassArgumentTableTraverseGtype ObjectClass
s GType
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
let val' :: CGType
val' = GType -> CGType
gtypeToCGType GType
val
Ptr CGType -> CGType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CGType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (CGType
val' :: CGType)
#if defined(ENABLE_OVERLOADING)
data ObjectClassArgumentTableTraverseGtypeFieldInfo
instance AttrInfo ObjectClassArgumentTableTraverseGtypeFieldInfo where
type AttrBaseTypeConstraint ObjectClassArgumentTableTraverseGtypeFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassArgumentTableTraverseGtypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ObjectClassArgumentTableTraverseGtypeFieldInfo = (~) GType
type AttrTransferTypeConstraint ObjectClassArgumentTableTraverseGtypeFieldInfo = (~)GType
type AttrTransferType ObjectClassArgumentTableTraverseGtypeFieldInfo = GType
type AttrGetType ObjectClassArgumentTableTraverseGtypeFieldInfo = GType
type AttrLabel ObjectClassArgumentTableTraverseGtypeFieldInfo = "argument_table_traverse_gtype"
type AttrOrigin ObjectClassArgumentTableTraverseGtypeFieldInfo = ObjectClass
attrGet = getObjectClassArgumentTableTraverseGtype
attrSet = setObjectClassArgumentTableTraverseGtype
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.argumentTableTraverseGtype"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:argumentTableTraverseGtype"
})
objectClass_argumentTableTraverseGtype :: AttrLabelProxy "argumentTableTraverseGtype"
objectClass_argumentTableTraverseGtype = AttrLabelProxy
#endif
getObjectClassDeprecated :: MonadIO m => ObjectClass -> m Bool
getObjectClassDeprecated :: forall (m :: * -> *). MonadIO m => ObjectClass -> m Bool
getObjectClassDeprecated ObjectClass
s = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO Bool) -> IO Bool
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO Bool) -> IO Bool)
-> (Ptr ObjectClass -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) :: IO CInt
let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'
setObjectClassDeprecated :: MonadIO m => ObjectClass -> Bool -> m ()
setObjectClassDeprecated :: forall (m :: * -> *). MonadIO m => ObjectClass -> Bool -> m ()
setObjectClassDeprecated ObjectClass
s Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
val
Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) (CInt
val' :: CInt)
#if defined(ENABLE_OVERLOADING)
data ObjectClassDeprecatedFieldInfo
instance AttrInfo ObjectClassDeprecatedFieldInfo where
type AttrBaseTypeConstraint ObjectClassDeprecatedFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassDeprecatedFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ObjectClassDeprecatedFieldInfo = (~) Bool
type AttrTransferTypeConstraint ObjectClassDeprecatedFieldInfo = (~)Bool
type AttrTransferType ObjectClassDeprecatedFieldInfo = Bool
type AttrGetType ObjectClassDeprecatedFieldInfo = Bool
type AttrLabel ObjectClassDeprecatedFieldInfo = "deprecated"
type AttrOrigin ObjectClassDeprecatedFieldInfo = ObjectClass
attrGet = getObjectClassDeprecated
attrSet = setObjectClassDeprecated
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.deprecated"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:deprecated"
})
objectClass_deprecated :: AttrLabelProxy "deprecated"
objectClass_deprecated = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ObjectClass
type instance O.AttributeList ObjectClass = ObjectClassAttributeList
type ObjectClassAttributeList = ('[ '("parentClass", ObjectClassParentClassFieldInfo), '("build", ObjectClassBuildFieldInfo), '("postbuild", ObjectClassPostbuildFieldInfo), '("rewind", ObjectClassRewindFieldInfo), '("preclose", ObjectClassPrecloseFieldInfo), '("close", ObjectClassCloseFieldInfo), '("postclose", ObjectClassPostcloseFieldInfo), '("outputNeedsArg", ObjectClassOutputNeedsArgFieldInfo), '("outputToArg", ObjectClassOutputToArgFieldInfo), '("nickname", ObjectClassNicknameFieldInfo), '("description", ObjectClassDescriptionFieldInfo), '("argumentTable", ObjectClassArgumentTableFieldInfo), '("argumentTableTraverse", ObjectClassArgumentTableTraverseFieldInfo), '("argumentTableTraverseGtype", ObjectClassArgumentTableTraverseGtypeFieldInfo), '("deprecated", ObjectClassDeprecatedFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "vips_object_class_install_argument" vips_object_class_install_argument ::
Ptr ObjectClass ->
Ptr GParamSpec ->
CUInt ->
Int32 ->
Word32 ->
IO ()
objectClassInstallArgument ::
(B.CallStack.HasCallStack, MonadIO m) =>
ObjectClass
-> GParamSpec
-> [Vips.Flags.ArgumentFlags]
-> Int32
-> Word32
-> m ()
objectClassInstallArgument :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectClass
-> GParamSpec -> [ArgumentFlags] -> Int32 -> Word32 -> m ()
objectClassInstallArgument ObjectClass
cls GParamSpec
pspec [ArgumentFlags]
flags Int32
priority Word32
offset = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ObjectClass
cls' <- ObjectClass -> IO (Ptr ObjectClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectClass
cls
Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
let flags' :: CUInt
flags' = [ArgumentFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ArgumentFlags]
flags
Ptr ObjectClass
-> Ptr GParamSpec -> CUInt -> Int32 -> Word32 -> IO ()
vips_object_class_install_argument Ptr ObjectClass
cls' Ptr GParamSpec
pspec' CUInt
flags' Int32
priority Word32
offset
ObjectClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectClass
cls
GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ObjectClassInstallArgumentMethodInfo
instance (signature ~ (GParamSpec -> [Vips.Flags.ArgumentFlags] -> Int32 -> Word32 -> m ()), MonadIO m) => O.OverloadedMethod ObjectClassInstallArgumentMethodInfo ObjectClass signature where
overloadedMethod = objectClassInstallArgument
instance O.OverloadedMethodInfo ObjectClassInstallArgumentMethodInfo ObjectClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.objectClassInstallArgument",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#v:objectClassInstallArgument"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveObjectClassMethod (t :: Symbol) (o :: *) :: * where
ResolveObjectClassMethod "installArgument" o = ObjectClassInstallArgumentMethodInfo
ResolveObjectClassMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveObjectClassMethod t ObjectClass, O.OverloadedMethod info ObjectClass p) => OL.IsLabel t (ObjectClass -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveObjectClassMethod t ObjectClass, O.OverloadedMethod info ObjectClass p, R.HasField t ObjectClass p) => R.HasField t ObjectClass p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveObjectClassMethod t ObjectClass, O.OverloadedMethodInfo info ObjectClass) => OL.IsLabel t (O.MethodProxy info ObjectClass) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif