    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A 4 vertex quadrilateral, as represented by four t'GI.Graphene.Structs.Point.Point'.
    --
    -- The contents of a t'GI.Graphene.Structs.Quad.Quad' are private and should never be
    -- accessed directly.
    --
    -- /Since: 1.0/

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Graphene.Structs.Quad
        (

    -- * Exported types
        Quad(..)                                ,
        newZeroQuad                             ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bounds]("GI.Graphene.Structs.Quad#g:method:bounds"), [contains]("GI.Graphene.Structs.Quad#g:method:contains"), [free]("GI.Graphene.Structs.Quad#g:method:free"), [init]("GI.Graphene.Structs.Quad#g:method:init"), [initFromPoints]("GI.Graphene.Structs.Quad#g:method:initFromPoints"), [initFromRect]("GI.Graphene.Structs.Quad#g:method:initFromRect").
    --
    -- ==== Getters
    -- [getPoint]("GI.Graphene.Structs.Quad#g:method:getPoint").
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveQuadMethod                       ,
    #endif

    -- ** alloc #method:alloc#

        quadAlloc                               ,

    -- ** bounds #method:bounds#

    #if defined(ENABLE_OVERLOADING)
        QuadBoundsMethodInfo                    ,
    #endif
        quadBounds                              ,

    -- ** contains #method:contains#

    #if defined(ENABLE_OVERLOADING)
        QuadContainsMethodInfo                  ,
    #endif
        quadContains                            ,

    -- ** free #method:free#

    #if defined(ENABLE_OVERLOADING)
        QuadFreeMethodInfo                      ,
    #endif
        quadFree                                ,

    -- ** getPoint #method:getPoint#

    #if defined(ENABLE_OVERLOADING)
        QuadGetPointMethodInfo                  ,
    #endif
        quadGetPoint                            ,

    -- ** init #method:init#

    #if defined(ENABLE_OVERLOADING)
        QuadInitMethodInfo                      ,
    #endif
        quadInit                                ,

    -- ** initFromPoints #method:initFromPoints#

    #if defined(ENABLE_OVERLOADING)
        QuadInitFromPointsMethodInfo            ,
    #endif
        quadInitFromPoints                      ,

    -- ** initFromRect #method:initFromRect#

    #if defined(ENABLE_OVERLOADING)
        QuadInitFromRectMethodInfo              ,
    #endif
        quadInitFromRect                        ,

        ) 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.Rect as Graphene.Rect
    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.Rect as Graphene.Rect

    #endif

    -- | Memory-managed wrapper type.
    newtype Quad = Quad (SP.ManagedPtr Quad)
        deriving (Quad -> Quad -> Bool
    (Quad -> Quad -> Bool) -> (Quad -> Quad -> Bool) -> Eq Quad
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Quad -> Quad -> Bool
    == :: Quad -> Quad -> Bool
    $c/= :: Quad -> Quad -> Bool
    /= :: Quad -> Quad -> Bool
    Eq)

    instance SP.ManagedPtrNewtype Quad where
        toManagedPtr :: Quad -> ManagedPtr Quad
    toManagedPtr (Quad ManagedPtr Quad
    p) = ManagedPtr Quad
    p

    foreign import ccall "graphene_quad_get_type" c_graphene_quad_get_type ::
        IO GType

    type instance O.ParentTypes Quad = '[]
    instance O.HasParentTypes Quad

    instance B.Types.TypedObject Quad where
        glibType :: IO GType
    glibType = IO GType
    c_graphene_quad_get_type

    instance B.Types.GBoxed Quad

    -- | Convert t'Quad' 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 Quad) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_graphene_quad_get_type
        gvalueSet_ :: Ptr GValue -> Maybe Quad -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe Quad
    P.Nothing = Ptr GValue -> Ptr Quad -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv (Ptr Quad
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr Quad)
        gvalueSet_ Ptr GValue
    gv (P.Just Quad
    obj) = Quad -> (Ptr Quad -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Quad
    obj (Ptr GValue -> Ptr Quad -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe Quad)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr Quad)
    forall b. Ptr GValue -> IO (Ptr b)
    B.GValue.get_boxed Ptr GValue
    gv :: IO (Ptr Quad)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newBoxed Quad ptr
            else return P.Nothing

    -- | Construct a t'Quad' struct initialized to zero.
    newZeroQuad :: MonadIO m => m Quad
    newZeroQuad :: forall (m :: * -> *). MonadIO m => m Quad
    newZeroQuad = IO Quad -> m Quad
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Quad -> m Quad) -> IO Quad -> m Quad
    forall a b. (a -> b) -> a -> b
    $ Int -> IO (Ptr Quad)
    forall a. GBoxed a => Int -> IO (Ptr a)
    callocBoxedBytes Int
    32 IO (Ptr Quad) -> (Ptr Quad -> IO Quad) -> IO Quad
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr Quad -> Quad) -> Ptr Quad -> IO Quad
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Quad -> Quad
    Quad

    instance tag ~ 'AttrSet => Constructible Quad tag where
        new :: forall (m :: * -> *).
    MonadIO m =>
    (ManagedPtr Quad -> Quad) -> [AttrOp Quad tag] -> m Quad
    new ManagedPtr Quad -> Quad
    _ [AttrOp Quad tag]
    attrs = do
            o <- m Quad
    forall (m :: * -> *). MonadIO m => m Quad
    newZeroQuad
            GI.Attributes.set o attrs
            return o

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Quad
    type instance O.AttributeList Quad = QuadAttributeList
    type QuadAttributeList = ('[ ] :: [(Symbol, DK.Type)])
    #endif

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

    foreign import ccall "graphene_quad_alloc" graphene_quad_alloc ::
        IO (Ptr Quad)

    -- | Allocates a new t'GI.Graphene.Structs.Quad.Quad' instance.
    --
    -- The contents of the returned instance are undefined.
    --
    -- /Since: 1.0/
    quadAlloc ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Quad
        -- ^ __Returns:__ the newly created t'GI.Graphene.Structs.Quad.Quad' instance
    quadAlloc :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Quad
    quadAlloc  = IO Quad -> m Quad
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Quad -> m Quad) -> IO Quad -> m Quad
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Quad)
    graphene_quad_alloc
        checkUnexpectedReturnNULL "quadAlloc" result
        result' <- (wrapBoxed Quad) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Quad::bounds
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "q"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Quad" }
    --           , argCType = Just "const graphene_quad_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_quad_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "r"
    --           , 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_quad_bounds" graphene_quad_bounds ::
        Ptr Quad ->                             -- q : TInterface (Name {namespace = "Graphene", name = "Quad"})
        Ptr Graphene.Rect.Rect ->               -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
        IO ()

    -- | Computes the bounding rectangle of /@q@/ and places it into /@r@/.
    --
    -- /Since: 1.0/
    quadBounds ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Quad
        -- ^ /@q@/: a t'GI.Graphene.Structs.Quad.Quad'
        -> m (Graphene.Rect.Rect)
    quadBounds :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Quad -> m Rect
    quadBounds Quad
    q = 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
        q' <- Quad -> IO (Ptr Quad)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Quad
    q
        r <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
        graphene_quad_bounds q' r
        r' <- (wrapBoxed Graphene.Rect.Rect) r
        touchManagedPtr q
        return r'

    #if defined(ENABLE_OVERLOADING)
    data QuadBoundsMethodInfo
    instance (signature ~ (m (Graphene.Rect.Rect)), MonadIO m) => O.OverloadedMethod QuadBoundsMethodInfo Quad signature where
        overloadedMethod = quadBounds

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

    #endif

    -- method Quad::contains
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "q"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Quad" }
    --           , argCType = Just "const graphene_quad_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_quad_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_quad_contains" graphene_quad_contains ::
        Ptr Quad ->                             -- q : TInterface (Name {namespace = "Graphene", name = "Quad"})
        Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
        IO CInt

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

    #if defined(ENABLE_OVERLOADING)
    data QuadContainsMethodInfo
    instance (signature ~ (Graphene.Point.Point -> m Bool), MonadIO m) => O.OverloadedMethod QuadContainsMethodInfo Quad signature where
        overloadedMethod = quadContains

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

    #endif

    -- method Quad::free
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "q"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Quad" }
    --           , argCType = Just "graphene_quad_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_quad_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_quad_free" graphene_quad_free ::
        Ptr Quad ->                             -- q : TInterface (Name {namespace = "Graphene", name = "Quad"})
        IO ()

    -- | Frees the resources allocated by 'GI.Graphene.Structs.Quad.quadAlloc'
    --
    -- /Since: 1.0/
    quadFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Quad
        -- ^ /@q@/: a t'GI.Graphene.Structs.Quad.Quad'
        -> m ()
    quadFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Quad -> m ()
    quadFree Quad
    q = 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
        q' <- Quad -> IO (Ptr Quad)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Quad
    q
        graphene_quad_free q'
        touchManagedPtr q
        return ()

    #if defined(ENABLE_OVERLOADING)
    data QuadFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod QuadFreeMethodInfo Quad signature where
        overloadedMethod = quadFree

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

    #endif

    -- method Quad::get_point
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "q"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Quad" }
    --           , argCType = Just "const graphene_quad_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_quad_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "index_"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "unsigned int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the index of the point to retrieve"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Point" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_quad_get_point" graphene_quad_get_point ::
        Ptr Quad ->                             -- q : TInterface (Name {namespace = "Graphene", name = "Quad"})
        Word32 ->                               -- index_ : TBasicType TUInt
        IO (Ptr Graphene.Point.Point)

    -- | Retrieves the point of a t'GI.Graphene.Structs.Quad.Quad' at the given index.
    --
    -- /Since: 1.0/
    quadGetPoint ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Quad
        -- ^ /@q@/: a t'GI.Graphene.Structs.Quad.Quad'
        -> Word32
        -- ^ /@index_@/: the index of the point to retrieve
        -> m Graphene.Point.Point
        -- ^ __Returns:__ a t'GI.Graphene.Structs.Point.Point'
    quadGetPoint :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Quad -> Word32 -> m Point
    quadGetPoint Quad
    q Word32
    index_ = 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
        q' <- Quad -> IO (Ptr Quad)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Quad
    q
        result <- graphene_quad_get_point q' index_
        checkUnexpectedReturnNULL "quadGetPoint" result
        result' <- (newBoxed Graphene.Point.Point) result
        touchManagedPtr q
        return result'

    #if defined(ENABLE_OVERLOADING)
    data QuadGetPointMethodInfo
    instance (signature ~ (Word32 -> m Graphene.Point.Point), MonadIO m) => O.OverloadedMethod QuadGetPointMethodInfo Quad signature where
        overloadedMethod = quadGetPoint

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

    #endif

    -- method Quad::init
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "q"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Quad" }
    --           , argCType = Just "graphene_quad_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_quad_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "p1"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point" }
    --           , argCType = Just "const graphene_point_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the first point of the quadrilateral"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "p2"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point" }
    --           , argCType = Just "const graphene_point_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the second point of the quadrilateral"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "p3"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point" }
    --           , argCType = Just "const graphene_point_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the third point of the quadrilateral"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "p4"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point" }
    --           , argCType = Just "const graphene_point_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the fourth point of the quadrilateral"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Quad" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_quad_init" graphene_quad_init ::
        Ptr Quad ->                             -- q : TInterface (Name {namespace = "Graphene", name = "Quad"})
        Ptr Graphene.Point.Point ->             -- p1 : TInterface (Name {namespace = "Graphene", name = "Point"})
        Ptr Graphene.Point.Point ->             -- p2 : TInterface (Name {namespace = "Graphene", name = "Point"})
        Ptr Graphene.Point.Point ->             -- p3 : TInterface (Name {namespace = "Graphene", name = "Point"})
        Ptr Graphene.Point.Point ->             -- p4 : TInterface (Name {namespace = "Graphene", name = "Point"})
        IO (Ptr Quad)

    -- | Initializes a t'GI.Graphene.Structs.Quad.Quad' with the given points.
    --
    -- /Since: 1.0/
    quadInit ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Quad
        -- ^ /@q@/: the t'GI.Graphene.Structs.Quad.Quad' to initialize
        -> Graphene.Point.Point
        -- ^ /@p1@/: the first point of the quadrilateral
        -> Graphene.Point.Point
        -- ^ /@p2@/: the second point of the quadrilateral
        -> Graphene.Point.Point
        -- ^ /@p3@/: the third point of the quadrilateral
        -> Graphene.Point.Point
        -- ^ /@p4@/: the fourth point of the quadrilateral
        -> m Quad
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Quad.Quad'
    quadInit :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Quad -> Point -> Point -> Point -> Point -> m Quad
    quadInit Quad
    q Point
    p1 Point
    p2 Point
    p3 Point
    p4 = IO Quad -> m Quad
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Quad -> m Quad) -> IO Quad -> m Quad
    forall a b. (a -> b) -> a -> b
    $ do
        q' <- Quad -> IO (Ptr Quad)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Quad
    q
        p1' <- unsafeManagedPtrGetPtr p1
        p2' <- unsafeManagedPtrGetPtr p2
        p3' <- unsafeManagedPtrGetPtr p3
        p4' <- unsafeManagedPtrGetPtr p4
        result <- graphene_quad_init q' p1' p2' p3' p4'
        checkUnexpectedReturnNULL "quadInit" result
        result' <- (newBoxed Quad) result
        touchManagedPtr q
        touchManagedPtr p1
        touchManagedPtr p2
        touchManagedPtr p3
        touchManagedPtr p4
        return result'

    #if defined(ENABLE_OVERLOADING)
    data QuadInitMethodInfo
    instance (signature ~ (Graphene.Point.Point -> Graphene.Point.Point -> Graphene.Point.Point -> Graphene.Point.Point -> m Quad), MonadIO m) => O.OverloadedMethod QuadInitMethodInfo Quad signature where
        overloadedMethod = quadInit

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

    #endif

    -- method Quad::init_from_points
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "q"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Quad" }
    --           , argCType = Just "graphene_quad_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_quad_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "points"
    --           , argType =
    --               TCArray
    --                 False
    --                 4
    --                 (-1)
    --                 (TInterface Name { namespace = "Graphene" , name = "Point" })
    --           , argCType = Just "const graphene_point_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an array of 4 #graphene_point_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Quad" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_quad_init_from_points" graphene_quad_init_from_points ::
        Ptr Quad ->                             -- q : TInterface (Name {namespace = "Graphene", name = "Quad"})
        Ptr Graphene.Point.Point ->             -- points : TCArray False 4 (-1) (TInterface (Name {namespace = "Graphene", name = "Point"}))
        IO (Ptr Quad)

    -- | Initializes a t'GI.Graphene.Structs.Quad.Quad' using an array of points.
    --
    -- /Since: 1.2/
    quadInitFromPoints ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Quad
        -- ^ /@q@/: the t'GI.Graphene.Structs.Quad.Quad' to initialize
        -> [Graphene.Point.Point]
        -- ^ /@points@/: an array of 4 t'GI.Graphene.Structs.Point.Point'
        -> m Quad
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Quad.Quad'
    quadInitFromPoints :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Quad -> [Point] -> m Quad
    quadInitFromPoints Quad
    q [Point]
    points = IO Quad -> m Quad
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Quad -> m Quad) -> IO Quad -> m Quad
    forall a b. (a -> b) -> a -> b
    $ do
        q' <- Quad -> IO (Ptr Quad)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Quad
    q
        points' <- mapM unsafeManagedPtrGetPtr points
        points'' <- packBlockArray 8 points'
        result <- graphene_quad_init_from_points q' points''
        checkUnexpectedReturnNULL "quadInitFromPoints" result
        result' <- (newBoxed Quad) result
        touchManagedPtr q
        mapM_ touchManagedPtr points
        freeMem points''
        return result'

    #if defined(ENABLE_OVERLOADING)
    data QuadInitFromPointsMethodInfo
    instance (signature ~ ([Graphene.Point.Point] -> m Quad), MonadIO m) => O.OverloadedMethod QuadInitFromPointsMethodInfo Quad signature where
        overloadedMethod = quadInitFromPoints

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

    #endif

    -- method Quad::init_from_rect
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "q"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Quad" }
    --           , argCType = Just "graphene_quad_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_quad_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , 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 (TInterface Name { namespace = "Graphene" , name = "Quad" })
    -- throws : False
    -- Skip return : False

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

    -- | Initializes a t'GI.Graphene.Structs.Quad.Quad' using the four corners of the
    -- given t'GI.Graphene.Structs.Rect.Rect'.
    --
    -- /Since: 1.0/
    quadInitFromRect ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Quad
        -- ^ /@q@/: the t'GI.Graphene.Structs.Quad.Quad' to initialize
        -> Graphene.Rect.Rect
        -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
        -> m Quad
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Quad.Quad'
    quadInitFromRect :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Quad -> Rect -> m Quad
    quadInitFromRect Quad
    q Rect
    r = IO Quad -> m Quad
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Quad -> m Quad) -> IO Quad -> m Quad
    forall a b. (a -> b) -> a -> b
    $ do
        q' <- Quad -> IO (Ptr Quad)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Quad
    q
        r' <- unsafeManagedPtrGetPtr r
        result <- graphene_quad_init_from_rect q' r'
        checkUnexpectedReturnNULL "quadInitFromRect" result
        result' <- (newBoxed Quad) result
        touchManagedPtr q
        touchManagedPtr r
        return result'

    #if defined(ENABLE_OVERLOADING)
    data QuadInitFromRectMethodInfo
    instance (signature ~ (Graphene.Rect.Rect -> m Quad), MonadIO m) => O.OverloadedMethod QuadInitFromRectMethodInfo Quad signature where
        overloadedMethod = quadInitFromRect

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

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveQuadMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveQuadMethod "bounds" o = QuadBoundsMethodInfo
        ResolveQuadMethod "contains" o = QuadContainsMethodInfo
        ResolveQuadMethod "free" o = QuadFreeMethodInfo
        ResolveQuadMethod "init" o = QuadInitMethodInfo
        ResolveQuadMethod "initFromPoints" o = QuadInitFromPointsMethodInfo
        ResolveQuadMethod "initFromRect" o = QuadInitFromRectMethodInfo
        ResolveQuadMethod "getPoint" o = QuadGetPointMethodInfo
        ResolveQuadMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveQuadMethod t Quad, O.OverloadedMethod info Quad p) => OL.IsLabel t (Quad -> 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 ~ ResolveQuadMethod t Quad, O.OverloadedMethod info Quad p, R.HasField t Quad p) => R.HasField t Quad p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveQuadMethod t Quad, O.OverloadedMethodInfo info Quad) => OL.IsLabel t (O.MethodProxy info Quad) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif