{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Vips.Structs.Area
(
Area(..) ,
newZeroArea ,
#if defined(ENABLE_OVERLOADING)
ResolveAreaMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
AreaAreaGetDataMethodInfo ,
#endif
areaAreaGetData ,
#if defined(ENABLE_OVERLOADING)
AreaCopyMethodInfo ,
#endif
areaCopy ,
areaNew ,
areaNewArray ,
areaNewArrayObject ,
#if defined(ENABLE_OVERLOADING)
AreaUnrefMethodInfo ,
#endif
areaUnref ,
#if defined(ENABLE_OVERLOADING)
area_data ,
#endif
clearAreaData ,
getAreaData ,
setAreaData ,
#if defined(ENABLE_OVERLOADING)
area_length ,
#endif
getAreaLength ,
setAreaLength ,
#if defined(ENABLE_OVERLOADING)
area_n ,
#endif
getAreaN ,
setAreaN ,
) 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
import qualified GI.Vips.Callbacks as Vips.Callbacks
newtype Area = Area (SP.ManagedPtr Area)
deriving (Area -> Area -> Bool
(Area -> Area -> Bool) -> (Area -> Area -> Bool) -> Eq Area
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Area -> Area -> Bool
$c/= :: Area -> Area -> Bool
== :: Area -> Area -> Bool
$c== :: Area -> Area -> Bool
Eq)
instance SP.ManagedPtrNewtype Area where
toManagedPtr :: Area -> ManagedPtr Area
toManagedPtr (Area ManagedPtr Area
p) = ManagedPtr Area
p
foreign import ccall "vips_area_get_type" c_vips_area_get_type ::
IO GType
type instance O.ParentTypes Area = '[]
instance O.HasParentTypes Area
instance B.Types.TypedObject Area where
glibType :: IO GType
glibType = IO GType
c_vips_area_get_type
instance B.Types.GBoxed Area
instance B.GValue.IsGValue (Maybe Area) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_vips_area_get_type
gvalueSet_ :: Ptr GValue -> Maybe Area -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Area
P.Nothing = Ptr GValue -> Ptr Area -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Area
forall a. Ptr a
FP.nullPtr :: FP.Ptr Area)
gvalueSet_ Ptr GValue
gv (P.Just Area
obj) = Area -> (Ptr Area -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Area
obj (Ptr GValue -> Ptr Area -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Area)
gvalueGet_ Ptr GValue
gv = do
Ptr Area
ptr <- Ptr GValue -> IO (Ptr Area)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Area)
if Ptr Area
ptr Ptr Area -> Ptr Area -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Area
forall a. Ptr a
FP.nullPtr
then Area -> Maybe Area
forall a. a -> Maybe a
P.Just (Area -> Maybe Area) -> IO Area -> IO (Maybe Area)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Area -> Area) -> Ptr Area -> IO Area
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Area -> Area
Area Ptr Area
ptr
else Maybe Area -> IO (Maybe Area)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Area
forall a. Maybe a
P.Nothing
newZeroArea :: MonadIO m => m Area
newZeroArea :: forall (m :: * -> *). MonadIO m => m Area
newZeroArea = IO Area -> m Area
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Area -> m Area) -> IO Area -> m Area
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Area)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
64 IO (Ptr Area) -> (Ptr Area -> IO Area) -> IO Area
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Area -> Area) -> Ptr Area -> IO Area
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Area -> Area
Area
instance tag ~ 'AttrSet => Constructible Area tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Area -> Area) -> [AttrOp Area tag] -> m Area
new ManagedPtr Area -> Area
_ [AttrOp Area tag]
attrs = do
Area
o <- m Area
forall (m :: * -> *). MonadIO m => m Area
newZeroArea
Area -> [AttrOp Area 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Area
o [AttrOp Area tag]
[AttrOp Area 'AttrSet]
attrs
Area -> m Area
forall (m :: * -> *) a. Monad m => a -> m a
return Area
o
getAreaData :: MonadIO m => Area -> m (Ptr ())
getAreaData :: forall (m :: * -> *). MonadIO m => Area -> m (Ptr ())
getAreaData Area
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
$ Area -> (Ptr Area -> IO (Ptr ())) -> IO (Ptr ())
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Area
s ((Ptr Area -> IO (Ptr ())) -> IO (Ptr ()))
-> (Ptr Area -> IO (Ptr ())) -> IO (Ptr ())
forall a b. (a -> b) -> a -> b
$ \Ptr Area
ptr -> do
Ptr ()
val <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek (Ptr Area
ptr Ptr Area -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr ())
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setAreaData :: MonadIO m => Area -> Ptr () -> m ()
setAreaData :: forall (m :: * -> *). MonadIO m => Area -> Ptr () -> m ()
setAreaData Area
s 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
$ Area -> (Ptr Area -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Area
s ((Ptr Area -> IO ()) -> IO ()) -> (Ptr Area -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Area
ptr -> do
Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Area
ptr Ptr Area -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr ()
val :: Ptr ())
clearAreaData :: MonadIO m => Area -> m ()
clearAreaData :: forall (m :: * -> *). MonadIO m => Area -> m ()
clearAreaData Area
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Area -> (Ptr Area -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Area
s ((Ptr Area -> IO ()) -> IO ()) -> (Ptr Area -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Area
ptr -> do
Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Area
ptr Ptr Area -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr ()
forall a. Ptr a
FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data AreaDataFieldInfo
instance AttrInfo AreaDataFieldInfo where
type AttrBaseTypeConstraint AreaDataFieldInfo = (~) Area
type AttrAllowedOps AreaDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AreaDataFieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint AreaDataFieldInfo = (~)(Ptr ())
type AttrTransferType AreaDataFieldInfo = (Ptr ())
type AttrGetType AreaDataFieldInfo = Ptr ()
type AttrLabel AreaDataFieldInfo = "data"
type AttrOrigin AreaDataFieldInfo = Area
attrGet = getAreaData
attrSet = setAreaData
attrConstruct = undefined
attrClear = clearAreaData
attrTransfer _ v = do
return v
area_data :: AttrLabelProxy "data"
area_data = AttrLabelProxy
#endif
getAreaLength :: MonadIO m => Area -> m Word64
getAreaLength :: forall (m :: * -> *). MonadIO m => Area -> m Word64
getAreaLength Area
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Area -> (Ptr Area -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Area
s ((Ptr Area -> IO Word64) -> IO Word64)
-> (Ptr Area -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Area
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Area
ptr Ptr Area -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setAreaLength :: MonadIO m => Area -> Word64 -> m ()
setAreaLength :: forall (m :: * -> *). MonadIO m => Area -> Word64 -> m ()
setAreaLength Area
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Area -> (Ptr Area -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Area
s ((Ptr Area -> IO ()) -> IO ()) -> (Ptr Area -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Area
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Area
ptr Ptr Area -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data AreaLengthFieldInfo
instance AttrInfo AreaLengthFieldInfo where
type AttrBaseTypeConstraint AreaLengthFieldInfo = (~) Area
type AttrAllowedOps AreaLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AreaLengthFieldInfo = (~) Word64
type AttrTransferTypeConstraint AreaLengthFieldInfo = (~)Word64
type AttrTransferType AreaLengthFieldInfo = Word64
type AttrGetType AreaLengthFieldInfo = Word64
type AttrLabel AreaLengthFieldInfo = "length"
type AttrOrigin AreaLengthFieldInfo = Area
attrGet = getAreaLength
attrSet = setAreaLength
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
area_length :: AttrLabelProxy "length"
area_length = AttrLabelProxy
#endif
getAreaN :: MonadIO m => Area -> m Int32
getAreaN :: forall (m :: * -> *). MonadIO m => Area -> m Int32
getAreaN Area
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Area -> (Ptr Area -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Area
s ((Ptr Area -> IO Int32) -> IO Int32)
-> (Ptr Area -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Area
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Area
ptr Ptr Area -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setAreaN :: MonadIO m => Area -> Int32 -> m ()
setAreaN :: forall (m :: * -> *). MonadIO m => Area -> Int32 -> m ()
setAreaN Area
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Area -> (Ptr Area -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Area
s ((Ptr Area -> IO ()) -> IO ()) -> (Ptr Area -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Area
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Area
ptr Ptr Area -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data AreaNFieldInfo
instance AttrInfo AreaNFieldInfo where
type AttrBaseTypeConstraint AreaNFieldInfo = (~) Area
type AttrAllowedOps AreaNFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AreaNFieldInfo = (~) Int32
type AttrTransferTypeConstraint AreaNFieldInfo = (~)Int32
type AttrTransferType AreaNFieldInfo = Int32
type AttrGetType AreaNFieldInfo = Int32
type AttrLabel AreaNFieldInfo = "n"
type AttrOrigin AreaNFieldInfo = Area
attrGet = getAreaN
attrSet = setAreaN
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
area_n :: AttrLabelProxy "n"
area_n = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Area
type instance O.AttributeList Area = AreaAttributeList
type AreaAttributeList = ('[ '("data", AreaDataFieldInfo), '("length", AreaLengthFieldInfo), '("n", AreaNFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "vips_area_new" vips_area_new ::
FunPtr Vips.Callbacks.C_CallbackFn ->
Ptr () ->
IO (Ptr Area)
areaNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Vips.Callbacks.CallbackFn
-> m Area
areaNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CallbackFn -> m Area
areaNew CallbackFn
freeFn = IO Area -> m Area
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Area -> m Area) -> IO Area -> m Area
forall a b. (a -> b) -> a -> b
$ do
Ptr (FunPtr CallbackFn)
ptrfreeFn <- IO (Ptr (FunPtr CallbackFn))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Vips.Callbacks.C_CallbackFn))
FunPtr CallbackFn
freeFn' <- CallbackFn -> IO (FunPtr CallbackFn)
Vips.Callbacks.mk_CallbackFn (Maybe (Ptr (FunPtr CallbackFn)) -> CallbackFn -> CallbackFn
Vips.Callbacks.wrap_CallbackFn (Ptr (FunPtr CallbackFn) -> Maybe (Ptr (FunPtr CallbackFn))
forall a. a -> Maybe a
Just Ptr (FunPtr CallbackFn)
ptrfreeFn) CallbackFn
freeFn)
Ptr (FunPtr CallbackFn) -> FunPtr CallbackFn -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr CallbackFn)
ptrfreeFn FunPtr CallbackFn
freeFn'
let data_ :: Ptr a
data_ = Ptr a
forall a. Ptr a
nullPtr
Ptr Area
result <- FunPtr CallbackFn -> Ptr () -> IO (Ptr Area)
vips_area_new FunPtr CallbackFn
freeFn' Ptr ()
forall a. Ptr a
data_
Text -> Ptr Area -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"areaNew" Ptr Area
result
Area
result' <- ((ManagedPtr Area -> Area) -> Ptr Area -> IO Area
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Area -> Area
Area) Ptr Area
result
Area -> IO Area
forall (m :: * -> *) a. Monad m => a -> m a
return Area
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "vips_area_new_array" vips_area_new_array ::
CGType ->
Word64 ->
Int32 ->
IO (Ptr Area)
areaNewArray ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> Word64
-> Int32
-> m Area
areaNewArray :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> Word64 -> Int32 -> m Area
areaNewArray GType
type_ Word64
sizeofType Int32
n = IO Area -> m Area
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Area -> m Area) -> IO Area -> m Area
forall a b. (a -> b) -> a -> b
$ do
let type_' :: Word64
type_' = GType -> Word64
gtypeToCGType GType
type_
Ptr Area
result <- Word64 -> Word64 -> Int32 -> IO (Ptr Area)
vips_area_new_array Word64
type_' Word64
sizeofType Int32
n
Text -> Ptr Area -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"areaNewArray" Ptr Area
result
Area
result' <- ((ManagedPtr Area -> Area) -> Ptr Area -> IO Area
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Area -> Area
Area) Ptr Area
result
Area -> IO Area
forall (m :: * -> *) a. Monad m => a -> m a
return Area
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "vips_area_new_array_object" vips_area_new_array_object ::
Int32 ->
IO (Ptr Area)
areaNewArrayObject ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> m Area
areaNewArrayObject :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Int32 -> m Area
areaNewArrayObject Int32
n = IO Area -> m Area
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Area -> m Area) -> IO Area -> m Area
forall a b. (a -> b) -> a -> b
$ do
Ptr Area
result <- Int32 -> IO (Ptr Area)
vips_area_new_array_object Int32
n
Text -> Ptr Area -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"areaNewArrayObject" Ptr Area
result
Area
result' <- ((ManagedPtr Area -> Area) -> Ptr Area -> IO Area
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Area -> Area
Area) Ptr Area
result
Area -> IO Area
forall (m :: * -> *) a. Monad m => a -> m a
return Area
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "vips_area_get_data" vips_area_get_data ::
Ptr Area ->
Word64 ->
Int32 ->
CGType ->
Word64 ->
IO (Ptr ())
areaAreaGetData ::
(B.CallStack.HasCallStack, MonadIO m) =>
Area
-> Word64
-> Int32
-> GType
-> Word64
-> m (Ptr ())
areaAreaGetData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Area -> Word64 -> Int32 -> GType -> Word64 -> m (Ptr ())
areaAreaGetData Area
area Word64
length_ Int32
n GType
type_ Word64
sizeofType = 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
$ do
Ptr Area
area' <- Area -> IO (Ptr Area)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Area
area
let type_' :: Word64
type_' = GType -> Word64
gtypeToCGType GType
type_
Ptr ()
result <- Ptr Area -> Word64 -> Int32 -> Word64 -> Word64 -> IO (Ptr ())
vips_area_get_data Ptr Area
area' Word64
length_ Int32
n Word64
type_' Word64
sizeofType
Area -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Area
area
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data AreaAreaGetDataMethodInfo
instance (signature ~ (Word64 -> Int32 -> GType -> Word64 -> m (Ptr ())), MonadIO m) => O.OverloadedMethod AreaAreaGetDataMethodInfo Area signature where
overloadedMethod = areaAreaGetData
instance O.OverloadedMethodInfo AreaAreaGetDataMethodInfo Area where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Structs.Area.areaAreaGetData",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Structs-Area.html#v:areaAreaGetData"
}
#endif
foreign import ccall "vips_area_copy" vips_area_copy ::
Ptr Area ->
IO (Ptr Area)
areaCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Area
-> m Area
areaCopy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Area -> m Area
areaCopy Area
area = IO Area -> m Area
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Area -> m Area) -> IO Area -> m Area
forall a b. (a -> b) -> a -> b
$ do
Ptr Area
area' <- Area -> IO (Ptr Area)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Area
area
Ptr Area
result <- Ptr Area -> IO (Ptr Area)
vips_area_copy Ptr Area
area'
Text -> Ptr Area -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"areaCopy" Ptr Area
result
Area
result' <- ((ManagedPtr Area -> Area) -> Ptr Area -> IO Area
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Area -> Area
Area) Ptr Area
result
Area -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Area
area
Area -> IO Area
forall (m :: * -> *) a. Monad m => a -> m a
return Area
result'
#if defined(ENABLE_OVERLOADING)
data AreaCopyMethodInfo
instance (signature ~ (m Area), MonadIO m) => O.OverloadedMethod AreaCopyMethodInfo Area signature where
overloadedMethod = areaCopy
instance O.OverloadedMethodInfo AreaCopyMethodInfo Area where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Structs.Area.areaCopy",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Structs-Area.html#v:areaCopy"
}
#endif
foreign import ccall "vips_area_unref" vips_area_unref ::
Ptr Area ->
IO ()
areaUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
Area
-> m ()
areaUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Area -> m ()
areaUnref Area
area = 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 Area
area' <- Area -> IO (Ptr Area)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Area
area
Ptr Area -> IO ()
vips_area_unref Ptr Area
area'
Area -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Area
area
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AreaUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod AreaUnrefMethodInfo Area signature where
overloadedMethod = areaUnref
instance O.OverloadedMethodInfo AreaUnrefMethodInfo Area where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Structs.Area.areaUnref",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Structs-Area.html#v:areaUnref"
}
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveAreaMethod (t :: Symbol) (o :: *) :: * where
ResolveAreaMethod "areaGetData" o = AreaAreaGetDataMethodInfo
ResolveAreaMethod "copy" o = AreaCopyMethodInfo
ResolveAreaMethod "unref" o = AreaUnrefMethodInfo
ResolveAreaMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAreaMethod t Area, O.OverloadedMethod info Area p) => OL.IsLabel t (Area -> 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 ~ ResolveAreaMethod t Area, O.OverloadedMethod info Area p, R.HasField t Area p) => R.HasField t Area p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveAreaMethod t Area, O.OverloadedMethodInfo info Area) => OL.IsLabel t (O.MethodProxy info Area) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif