{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Vips.Objects.Region
(
Region(..) ,
IsRegion ,
toRegion ,
#if defined(ENABLE_OVERLOADING)
ResolveRegionMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
RegionCopyMethodInfo ,
#endif
regionCopy ,
#if defined(ENABLE_OVERLOADING)
RegionEqualsregionMethodInfo ,
#endif
regionEqualsregion ,
regionNew ,
#if defined(ENABLE_OVERLOADING)
RegionRegionBlackMethodInfo ,
#endif
regionRegionBlack ,
#if defined(ENABLE_OVERLOADING)
RegionRegionBufferMethodInfo ,
#endif
regionRegionBuffer ,
#if defined(ENABLE_OVERLOADING)
RegionRegionFetchMethodInfo ,
#endif
regionRegionFetch ,
#if defined(ENABLE_OVERLOADING)
RegionRegionHeightMethodInfo ,
#endif
regionRegionHeight ,
#if defined(ENABLE_OVERLOADING)
RegionRegionImageMethodInfo ,
#endif
regionRegionImage ,
#if defined(ENABLE_OVERLOADING)
RegionRegionInvalidateMethodInfo ,
#endif
regionRegionInvalidate ,
#if defined(ENABLE_OVERLOADING)
RegionRegionPaintMethodInfo ,
#endif
regionRegionPaint ,
#if defined(ENABLE_OVERLOADING)
RegionRegionPaintPelMethodInfo ,
#endif
regionRegionPaintPel ,
#if defined(ENABLE_OVERLOADING)
RegionRegionPositionMethodInfo ,
#endif
regionRegionPosition ,
#if defined(ENABLE_OVERLOADING)
RegionRegionPrepareMethodInfo ,
#endif
regionRegionPrepare ,
#if defined(ENABLE_OVERLOADING)
RegionRegionPrepareToMethodInfo ,
#endif
regionRegionPrepareTo ,
#if defined(ENABLE_OVERLOADING)
RegionRegionRegionMethodInfo ,
#endif
regionRegionRegion ,
#if defined(ENABLE_OVERLOADING)
RegionRegionWidthMethodInfo ,
#endif
regionRegionWidth ,
#if defined(ENABLE_OVERLOADING)
RegionShrinkMethodMethodInfo ,
#endif
regionShrinkMethod ,
) 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.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Vips.Enums as Vips.Enums
import {-# SOURCE #-} qualified GI.Vips.Objects.Image as Vips.Image
import {-# SOURCE #-} qualified GI.Vips.Objects.Object as Vips.Object
import {-# SOURCE #-} qualified GI.Vips.Structs.Rect as Vips.Rect
newtype Region = Region (SP.ManagedPtr Region)
deriving (Region -> Region -> Bool
(Region -> Region -> Bool)
-> (Region -> Region -> Bool) -> Eq Region
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Region -> Region -> Bool
$c/= :: Region -> Region -> Bool
== :: Region -> Region -> Bool
$c== :: Region -> Region -> Bool
Eq)
instance SP.ManagedPtrNewtype Region where
toManagedPtr :: Region -> ManagedPtr Region
toManagedPtr (Region ManagedPtr Region
p) = ManagedPtr Region
p
foreign import ccall "vips_region_get_type"
c_vips_region_get_type :: IO B.Types.GType
instance B.Types.TypedObject Region where
glibType :: IO GType
glibType = IO GType
c_vips_region_get_type
instance B.Types.GObject Region
class (SP.GObject o, O.IsDescendantOf Region o) => IsRegion o
instance (SP.GObject o, O.IsDescendantOf Region o) => IsRegion o
instance O.HasParentTypes Region
type instance O.ParentTypes Region = '[Vips.Object.Object, GObject.Object.Object]
toRegion :: (MIO.MonadIO m, IsRegion o) => o -> m Region
toRegion :: forall (m :: * -> *) o. (MonadIO m, IsRegion o) => o -> m Region
toRegion = IO Region -> m Region
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Region -> m Region) -> (o -> IO Region) -> o -> m Region
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Region -> Region) -> o -> IO Region
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Region -> Region
Region
instance B.GValue.IsGValue (Maybe Region) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_vips_region_get_type
gvalueSet_ :: Ptr GValue -> Maybe Region -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Region
P.Nothing = Ptr GValue -> Ptr Region -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Region
forall a. Ptr a
FP.nullPtr :: FP.Ptr Region)
gvalueSet_ Ptr GValue
gv (P.Just Region
obj) = Region -> (Ptr Region -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Region
obj (Ptr GValue -> Ptr Region -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Region)
gvalueGet_ Ptr GValue
gv = do
Ptr Region
ptr <- Ptr GValue -> IO (Ptr Region)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Region)
if Ptr Region
ptr Ptr Region -> Ptr Region -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Region
forall a. Ptr a
FP.nullPtr
then Region -> Maybe Region
forall a. a -> Maybe a
P.Just (Region -> Maybe Region) -> IO Region -> IO (Maybe Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Region -> Region) -> Ptr Region -> IO Region
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Region -> Region
Region Ptr Region
ptr
else Maybe Region -> IO (Maybe Region)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Region
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveRegionMethod (t :: Symbol) (o :: *) :: * where
ResolveRegionMethod "argumentIsset" o = Vips.Object.ObjectArgumentIssetMethodInfo
ResolveRegionMethod "argumentNeedsstring" o = Vips.Object.ObjectArgumentNeedsstringMethodInfo
ResolveRegionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveRegionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveRegionMethod "build" o = Vips.Object.ObjectBuildMethodInfo
ResolveRegionMethod "copy" o = RegionCopyMethodInfo
ResolveRegionMethod "equalsregion" o = RegionEqualsregionMethodInfo
ResolveRegionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveRegionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveRegionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveRegionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveRegionMethod "localCb" o = Vips.Object.ObjectLocalCbMethodInfo
ResolveRegionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveRegionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveRegionMethod "preclose" o = Vips.Object.ObjectPrecloseMethodInfo
ResolveRegionMethod "printDump" o = Vips.Object.ObjectPrintDumpMethodInfo
ResolveRegionMethod "printName" o = Vips.Object.ObjectPrintNameMethodInfo
ResolveRegionMethod "printSummary" o = Vips.Object.ObjectPrintSummaryMethodInfo
ResolveRegionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveRegionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveRegionMethod "regionBlack" o = RegionRegionBlackMethodInfo
ResolveRegionMethod "regionBuffer" o = RegionRegionBufferMethodInfo
ResolveRegionMethod "regionFetch" o = RegionRegionFetchMethodInfo
ResolveRegionMethod "regionHeight" o = RegionRegionHeightMethodInfo
ResolveRegionMethod "regionImage" o = RegionRegionImageMethodInfo
ResolveRegionMethod "regionInvalidate" o = RegionRegionInvalidateMethodInfo
ResolveRegionMethod "regionPaint" o = RegionRegionPaintMethodInfo
ResolveRegionMethod "regionPaintPel" o = RegionRegionPaintPelMethodInfo
ResolveRegionMethod "regionPosition" o = RegionRegionPositionMethodInfo
ResolveRegionMethod "regionPrepare" o = RegionRegionPrepareMethodInfo
ResolveRegionMethod "regionPrepareTo" o = RegionRegionPrepareToMethodInfo
ResolveRegionMethod "regionRegion" o = RegionRegionRegionMethodInfo
ResolveRegionMethod "regionWidth" o = RegionRegionWidthMethodInfo
ResolveRegionMethod "rewind" o = Vips.Object.ObjectRewindMethodInfo
ResolveRegionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveRegionMethod "sanity" o = Vips.Object.ObjectSanityMethodInfo
ResolveRegionMethod "shrinkMethod" o = RegionShrinkMethodMethodInfo
ResolveRegionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveRegionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveRegionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveRegionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveRegionMethod "unrefOutputs" o = Vips.Object.ObjectUnrefOutputsMethodInfo
ResolveRegionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveRegionMethod "getArgumentFlags" o = Vips.Object.ObjectGetArgumentFlagsMethodInfo
ResolveRegionMethod "getArgumentPriority" o = Vips.Object.ObjectGetArgumentPriorityMethodInfo
ResolveRegionMethod "getArgumentToString" o = Vips.Object.ObjectGetArgumentToStringMethodInfo
ResolveRegionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveRegionMethod "getDescription" o = Vips.Object.ObjectGetDescriptionMethodInfo
ResolveRegionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveRegionMethod "setArgumentFromString" o = Vips.Object.ObjectSetArgumentFromStringMethodInfo
ResolveRegionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveRegionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveRegionMethod "setFromString" o = Vips.Object.ObjectSetFromStringMethodInfo
ResolveRegionMethod "setRequired" o = Vips.Object.ObjectSetRequiredMethodInfo
ResolveRegionMethod "setStatic" o = Vips.Object.ObjectSetStaticMethodInfo
ResolveRegionMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRegionMethod t Region, O.OverloadedMethod info Region p) => OL.IsLabel t (Region -> 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 ~ ResolveRegionMethod t Region, O.OverloadedMethod info Region p, R.HasField t Region p) => R.HasField t Region p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveRegionMethod t Region, O.OverloadedMethodInfo info Region) => OL.IsLabel t (O.MethodProxy info Region) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Region
type instance O.AttributeList Region = RegionAttributeList
type RegionAttributeList = ('[ '("description", Vips.Object.ObjectDescriptionPropertyInfo), '("nickname", Vips.Object.ObjectNicknamePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Region = RegionSignalList
type RegionSignalList = ('[ '("close", Vips.Object.ObjectCloseSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("postbuild", Vips.Object.ObjectPostbuildSignalInfo), '("postclose", Vips.Object.ObjectPostcloseSignalInfo), '("preclose", Vips.Object.ObjectPrecloseSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "vips_region_new" vips_region_new ::
Ptr Vips.Image.Image ->
IO (Ptr Region)
regionNew ::
(B.CallStack.HasCallStack, MonadIO m, Vips.Image.IsImage a) =>
a
-> m Region
regionNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsImage a) =>
a -> m Region
regionNew a
image = IO Region -> m Region
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Region -> m Region) -> IO Region -> m Region
forall a b. (a -> b) -> a -> b
$ do
Ptr Image
image' <- a -> IO (Ptr Image)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
image
Ptr Region
result <- Ptr Image -> IO (Ptr Region)
vips_region_new Ptr Image
image'
Text -> Ptr Region -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"regionNew" Ptr Region
result
Region
result' <- ((ManagedPtr Region -> Region) -> Ptr Region -> IO Region
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Region -> Region
Region) Ptr Region
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
image
Region -> IO Region
forall (m :: * -> *) a. Monad m => a -> m a
return Region
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "vips_region_copy" vips_region_copy ::
Ptr Region ->
Ptr (Ptr Region) ->
Ptr Vips.Rect.Rect ->
Int32 ->
Int32 ->
IO ()
regionCopy ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a
-> b
-> Vips.Rect.Rect
-> Int32
-> Int32
-> m (Region)
regionCopy :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a -> b -> Rect -> Int32 -> Int32 -> m Region
regionCopy a
reg b
dest Rect
r Int32
x Int32
y = IO Region -> m Region
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Region -> m Region) -> IO Region -> m Region
forall a b. (a -> b) -> a -> b
$ do
Ptr Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Region
dest' <- b -> IO (Ptr Region)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject b
dest
Ptr (Ptr Region)
dest'' <- IO (Ptr (Ptr Region))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr Region))
Ptr (Ptr Region) -> Ptr Region -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (Ptr Region)
dest'' Ptr Region
dest'
Ptr Rect
r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
Ptr Region
-> Ptr (Ptr Region) -> Ptr Rect -> Int32 -> Int32 -> IO ()
vips_region_copy Ptr Region
reg' Ptr (Ptr Region)
dest'' Ptr Rect
r' Int32
x Int32
y
Ptr Region
dest''' <- Ptr (Ptr Region) -> IO (Ptr Region)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Region)
dest''
Region
dest'''' <- ((ManagedPtr Region -> Region) -> Ptr Region -> IO Region
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Region -> Region
Region) Ptr Region
dest'''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
r
Ptr (Ptr Region) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Region)
dest''
Region -> IO Region
forall (m :: * -> *) a. Monad m => a -> m a
return Region
dest''''
#if defined(ENABLE_OVERLOADING)
data RegionCopyMethodInfo
instance (signature ~ (b -> Vips.Rect.Rect -> Int32 -> Int32 -> m (Region)), MonadIO m, IsRegion a, IsRegion b) => O.OverloadedMethod RegionCopyMethodInfo a signature where
overloadedMethod = regionCopy
instance O.OverloadedMethodInfo RegionCopyMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionCopy",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionCopy"
}
#endif
foreign import ccall "vips_region_equalsregion" vips_region_equalsregion ::
Ptr Region ->
Ptr Region ->
IO Int32
regionEqualsregion ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a
-> b
-> m Int32
regionEqualsregion :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a -> b -> m Int32
regionEqualsregion a
reg1 b
reg2 = 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
$ do
Ptr Region
reg1' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg1
Ptr Region
reg2' <- b -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
reg2
Int32
result <- Ptr Region -> Ptr Region -> IO Int32
vips_region_equalsregion Ptr Region
reg1' Ptr Region
reg2'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg1
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
reg2
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionEqualsregionMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsRegion a, IsRegion b) => O.OverloadedMethod RegionEqualsregionMethodInfo a signature where
overloadedMethod = regionEqualsregion
instance O.OverloadedMethodInfo RegionEqualsregionMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionEqualsregion",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionEqualsregion"
}
#endif
foreign import ccall "vips_region_black" vips_region_black ::
Ptr Region ->
IO ()
regionRegionBlack ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> m ()
regionRegionBlack :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> m ()
regionRegionBlack a
reg = 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 Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Region -> IO ()
vips_region_black Ptr Region
reg'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegionRegionBlackMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionBlackMethodInfo a signature where
overloadedMethod = regionRegionBlack
instance O.OverloadedMethodInfo RegionRegionBlackMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionBlack",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionBlack"
}
#endif
foreign import ccall "vips_region_buffer" vips_region_buffer ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
IO Int32
regionRegionBuffer ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> m Int32
regionRegionBuffer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> m Int32
regionRegionBuffer a
reg Rect
r = 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
$ do
Ptr Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Rect
r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
Int32
result <- Ptr Region -> Ptr Rect -> IO Int32
vips_region_buffer Ptr Region
reg' Ptr Rect
r'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
r
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionRegionBufferMethodInfo
instance (signature ~ (Vips.Rect.Rect -> m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionBufferMethodInfo a signature where
overloadedMethod = regionRegionBuffer
instance O.OverloadedMethodInfo RegionRegionBufferMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionBuffer",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionBuffer"
}
#endif
foreign import ccall "vips_region_fetch" vips_region_fetch ::
Ptr Region ->
Int32 ->
Int32 ->
Int32 ->
Int32 ->
Word64 ->
IO Word8
regionRegionFetch ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Int32
-> Int32
-> Int32
-> Int32
-> Word64
-> m Word8
regionRegionFetch :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Int32 -> Int32 -> Int32 -> Int32 -> Word64 -> m Word8
regionRegionFetch a
region Int32
left Int32
top Int32
width Int32
height Word64
len = IO Word8 -> m Word8
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
Ptr Region
region' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
region
Word8
result <- Ptr Region
-> Int32 -> Int32 -> Int32 -> Int32 -> Word64 -> IO Word8
vips_region_fetch Ptr Region
region' Int32
left Int32
top Int32
width Int32
height Word64
len
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
region
Word8 -> IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result
#if defined(ENABLE_OVERLOADING)
data RegionRegionFetchMethodInfo
instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> Word64 -> m Word8), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionFetchMethodInfo a signature where
overloadedMethod = regionRegionFetch
instance O.OverloadedMethodInfo RegionRegionFetchMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionFetch",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionFetch"
}
#endif
foreign import ccall "vips_region_height" vips_region_height ::
Ptr Region ->
IO Int32
regionRegionHeight ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> m Int32
regionRegionHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> m Int32
regionRegionHeight a
region = 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
$ do
Ptr Region
region' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
region
Int32
result <- Ptr Region -> IO Int32
vips_region_height Ptr Region
region'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
region
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionRegionHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionHeightMethodInfo a signature where
overloadedMethod = regionRegionHeight
instance O.OverloadedMethodInfo RegionRegionHeightMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionHeight",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionHeight"
}
#endif
foreign import ccall "vips_region_image" vips_region_image ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
IO Int32
regionRegionImage ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> m Int32
regionRegionImage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> m Int32
regionRegionImage a
reg Rect
r = 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
$ do
Ptr Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Rect
r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
Int32
result <- Ptr Region -> Ptr Rect -> IO Int32
vips_region_image Ptr Region
reg' Ptr Rect
r'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
r
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionRegionImageMethodInfo
instance (signature ~ (Vips.Rect.Rect -> m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionImageMethodInfo a signature where
overloadedMethod = regionRegionImage
instance O.OverloadedMethodInfo RegionRegionImageMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionImage",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionImage"
}
#endif
foreign import ccall "vips_region_invalidate" vips_region_invalidate ::
Ptr Region ->
IO ()
regionRegionInvalidate ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> m ()
regionRegionInvalidate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> m ()
regionRegionInvalidate a
reg = 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 Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Region -> IO ()
vips_region_invalidate Ptr Region
reg'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegionRegionInvalidateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionInvalidateMethodInfo a signature where
overloadedMethod = regionRegionInvalidate
instance O.OverloadedMethodInfo RegionRegionInvalidateMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionInvalidate",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionInvalidate"
}
#endif
foreign import ccall "vips_region_paint" vips_region_paint ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
Int32 ->
IO ()
regionRegionPaint ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> Int32
-> m ()
regionRegionPaint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> Int32 -> m ()
regionRegionPaint a
reg Rect
r Int32
value = 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 Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Rect
r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
Ptr Region -> Ptr Rect -> Int32 -> IO ()
vips_region_paint Ptr Region
reg' Ptr Rect
r' Int32
value
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
r
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegionRegionPaintMethodInfo
instance (signature ~ (Vips.Rect.Rect -> Int32 -> m ()), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionPaintMethodInfo a signature where
overloadedMethod = regionRegionPaint
instance O.OverloadedMethodInfo RegionRegionPaintMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionPaint",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionPaint"
}
#endif
foreign import ccall "vips_region_paint_pel" vips_region_paint_pel ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
Word8 ->
IO ()
regionRegionPaintPel ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> Word8
-> m ()
regionRegionPaintPel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> Word8 -> m ()
regionRegionPaintPel a
reg Rect
r Word8
ink = 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 Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Rect
r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
Ptr Region -> Ptr Rect -> Word8 -> IO ()
vips_region_paint_pel Ptr Region
reg' Ptr Rect
r' Word8
ink
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
r
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegionRegionPaintPelMethodInfo
instance (signature ~ (Vips.Rect.Rect -> Word8 -> m ()), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionPaintPelMethodInfo a signature where
overloadedMethod = regionRegionPaintPel
instance O.OverloadedMethodInfo RegionRegionPaintPelMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionPaintPel",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionPaintPel"
}
#endif
foreign import ccall "vips_region_position" vips_region_position ::
Ptr Region ->
Int32 ->
Int32 ->
IO Int32
regionRegionPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Int32
-> Int32
-> m Int32
regionRegionPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Int32 -> Int32 -> m Int32
regionRegionPosition a
reg Int32
x Int32
y = 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
$ do
Ptr Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Int32
result <- Ptr Region -> Int32 -> Int32 -> IO Int32
vips_region_position Ptr Region
reg' Int32
x Int32
y
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionRegionPositionMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionPositionMethodInfo a signature where
overloadedMethod = regionRegionPosition
instance O.OverloadedMethodInfo RegionRegionPositionMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionPosition",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionPosition"
}
#endif
foreign import ccall "vips_region_prepare" vips_region_prepare ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
IO Int32
regionRegionPrepare ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> m Int32
regionRegionPrepare :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> m Int32
regionRegionPrepare a
reg Rect
r = 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
$ do
Ptr Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Rect
r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
Int32
result <- Ptr Region -> Ptr Rect -> IO Int32
vips_region_prepare Ptr Region
reg' Ptr Rect
r'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
r
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionRegionPrepareMethodInfo
instance (signature ~ (Vips.Rect.Rect -> m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionPrepareMethodInfo a signature where
overloadedMethod = regionRegionPrepare
instance O.OverloadedMethodInfo RegionRegionPrepareMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionPrepare",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionPrepare"
}
#endif
foreign import ccall "vips_region_prepare_to" vips_region_prepare_to ::
Ptr Region ->
Ptr (Ptr Region) ->
Ptr Vips.Rect.Rect ->
Int32 ->
Int32 ->
IO Int32
regionRegionPrepareTo ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a
-> b
-> Vips.Rect.Rect
-> Int32
-> Int32
-> m ((Int32, Region))
regionRegionPrepareTo :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a -> b -> Rect -> Int32 -> Int32 -> m (Int32, Region)
regionRegionPrepareTo a
reg b
dest Rect
r Int32
x Int32
y = IO (Int32, Region) -> m (Int32, Region)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Region) -> m (Int32, Region))
-> IO (Int32, Region) -> m (Int32, Region)
forall a b. (a -> b) -> a -> b
$ do
Ptr Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Region
dest' <- b -> IO (Ptr Region)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject b
dest
Ptr (Ptr Region)
dest'' <- IO (Ptr (Ptr Region))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr Region))
Ptr (Ptr Region) -> Ptr Region -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (Ptr Region)
dest'' Ptr Region
dest'
Ptr Rect
r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
Int32
result <- Ptr Region
-> Ptr (Ptr Region) -> Ptr Rect -> Int32 -> Int32 -> IO Int32
vips_region_prepare_to Ptr Region
reg' Ptr (Ptr Region)
dest'' Ptr Rect
r' Int32
x Int32
y
Ptr Region
dest''' <- Ptr (Ptr Region) -> IO (Ptr Region)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Region)
dest''
Region
dest'''' <- ((ManagedPtr Region -> Region) -> Ptr Region -> IO Region
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Region -> Region
Region) Ptr Region
dest'''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
r
Ptr (Ptr Region) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Region)
dest''
(Int32, Region) -> IO (Int32, Region)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
result, Region
dest'''')
#if defined(ENABLE_OVERLOADING)
data RegionRegionPrepareToMethodInfo
instance (signature ~ (b -> Vips.Rect.Rect -> Int32 -> Int32 -> m ((Int32, Region))), MonadIO m, IsRegion a, IsRegion b) => O.OverloadedMethod RegionRegionPrepareToMethodInfo a signature where
overloadedMethod = regionRegionPrepareTo
instance O.OverloadedMethodInfo RegionRegionPrepareToMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionPrepareTo",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionPrepareTo"
}
#endif
foreign import ccall "vips_region_region" vips_region_region ::
Ptr Region ->
Ptr Region ->
Ptr Vips.Rect.Rect ->
Int32 ->
Int32 ->
IO Int32
regionRegionRegion ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a
-> b
-> Vips.Rect.Rect
-> Int32
-> Int32
-> m Int32
regionRegionRegion :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a -> b -> Rect -> Int32 -> Int32 -> m Int32
regionRegionRegion a
reg b
dest Rect
r Int32
x Int32
y = 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
$ do
Ptr Region
reg' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reg
Ptr Region
dest' <- b -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dest
Ptr Rect
r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
Int32
result <- Ptr Region -> Ptr Region -> Ptr Rect -> Int32 -> Int32 -> IO Int32
vips_region_region Ptr Region
reg' Ptr Region
dest' Ptr Rect
r' Int32
x Int32
y
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reg
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
r
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionRegionRegionMethodInfo
instance (signature ~ (b -> Vips.Rect.Rect -> Int32 -> Int32 -> m Int32), MonadIO m, IsRegion a, IsRegion b) => O.OverloadedMethod RegionRegionRegionMethodInfo a signature where
overloadedMethod = regionRegionRegion
instance O.OverloadedMethodInfo RegionRegionRegionMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionRegion",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionRegion"
}
#endif
foreign import ccall "vips_region_width" vips_region_width ::
Ptr Region ->
IO Int32
regionRegionWidth ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> m Int32
regionRegionWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> m Int32
regionRegionWidth a
region = 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
$ do
Ptr Region
region' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
region
Int32
result <- Ptr Region -> IO Int32
vips_region_width Ptr Region
region'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
region
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionRegionWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionRegionWidthMethodInfo a signature where
overloadedMethod = regionRegionWidth
instance O.OverloadedMethodInfo RegionRegionWidthMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionRegionWidth",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionRegionWidth"
}
#endif
foreign import ccall "vips_region_shrink_method" vips_region_shrink_method ::
Ptr Region ->
Ptr (Ptr Region) ->
Ptr Vips.Rect.Rect ->
CUInt ->
IO Int32
regionShrinkMethod ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a
-> b
-> Vips.Rect.Rect
-> Vips.Enums.RegionShrink
-> m ((Int32, Region))
regionShrinkMethod :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a -> b -> Rect -> RegionShrink -> m (Int32, Region)
regionShrinkMethod a
from b
to Rect
target RegionShrink
method = IO (Int32, Region) -> m (Int32, Region)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Region) -> m (Int32, Region))
-> IO (Int32, Region) -> m (Int32, Region)
forall a b. (a -> b) -> a -> b
$ do
Ptr Region
from' <- a -> IO (Ptr Region)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
from
Ptr Region
to' <- b -> IO (Ptr Region)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject b
to
Ptr (Ptr Region)
to'' <- IO (Ptr (Ptr Region))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr Region))
Ptr (Ptr Region) -> Ptr Region -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (Ptr Region)
to'' Ptr Region
to'
Ptr Rect
target' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
target
let method' :: CUInt
method' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (RegionShrink -> Int) -> RegionShrink -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RegionShrink -> Int
forall a. Enum a => a -> Int
fromEnum) RegionShrink
method
Int32
result <- Ptr Region -> Ptr (Ptr Region) -> Ptr Rect -> CUInt -> IO Int32
vips_region_shrink_method Ptr Region
from' Ptr (Ptr Region)
to'' Ptr Rect
target' CUInt
method'
Ptr Region
to''' <- Ptr (Ptr Region) -> IO (Ptr Region)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Region)
to''
Region
to'''' <- ((ManagedPtr Region -> Region) -> Ptr Region -> IO Region
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Region -> Region
Region) Ptr Region
to'''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
from
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
to
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
target
Ptr (Ptr Region) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Region)
to''
(Int32, Region) -> IO (Int32, Region)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
result, Region
to'''')
#if defined(ENABLE_OVERLOADING)
data RegionShrinkMethodMethodInfo
instance (signature ~ (b -> Vips.Rect.Rect -> Vips.Enums.RegionShrink -> m ((Int32, Region))), MonadIO m, IsRegion a, IsRegion b) => O.OverloadedMethod RegionShrinkMethodMethodInfo a signature where
overloadedMethod = regionShrinkMethod
instance O.OverloadedMethodInfo RegionShrinkMethodMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Objects.Region.regionShrinkMethod",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Objects-Region.html#v:regionShrinkMethod"
}
#endif