{-# 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)
RegionBlackMethodInfo ,
#endif
regionBlack ,
#if defined(ENABLE_OVERLOADING)
RegionBufferMethodInfo ,
#endif
regionBuffer ,
#if defined(ENABLE_OVERLOADING)
RegionCopyMethodInfo ,
#endif
regionCopy ,
#if defined(ENABLE_OVERLOADING)
RegionEqualsregionMethodInfo ,
#endif
regionEqualsregion ,
#if defined(ENABLE_OVERLOADING)
RegionFetchMethodInfo ,
#endif
regionFetch ,
#if defined(ENABLE_OVERLOADING)
RegionHeightMethodInfo ,
#endif
regionHeight ,
#if defined(ENABLE_OVERLOADING)
RegionImageMethodInfo ,
#endif
regionImage ,
#if defined(ENABLE_OVERLOADING)
RegionInvalidateMethodInfo ,
#endif
regionInvalidate ,
regionNew ,
#if defined(ENABLE_OVERLOADING)
RegionPaintMethodInfo ,
#endif
regionPaint ,
#if defined(ENABLE_OVERLOADING)
RegionPaintPelMethodInfo ,
#endif
regionPaintPel ,
#if defined(ENABLE_OVERLOADING)
RegionPositionMethodInfo ,
#endif
regionPosition ,
#if defined(ENABLE_OVERLOADING)
RegionPrepareMethodInfo ,
#endif
regionPrepare ,
#if defined(ENABLE_OVERLOADING)
RegionPrepareToMethodInfo ,
#endif
regionPrepareTo ,
#if defined(ENABLE_OVERLOADING)
RegionRegionMethodInfo ,
#endif
regionRegion ,
#if defined(ENABLE_OVERLOADING)
RegionShrinkMethodMethodInfo ,
#endif
regionShrinkMethod ,
#if defined(ENABLE_OVERLOADING)
RegionWidthMethodInfo ,
#endif
regionWidth ,
) 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.GHashTable as B.GHT
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.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
$c== :: Region -> Region -> Bool
== :: Region -> Region -> Bool
$c/= :: Region -> Region -> Bool
/= :: 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 a. IO a -> m a
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 a. a -> IO a
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 "black" o = RegionBlackMethodInfo
ResolveRegionMethod "buffer" o = RegionBufferMethodInfo
ResolveRegionMethod "build" o = Vips.Object.ObjectBuildMethodInfo
ResolveRegionMethod "copy" o = RegionCopyMethodInfo
ResolveRegionMethod "equalsregion" o = RegionEqualsregionMethodInfo
ResolveRegionMethod "fetch" o = RegionFetchMethodInfo
ResolveRegionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveRegionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveRegionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveRegionMethod "height" o = RegionHeightMethodInfo
ResolveRegionMethod "image" o = RegionImageMethodInfo
ResolveRegionMethod "invalidate" o = RegionInvalidateMethodInfo
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 "paint" o = RegionPaintMethodInfo
ResolveRegionMethod "paintPel" o = RegionPaintPelMethodInfo
ResolveRegionMethod "position" o = RegionPositionMethodInfo
ResolveRegionMethod "preclose" o = Vips.Object.ObjectPrecloseMethodInfo
ResolveRegionMethod "prepare" o = RegionPrepareMethodInfo
ResolveRegionMethod "prepareTo" o = RegionPrepareToMethodInfo
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 "region" o = RegionRegionMethodInfo
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 "toString" o = Vips.Object.ObjectToStringMethodInfo
ResolveRegionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveRegionMethod "unrefOutputs" o = Vips.Object.ObjectUnrefOutputsMethodInfo
ResolveRegionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveRegionMethod "width" o = RegionWidthMethodInfo
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 a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Region
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "vips_region_black" vips_region_black ::
Ptr Region ->
IO ()
regionBlack ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> m ()
regionBlack :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> m ()
regionBlack a
reg = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegionBlackMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRegion a) => O.OverloadedMethod RegionBlackMethodInfo a signature where
overloadedMethod = regionBlack
instance O.OverloadedMethodInfo RegionBlackMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionBlack",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionBlack"
})
#endif
foreign import ccall "vips_region_buffer" vips_region_buffer ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
IO Int32
regionBuffer ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> m Int32
regionBuffer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> m Int32
regionBuffer a
reg Rect
r = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionBufferMethodInfo
instance (signature ~ (Vips.Rect.Rect -> m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionBufferMethodInfo a signature where
overloadedMethod = regionBuffer
instance O.OverloadedMethodInfo RegionBufferMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionBuffer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionBuffer"
})
#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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionEqualsregion",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionEqualsregion"
})
#endif
foreign import ccall "vips_region_fetch" vips_region_fetch ::
Ptr Region ->
Int32 ->
Int32 ->
Int32 ->
Int32 ->
Word64 ->
IO Word8
regionFetch ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Int32
-> Int32
-> Int32
-> Int32
-> Word64
-> m Word8
regionFetch :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Int32 -> Int32 -> Int32 -> Int32 -> Word64 -> m Word8
regionFetch a
region Int32
left Int32
top Int32
width Int32
height Word64
len = IO Word8 -> m Word8
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result
#if defined(ENABLE_OVERLOADING)
data RegionFetchMethodInfo
instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> Word64 -> m Word8), MonadIO m, IsRegion a) => O.OverloadedMethod RegionFetchMethodInfo a signature where
overloadedMethod = regionFetch
instance O.OverloadedMethodInfo RegionFetchMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionFetch",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionFetch"
})
#endif
foreign import ccall "vips_region_height" vips_region_height ::
Ptr Region ->
IO Int32
regionHeight ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> m Int32
regionHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> m Int32
regionHeight a
region = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionHeightMethodInfo a signature where
overloadedMethod = regionHeight
instance O.OverloadedMethodInfo RegionHeightMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionHeight",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionHeight"
})
#endif
foreign import ccall "vips_region_image" vips_region_image ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
IO Int32
regionImage ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> m Int32
regionImage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> m Int32
regionImage a
reg Rect
r = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionImageMethodInfo
instance (signature ~ (Vips.Rect.Rect -> m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionImageMethodInfo a signature where
overloadedMethod = regionImage
instance O.OverloadedMethodInfo RegionImageMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionImage",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionImage"
})
#endif
foreign import ccall "vips_region_invalidate" vips_region_invalidate ::
Ptr Region ->
IO ()
regionInvalidate ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> m ()
regionInvalidate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> m ()
regionInvalidate a
reg = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegionInvalidateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRegion a) => O.OverloadedMethod RegionInvalidateMethodInfo a signature where
overloadedMethod = regionInvalidate
instance O.OverloadedMethodInfo RegionInvalidateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionInvalidate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionInvalidate"
})
#endif
foreign import ccall "vips_region_paint" vips_region_paint ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
Int32 ->
IO ()
regionPaint ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> Int32
-> m ()
regionPaint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> Int32 -> m ()
regionPaint a
reg Rect
r Int32
value = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegionPaintMethodInfo
instance (signature ~ (Vips.Rect.Rect -> Int32 -> m ()), MonadIO m, IsRegion a) => O.OverloadedMethod RegionPaintMethodInfo a signature where
overloadedMethod = regionPaint
instance O.OverloadedMethodInfo RegionPaintMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionPaint",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionPaint"
})
#endif
foreign import ccall "vips_region_paint_pel" vips_region_paint_pel ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
Word8 ->
IO ()
regionPaintPel ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> Word8
-> m ()
regionPaintPel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> Word8 -> m ()
regionPaintPel a
reg Rect
r Word8
ink = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegionPaintPelMethodInfo
instance (signature ~ (Vips.Rect.Rect -> Word8 -> m ()), MonadIO m, IsRegion a) => O.OverloadedMethod RegionPaintPelMethodInfo a signature where
overloadedMethod = regionPaintPel
instance O.OverloadedMethodInfo RegionPaintPelMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionPaintPel",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionPaintPel"
})
#endif
foreign import ccall "vips_region_position" vips_region_position ::
Ptr Region ->
Int32 ->
Int32 ->
IO Int32
regionPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Int32
-> Int32
-> m Int32
regionPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Int32 -> Int32 -> m Int32
regionPosition a
reg Int32
x Int32
y = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionPositionMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionPositionMethodInfo a signature where
overloadedMethod = regionPosition
instance O.OverloadedMethodInfo RegionPositionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionPosition",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionPosition"
})
#endif
foreign import ccall "vips_region_prepare" vips_region_prepare ::
Ptr Region ->
Ptr Vips.Rect.Rect ->
IO Int32
regionPrepare ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> Vips.Rect.Rect
-> m Int32
regionPrepare :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> Rect -> m Int32
regionPrepare a
reg Rect
r = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionPrepareMethodInfo
instance (signature ~ (Vips.Rect.Rect -> m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionPrepareMethodInfo a signature where
overloadedMethod = regionPrepare
instance O.OverloadedMethodInfo RegionPrepareMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionPrepare",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionPrepare"
})
#endif
foreign import ccall "vips_region_prepare_to" vips_region_prepare_to ::
Ptr Region ->
Ptr Region ->
Ptr Vips.Rect.Rect ->
Int32 ->
Int32 ->
IO Int32
regionPrepareTo ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a
-> b
-> Vips.Rect.Rect
-> Int32
-> Int32
-> m Int32
regionPrepareTo :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a -> b -> Rect -> Int32 -> Int32 -> m Int32
regionPrepareTo a
reg b
dest Rect
r Int32
x Int32
y = IO Int32 -> m Int32
forall a. IO a -> m a
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_prepare_to 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionPrepareToMethodInfo
instance (signature ~ (b -> Vips.Rect.Rect -> Int32 -> Int32 -> m Int32), MonadIO m, IsRegion a, IsRegion b) => O.OverloadedMethod RegionPrepareToMethodInfo a signature where
overloadedMethod = regionPrepareTo
instance O.OverloadedMethodInfo RegionPrepareToMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionPrepareTo",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionPrepareTo"
})
#endif
foreign import ccall "vips_region_region" vips_region_region ::
Ptr Region ->
Ptr Region ->
Ptr Vips.Rect.Rect ->
Int32 ->
Int32 ->
IO Int32
regionRegion ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a
-> b
-> Vips.Rect.Rect
-> Int32
-> Int32
-> m Int32
regionRegion :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRegion a, IsRegion b) =>
a -> b -> Rect -> Int32 -> Int32 -> m Int32
regionRegion a
reg b
dest Rect
r Int32
x Int32
y = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionRegionMethodInfo
instance (signature ~ (b -> Vips.Rect.Rect -> Int32 -> Int32 -> m Int32), MonadIO m, IsRegion a, IsRegion b) => O.OverloadedMethod RegionRegionMethodInfo a signature where
overloadedMethod = regionRegion
instance O.OverloadedMethodInfo RegionRegionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionRegion",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionRegion"
})
#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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionShrinkMethod",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionShrinkMethod"
})
#endif
foreign import ccall "vips_region_width" vips_region_width ::
Ptr Region ->
IO Int32
regionWidth ::
(B.CallStack.HasCallStack, MonadIO m, IsRegion a) =>
a
-> m Int32
regionWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegion a) =>
a -> m Int32
regionWidth a
region = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data RegionWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsRegion a) => O.OverloadedMethod RegionWidthMethodInfo a signature where
overloadedMethod = regionWidth
instance O.OverloadedMethodInfo RegionWidthMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Objects.Region.regionWidth",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.3/docs/GI-Vips-Objects-Region.html#v:regionWidth"
})
#endif