{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Vips.Structs.Argument
(
Argument(..) ,
newZeroArgument ,
#if defined(ENABLE_OVERLOADING)
ResolveArgumentMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
argument_pspec ,
#endif
clearArgumentPspec ,
getArgumentPspec ,
setArgumentPspec ,
) 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.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
newtype Argument = Argument (SP.ManagedPtr Argument)
deriving (Argument -> Argument -> Bool
(Argument -> Argument -> Bool)
-> (Argument -> Argument -> Bool) -> Eq Argument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Argument -> Argument -> Bool
$c/= :: Argument -> Argument -> Bool
== :: Argument -> Argument -> Bool
$c== :: Argument -> Argument -> Bool
Eq)
instance SP.ManagedPtrNewtype Argument where
toManagedPtr :: Argument -> ManagedPtr Argument
toManagedPtr (Argument ManagedPtr Argument
p) = ManagedPtr Argument
p
instance BoxedPtr Argument where
boxedPtrCopy :: Argument -> IO Argument
boxedPtrCopy = \Argument
p -> Argument -> (Ptr Argument -> IO Argument) -> IO Argument
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Argument
p (Int -> Ptr Argument -> IO (Ptr Argument)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
8 (Ptr Argument -> IO (Ptr Argument))
-> (Ptr Argument -> IO Argument) -> Ptr Argument -> IO Argument
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr Argument -> Argument) -> Ptr Argument -> IO Argument
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr Argument -> Argument
Argument)
boxedPtrFree :: Argument -> IO ()
boxedPtrFree = \Argument
x -> Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr Argument
x Ptr Argument -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr Argument where
boxedPtrCalloc :: IO (Ptr Argument)
boxedPtrCalloc = Int -> IO (Ptr Argument)
forall a. Int -> IO (Ptr a)
callocBytes Int
8
newZeroArgument :: MonadIO m => m Argument
newZeroArgument :: forall (m :: * -> *). MonadIO m => m Argument
newZeroArgument = IO Argument -> m Argument
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Argument -> m Argument) -> IO Argument -> m Argument
forall a b. (a -> b) -> a -> b
$ IO (Ptr Argument)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr Argument) -> (Ptr Argument -> IO Argument) -> IO Argument
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Argument -> Argument) -> Ptr Argument -> IO Argument
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Argument -> Argument
Argument
instance tag ~ 'AttrSet => Constructible Argument tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Argument -> Argument)
-> [AttrOp Argument tag] -> m Argument
new ManagedPtr Argument -> Argument
_ [AttrOp Argument tag]
attrs = do
Argument
o <- m Argument
forall (m :: * -> *). MonadIO m => m Argument
newZeroArgument
Argument -> [AttrOp Argument 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Argument
o [AttrOp Argument tag]
[AttrOp Argument 'AttrSet]
attrs
Argument -> m Argument
forall (m :: * -> *) a. Monad m => a -> m a
return Argument
o
getArgumentPspec :: MonadIO m => Argument -> m (Maybe GParamSpec)
getArgumentPspec :: forall (m :: * -> *). MonadIO m => Argument -> m (Maybe GParamSpec)
getArgumentPspec Argument
s = IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GParamSpec) -> m (Maybe GParamSpec))
-> IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ Argument
-> (Ptr Argument -> IO (Maybe GParamSpec)) -> IO (Maybe GParamSpec)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO (Maybe GParamSpec)) -> IO (Maybe GParamSpec))
-> (Ptr Argument -> IO (Maybe GParamSpec)) -> IO (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ \Ptr Argument
ptr -> do
Ptr GParamSpec
val <- Ptr (Ptr GParamSpec) -> IO (Ptr GParamSpec)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> Int -> Ptr (Ptr GParamSpec)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr GParamSpec)
Maybe GParamSpec
result <- Ptr GParamSpec
-> (Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr GParamSpec
val ((Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec))
-> (Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ \Ptr GParamSpec
val' -> do
GParamSpec
val'' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
val'
GParamSpec -> IO GParamSpec
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
val''
Maybe GParamSpec -> IO (Maybe GParamSpec)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GParamSpec
result
setArgumentPspec :: MonadIO m => Argument -> Ptr GParamSpec -> m ()
setArgumentPspec :: forall (m :: * -> *).
MonadIO m =>
Argument -> Ptr GParamSpec -> m ()
setArgumentPspec Argument
s Ptr GParamSpec
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Argument
ptr -> do
Ptr (Ptr GParamSpec) -> Ptr GParamSpec -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr (Ptr GParamSpec)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr GParamSpec
val :: Ptr GParamSpec)
clearArgumentPspec :: MonadIO m => Argument -> m ()
clearArgumentPspec :: forall (m :: * -> *). MonadIO m => Argument -> m ()
clearArgumentPspec Argument
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Argument
ptr -> do
Ptr (Ptr GParamSpec) -> Ptr GParamSpec -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr (Ptr GParamSpec)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr GParamSpec
forall a. Ptr a
FP.nullPtr :: Ptr GParamSpec)
#if defined(ENABLE_OVERLOADING)
data ArgumentPspecFieldInfo
instance AttrInfo ArgumentPspecFieldInfo where
type AttrBaseTypeConstraint ArgumentPspecFieldInfo = (~) Argument
type AttrAllowedOps ArgumentPspecFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ArgumentPspecFieldInfo = (~) (Ptr GParamSpec)
type AttrTransferTypeConstraint ArgumentPspecFieldInfo = (~)(Ptr GParamSpec)
type AttrTransferType ArgumentPspecFieldInfo = (Ptr GParamSpec)
type AttrGetType ArgumentPspecFieldInfo = Maybe GParamSpec
type AttrLabel ArgumentPspecFieldInfo = "pspec"
type AttrOrigin ArgumentPspecFieldInfo = Argument
attrGet = getArgumentPspec
attrSet = setArgumentPspec
attrConstruct = undefined
attrClear = clearArgumentPspec
attrTransfer _ v = do
return v
argument_pspec :: AttrLabelProxy "pspec"
argument_pspec = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Argument
type instance O.AttributeList Argument = ArgumentAttributeList
type ArgumentAttributeList = ('[ '("pspec", ArgumentPspecFieldInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveArgumentMethod (t :: Symbol) (o :: *) :: * where
ResolveArgumentMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveArgumentMethod t Argument, O.OverloadedMethod info Argument p) => OL.IsLabel t (Argument -> 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 ~ ResolveArgumentMethod t Argument, O.OverloadedMethod info Argument p, R.HasField t Argument p) => R.HasField t Argument p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveArgumentMethod t Argument, O.OverloadedMethodInfo info Argument) => OL.IsLabel t (O.MethodProxy info Argument) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif