{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Graphene.Structs.Quad
(
Quad(..) ,
newZeroQuad ,
noQuad ,
#if defined(ENABLE_OVERLOADING)
ResolveQuadMethod ,
#endif
quadAlloc ,
#if defined(ENABLE_OVERLOADING)
QuadBoundsMethodInfo ,
#endif
quadBounds ,
#if defined(ENABLE_OVERLOADING)
QuadContainsMethodInfo ,
#endif
quadContains ,
#if defined(ENABLE_OVERLOADING)
QuadFreeMethodInfo ,
#endif
quadFree ,
#if defined(ENABLE_OVERLOADING)
QuadGetPointMethodInfo ,
#endif
quadGetPoint ,
#if defined(ENABLE_OVERLOADING)
QuadInitMethodInfo ,
#endif
quadInit ,
#if defined(ENABLE_OVERLOADING)
QuadInitFromPointsMethodInfo ,
#endif
quadInitFromPoints ,
#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import {-# SOURCE #-} qualified GI.Graphene.Structs.Point as Graphene.Point
import {-# SOURCE #-} qualified GI.Graphene.Structs.Rect as Graphene.Rect
newtype Quad = Quad (ManagedPtr Quad)
deriving (Quad -> Quad -> Bool
(Quad -> Quad -> Bool) -> (Quad -> Quad -> Bool) -> Eq Quad
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Quad -> Quad -> Bool
$c/= :: Quad -> Quad -> Bool
== :: Quad -> Quad -> Bool
$c== :: Quad -> Quad -> Bool
Eq)
foreign import ccall "graphene_quad_get_type" c_graphene_quad_get_type ::
IO GType
instance BoxedObject Quad where
boxedType :: Quad -> IO GType
boxedType _ = IO GType
c_graphene_quad_get_type
instance B.GValue.IsGValue Quad where
toGValue :: Quad -> IO GValue
toGValue o :: Quad
o = do
GType
gtype <- IO GType
c_graphene_quad_get_type
Quad -> (Ptr Quad -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Quad
o (GType -> (GValue -> Ptr Quad -> IO ()) -> Ptr Quad -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Quad -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO Quad
fromGValue gv :: GValue
gv = do
Ptr Quad
ptr <- GValue -> IO (Ptr Quad)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr Quad)
(ManagedPtr Quad -> Quad) -> Ptr Quad -> IO Quad
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Quad -> Quad
Quad Ptr Quad
ptr
newZeroQuad :: MonadIO m => m Quad
newZeroQuad :: m Quad
newZeroQuad = IO Quad -> m Quad
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. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 32 IO (Ptr Quad) -> (Ptr Quad -> IO Quad) -> IO Quad
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Quad -> Quad) -> Ptr Quad -> IO Quad
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Quad -> Quad
Quad
instance tag ~ 'AttrSet => Constructible Quad tag where
new :: (ManagedPtr Quad -> Quad) -> [AttrOp Quad tag] -> m Quad
new _ attrs :: [AttrOp Quad tag]
attrs = do
Quad
o <- m Quad
forall (m :: * -> *). MonadIO m => m Quad
newZeroQuad
Quad -> [AttrOp Quad 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Quad
o [AttrOp Quad tag]
[AttrOp Quad 'AttrSet]
attrs
Quad -> m Quad
forall (m :: * -> *) a. Monad m => a -> m a
return Quad
o
noQuad :: Maybe Quad
noQuad :: Maybe Quad
noQuad = Maybe Quad
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Quad
type instance O.AttributeList Quad = QuadAttributeList
type QuadAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "graphene_quad_alloc" graphene_quad_alloc ::
IO (Ptr Quad)
quadAlloc ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Quad
quadAlloc :: m Quad
quadAlloc = IO Quad -> m Quad
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
Ptr Quad
result <- IO (Ptr Quad)
graphene_quad_alloc
Text -> Ptr Quad -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "quadAlloc" Ptr Quad
result
Quad
result' <- ((ManagedPtr Quad -> Quad) -> Ptr Quad -> IO Quad
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Quad -> Quad
Quad) Ptr Quad
result
Quad -> IO Quad
forall (m :: * -> *) a. Monad m => a -> m a
return Quad
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "graphene_quad_bounds" graphene_quad_bounds ::
Ptr Quad ->
Ptr Graphene.Rect.Rect ->
IO ()
quadBounds ::
(B.CallStack.HasCallStack, MonadIO m) =>
Quad
-> m (Graphene.Rect.Rect)
quadBounds :: Quad -> m Rect
quadBounds q :: Quad
q = IO Rect -> m Rect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
Ptr Quad
q' <- Quad -> IO (Ptr Quad)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quad
q
Ptr Rect
r <- Int -> IO (Ptr Rect)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
Ptr Quad -> Ptr Rect -> IO ()
graphene_quad_bounds Ptr Quad
q' Ptr Rect
r
Rect
r' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Graphene.Rect.Rect) Ptr Rect
r
Quad -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Quad
q
Rect -> IO Rect
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
r'
#if defined(ENABLE_OVERLOADING)
data QuadBoundsMethodInfo
instance (signature ~ (m (Graphene.Rect.Rect)), MonadIO m) => O.MethodInfo QuadBoundsMethodInfo Quad signature where
overloadedMethod = quadBounds
#endif
foreign import ccall "graphene_quad_contains" graphene_quad_contains ::
Ptr Quad ->
Ptr Graphene.Point.Point ->
IO CInt
quadContains ::
(B.CallStack.HasCallStack, MonadIO m) =>
Quad
-> Graphene.Point.Point
-> m Bool
quadContains :: Quad -> Point -> m Bool
quadContains q :: Quad
q p :: Point
p = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Quad
q' <- Quad -> IO (Ptr Quad)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quad
q
Ptr Point
p' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
p
CInt
result <- Ptr Quad -> Ptr Point -> IO CInt
graphene_quad_contains Ptr Quad
q' Ptr Point
p'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Quad -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Quad
q
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
p
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data QuadContainsMethodInfo
instance (signature ~ (Graphene.Point.Point -> m Bool), MonadIO m) => O.MethodInfo QuadContainsMethodInfo Quad signature where
overloadedMethod = quadContains
#endif
foreign import ccall "graphene_quad_free" graphene_quad_free ::
Ptr Quad ->
IO ()
quadFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Quad
-> m ()
quadFree :: Quad -> m ()
quadFree q :: Quad
q = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Quad
q' <- Quad -> IO (Ptr Quad)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quad
q
Ptr Quad -> IO ()
graphene_quad_free Ptr Quad
q'
Quad -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Quad
q
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QuadFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo QuadFreeMethodInfo Quad signature where
overloadedMethod = quadFree
#endif
foreign import ccall "graphene_quad_get_point" graphene_quad_get_point ::
Ptr Quad ->
Word32 ->
IO (Ptr Graphene.Point.Point)
quadGetPoint ::
(B.CallStack.HasCallStack, MonadIO m) =>
Quad
-> Word32
-> m Graphene.Point.Point
quadGetPoint :: Quad -> Word32 -> m Point
quadGetPoint q :: Quad
q index_ :: Word32
index_ = IO Point -> m Point
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ do
Ptr Quad
q' <- Quad -> IO (Ptr Quad)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quad
q
Ptr Point
result <- Ptr Quad -> Word32 -> IO (Ptr Point)
graphene_quad_get_point Ptr Quad
q' Word32
index_
Text -> Ptr Point -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "quadGetPoint" Ptr Point
result
Point
result' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Point -> Point
Graphene.Point.Point) Ptr Point
result
Quad -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Quad
q
Point -> IO Point
forall (m :: * -> *) a. Monad m => a -> m a
return Point
result'
#if defined(ENABLE_OVERLOADING)
data QuadGetPointMethodInfo
instance (signature ~ (Word32 -> m Graphene.Point.Point), MonadIO m) => O.MethodInfo QuadGetPointMethodInfo Quad signature where
overloadedMethod = quadGetPoint
#endif
foreign import ccall "graphene_quad_init" graphene_quad_init ::
Ptr Quad ->
Ptr Graphene.Point.Point ->
Ptr Graphene.Point.Point ->
Ptr Graphene.Point.Point ->
Ptr Graphene.Point.Point ->
IO (Ptr Quad)
quadInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
Quad
-> Graphene.Point.Point
-> Graphene.Point.Point
-> Graphene.Point.Point
-> Graphene.Point.Point
-> m Quad
quadInit :: Quad -> Point -> Point -> Point -> Point -> m Quad
quadInit q :: Quad
q p1 :: Point
p1 p2 :: Point
p2 p3 :: Point
p3 p4 :: Point
p4 = IO Quad -> m Quad
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
Ptr Quad
q' <- Quad -> IO (Ptr Quad)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quad
q
Ptr Point
p1' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
p1
Ptr Point
p2' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
p2
Ptr Point
p3' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
p3
Ptr Point
p4' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
p4
Ptr Quad
result <- Ptr Quad
-> Ptr Point
-> Ptr Point
-> Ptr Point
-> Ptr Point
-> IO (Ptr Quad)
graphene_quad_init Ptr Quad
q' Ptr Point
p1' Ptr Point
p2' Ptr Point
p3' Ptr Point
p4'
Text -> Ptr Quad -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "quadInit" Ptr Quad
result
Quad
result' <- ((ManagedPtr Quad -> Quad) -> Ptr Quad -> IO Quad
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Quad -> Quad
Quad) Ptr Quad
result
Quad -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Quad
q
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
p1
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
p2
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
p3
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
p4
Quad -> IO Quad
forall (m :: * -> *) a. Monad m => a -> m a
return Quad
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.MethodInfo QuadInitMethodInfo Quad signature where
overloadedMethod = quadInit
#endif
foreign import ccall "graphene_quad_init_from_points" graphene_quad_init_from_points ::
Ptr Quad ->
Ptr Graphene.Point.Point ->
IO (Ptr Quad)
quadInitFromPoints ::
(B.CallStack.HasCallStack, MonadIO m) =>
Quad
-> [Graphene.Point.Point]
-> m Quad
quadInitFromPoints :: Quad -> [Point] -> m Quad
quadInitFromPoints q :: Quad
q points :: [Point]
points = IO Quad -> m Quad
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
Ptr Quad
q' <- Quad -> IO (Ptr Quad)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quad
q
[Ptr Point]
points' <- (Point -> IO (Ptr Point)) -> [Point] -> IO [Ptr Point]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [Point]
points
Ptr Point
points'' <- Int -> [Ptr Point] -> IO (Ptr Point)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray 8 [Ptr Point]
points'
Ptr Quad
result <- Ptr Quad -> Ptr Point -> IO (Ptr Quad)
graphene_quad_init_from_points Ptr Quad
q' Ptr Point
points''
Text -> Ptr Quad -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "quadInitFromPoints" Ptr Quad
result
Quad
result' <- ((ManagedPtr Quad -> Quad) -> Ptr Quad -> IO Quad
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Quad -> Quad
Quad) Ptr Quad
result
Quad -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Quad
q
(Point -> IO ()) -> [Point] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [Point]
points
Ptr Point -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Point
points''
Quad -> IO Quad
forall (m :: * -> *) a. Monad m => a -> m a
return Quad
result'
#if defined(ENABLE_OVERLOADING)
data QuadInitFromPointsMethodInfo
instance (signature ~ ([Graphene.Point.Point] -> m Quad), MonadIO m) => O.MethodInfo QuadInitFromPointsMethodInfo Quad signature where
overloadedMethod = quadInitFromPoints
#endif
foreign import ccall "graphene_quad_init_from_rect" graphene_quad_init_from_rect ::
Ptr Quad ->
Ptr Graphene.Rect.Rect ->
IO (Ptr Quad)
quadInitFromRect ::
(B.CallStack.HasCallStack, MonadIO m) =>
Quad
-> Graphene.Rect.Rect
-> m Quad
quadInitFromRect :: Quad -> Rect -> m Quad
quadInitFromRect q :: Quad
q r :: Rect
r = IO Quad -> m Quad
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
Ptr Quad
q' <- Quad -> IO (Ptr Quad)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quad
q
Ptr Rect
r' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
r
Ptr Quad
result <- Ptr Quad -> Ptr Rect -> IO (Ptr Quad)
graphene_quad_init_from_rect Ptr Quad
q' Ptr Rect
r'
Text -> Ptr Quad -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "quadInitFromRect" Ptr Quad
result
Quad
result' <- ((ManagedPtr Quad -> Quad) -> Ptr Quad -> IO Quad
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Quad -> Quad
Quad) Ptr Quad
result
Quad -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Quad
q
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
r
Quad -> IO Quad
forall (m :: * -> *) a. Monad m => a -> m a
return Quad
result'
#if defined(ENABLE_OVERLOADING)
data QuadInitFromRectMethodInfo
instance (signature ~ (Graphene.Rect.Rect -> m Quad), MonadIO m) => O.MethodInfo QuadInitFromRectMethodInfo Quad signature where
overloadedMethod = quadInitFromRect
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveQuadMethod (t :: Symbol) (o :: *) :: * 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.MethodInfo 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
#endif