{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The location and size of a rectangle region.
-- 
-- The width and height of a t'GI.Graphene.Structs.Rect.Rect' can be negative; for instance,
-- a t'GI.Graphene.Structs.Rect.Rect' with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is
-- equivalent to a t'GI.Graphene.Structs.Rect.Rect' with an origin of [ 10, 10 ] and a size
-- of [ -10, -10 ].
-- 
-- Application code can normalize rectangles using 'GI.Graphene.Structs.Rect.rectNormalize';
-- this function will ensure that the width and height of a rectangle are
-- positive values. All functions taking a t'GI.Graphene.Structs.Rect.Rect' as an argument
-- will internally operate on a normalized copy; all functions returning a
-- t'GI.Graphene.Structs.Rect.Rect' will always return a normalized rectangle.
-- 
-- /Since: 1.0/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Graphene.Structs.Rect
    ( 

-- * Exported types
    Rect(..)                                ,
    newZeroRect                             ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [containsPoint]("GI.Graphene.Structs.Rect#g:method:containsPoint"), [containsRect]("GI.Graphene.Structs.Rect#g:method:containsRect"), [equal]("GI.Graphene.Structs.Rect#g:method:equal"), [expand]("GI.Graphene.Structs.Rect#g:method:expand"), [free]("GI.Graphene.Structs.Rect#g:method:free"), [init]("GI.Graphene.Structs.Rect#g:method:init"), [initFromRect]("GI.Graphene.Structs.Rect#g:method:initFromRect"), [inset]("GI.Graphene.Structs.Rect#g:method:inset"), [insetR]("GI.Graphene.Structs.Rect#g:method:insetR"), [interpolate]("GI.Graphene.Structs.Rect#g:method:interpolate"), [intersection]("GI.Graphene.Structs.Rect#g:method:intersection"), [normalize]("GI.Graphene.Structs.Rect#g:method:normalize"), [normalizeR]("GI.Graphene.Structs.Rect#g:method:normalizeR"), [offset]("GI.Graphene.Structs.Rect#g:method:offset"), [offsetR]("GI.Graphene.Structs.Rect#g:method:offsetR"), [round]("GI.Graphene.Structs.Rect#g:method:round"), [roundExtents]("GI.Graphene.Structs.Rect#g:method:roundExtents"), [roundToPixel]("GI.Graphene.Structs.Rect#g:method:roundToPixel"), [scale]("GI.Graphene.Structs.Rect#g:method:scale"), [union]("GI.Graphene.Structs.Rect#g:method:union").
-- 
-- ==== Getters
-- [getArea]("GI.Graphene.Structs.Rect#g:method:getArea"), [getBottomLeft]("GI.Graphene.Structs.Rect#g:method:getBottomLeft"), [getBottomRight]("GI.Graphene.Structs.Rect#g:method:getBottomRight"), [getCenter]("GI.Graphene.Structs.Rect#g:method:getCenter"), [getHeight]("GI.Graphene.Structs.Rect#g:method:getHeight"), [getTopLeft]("GI.Graphene.Structs.Rect#g:method:getTopLeft"), [getTopRight]("GI.Graphene.Structs.Rect#g:method:getTopRight"), [getWidth]("GI.Graphene.Structs.Rect#g:method:getWidth"), [getX]("GI.Graphene.Structs.Rect#g:method:getX"), [getY]("GI.Graphene.Structs.Rect#g:method:getY").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveRectMethod                       ,
#endif

-- ** alloc #method:alloc#

    rectAlloc                               ,


-- ** containsPoint #method:containsPoint#

#if defined(ENABLE_OVERLOADING)
    RectContainsPointMethodInfo             ,
#endif
    rectContainsPoint                       ,


-- ** containsRect #method:containsRect#

#if defined(ENABLE_OVERLOADING)
    RectContainsRectMethodInfo              ,
#endif
    rectContainsRect                        ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    RectEqualMethodInfo                     ,
#endif
    rectEqual                               ,


-- ** expand #method:expand#

#if defined(ENABLE_OVERLOADING)
    RectExpandMethodInfo                    ,
#endif
    rectExpand                              ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    RectFreeMethodInfo                      ,
#endif
    rectFree                                ,


-- ** getArea #method:getArea#

#if defined(ENABLE_OVERLOADING)
    RectGetAreaMethodInfo                   ,
#endif
    rectGetArea                             ,


-- ** getBottomLeft #method:getBottomLeft#

#if defined(ENABLE_OVERLOADING)
    RectGetBottomLeftMethodInfo             ,
#endif
    rectGetBottomLeft                       ,


-- ** getBottomRight #method:getBottomRight#

#if defined(ENABLE_OVERLOADING)
    RectGetBottomRightMethodInfo            ,
#endif
    rectGetBottomRight                      ,


-- ** getCenter #method:getCenter#

#if defined(ENABLE_OVERLOADING)
    RectGetCenterMethodInfo                 ,
#endif
    rectGetCenter                           ,


-- ** getHeight #method:getHeight#

#if defined(ENABLE_OVERLOADING)
    RectGetHeightMethodInfo                 ,
#endif
    rectGetHeight                           ,


-- ** getTopLeft #method:getTopLeft#

#if defined(ENABLE_OVERLOADING)
    RectGetTopLeftMethodInfo                ,
#endif
    rectGetTopLeft                          ,


-- ** getTopRight #method:getTopRight#

#if defined(ENABLE_OVERLOADING)
    RectGetTopRightMethodInfo               ,
#endif
    rectGetTopRight                         ,


-- ** getWidth #method:getWidth#

#if defined(ENABLE_OVERLOADING)
    RectGetWidthMethodInfo                  ,
#endif
    rectGetWidth                            ,


-- ** getX #method:getX#

#if defined(ENABLE_OVERLOADING)
    RectGetXMethodInfo                      ,
#endif
    rectGetX                                ,


-- ** getY #method:getY#

#if defined(ENABLE_OVERLOADING)
    RectGetYMethodInfo                      ,
#endif
    rectGetY                                ,


-- ** init #method:init#

#if defined(ENABLE_OVERLOADING)
    RectInitMethodInfo                      ,
#endif
    rectInit                                ,


-- ** initFromRect #method:initFromRect#

#if defined(ENABLE_OVERLOADING)
    RectInitFromRectMethodInfo              ,
#endif
    rectInitFromRect                        ,


-- ** inset #method:inset#

#if defined(ENABLE_OVERLOADING)
    RectInsetMethodInfo                     ,
#endif
    rectInset                               ,


-- ** insetR #method:insetR#

#if defined(ENABLE_OVERLOADING)
    RectInsetRMethodInfo                    ,
#endif
    rectInsetR                              ,


-- ** interpolate #method:interpolate#

#if defined(ENABLE_OVERLOADING)
    RectInterpolateMethodInfo               ,
#endif
    rectInterpolate                         ,


-- ** intersection #method:intersection#

#if defined(ENABLE_OVERLOADING)
    RectIntersectionMethodInfo              ,
#endif
    rectIntersection                        ,


-- ** normalize #method:normalize#

#if defined(ENABLE_OVERLOADING)
    RectNormalizeMethodInfo                 ,
#endif
    rectNormalize                           ,


-- ** normalizeR #method:normalizeR#

#if defined(ENABLE_OVERLOADING)
    RectNormalizeRMethodInfo                ,
#endif
    rectNormalizeR                          ,


-- ** offset #method:offset#

#if defined(ENABLE_OVERLOADING)
    RectOffsetMethodInfo                    ,
#endif
    rectOffset                              ,


-- ** offsetR #method:offsetR#

#if defined(ENABLE_OVERLOADING)
    RectOffsetRMethodInfo                   ,
#endif
    rectOffsetR                             ,


-- ** round #method:round#

#if defined(ENABLE_OVERLOADING)
    RectRoundMethodInfo                     ,
#endif
    rectRound                               ,


-- ** roundExtents #method:roundExtents#

#if defined(ENABLE_OVERLOADING)
    RectRoundExtentsMethodInfo              ,
#endif
    rectRoundExtents                        ,


-- ** roundToPixel #method:roundToPixel#

#if defined(ENABLE_OVERLOADING)
    RectRoundToPixelMethodInfo              ,
#endif
    rectRoundToPixel                        ,


-- ** scale #method:scale#

#if defined(ENABLE_OVERLOADING)
    RectScaleMethodInfo                     ,
#endif
    rectScale                               ,


-- ** union #method:union#

#if defined(ENABLE_OVERLOADING)
    RectUnionMethodInfo                     ,
#endif
    rectUnion                               ,


-- ** zero #method:zero#

    rectZero                                ,




 -- * Properties


-- ** origin #attr:origin#
-- | the coordinates of the origin of the rectangle

    getRectOrigin                           ,
#if defined(ENABLE_OVERLOADING)
    rect_origin                             ,
#endif


-- ** size #attr:size#
-- | the size of the rectangle

    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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.Graphene.Structs.Point as Graphene.Point
import {-# SOURCE #-} qualified GI.Graphene.Structs.Size as Graphene.Size
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec2 as Graphene.Vec2

#else
import {-# SOURCE #-} qualified GI.Graphene.Structs.Point as Graphene.Point
import {-# SOURCE #-} qualified GI.Graphene.Structs.Size as Graphene.Size

#endif

-- | Memory-managed wrapper type.
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 "graphene_rect_get_type" c_graphene_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_graphene_rect_get_type

instance B.Types.GBoxed Rect

-- | Convert t'Rect' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Rect) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_graphene_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 <- Ptr GValue -> IO (Ptr Rect)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Rect)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newBoxed Rect ptr
        else return P.Nothing
        
    

-- | Construct a t'Rect' struct initialized to zero.
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
        o <- m Rect
forall (m :: * -> *). MonadIO m => m Rect
newZeroRect
        GI.Attributes.set o attrs
        return o


-- | Get the value of the “@origin@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' rect #origin
-- @
getRectOrigin :: MonadIO m => Rect -> m Graphene.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 Graphene.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
Graphene.Point.Point) Ptr Point
val
    return val'

#if defined(ENABLE_OVERLOADING)
data RectOriginFieldInfo
instance AttrInfo RectOriginFieldInfo where
    type AttrBaseTypeConstraint RectOriginFieldInfo = (~) Rect
    type AttrAllowedOps RectOriginFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint RectOriginFieldInfo = (~) (Ptr Graphene.Point.Point)
    type AttrTransferTypeConstraint RectOriginFieldInfo = (~)(Ptr Graphene.Point.Point)
    type AttrTransferType RectOriginFieldInfo = (Ptr Graphene.Point.Point)
    type AttrGetType RectOriginFieldInfo = Graphene.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.Graphene.Structs.Rect.origin"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#g:attr:origin"
        })

rect_origin :: AttrLabelProxy "origin"
rect_origin = AttrLabelProxy

#endif


-- | Get the value of the “@size@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' rect #size
-- @
getRectSize :: MonadIO m => Rect -> m Graphene.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 Graphene.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
Graphene.Size.Size) Ptr Size
val
    return val'

#if defined(ENABLE_OVERLOADING)
data RectSizeFieldInfo
instance AttrInfo RectSizeFieldInfo where
    type AttrBaseTypeConstraint RectSizeFieldInfo = (~) Rect
    type AttrAllowedOps RectSizeFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint RectSizeFieldInfo = (~) (Ptr Graphene.Size.Size)
    type AttrTransferTypeConstraint RectSizeFieldInfo = (~)(Ptr Graphene.Size.Size)
    type AttrTransferType RectSizeFieldInfo = (Ptr Graphene.Size.Size)
    type AttrGetType RectSizeFieldInfo = Graphene.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.Graphene.Structs.Rect.size"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-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

-- method Rect::contains_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "const graphene_point_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_contains_point" graphene_rect_contains_point :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO CInt

-- | Checks whether a t'GI.Graphene.Structs.Rect.Rect' contains the given coordinates.
-- 
-- /Since: 1.0/
rectContainsPoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Graphene.Point.Point
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point.Point'
    -> m Bool
    -- ^ __Returns:__ @true@ if the rectangle contains the point
rectContainsPoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Point -> m Bool
rectContainsPoint Rect
r Point
p = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    p' <- unsafeManagedPtrGetPtr p
    result <- graphene_rect_contains_point r' p'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr r
    touchManagedPtr p
    return result'

#if defined(ENABLE_OVERLOADING)
data RectContainsPointMethodInfo
instance (signature ~ (Graphene.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.Graphene.Structs.Rect.rectContainsPoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectContainsPoint"
        })


#endif

-- method Rect::contains_rect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_contains_rect" graphene_rect_contains_rect :: 
    Ptr Rect ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CInt

-- | Checks whether a t'GI.Graphene.Structs.Rect.Rect' fully contains the given
-- rectangle.
-- 
-- /Since: 1.0/
rectContainsRect ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@a@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Rect
    -- ^ /@b@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Bool
    -- ^ __Returns:__ @true@ if the rectangle /@a@/ fully contains /@b@/
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
    a' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
a
    b' <- unsafeManagedPtrGetPtr b
    result <- graphene_rect_contains_rect a' b'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr a
    touchManagedPtr b
    return 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.Graphene.Structs.Rect.rectContainsRect",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectContainsRect"
        })


#endif

-- method Rect::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_equal" graphene_rect_equal :: 
    Ptr Rect ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CInt

-- | Checks whether the two given rectangle are equal.
-- 
-- /Since: 1.0/
rectEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@a@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Rect
    -- ^ /@b@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Bool
    -- ^ __Returns:__ @true@ if the rectangles are equal
rectEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Rect -> m Bool
rectEqual 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
    a' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
a
    b' <- unsafeManagedPtrGetPtr b
    result <- graphene_rect_equal a' b'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr a
    touchManagedPtr b
    return result'

#if defined(ENABLE_OVERLOADING)
data RectEqualMethodInfo
instance (signature ~ (Rect -> m Bool), MonadIO m) => O.OverloadedMethod RectEqualMethodInfo Rect signature where
    overloadedMethod = rectEqual

instance O.OverloadedMethodInfo RectEqualMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectEqual",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectEqual"
        })


#endif

-- method Rect::expand
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "const graphene_point_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the expanded rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_expand" graphene_rect_expand :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Expands a t'GI.Graphene.Structs.Rect.Rect' to contain the given t'GI.Graphene.Structs.Point.Point'.
-- 
-- /Since: 1.4/
rectExpand ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Graphene.Point.Point
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point.Point'
    -> m (Rect)
rectExpand :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Point -> m Rect
rectExpand Rect
r Point
p = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    p' <- unsafeManagedPtrGetPtr p
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    graphene_rect_expand r' p' res
    res' <- (wrapBoxed Rect) res
    touchManagedPtr r
    touchManagedPtr p
    return res'

#if defined(ENABLE_OVERLOADING)
data RectExpandMethodInfo
instance (signature ~ (Graphene.Point.Point -> m (Rect)), MonadIO m) => O.OverloadedMethod RectExpandMethodInfo Rect signature where
    overloadedMethod = rectExpand

instance O.OverloadedMethodInfo RectExpandMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectExpand",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectExpand"
        })


#endif

-- method Rect::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_free" graphene_rect_free :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Frees the resources allocated by 'GI.Graphene.Functions.rectAlloc'.
-- 
-- /Since: 1.0/
rectFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m ()
rectFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m ()
rectFree Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    graphene_rect_free r'
    touchManagedPtr r
    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.Graphene.Structs.Rect.rectFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectFree"
        })


#endif

-- method Rect::get_area
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_area" graphene_rect_get_area :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CFloat

-- | Compute the area of given normalized rectangle.
-- 
-- /Since: 1.10/
rectGetArea ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Float
    -- ^ __Returns:__ the area of the normalized rectangle
rectGetArea :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Float
rectGetArea Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    result <- graphene_rect_get_area r'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr r
    return result'

#if defined(ENABLE_OVERLOADING)
data RectGetAreaMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod RectGetAreaMethodInfo Rect signature where
    overloadedMethod = rectGetArea

instance O.OverloadedMethodInfo RectGetAreaMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectGetArea",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetArea"
        })


#endif

-- method Rect::get_bottom_left
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "graphene_point_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #graphene_point_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_bottom_left" graphene_rect_get_bottom_left :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO ()

-- | Retrieves the coordinates of the bottom-left corner of the given rectangle.
-- 
-- /Since: 1.0/
rectGetBottomLeft ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Graphene.Point.Point)
rectGetBottomLeft :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Point
rectGetBottomLeft Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    p <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    graphene_rect_get_bottom_left r' p
    p' <- (wrapBoxed Graphene.Point.Point) p
    touchManagedPtr r
    return p'

#if defined(ENABLE_OVERLOADING)
data RectGetBottomLeftMethodInfo
instance (signature ~ (m (Graphene.Point.Point)), MonadIO m) => O.OverloadedMethod RectGetBottomLeftMethodInfo Rect signature where
    overloadedMethod = rectGetBottomLeft

instance O.OverloadedMethodInfo RectGetBottomLeftMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectGetBottomLeft",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetBottomLeft"
        })


#endif

-- method Rect::get_bottom_right
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "graphene_point_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #graphene_point_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_bottom_right" graphene_rect_get_bottom_right :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO ()

-- | Retrieves the coordinates of the bottom-right corner of the given rectangle.
-- 
-- /Since: 1.0/
rectGetBottomRight ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Graphene.Point.Point)
rectGetBottomRight :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Point
rectGetBottomRight Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    p <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    graphene_rect_get_bottom_right r' p
    p' <- (wrapBoxed Graphene.Point.Point) p
    touchManagedPtr r
    return p'

#if defined(ENABLE_OVERLOADING)
data RectGetBottomRightMethodInfo
instance (signature ~ (m (Graphene.Point.Point)), MonadIO m) => O.OverloadedMethod RectGetBottomRightMethodInfo Rect signature where
    overloadedMethod = rectGetBottomRight

instance O.OverloadedMethodInfo RectGetBottomRightMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectGetBottomRight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetBottomRight"
        })


#endif

-- method Rect::get_center
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "graphene_point_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #graphene_point_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_center" graphene_rect_get_center :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO ()

-- | Retrieves the coordinates of the center of the given rectangle.
-- 
-- /Since: 1.0/
rectGetCenter ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Graphene.Point.Point)
rectGetCenter :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Point
rectGetCenter Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    p <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    graphene_rect_get_center r' p
    p' <- (wrapBoxed Graphene.Point.Point) p
    touchManagedPtr r
    return p'

#if defined(ENABLE_OVERLOADING)
data RectGetCenterMethodInfo
instance (signature ~ (m (Graphene.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.Graphene.Structs.Rect.rectGetCenter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetCenter"
        })


#endif

-- method Rect::get_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_height" graphene_rect_get_height :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CFloat

-- | Retrieves the normalized height of the given rectangle.
-- 
-- /Since: 1.0/
rectGetHeight ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Float
    -- ^ __Returns:__ the normalized height of the rectangle
rectGetHeight :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Float
rectGetHeight Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    result <- graphene_rect_get_height r'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr r
    return 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.Graphene.Structs.Rect.rectGetHeight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetHeight"
        })


#endif

-- method Rect::get_top_left
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "graphene_point_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #graphene_point_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_top_left" graphene_rect_get_top_left :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO ()

-- | Retrieves the coordinates of the top-left corner of the given rectangle.
-- 
-- /Since: 1.0/
rectGetTopLeft ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Graphene.Point.Point)
rectGetTopLeft :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Point
rectGetTopLeft Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    p <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    graphene_rect_get_top_left r' p
    p' <- (wrapBoxed Graphene.Point.Point) p
    touchManagedPtr r
    return p'

#if defined(ENABLE_OVERLOADING)
data RectGetTopLeftMethodInfo
instance (signature ~ (m (Graphene.Point.Point)), MonadIO m) => O.OverloadedMethod RectGetTopLeftMethodInfo Rect signature where
    overloadedMethod = rectGetTopLeft

instance O.OverloadedMethodInfo RectGetTopLeftMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectGetTopLeft",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetTopLeft"
        })


#endif

-- method Rect::get_top_right
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "graphene_point_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #graphene_point_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_top_right" graphene_rect_get_top_right :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO ()

-- | Retrieves the coordinates of the top-right corner of the given rectangle.
-- 
-- /Since: 1.0/
rectGetTopRight ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Graphene.Point.Point)
rectGetTopRight :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Point
rectGetTopRight Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    p <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    graphene_rect_get_top_right r' p
    p' <- (wrapBoxed Graphene.Point.Point) p
    touchManagedPtr r
    return p'

#if defined(ENABLE_OVERLOADING)
data RectGetTopRightMethodInfo
instance (signature ~ (m (Graphene.Point.Point)), MonadIO m) => O.OverloadedMethod RectGetTopRightMethodInfo Rect signature where
    overloadedMethod = rectGetTopRight

instance O.OverloadedMethodInfo RectGetTopRightMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectGetTopRight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetTopRight"
        })


#endif

-- XXX Could not generate method Rect::get_vertices
-- Not implemented: Don't know how to allocate "vertices" of type TCArray False 4 (-1) (TInterface (Name {namespace = "Graphene", name = "Vec2"}))
-- method Rect::get_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_width" graphene_rect_get_width :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CFloat

-- | Retrieves the normalized width of the given rectangle.
-- 
-- /Since: 1.0/
rectGetWidth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Float
    -- ^ __Returns:__ the normalized width of the rectangle
rectGetWidth :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Float
rectGetWidth Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    result <- graphene_rect_get_width r'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr r
    return 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.Graphene.Structs.Rect.rectGetWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetWidth"
        })


#endif

-- method Rect::get_x
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_x" graphene_rect_get_x :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CFloat

-- | Retrieves the normalized X coordinate of the origin of the given
-- rectangle.
-- 
-- /Since: 1.0/
rectGetX ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Float
    -- ^ __Returns:__ the normalized X coordinate of the rectangle
rectGetX :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Float
rectGetX Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    result <- graphene_rect_get_x r'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr r
    return 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.Graphene.Structs.Rect.rectGetX",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetX"
        })


#endif

-- method Rect::get_y
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_get_y" graphene_rect_get_y :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CFloat

-- | Retrieves the normalized Y coordinate of the origin of the given
-- rectangle.
-- 
-- /Since: 1.0/
rectGetY ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Float
    -- ^ __Returns:__ the normalized Y coordinate of the rectangle
rectGetY :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Float
rectGetY Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    result <- graphene_rect_get_y r'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr r
    return 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.Graphene.Structs.Rect.rectGetY",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectGetY"
        })


#endif

-- method Rect::init
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the X coordinate of the @graphene_rect_t.origin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the Y coordinate of the @graphene_rect_t.origin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the width of the @graphene_rect_t.size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the height of the @graphene_rect_t.size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_init" graphene_rect_init :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    CFloat ->                               -- width : TBasicType TFloat
    CFloat ->                               -- height : TBasicType TFloat
    IO (Ptr Rect)

-- | Initializes the given t'GI.Graphene.Structs.Rect.Rect' with the given values.
-- 
-- This function will implicitly normalize the t'GI.Graphene.Structs.Rect.Rect'
-- before returning.
-- 
-- /Since: 1.0/
rectInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Float
    -- ^ /@x@/: the X coordinate of the /@grapheneRectT@/.origin
    -> Float
    -- ^ /@y@/: the Y coordinate of the /@grapheneRectT@/.origin
    -> Float
    -- ^ /@width@/: the width of the /@grapheneRectT@/.size
    -> Float
    -- ^ /@height@/: the height of the /@grapheneRectT@/.size
    -> m Rect
    -- ^ __Returns:__ the initialized rectangle
rectInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Float -> Float -> Float -> Float -> m Rect
rectInit Rect
r 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    let x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    let width' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
width
    let height' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
height
    result <- graphene_rect_init r' x' y' width' height'
    checkUnexpectedReturnNULL "rectInit" result
    result' <- (newBoxed Rect) result
    touchManagedPtr r
    return 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.Graphene.Structs.Rect.rectInit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectInit"
        })


#endif

-- method Rect::init_from_rect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "src"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_init_from_rect" graphene_rect_init_from_rect :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- src : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO (Ptr Rect)

-- | Initializes /@r@/ using the given /@src@/ rectangle.
-- 
-- This function will implicitly normalize the t'GI.Graphene.Structs.Rect.Rect'
-- before returning.
-- 
-- /Since: 1.0/
rectInitFromRect ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Rect
    -- ^ /@src@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Rect
    -- ^ __Returns:__ the initialized rectangle
rectInitFromRect :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Rect -> m Rect
rectInitFromRect Rect
r Rect
src = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    src' <- unsafeManagedPtrGetPtr src
    result <- graphene_rect_init_from_rect r' src'
    checkUnexpectedReturnNULL "rectInitFromRect" result
    result' <- (newBoxed Rect) result
    touchManagedPtr r
    touchManagedPtr src
    return result'

#if defined(ENABLE_OVERLOADING)
data RectInitFromRectMethodInfo
instance (signature ~ (Rect -> m Rect), MonadIO m) => O.OverloadedMethod RectInitFromRectMethodInfo Rect signature where
    overloadedMethod = rectInitFromRect

instance O.OverloadedMethodInfo RectInitFromRectMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectInitFromRect",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectInitFromRect"
        })


#endif

-- method Rect::inset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "d_x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the horizontal inset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "d_y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the vertical inset" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_inset" graphene_rect_inset :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    CFloat ->                               -- d_x : TBasicType TFloat
    CFloat ->                               -- d_y : TBasicType TFloat
    IO (Ptr Rect)

-- | Changes the given rectangle to be smaller, or larger depending on the
-- given inset parameters.
-- 
-- To create an inset rectangle, use positive /@dX@/ or /@dY@/ values; to
-- create a larger, encompassing rectangle, use negative /@dX@/ or /@dY@/
-- values.
-- 
-- The origin of the rectangle is offset by /@dX@/ and /@dY@/, while the size
-- is adjusted by @(2 * \@d_x, 2 * \@d_y)@. If /@dX@/ and /@dY@/ are positive
-- values, the size of the rectangle is decreased; if /@dX@/ and /@dY@/ are
-- negative values, the size of the rectangle is increased.
-- 
-- If the size of the resulting inset rectangle has a negative width or
-- height then the size will be set to zero.
-- 
-- /Since: 1.0/
rectInset ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Float
    -- ^ /@dX@/: the horizontal inset
    -> Float
    -- ^ /@dY@/: the vertical inset
    -> m Rect
    -- ^ __Returns:__ the inset rectangle
rectInset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Float -> Float -> m Rect
rectInset Rect
r Float
dX Float
dY = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    let dX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dX
    let dY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dY
    result <- graphene_rect_inset r' dX' dY'
    checkUnexpectedReturnNULL "rectInset" result
    result' <- (newBoxed Rect) result
    touchManagedPtr r
    return result'

#if defined(ENABLE_OVERLOADING)
data RectInsetMethodInfo
instance (signature ~ (Float -> Float -> m Rect), MonadIO m) => O.OverloadedMethod RectInsetMethodInfo Rect signature where
    overloadedMethod = rectInset

instance O.OverloadedMethodInfo RectInsetMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectInset",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectInset"
        })


#endif

-- method Rect::inset_r
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "d_x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the horizontal inset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "d_y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the vertical inset" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the inset rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_inset_r" graphene_rect_inset_r :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    CFloat ->                               -- d_x : TBasicType TFloat
    CFloat ->                               -- d_y : TBasicType TFloat
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Changes the given rectangle to be smaller, or larger depending on the
-- given inset parameters.
-- 
-- To create an inset rectangle, use positive /@dX@/ or /@dY@/ values; to
-- create a larger, encompassing rectangle, use negative /@dX@/ or /@dY@/
-- values.
-- 
-- The origin of the rectangle is offset by /@dX@/ and /@dY@/, while the size
-- is adjusted by @(2 * \@d_x, 2 * \@d_y)@. If /@dX@/ and /@dY@/ are positive
-- values, the size of the rectangle is decreased; if /@dX@/ and /@dY@/ are
-- negative values, the size of the rectangle is increased.
-- 
-- If the size of the resulting inset rectangle has a negative width or
-- height then the size will be set to zero.
-- 
-- /Since: 1.4/
rectInsetR ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Float
    -- ^ /@dX@/: the horizontal inset
    -> Float
    -- ^ /@dY@/: the vertical inset
    -> m (Rect)
rectInsetR :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Float -> Float -> m Rect
rectInsetR Rect
r Float
dX Float
dY = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    let dX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dX
    let dY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dY
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    graphene_rect_inset_r r' dX' dY' res
    res' <- (wrapBoxed Rect) res
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data RectInsetRMethodInfo
instance (signature ~ (Float -> Float -> m (Rect)), MonadIO m) => O.OverloadedMethod RectInsetRMethodInfo Rect signature where
    overloadedMethod = rectInsetR

instance O.OverloadedMethodInfo RectInsetRMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectInsetR",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectInsetR"
        })


#endif

-- method Rect::interpolate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factor"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the linear interpolation factor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the\n  interpolated rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_interpolate" graphene_rect_interpolate :: 
    Ptr Rect ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Rect"})
    CDouble ->                              -- factor : TBasicType TDouble
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Linearly interpolates the origin and size of the two given
-- rectangles.
-- 
-- /Since: 1.0/
rectInterpolate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@a@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Rect
    -- ^ /@b@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Double
    -- ^ /@factor@/: the linear interpolation factor
    -> m (Rect)
rectInterpolate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Rect -> Double -> m Rect
rectInterpolate Rect
a Rect
b Double
factor = 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
    a' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
a
    b' <- unsafeManagedPtrGetPtr b
    let factor' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
factor
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    graphene_rect_interpolate a' b' factor' res
    res' <- (wrapBoxed Rect) res
    touchManagedPtr a
    touchManagedPtr b
    return res'

#if defined(ENABLE_OVERLOADING)
data RectInterpolateMethodInfo
instance (signature ~ (Rect -> Double -> m (Rect)), MonadIO m) => O.OverloadedMethod RectInterpolateMethodInfo Rect signature where
    overloadedMethod = rectInterpolate

instance O.OverloadedMethodInfo RectInterpolateMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectInterpolate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectInterpolate"
        })


#endif

-- method Rect::intersection
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for\n  a #graphene_rect_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_intersection" graphene_rect_intersection :: 
    Ptr Rect ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CInt

-- | Computes the intersection of the two given rectangles.
-- 
-- <<http://developer.gnome.org/graphene/stable/rectangle-intersection.png>>
-- 
-- The intersection in the image above is the blue outline.
-- 
-- If the two rectangles do not intersect, /@res@/ will contain
-- a degenerate rectangle with origin in (0, 0) and a size of 0.
-- 
-- /Since: 1.0/
rectIntersection ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@a@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Rect
    -- ^ /@b@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m ((Bool, Rect))
    -- ^ __Returns:__ @true@ if the two rectangles intersect
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
    a' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
a
    b' <- unsafeManagedPtrGetPtr b
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    result <- graphene_rect_intersection a' b' res
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    res' <- (wrapBoxed Rect) res
    touchManagedPtr a
    touchManagedPtr b
    return (result', 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.Graphene.Structs.Rect.rectIntersection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectIntersection"
        })


#endif

-- method Rect::normalize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_normalize" graphene_rect_normalize :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO (Ptr Rect)

-- | Normalizes the passed rectangle.
-- 
-- This function ensures that the size of the rectangle is made of
-- positive values, and that the origin is the top-left corner of
-- the rectangle.
-- 
-- /Since: 1.0/
rectNormalize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Rect
    -- ^ __Returns:__ the normalized rectangle
rectNormalize :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Rect
rectNormalize Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    result <- graphene_rect_normalize r'
    checkUnexpectedReturnNULL "rectNormalize" result
    result' <- (newBoxed Rect) result
    touchManagedPtr r
    return 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.Graphene.Structs.Rect.rectNormalize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectNormalize"
        })


#endif

-- method Rect::normalize_r
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the return location for the\n  normalized rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_normalize_r" graphene_rect_normalize_r :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Normalizes the passed rectangle.
-- 
-- This function ensures that the size of the rectangle is made of
-- positive values, and that the origin is in the top-left corner
-- of the rectangle.
-- 
-- /Since: 1.4/
rectNormalizeR ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Rect)
rectNormalizeR :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Rect
rectNormalizeR Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    graphene_rect_normalize_r r' res
    res' <- (wrapBoxed Rect) res
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data RectNormalizeRMethodInfo
instance (signature ~ (m (Rect)), MonadIO m) => O.OverloadedMethod RectNormalizeRMethodInfo Rect signature where
    overloadedMethod = rectNormalizeR

instance O.OverloadedMethodInfo RectNormalizeRMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectNormalizeR",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectNormalizeR"
        })


#endif

-- method Rect::offset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "d_x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the horizontal offset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "d_y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the vertical offset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_offset" graphene_rect_offset :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    CFloat ->                               -- d_x : TBasicType TFloat
    CFloat ->                               -- d_y : TBasicType TFloat
    IO (Ptr Rect)

-- | Offsets the origin by /@dX@/ and /@dY@/.
-- 
-- The size of the rectangle is unchanged.
-- 
-- /Since: 1.0/
rectOffset ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Float
    -- ^ /@dX@/: the horizontal offset
    -> Float
    -- ^ /@dY@/: the vertical offset
    -> m Rect
    -- ^ __Returns:__ the offset rectangle
rectOffset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Float -> Float -> m Rect
rectOffset Rect
r Float
dX Float
dY = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    let dX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dX
    let dY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dY
    result <- graphene_rect_offset r' dX' dY'
    checkUnexpectedReturnNULL "rectOffset" result
    result' <- (newBoxed Rect) result
    touchManagedPtr r
    return result'

#if defined(ENABLE_OVERLOADING)
data RectOffsetMethodInfo
instance (signature ~ (Float -> Float -> m Rect), MonadIO m) => O.OverloadedMethod RectOffsetMethodInfo Rect signature where
    overloadedMethod = rectOffset

instance O.OverloadedMethodInfo RectOffsetMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectOffset",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectOffset"
        })


#endif

-- method Rect::offset_r
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "d_x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the horizontal offset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "d_y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the vertical offset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the offset\n  rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_offset_r" graphene_rect_offset_r :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    CFloat ->                               -- d_x : TBasicType TFloat
    CFloat ->                               -- d_y : TBasicType TFloat
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Offsets the origin of the given rectangle by /@dX@/ and /@dY@/.
-- 
-- The size of the rectangle is left unchanged.
-- 
-- /Since: 1.4/
rectOffsetR ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Float
    -- ^ /@dX@/: the horizontal offset
    -> Float
    -- ^ /@dY@/: the vertical offset
    -> m (Rect)
rectOffsetR :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Float -> Float -> m Rect
rectOffsetR Rect
r Float
dX Float
dY = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    let dX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dX
    let dY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dY
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    graphene_rect_offset_r r' dX' dY' res
    res' <- (wrapBoxed Rect) res
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data RectOffsetRMethodInfo
instance (signature ~ (Float -> Float -> m (Rect)), MonadIO m) => O.OverloadedMethod RectOffsetRMethodInfo Rect signature where
    overloadedMethod = rectOffsetR

instance O.OverloadedMethodInfo RectOffsetRMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectOffsetR",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectOffsetR"
        })


#endif

-- method Rect::round
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the\n  rounded rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_round" graphene_rect_round :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

{-# DEPRECATED rectRound ["(Since version 1.10)","Use 'GI.Graphene.Structs.Rect.rectRoundExtents' instead"] #-}
-- | Rounds the origin and size of the given rectangle to
-- their nearest integer values; the rounding is guaranteed
-- to be large enough to have an area bigger or equal to the
-- original rectangle, but might not fully contain its extents.
-- Use 'GI.Graphene.Structs.Rect.rectRoundExtents' in case you need to round
-- to a rectangle that covers fully the original one.
-- 
-- This function is the equivalent of calling @floor@ on
-- the coordinates of the origin, and @ceil@ on the size.
-- 
-- /Since: 1.4/
rectRound ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Rect)
rectRound :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Rect
rectRound Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    graphene_rect_round r' res
    res' <- (wrapBoxed Rect) res
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data RectRoundMethodInfo
instance (signature ~ (m (Rect)), MonadIO m) => O.OverloadedMethod RectRoundMethodInfo Rect signature where
    overloadedMethod = rectRound

instance O.OverloadedMethodInfo RectRoundMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectRound",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectRound"
        })


#endif

-- method Rect::round_extents
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the\n  rectangle with rounded extents"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_round_extents" graphene_rect_round_extents :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Rounds the origin of the given rectangle to its nearest
-- integer value and and recompute the size so that the
-- rectangle is large enough to contain all the conrners
-- of the original rectangle.
-- 
-- This function is the equivalent of calling @floor@ on
-- the coordinates of the origin, and recomputing the size
-- calling @ceil@ on the bottom-right coordinates.
-- 
-- If you want to be sure that the rounded rectangle
-- completely covers the area that was covered by the
-- original rectangle — i.e. you want to cover the area
-- including all its corners — this function will make sure
-- that the size is recomputed taking into account the ceiling
-- of the coordinates of the bottom-right corner.
-- If the difference between the original coordinates and the
-- coordinates of the rounded rectangle is greater than the
-- difference between the original size and and the rounded
-- size, then the move of the origin would not be compensated
-- by a move in the anti-origin, leaving the corners of the
-- original rectangle outside the rounded one.
-- 
-- /Since: 1.10/
rectRoundExtents ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Rect)
rectRoundExtents :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Rect
rectRoundExtents Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    graphene_rect_round_extents r' res
    res' <- (wrapBoxed Rect) res
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data RectRoundExtentsMethodInfo
instance (signature ~ (m (Rect)), MonadIO m) => O.OverloadedMethod RectRoundExtentsMethodInfo Rect signature where
    overloadedMethod = rectRoundExtents

instance O.OverloadedMethodInfo RectRoundExtentsMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectRoundExtents",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectRoundExtents"
        })


#endif

-- method Rect::round_to_pixel
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_round_to_pixel" graphene_rect_round_to_pixel :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO (Ptr Rect)

{-# DEPRECATED rectRoundToPixel ["(Since version 1.4)","Use 'GI.Graphene.Structs.Rect.rectRound' instead"] #-}
-- | Rounds the origin and the size of the given rectangle to
-- their nearest integer values; the rounding is guaranteed
-- to be large enough to contain the original rectangle.
-- 
-- /Since: 1.0/
rectRoundToPixel ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m Rect
    -- ^ __Returns:__ the pixel-aligned rectangle.
rectRoundToPixel :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Rect -> m Rect
rectRoundToPixel Rect
r = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    result <- graphene_rect_round_to_pixel r'
    checkUnexpectedReturnNULL "rectRoundToPixel" result
    result' <- (newBoxed Rect) result
    touchManagedPtr r
    return result'

#if defined(ENABLE_OVERLOADING)
data RectRoundToPixelMethodInfo
instance (signature ~ (m Rect), MonadIO m) => O.OverloadedMethod RectRoundToPixelMethodInfo Rect signature where
    overloadedMethod = rectRoundToPixel

instance O.OverloadedMethodInfo RectRoundToPixelMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectRoundToPixel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectRoundToPixel"
        })


#endif

-- method Rect::scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "s_h"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "horizontal scale factor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "s_v"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "vertical scale factor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the\n  scaled rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_scale" graphene_rect_scale :: 
    Ptr Rect ->                             -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    CFloat ->                               -- s_h : TBasicType TFloat
    CFloat ->                               -- s_v : TBasicType TFloat
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Scales the size and origin of a rectangle horizontaly by /@sH@/,
-- and vertically by /@sV@/. The result /@res@/ is normalized.
-- 
-- /Since: 1.10/
rectScale ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Float
    -- ^ /@sH@/: horizontal scale factor
    -> Float
    -- ^ /@sV@/: vertical scale factor
    -> m (Rect)
rectScale :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect -> Float -> Float -> m Rect
rectScale Rect
r Float
sH Float
sV = 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
    r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
    let sH' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
sH
    let sV' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
sV
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    graphene_rect_scale r' sH' sV' res
    res' <- (wrapBoxed Rect) res
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data RectScaleMethodInfo
instance (signature ~ (Float -> Float -> m (Rect)), MonadIO m) => O.OverloadedMethod RectScaleMethodInfo Rect signature where
    overloadedMethod = rectScale

instance O.OverloadedMethodInfo RectScaleMethodInfo Rect where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Rect.rectScale",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectScale"
        })


#endif

-- method Rect::union
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #graphene_rect_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_union" graphene_rect_union :: 
    Ptr Rect ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Rect ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Computes the union of the two given rectangles.
-- 
-- <<http://developer.gnome.org/graphene/stable/rectangle-union.png>>
-- 
-- The union in the image above is the blue outline.
-- 
-- /Since: 1.0/
rectUnion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Rect
    -- ^ /@a@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Rect
    -- ^ /@b@/: a t'GI.Graphene.Structs.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
    a' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
a
    b' <- unsafeManagedPtrGetPtr b
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Rect)
    graphene_rect_union a' b' res
    res' <- (wrapBoxed Rect) res
    touchManagedPtr a
    touchManagedPtr b
    return 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.Graphene.Structs.Rect.rectUnion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Rect.html#v:rectUnion"
        })


#endif

-- method Rect::alloc
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_alloc" graphene_rect_alloc :: 
    IO (Ptr Rect)

-- | Allocates a new t'GI.Graphene.Structs.Rect.Rect'.
-- 
-- The contents of the returned rectangle are undefined.
-- 
-- /Since: 1.0/
rectAlloc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Rect
    -- ^ __Returns:__ the newly allocated rectangle
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
    result <- IO (Ptr Rect)
graphene_rect_alloc
    checkUnexpectedReturnNULL "rectAlloc" result
    result' <- (wrapBoxed Rect) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Rect::zero
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_rect_zero" graphene_rect_zero :: 
    IO (Ptr Rect)

-- | Returns a degenerate rectangle with origin fixed at (0, 0) and
-- a size of 0, 0.
-- 
-- /Since: 1.4/
rectZero ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Rect
    -- ^ __Returns:__ a fixed rectangle
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
    result <- IO (Ptr Rect)
graphene_rect_zero
    checkUnexpectedReturnNULL "rectZero" result
    result' <- (newBoxed Rect) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveRectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveRectMethod "containsPoint" o = RectContainsPointMethodInfo
    ResolveRectMethod "containsRect" o = RectContainsRectMethodInfo
    ResolveRectMethod "equal" o = RectEqualMethodInfo
    ResolveRectMethod "expand" o = RectExpandMethodInfo
    ResolveRectMethod "free" o = RectFreeMethodInfo
    ResolveRectMethod "init" o = RectInitMethodInfo
    ResolveRectMethod "initFromRect" o = RectInitFromRectMethodInfo
    ResolveRectMethod "inset" o = RectInsetMethodInfo
    ResolveRectMethod "insetR" o = RectInsetRMethodInfo
    ResolveRectMethod "interpolate" o = RectInterpolateMethodInfo
    ResolveRectMethod "intersection" o = RectIntersectionMethodInfo
    ResolveRectMethod "normalize" o = RectNormalizeMethodInfo
    ResolveRectMethod "normalizeR" o = RectNormalizeRMethodInfo
    ResolveRectMethod "offset" o = RectOffsetMethodInfo
    ResolveRectMethod "offsetR" o = RectOffsetRMethodInfo
    ResolveRectMethod "round" o = RectRoundMethodInfo
    ResolveRectMethod "roundExtents" o = RectRoundExtentsMethodInfo
    ResolveRectMethod "roundToPixel" o = RectRoundToPixelMethodInfo
    ResolveRectMethod "scale" o = RectScaleMethodInfo
    ResolveRectMethod "union" o = RectUnionMethodInfo
    ResolveRectMethod "getArea" o = RectGetAreaMethodInfo
    ResolveRectMethod "getBottomLeft" o = RectGetBottomLeftMethodInfo
    ResolveRectMethod "getBottomRight" o = RectGetBottomRightMethodInfo
    ResolveRectMethod "getCenter" o = RectGetCenterMethodInfo
    ResolveRectMethod "getHeight" o = RectGetHeightMethodInfo
    ResolveRectMethod "getTopLeft" o = RectGetTopLeftMethodInfo
    ResolveRectMethod "getTopRight" o = RectGetTopRightMethodInfo
    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