{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Structs.Rect
(
Rect(..) ,
newZeroRect ,
#if defined(ENABLE_OVERLOADING)
ResolveRectMethod ,
#endif
rectAlloc ,
#if defined(ENABLE_OVERLOADING)
RectClampToPixelMethodInfo ,
#endif
rectClampToPixel ,
#if defined(ENABLE_OVERLOADING)
RectContainsPointMethodInfo ,
#endif
rectContainsPoint ,
#if defined(ENABLE_OVERLOADING)
RectContainsRectMethodInfo ,
#endif
rectContainsRect ,
#if defined(ENABLE_OVERLOADING)
RectCopyMethodInfo ,
#endif
rectCopy ,
#if defined(ENABLE_OVERLOADING)
RectEqualsMethodInfo ,
#endif
rectEquals ,
#if defined(ENABLE_OVERLOADING)
RectFreeMethodInfo ,
#endif
rectFree ,
#if defined(ENABLE_OVERLOADING)
RectGetCenterMethodInfo ,
#endif
rectGetCenter ,
#if defined(ENABLE_OVERLOADING)
RectGetHeightMethodInfo ,
#endif
rectGetHeight ,
#if defined(ENABLE_OVERLOADING)
RectGetWidthMethodInfo ,
#endif
rectGetWidth ,
#if defined(ENABLE_OVERLOADING)
RectGetXMethodInfo ,
#endif
rectGetX ,
#if defined(ENABLE_OVERLOADING)
RectGetYMethodInfo ,
#endif
rectGetY ,
#if defined(ENABLE_OVERLOADING)
RectInitMethodInfo ,
#endif
rectInit ,
#if defined(ENABLE_OVERLOADING)
RectInsetMethodInfo ,
#endif
rectInset ,
#if defined(ENABLE_OVERLOADING)
RectIntersectionMethodInfo ,
#endif
rectIntersection ,
#if defined(ENABLE_OVERLOADING)
RectNormalizeMethodInfo ,
#endif
rectNormalize ,
#if defined(ENABLE_OVERLOADING)
RectOffsetMethodInfo ,
#endif
rectOffset ,
#if defined(ENABLE_OVERLOADING)
RectUnionMethodInfo ,
#endif
rectUnion ,
rectZero ,
getRectOrigin ,
#if defined(ENABLE_OVERLOADING)
rect_origin ,
#endif
getRectSize ,
#if defined(ENABLE_OVERLOADING)
rect_size ,
#endif
) 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.Kind as DK
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 {-# SOURCE #-} qualified GI.Clutter.Structs.Point as Clutter.Point
import {-# SOURCE #-} qualified GI.Clutter.Structs.Size as Clutter.Size
newtype Rect = Rect (SP.ManagedPtr Rect)
deriving (Rect -> Rect -> Bool
(Rect -> Rect -> Bool) -> (Rect -> Rect -> Bool) -> Eq Rect
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Rect -> Rect -> Bool
== :: Rect -> Rect -> Bool
$c/= :: Rect -> Rect -> Bool
/= :: Rect -> Rect -> Bool
Eq)
instance SP.ManagedPtrNewtype Rect where
toManagedPtr :: Rect -> ManagedPtr Rect
toManagedPtr (Rect ManagedPtr Rect
p) = ManagedPtr Rect
p
foreign import ccall "clutter_rect_get_type" c_clutter_rect_get_type ::
IO GType
type instance O.ParentTypes Rect = '[]
instance O.HasParentTypes Rect
instance B.Types.TypedObject Rect where
glibType :: IO GType
glibType = IO GType
c_clutter_rect_get_type
instance B.Types.GBoxed Rect
instance B.GValue.IsGValue (Maybe Rect) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_rect_get_type
gvalueSet_ :: Ptr GValue -> Maybe Rect -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Rect
P.Nothing = Ptr GValue -> Ptr Rect -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Rect
forall a. Ptr a
FP.nullPtr :: FP.Ptr Rect)
gvalueSet_ Ptr GValue
gv (P.Just Rect
obj) = Rect -> (Ptr Rect -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Rect
obj (Ptr GValue -> Ptr Rect -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Rect)
gvalueGet_ Ptr GValue
gv = do
Ptr Rect
ptr <- Ptr GValue -> IO (Ptr Rect)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Rect)
if Ptr Rect
ptr Ptr Rect -> Ptr Rect -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Rect
forall a. Ptr a
FP.nullPtr
then Rect -> Maybe Rect
forall a. a -> Maybe a
P.Just (Rect -> Maybe Rect) -> IO Rect -> IO (Maybe Rect)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Rect -> Rect
Rect Ptr Rect
ptr
else Maybe Rect -> IO (Maybe Rect)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Rect
forall a. Maybe a
P.Nothing
newZeroRect :: MonadIO m => m Rect
newZeroRect :: forall (m :: * -> *). MonadIO m => m Rect
newZeroRect = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Rect)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
16 IO (Ptr Rect) -> (Ptr Rect -> IO Rect) -> IO Rect
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Rect
instance tag ~ 'AttrSet => Constructible Rect tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Rect -> Rect) -> [AttrOp Rect tag] -> m Rect
new ManagedPtr Rect -> Rect
_ [AttrOp Rect tag]
attrs = do
Rect
o <- m Rect
forall (m :: * -> *). MonadIO m => m Rect
newZeroRect
Rect -> [AttrOp Rect 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Rect
o [AttrOp Rect tag]
[AttrOp Rect 'AttrSet]
attrs
Rect -> m Rect
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
o
getRectOrigin :: MonadIO m => Rect -> m Clutter.Point.Point
getRectOrigin :: forall (m :: * -> *). MonadIO m => Rect -> m Point
getRectOrigin Rect
s = IO Point -> m Point
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ Rect -> (Ptr Rect -> IO Point) -> IO Point
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Rect
s ((Ptr Rect -> IO Point) -> IO Point)
-> (Ptr Rect -> IO Point) -> IO Point
forall a b. (a -> b) -> a -> b
$ \Ptr Rect
ptr -> do
let val :: Ptr Point
val = Ptr Rect
ptr Ptr Rect -> Int -> Ptr Point
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Clutter.Point.Point)
Point
val' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Point -> Point
Clutter.Point.Point) Ptr Point
val
Point -> IO Point
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Point
val'
#if defined(ENABLE_OVERLOADING)
data RectOriginFieldInfo
instance AttrInfo RectOriginFieldInfo where
type AttrBaseTypeConstraint RectOriginFieldInfo = (~) Rect
type AttrAllowedOps RectOriginFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint RectOriginFieldInfo = (~) (Ptr Clutter.Point.Point)
type AttrTransferTypeConstraint RectOriginFieldInfo = (~)(Ptr Clutter.Point.Point)
type AttrTransferType RectOriginFieldInfo = (Ptr Clutter.Point.Point)
type AttrGetType RectOriginFieldInfo = Clutter.Point.Point
type AttrLabel RectOriginFieldInfo = "origin"
type AttrOrigin RectOriginFieldInfo = Rect
attrGet = getRectOrigin
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.origin"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#g:attr:origin"
})
rect_origin :: AttrLabelProxy "origin"
rect_origin = AttrLabelProxy
#endif
getRectSize :: MonadIO m => Rect -> m Clutter.Size.Size
getRectSize :: forall (m :: * -> *). MonadIO m => Rect -> m Size
getRectSize Rect
s = IO Size -> m Size
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Size -> m Size) -> IO Size -> m Size
forall a b. (a -> b) -> a -> b
$ Rect -> (Ptr Rect -> IO Size) -> IO Size
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Rect
s ((Ptr Rect -> IO Size) -> IO Size)
-> (Ptr Rect -> IO Size) -> IO Size
forall a b. (a -> b) -> a -> b
$ \Ptr Rect
ptr -> do
let val :: Ptr Size
val = Ptr Rect
ptr Ptr Rect -> Int -> Ptr Size
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: (Ptr Clutter.Size.Size)
Size
val' <- ((ManagedPtr Size -> Size) -> Ptr Size -> IO Size
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Size -> Size
Clutter.Size.Size) Ptr Size
val
Size -> IO Size
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Size
val'
#if defined(ENABLE_OVERLOADING)
data RectSizeFieldInfo
instance AttrInfo RectSizeFieldInfo where
type AttrBaseTypeConstraint RectSizeFieldInfo = (~) Rect
type AttrAllowedOps RectSizeFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint RectSizeFieldInfo = (~) (Ptr Clutter.Size.Size)
type AttrTransferTypeConstraint RectSizeFieldInfo = (~)(Ptr Clutter.Size.Size)
type AttrTransferType RectSizeFieldInfo = (Ptr Clutter.Size.Size)
type AttrGetType RectSizeFieldInfo = Clutter.Size.Size
type AttrLabel RectSizeFieldInfo = "size"
type AttrOrigin RectSizeFieldInfo = Rect
attrGet = getRectSize
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.size"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#g:attr:size"
})
rect_size :: AttrLabelProxy "size"
rect_size = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Rect
type instance O.AttributeList Rect = RectAttributeList
type RectAttributeList = ('[ '("origin", RectOriginFieldInfo), '("size", RectSizeFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "clutter_rect_alloc" clutter_rect_alloc ::
IO (Ptr Rect)
rectAlloc ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Rect
rectAlloc :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Rect
rectAlloc = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
result <- IO (Ptr Rect)
clutter_rect_alloc
Text -> Ptr Rect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"rectAlloc" Ptr Rect
result
Rect
result' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Rect) Ptr Rect
result
Rect -> IO Rect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_rect_clamp_to_pixel" clutter_rect_clamp_to_pixel ::
Ptr Rect ->
IO ()
rectClampToPixel ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> m ()
rectClampToPixel :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m ()
rectClampToPixel Rect
rect = 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 Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
Ptr Rect -> IO ()
clutter_rect_clamp_to_pixel Ptr Rect
rect'
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RectClampToPixelMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod RectClampToPixelMethodInfo Rect signature where
overloadedMethod = rectClampToPixel
instance O.OverloadedMethodInfo RectClampToPixelMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectClampToPixel",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectClampToPixel"
})
#endif
foreign import ccall "clutter_rect_contains_point" clutter_rect_contains_point ::
Ptr Rect ->
Ptr Clutter.Point.Point ->
IO CInt
rectContainsPoint ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> Clutter.Point.Point
-> m Bool
rectContainsPoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Point -> m Bool
rectContainsPoint Rect
rect Point
point = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
Ptr Point
point' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
point
CInt
result <- Ptr Rect -> Ptr Point -> IO CInt
clutter_rect_contains_point Ptr Rect
rect' Ptr Point
point'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
point
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RectContainsPointMethodInfo
instance (signature ~ (Clutter.Point.Point -> m Bool), MonadIO m) => O.OverloadedMethod RectContainsPointMethodInfo Rect signature where
overloadedMethod = rectContainsPoint
instance O.OverloadedMethodInfo RectContainsPointMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectContainsPoint",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectContainsPoint"
})
#endif
foreign import ccall "clutter_rect_contains_rect" clutter_rect_contains_rect ::
Ptr Rect ->
Ptr Rect ->
IO CInt
rectContainsRect ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> Rect
-> m Bool
rectContainsRect :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Rect -> m Bool
rectContainsRect Rect
a Rect
b = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
a' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
a
Ptr Rect
b' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
b
CInt
result <- Ptr Rect -> Ptr Rect -> IO CInt
clutter_rect_contains_rect Ptr Rect
a' Ptr Rect
b'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
a
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
b
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RectContainsRectMethodInfo
instance (signature ~ (Rect -> m Bool), MonadIO m) => O.OverloadedMethod RectContainsRectMethodInfo Rect signature where
overloadedMethod = rectContainsRect
instance O.OverloadedMethodInfo RectContainsRectMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectContainsRect",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectContainsRect"
})
#endif
foreign import ccall "clutter_rect_copy" clutter_rect_copy ::
Ptr Rect ->
IO (Ptr Rect)
rectCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> m Rect
rectCopy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Rect
rectCopy Rect
rect = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
Ptr Rect
result <- Ptr Rect -> IO (Ptr Rect)
clutter_rect_copy Ptr Rect
rect'
Text -> Ptr Rect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"rectCopy" Ptr Rect
result
Rect
result' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Rect) Ptr Rect
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Rect -> IO Rect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
result'
#if defined(ENABLE_OVERLOADING)
data RectCopyMethodInfo
instance (signature ~ (m Rect), MonadIO m) => O.OverloadedMethod RectCopyMethodInfo Rect signature where
overloadedMethod = rectCopy
instance O.OverloadedMethodInfo RectCopyMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectCopy"
})
#endif
foreign import ccall "clutter_rect_equals" clutter_rect_equals ::
Ptr Rect ->
Ptr Rect ->
IO CInt
rectEquals ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> Rect
-> m Bool
rectEquals :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Rect -> m Bool
rectEquals Rect
a Rect
b = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
a' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
a
Ptr Rect
b' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
b
CInt
result <- Ptr Rect -> Ptr Rect -> IO CInt
clutter_rect_equals Ptr Rect
a' Ptr Rect
b'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
a
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
b
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RectEqualsMethodInfo
instance (signature ~ (Rect -> m Bool), MonadIO m) => O.OverloadedMethod RectEqualsMethodInfo Rect signature where
overloadedMethod = rectEquals
instance O.OverloadedMethodInfo RectEqualsMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectEquals",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectEquals"
})
#endif
foreign import ccall "clutter_rect_free" clutter_rect_free ::
Ptr Rect ->
IO ()
rectFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> m ()
rectFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m ()
rectFree Rect
rect = 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 Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
Ptr Rect -> IO ()
clutter_rect_free Ptr Rect
rect'
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RectFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod RectFreeMethodInfo Rect signature where
overloadedMethod = rectFree
instance O.OverloadedMethodInfo RectFreeMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectFree"
})
#endif
foreign import ccall "clutter_rect_get_center" clutter_rect_get_center ::
Ptr Rect ->
Ptr Clutter.Point.Point ->
IO ()
rectGetCenter ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> m (Clutter.Point.Point)
rectGetCenter :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Point
rectGetCenter Rect
rect = IO Point -> m Point
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
Ptr Point
center <- Int -> IO (Ptr Point)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
8 :: IO (Ptr Clutter.Point.Point)
Ptr Rect -> Ptr Point -> IO ()
clutter_rect_get_center Ptr Rect
rect' Ptr Point
center
Point
center' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Point -> Point
Clutter.Point.Point) Ptr Point
center
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Point -> IO Point
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Point
center'
#if defined(ENABLE_OVERLOADING)
data RectGetCenterMethodInfo
instance (signature ~ (m (Clutter.Point.Point)), MonadIO m) => O.OverloadedMethod RectGetCenterMethodInfo Rect signature where
overloadedMethod = rectGetCenter
instance O.OverloadedMethodInfo RectGetCenterMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectGetCenter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectGetCenter"
})
#endif
foreign import ccall "clutter_rect_get_height" clutter_rect_get_height ::
Ptr Rect ->
IO CFloat
rectGetHeight ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> m Float
rectGetHeight :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Float
rectGetHeight Rect
rect = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
CFloat
result <- Ptr Rect -> IO CFloat
clutter_rect_get_height Ptr Rect
rect'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data RectGetHeightMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod RectGetHeightMethodInfo Rect signature where
overloadedMethod = rectGetHeight
instance O.OverloadedMethodInfo RectGetHeightMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectGetHeight",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectGetHeight"
})
#endif
foreign import ccall "clutter_rect_get_width" clutter_rect_get_width ::
Ptr Rect ->
IO CFloat
rectGetWidth ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> m Float
rectGetWidth :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Float
rectGetWidth Rect
rect = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
CFloat
result <- Ptr Rect -> IO CFloat
clutter_rect_get_width Ptr Rect
rect'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data RectGetWidthMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod RectGetWidthMethodInfo Rect signature where
overloadedMethod = rectGetWidth
instance O.OverloadedMethodInfo RectGetWidthMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectGetWidth",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectGetWidth"
})
#endif
foreign import ccall "clutter_rect_get_x" clutter_rect_get_x ::
Ptr Rect ->
IO CFloat
rectGetX ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> m Float
rectGetX :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Float
rectGetX Rect
rect = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
CFloat
result <- Ptr Rect -> IO CFloat
clutter_rect_get_x Ptr Rect
rect'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data RectGetXMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod RectGetXMethodInfo Rect signature where
overloadedMethod = rectGetX
instance O.OverloadedMethodInfo RectGetXMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectGetX",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectGetX"
})
#endif
foreign import ccall "clutter_rect_get_y" clutter_rect_get_y ::
Ptr Rect ->
IO CFloat
rectGetY ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> m Float
rectGetY :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Float
rectGetY Rect
rect = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
CFloat
result <- Ptr Rect -> IO CFloat
clutter_rect_get_y Ptr Rect
rect'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data RectGetYMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod RectGetYMethodInfo Rect signature where
overloadedMethod = rectGetY
instance O.OverloadedMethodInfo RectGetYMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectGetY",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectGetY"
})
#endif
foreign import ccall "clutter_rect_init" clutter_rect_init ::
Ptr Rect ->
CFloat ->
CFloat ->
CFloat ->
CFloat ->
IO (Ptr Rect)
rectInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> Float
-> Float
-> Float
-> Float
-> m Rect
rectInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Float -> Float -> Float -> Float -> m Rect
rectInit Rect
rect Float
x Float
y Float
width Float
height = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
let width' :: CFloat
width' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
width
let height' :: CFloat
height' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
height
Ptr Rect
result <- Ptr Rect -> CFloat -> CFloat -> CFloat -> CFloat -> IO (Ptr Rect)
clutter_rect_init Ptr Rect
rect' CFloat
x' CFloat
y' CFloat
width' CFloat
height'
Text -> Ptr Rect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"rectInit" Ptr Rect
result
Rect
result' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Rect -> Rect
Rect) Ptr Rect
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Rect -> IO Rect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
result'
#if defined(ENABLE_OVERLOADING)
data RectInitMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m Rect), MonadIO m) => O.OverloadedMethod RectInitMethodInfo Rect signature where
overloadedMethod = rectInit
instance O.OverloadedMethodInfo RectInitMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectInit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectInit"
})
#endif
foreign import ccall "clutter_rect_inset" clutter_rect_inset ::
Ptr Rect ->
CFloat ->
CFloat ->
IO ()
rectInset ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> Float
-> Float
-> m ()
rectInset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Float -> Float -> m ()
rectInset Rect
rect Float
dX Float
dY = 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 Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
let dX' :: CFloat
dX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dX
let dY' :: CFloat
dY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dY
Ptr Rect -> CFloat -> CFloat -> IO ()
clutter_rect_inset Ptr Rect
rect' CFloat
dX' CFloat
dY'
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RectInsetMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod RectInsetMethodInfo Rect signature where
overloadedMethod = rectInset
instance O.OverloadedMethodInfo RectInsetMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectInset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectInset"
})
#endif
foreign import ccall "clutter_rect_intersection" clutter_rect_intersection ::
Ptr Rect ->
Ptr Rect ->
Ptr Rect ->
IO CInt
rectIntersection ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> Rect
-> m ((Bool, Rect))
rectIntersection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Rect -> m (Bool, Rect)
rectIntersection Rect
a Rect
b = IO (Bool, Rect) -> m (Bool, Rect)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Rect) -> m (Bool, Rect))
-> IO (Bool, Rect) -> m (Bool, Rect)
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
a' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
a
Ptr Rect
b' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
b
Ptr Rect
res <- Int -> IO (Ptr Rect)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Rect)
CInt
result <- Ptr Rect -> Ptr Rect -> Ptr Rect -> IO CInt
clutter_rect_intersection Ptr Rect
a' Ptr Rect
b' Ptr Rect
res
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Rect
res' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Rect) Ptr Rect
res
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
a
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
b
(Bool, Rect) -> IO (Bool, Rect)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Rect
res')
#if defined(ENABLE_OVERLOADING)
data RectIntersectionMethodInfo
instance (signature ~ (Rect -> m ((Bool, Rect))), MonadIO m) => O.OverloadedMethod RectIntersectionMethodInfo Rect signature where
overloadedMethod = rectIntersection
instance O.OverloadedMethodInfo RectIntersectionMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectIntersection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectIntersection"
})
#endif
foreign import ccall "clutter_rect_normalize" clutter_rect_normalize ::
Ptr Rect ->
IO (Ptr Rect)
rectNormalize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> m Rect
rectNormalize :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Rect
rectNormalize Rect
rect = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
Ptr Rect
result <- Ptr Rect -> IO (Ptr Rect)
clutter_rect_normalize Ptr Rect
rect'
Text -> Ptr Rect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"rectNormalize" Ptr Rect
result
Rect
result' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Rect) Ptr Rect
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Rect -> IO Rect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
result'
#if defined(ENABLE_OVERLOADING)
data RectNormalizeMethodInfo
instance (signature ~ (m Rect), MonadIO m) => O.OverloadedMethod RectNormalizeMethodInfo Rect signature where
overloadedMethod = rectNormalize
instance O.OverloadedMethodInfo RectNormalizeMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectNormalize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectNormalize"
})
#endif
foreign import ccall "clutter_rect_offset" clutter_rect_offset ::
Ptr Rect ->
CFloat ->
CFloat ->
IO ()
rectOffset ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> Float
-> Float
-> m ()
rectOffset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Float -> Float -> m ()
rectOffset Rect
rect Float
dX Float
dY = 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 Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
let dX' :: CFloat
dX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dX
let dY' :: CFloat
dY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dY
Ptr Rect -> CFloat -> CFloat -> IO ()
clutter_rect_offset Ptr Rect
rect' CFloat
dX' CFloat
dY'
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RectOffsetMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod RectOffsetMethodInfo Rect signature where
overloadedMethod = rectOffset
instance O.OverloadedMethodInfo RectOffsetMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectOffset"
})
#endif
foreign import ccall "clutter_rect_union" clutter_rect_union ::
Ptr Rect ->
Ptr Rect ->
Ptr Rect ->
IO ()
rectUnion ::
(B.CallStack.HasCallStack, MonadIO m) =>
Rect
-> Rect
-> m (Rect)
rectUnion :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Rect -> m Rect
rectUnion Rect
a Rect
b = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
a' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
a
Ptr Rect
b' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
b
Ptr Rect
res <- Int -> IO (Ptr Rect)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Rect)
Ptr Rect -> Ptr Rect -> Ptr Rect -> IO ()
clutter_rect_union Ptr Rect
a' Ptr Rect
b' Ptr Rect
res
Rect
res' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Rect) Ptr Rect
res
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
a
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
b
Rect -> IO Rect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
res'
#if defined(ENABLE_OVERLOADING)
data RectUnionMethodInfo
instance (signature ~ (Rect -> m (Rect)), MonadIO m) => O.OverloadedMethod RectUnionMethodInfo Rect signature where
overloadedMethod = rectUnion
instance O.OverloadedMethodInfo RectUnionMethodInfo Rect where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Rect.rectUnion",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Rect.html#v:rectUnion"
})
#endif
foreign import ccall "clutter_rect_zero" clutter_rect_zero ::
IO (Ptr Rect)
rectZero ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Rect
rectZero :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Rect
rectZero = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
Ptr Rect
result <- IO (Ptr Rect)
clutter_rect_zero
Text -> Ptr Rect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"rectZero" Ptr Rect
result
Rect
result' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Rect -> Rect
Rect) Ptr Rect
result
Rect -> IO Rect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
result'
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveRectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveRectMethod "clampToPixel" o = RectClampToPixelMethodInfo
ResolveRectMethod "containsPoint" o = RectContainsPointMethodInfo
ResolveRectMethod "containsRect" o = RectContainsRectMethodInfo
ResolveRectMethod "copy" o = RectCopyMethodInfo
ResolveRectMethod "equals" o = RectEqualsMethodInfo
ResolveRectMethod "free" o = RectFreeMethodInfo
ResolveRectMethod "init" o = RectInitMethodInfo
ResolveRectMethod "inset" o = RectInsetMethodInfo
ResolveRectMethod "intersection" o = RectIntersectionMethodInfo
ResolveRectMethod "normalize" o = RectNormalizeMethodInfo
ResolveRectMethod "offset" o = RectOffsetMethodInfo
ResolveRectMethod "union" o = RectUnionMethodInfo
ResolveRectMethod "getCenter" o = RectGetCenterMethodInfo
ResolveRectMethod "getHeight" o = RectGetHeightMethodInfo
ResolveRectMethod "getWidth" o = RectGetWidthMethodInfo
ResolveRectMethod "getX" o = RectGetXMethodInfo
ResolveRectMethod "getY" o = RectGetYMethodInfo
ResolveRectMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRectMethod t Rect, O.OverloadedMethod info Rect p) => OL.IsLabel t (Rect -> 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 ~ ResolveRectMethod t Rect, O.OverloadedMethod info Rect p, R.HasField t Rect p) => R.HasField t Rect p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveRectMethod t Rect, O.OverloadedMethodInfo info Rect) => OL.IsLabel t (O.MethodProxy info Rect) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif