{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a point on a path.
-- 
-- It can be queried for properties of the path at that point,
-- such as its tangent or its curvature.
-- 
-- To obtain a @GskPathPoint@, use 'GI.Gsk.Structs.Path.pathGetClosestPoint',
-- 'GI.Gsk.Structs.Path.pathGetStartPoint', 'GI.Gsk.Structs.Path.pathGetEndPoint'
-- or 'GI.Gsk.Structs.PathMeasure.pathMeasureGetPoint'.
-- 
-- Note that @GskPathPoint@ structs are meant to be stack-allocated,
-- and don\'t hold a reference to the path object they are obtained from.
-- It is the callers responsibility to keep a reference to the path
-- as long as the @GskPathPoint@ is used.
-- 
-- /Since: 4.14/

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

module GI.Gsk.Structs.PathPoint
    ( 

-- * Exported types
    PathPoint(..)                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [compare]("GI.Gsk.Structs.PathPoint#g:method:compare"), [copy]("GI.Gsk.Structs.PathPoint#g:method:copy"), [equal]("GI.Gsk.Structs.PathPoint#g:method:equal"), [free]("GI.Gsk.Structs.PathPoint#g:method:free").
-- 
-- ==== Getters
-- [getCurvature]("GI.Gsk.Structs.PathPoint#g:method:getCurvature"), [getDistance]("GI.Gsk.Structs.PathPoint#g:method:getDistance"), [getPosition]("GI.Gsk.Structs.PathPoint#g:method:getPosition"), [getRotation]("GI.Gsk.Structs.PathPoint#g:method:getRotation"), [getTangent]("GI.Gsk.Structs.PathPoint#g:method:getTangent").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolvePathPointMethod                  ,
#endif

-- ** compare #method:compare#

#if defined(ENABLE_OVERLOADING)
    PathPointCompareMethodInfo              ,
#endif
    pathPointCompare                        ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    PathPointCopyMethodInfo                 ,
#endif
    pathPointCopy                           ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    PathPointEqualMethodInfo                ,
#endif
    pathPointEqual                          ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    PathPointFreeMethodInfo                 ,
#endif
    pathPointFree                           ,


-- ** getCurvature #method:getCurvature#

#if defined(ENABLE_OVERLOADING)
    PathPointGetCurvatureMethodInfo         ,
#endif
    pathPointGetCurvature                   ,


-- ** getDistance #method:getDistance#

#if defined(ENABLE_OVERLOADING)
    PathPointGetDistanceMethodInfo          ,
#endif
    pathPointGetDistance                    ,


-- ** getPosition #method:getPosition#

#if defined(ENABLE_OVERLOADING)
    PathPointGetPositionMethodInfo          ,
#endif
    pathPointGetPosition                    ,


-- ** getRotation #method:getRotation#

#if defined(ENABLE_OVERLOADING)
    PathPointGetRotationMethodInfo          ,
#endif
    pathPointGetRotation                    ,


-- ** getTangent #method:getTangent#

#if defined(ENABLE_OVERLOADING)
    PathPointGetTangentMethodInfo           ,
#endif
    pathPointGetTangent                     ,




    ) 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 qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import qualified GI.Graphene.Structs.Vec2 as Graphene.Vec2
import qualified GI.Gsk.Callbacks as Gsk.Callbacks
import {-# SOURCE #-} qualified GI.Gsk.Enums as Gsk.Enums
import {-# SOURCE #-} qualified GI.Gsk.Flags as Gsk.Flags
import {-# SOURCE #-} qualified GI.Gsk.Structs.Path as Gsk.Path
import {-# SOURCE #-} qualified GI.Gsk.Structs.PathMeasure as Gsk.PathMeasure
import {-# SOURCE #-} qualified GI.Gsk.Structs.Stroke as Gsk.Stroke

#else
import qualified GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Vec2 as Graphene.Vec2
import {-# SOURCE #-} qualified GI.Gsk.Enums as Gsk.Enums
import {-# SOURCE #-} qualified GI.Gsk.Structs.Path as Gsk.Path
import {-# SOURCE #-} qualified GI.Gsk.Structs.PathMeasure as Gsk.PathMeasure

#endif

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

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

foreign import ccall "gsk_path_point_get_type" c_gsk_path_point_get_type :: 
    IO GType

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

instance B.Types.TypedObject PathPoint where
    glibType :: IO GType
glibType = IO GType
c_gsk_path_point_get_type

instance B.Types.GBoxed PathPoint

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


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

-- method PathPoint::compare
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "point1"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path point" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point2"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "another path point" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_path_point_compare" gsk_path_point_compare :: 
    Ptr PathPoint ->                        -- point1 : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    Ptr PathPoint ->                        -- point2 : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    IO Int32

-- | Returns whether /@point1@/ is before or after /@point2@/.
-- 
-- /Since: 4.14/
pathPointCompare ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathPoint
    -- ^ /@point1@/: a path point
    -> PathPoint
    -- ^ /@point2@/: another path point
    -> m Int32
    -- ^ __Returns:__ -1 if /@point1@/ is before /@point2@/,
    --   1 if /@point1@/ is after /@point2@/,
    --   0 if they are equal
pathPointCompare :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathPoint -> PathPoint -> m Int32
pathPointCompare PathPoint
point1 PathPoint
point2 = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    point1' <- PathPoint -> IO (Ptr PathPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathPoint
point1
    point2' <- unsafeManagedPtrGetPtr point2
    result <- gsk_path_point_compare point1' point2'
    touchManagedPtr point1
    touchManagedPtr point2
    return result

#if defined(ENABLE_OVERLOADING)
data PathPointCompareMethodInfo
instance (signature ~ (PathPoint -> m Int32), MonadIO m) => O.OverloadedMethod PathPointCompareMethodInfo PathPoint signature where
    overloadedMethod = pathPointCompare

instance O.OverloadedMethodInfo PathPointCompareMethodInfo PathPoint where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.PathPoint.pathPointCompare",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-PathPoint.html#v:pathPointCompare"
        })


#endif

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

foreign import ccall "gsk_path_point_copy" gsk_path_point_copy :: 
    Ptr PathPoint ->                        -- point : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    IO (Ptr PathPoint)

-- | Copies a path point.
-- 
-- /Since: 4.14/
pathPointCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathPoint
    -- ^ /@point@/: a path point
    -> m PathPoint
    -- ^ __Returns:__ the copied point
pathPointCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathPoint -> m PathPoint
pathPointCopy PathPoint
point = IO PathPoint -> m PathPoint
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PathPoint -> m PathPoint) -> IO PathPoint -> m PathPoint
forall a b. (a -> b) -> a -> b
$ do
    point' <- PathPoint -> IO (Ptr PathPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathPoint
point
    result <- gsk_path_point_copy point'
    checkUnexpectedReturnNULL "pathPointCopy" result
    result' <- (wrapBoxed PathPoint) result
    touchManagedPtr point
    return result'

#if defined(ENABLE_OVERLOADING)
data PathPointCopyMethodInfo
instance (signature ~ (m PathPoint), MonadIO m) => O.OverloadedMethod PathPointCopyMethodInfo PathPoint signature where
    overloadedMethod = pathPointCopy

instance O.OverloadedMethodInfo PathPointCopyMethodInfo PathPoint where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.PathPoint.pathPointCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-PathPoint.html#v:pathPointCopy"
        })


#endif

-- method PathPoint::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "point1"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path point" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point2"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "another path point" , 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 "gsk_path_point_equal" gsk_path_point_equal :: 
    Ptr PathPoint ->                        -- point1 : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    Ptr PathPoint ->                        -- point2 : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    IO CInt

-- | Returns whether the two path points refer to the same
-- location on all paths.
-- 
-- Note that the start- and endpoint of a closed contour
-- will compare nonequal according to this definition.
-- Use 'GI.Gsk.Structs.Path.pathIsClosed' to find out if the
-- start- and endpoint of a concrete path refer to the
-- same location.
-- 
-- /Since: 4.14/
pathPointEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathPoint
    -- ^ /@point1@/: a path point
    -> PathPoint
    -- ^ /@point2@/: another path point
    -> m Bool
    -- ^ __Returns:__ true if /@point1@/ and /@point2@/ are equal
pathPointEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathPoint -> PathPoint -> m Bool
pathPointEqual PathPoint
point1 PathPoint
point2 = 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
    point1' <- PathPoint -> IO (Ptr PathPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathPoint
point1
    point2' <- unsafeManagedPtrGetPtr point2
    result <- gsk_path_point_equal point1' point2'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr point1
    touchManagedPtr point2
    return result'

#if defined(ENABLE_OVERLOADING)
data PathPointEqualMethodInfo
instance (signature ~ (PathPoint -> m Bool), MonadIO m) => O.OverloadedMethod PathPointEqualMethodInfo PathPoint signature where
    overloadedMethod = pathPointEqual

instance O.OverloadedMethodInfo PathPointEqualMethodInfo PathPoint where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.PathPoint.pathPointEqual",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-PathPoint.html#v:pathPointEqual"
        })


#endif

-- method PathPoint::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path point" , 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 "gsk_path_point_free" gsk_path_point_free :: 
    Ptr PathPoint ->                        -- point : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    IO ()

-- | Frees a path point copied by 'GI.Gsk.Structs.PathPoint.pathPointCopy'.
-- 
-- /Since: 4.14/
pathPointFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathPoint
    -- ^ /@point@/: a path point
    -> m ()
pathPointFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathPoint -> m ()
pathPointFree PathPoint
point = 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
    point' <- PathPoint -> IO (Ptr PathPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathPoint
point
    gsk_path_point_free point'
    touchManagedPtr point
    return ()

#if defined(ENABLE_OVERLOADING)
data PathPointFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod PathPointFreeMethodInfo PathPoint signature where
    overloadedMethod = pathPointFree

instance O.OverloadedMethodInfo PathPointFreeMethodInfo PathPoint where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.PathPoint.pathPointFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-PathPoint.html#v:pathPointFree"
        })


#endif

-- method PathPoint::get_curvature
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path point" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path that @point is on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "direction"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathDirection" }
--           , argCType = Just "GskPathDirection"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the direction for which to return the curvature"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "center"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "graphene_point_t*"
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for\n  the center of the osculating circle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_path_point_get_curvature" gsk_path_point_get_curvature :: 
    Ptr PathPoint ->                        -- point : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    Ptr Gsk.Path.Path ->                    -- path : TInterface (Name {namespace = "Gsk", name = "Path"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Gsk", name = "PathDirection"})
    Ptr Graphene.Point.Point ->             -- center : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO CFloat

-- | Calculates the curvature of the path at the point.
-- 
-- Optionally, returns the center of the osculating circle as well.
-- The curvature is the inverse of the radius of the osculating circle.
-- 
-- Lines have a curvature of zero (indicating an osculating circle of
-- infinite radius). In this case, the /@center@/ is not modified.
-- 
-- Circles with a radius of zero have @INFINITY@ as curvature
-- 
-- Note that certain points on a path may not have a single curvature,
-- such as sharp turns. At such points, there are two curvatures — the
-- (limit of) the curvature of the path going into the point, and the
-- (limit of) the curvature of the path coming out of it. The /@direction@/
-- argument lets you choose which one to get.
-- 
-- \<picture>
--   \<source srcset=\"curvature-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img alt=\"Osculating circle\" src=\"curvature-light.png\">
-- \<\/picture>
-- 
-- /Since: 4.14/
pathPointGetCurvature ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathPoint
    -- ^ /@point@/: a path point
    -> Gsk.Path.Path
    -- ^ /@path@/: the path that /@point@/ is on
    -> Gsk.Enums.PathDirection
    -- ^ /@direction@/: the direction for which to return the curvature
    -> m ((Float, Maybe Graphene.Point.Point))
    -- ^ __Returns:__ the curvature of the path at the given point
pathPointGetCurvature :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathPoint -> Path -> PathDirection -> m (Float, Maybe Point)
pathPointGetCurvature PathPoint
point Path
path PathDirection
direction = IO (Float, Maybe Point) -> m (Float, Maybe Point)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Maybe Point) -> m (Float, Maybe Point))
-> IO (Float, Maybe Point) -> m (Float, Maybe Point)
forall a b. (a -> b) -> a -> b
$ do
    point' <- PathPoint -> IO (Ptr PathPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathPoint
point
    path' <- unsafeManagedPtrGetPtr path
    let direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PathDirection -> Int) -> PathDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathDirection -> Int
forall a. Enum a => a -> Int
fromEnum) PathDirection
direction
    center <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    result <- gsk_path_point_get_curvature point' path' direction' center
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    maybeCenter <- convertIfNonNull center $ \Ptr Point
center' -> do
        center'' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Point -> Point
Graphene.Point.Point) Ptr Point
center'
        return center''
    touchManagedPtr point
    touchManagedPtr path
    return (result', maybeCenter)

#if defined(ENABLE_OVERLOADING)
data PathPointGetCurvatureMethodInfo
instance (signature ~ (Gsk.Path.Path -> Gsk.Enums.PathDirection -> m ((Float, Maybe Graphene.Point.Point))), MonadIO m) => O.OverloadedMethod PathPointGetCurvatureMethodInfo PathPoint signature where
    overloadedMethod = pathPointGetCurvature

instance O.OverloadedMethodInfo PathPointGetCurvatureMethodInfo PathPoint where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.PathPoint.pathPointGetCurvature",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-PathPoint.html#v:pathPointGetCurvature"
        })


#endif

-- method PathPoint::get_distance
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a point on the path"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "measure"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathMeasure" }
--           , argCType = Just "GskPathMeasure*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path measure for the path"
--                 , 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 "gsk_path_point_get_distance" gsk_path_point_get_distance :: 
    Ptr PathPoint ->                        -- point : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    Ptr Gsk.PathMeasure.PathMeasure ->      -- measure : TInterface (Name {namespace = "Gsk", name = "PathMeasure"})
    IO CFloat

-- | Returns the distance from the beginning of the path
-- to the point.
-- 
-- /Since: 4.14/
pathPointGetDistance ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathPoint
    -- ^ /@point@/: a point on the path
    -> Gsk.PathMeasure.PathMeasure
    -- ^ /@measure@/: a path measure for the path
    -> m Float
    -- ^ __Returns:__ the distance of /@point@/
pathPointGetDistance :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathPoint -> PathMeasure -> m Float
pathPointGetDistance PathPoint
point PathMeasure
measure = 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
    point' <- PathPoint -> IO (Ptr PathPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathPoint
point
    measure' <- unsafeManagedPtrGetPtr measure
    result <- gsk_path_point_get_distance point' measure'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr point
    touchManagedPtr measure
    return result'

#if defined(ENABLE_OVERLOADING)
data PathPointGetDistanceMethodInfo
instance (signature ~ (Gsk.PathMeasure.PathMeasure -> m Float), MonadIO m) => O.OverloadedMethod PathPointGetDistanceMethodInfo PathPoint signature where
    overloadedMethod = pathPointGetDistance

instance O.OverloadedMethodInfo PathPointGetDistanceMethodInfo PathPoint where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.PathPoint.pathPointGetDistance",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-PathPoint.html#v:pathPointGetDistance"
        })


#endif

-- method PathPoint::get_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path point" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path that @point is on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "graphene_point_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Return location for\n  the coordinates of the point"
--                 , 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 "gsk_path_point_get_position" gsk_path_point_get_position :: 
    Ptr PathPoint ->                        -- point : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    Ptr Gsk.Path.Path ->                    -- path : TInterface (Name {namespace = "Gsk", name = "Path"})
    Ptr Graphene.Point.Point ->             -- position : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO ()

-- | Gets the position of the point.
-- 
-- /Since: 4.14/
pathPointGetPosition ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathPoint
    -- ^ /@point@/: a path point
    -> Gsk.Path.Path
    -- ^ /@path@/: the path that /@point@/ is on
    -> m (Graphene.Point.Point)
pathPointGetPosition :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathPoint -> Path -> m Point
pathPointGetPosition PathPoint
point Path
path = 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
    point' <- PathPoint -> IO (Ptr PathPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathPoint
point
    path' <- unsafeManagedPtrGetPtr path
    position <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    gsk_path_point_get_position point' path' position
    position' <- (wrapBoxed Graphene.Point.Point) position
    touchManagedPtr point
    touchManagedPtr path
    return position'

#if defined(ENABLE_OVERLOADING)
data PathPointGetPositionMethodInfo
instance (signature ~ (Gsk.Path.Path -> m (Graphene.Point.Point)), MonadIO m) => O.OverloadedMethod PathPointGetPositionMethodInfo PathPoint signature where
    overloadedMethod = pathPointGetPosition

instance O.OverloadedMethodInfo PathPointGetPositionMethodInfo PathPoint where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.PathPoint.pathPointGetPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-PathPoint.html#v:pathPointGetPosition"
        })


#endif

-- method PathPoint::get_rotation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path point" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path that @point is on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "direction"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathDirection" }
--           , argCType = Just "GskPathDirection"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the direction for which to return the rotation"
--                 , 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 "gsk_path_point_get_rotation" gsk_path_point_get_rotation :: 
    Ptr PathPoint ->                        -- point : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    Ptr Gsk.Path.Path ->                    -- path : TInterface (Name {namespace = "Gsk", name = "Path"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Gsk", name = "PathDirection"})
    IO CFloat

-- | Gets the direction of the tangent at a given point.
-- 
-- This is a convenience variant of 'GI.Gsk.Structs.PathPoint.pathPointGetTangent'
-- that returns the angle between the tangent and the X axis. The angle
-- can e.g. be used in
-- <http://developer.gnome.org/gsk/stable/../gtk4/method.Snapshot.rotate.html gtk_snapshot_rotate()>.
-- 
-- /Since: 4.14/
pathPointGetRotation ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathPoint
    -- ^ /@point@/: a path point
    -> Gsk.Path.Path
    -- ^ /@path@/: the path that /@point@/ is on
    -> Gsk.Enums.PathDirection
    -- ^ /@direction@/: the direction for which to return the rotation
    -> m Float
    -- ^ __Returns:__ the angle between the tangent and the X axis, in degrees
pathPointGetRotation :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathPoint -> Path -> PathDirection -> m Float
pathPointGetRotation PathPoint
point Path
path PathDirection
direction = 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
    point' <- PathPoint -> IO (Ptr PathPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathPoint
point
    path' <- unsafeManagedPtrGetPtr path
    let direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PathDirection -> Int) -> PathDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathDirection -> Int
forall a. Enum a => a -> Int
fromEnum) PathDirection
direction
    result <- gsk_path_point_get_rotation point' path' direction'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr point
    touchManagedPtr path
    return result'

#if defined(ENABLE_OVERLOADING)
data PathPointGetRotationMethodInfo
instance (signature ~ (Gsk.Path.Path -> Gsk.Enums.PathDirection -> m Float), MonadIO m) => O.OverloadedMethod PathPointGetRotationMethodInfo PathPoint signature where
    overloadedMethod = pathPointGetRotation

instance O.OverloadedMethodInfo PathPointGetRotationMethodInfo PathPoint where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.PathPoint.pathPointGetRotation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-PathPoint.html#v:pathPointGetRotation"
        })


#endif

-- method PathPoint::get_tangent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path point" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path that @point is on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "direction"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathDirection" }
--           , argCType = Just "GskPathDirection"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the direction for which to return the tangent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tangent"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec2" }
--           , argCType = Just "graphene_vec2_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Return location for\n  the tangent at the point"
--                 , 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 "gsk_path_point_get_tangent" gsk_path_point_get_tangent :: 
    Ptr PathPoint ->                        -- point : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    Ptr Gsk.Path.Path ->                    -- path : TInterface (Name {namespace = "Gsk", name = "Path"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Gsk", name = "PathDirection"})
    Ptr Graphene.Vec2.Vec2 ->               -- tangent : TInterface (Name {namespace = "Graphene", name = "Vec2"})
    IO ()

-- | Gets the tangent of the path at the point.
-- 
-- Note that certain points on a path may not have a single
-- tangent, such as sharp turns. At such points, there are
-- two tangents — the direction of the path going into the
-- point, and the direction coming out of it. The /@direction@/
-- argument lets you choose which one to get.
-- 
-- If the path is just a single point (e.g. a circle with
-- radius zero), then the tangent is set to @0, 0@.
-- 
-- If you want to orient something in the direction of the
-- path, 'GI.Gsk.Structs.PathPoint.pathPointGetRotation' may be more
-- convenient to use.
-- 
-- /Since: 4.14/
pathPointGetTangent ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathPoint
    -- ^ /@point@/: a path point
    -> Gsk.Path.Path
    -- ^ /@path@/: the path that /@point@/ is on
    -> Gsk.Enums.PathDirection
    -- ^ /@direction@/: the direction for which to return the tangent
    -> m (Graphene.Vec2.Vec2)
pathPointGetTangent :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathPoint -> Path -> PathDirection -> m Vec2
pathPointGetTangent PathPoint
point Path
path PathDirection
direction = IO Vec2 -> m Vec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
forall a b. (a -> b) -> a -> b
$ do
    point' <- PathPoint -> IO (Ptr PathPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathPoint
point
    path' <- unsafeManagedPtrGetPtr path
    let direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PathDirection -> Int) -> PathDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathDirection -> Int
forall a. Enum a => a -> Int
fromEnum) PathDirection
direction
    tangent <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec2.Vec2)
    gsk_path_point_get_tangent point' path' direction' tangent
    tangent' <- (wrapBoxed Graphene.Vec2.Vec2) tangent
    touchManagedPtr point
    touchManagedPtr path
    return tangent'

#if defined(ENABLE_OVERLOADING)
data PathPointGetTangentMethodInfo
instance (signature ~ (Gsk.Path.Path -> Gsk.Enums.PathDirection -> m (Graphene.Vec2.Vec2)), MonadIO m) => O.OverloadedMethod PathPointGetTangentMethodInfo PathPoint signature where
    overloadedMethod = pathPointGetTangent

instance O.OverloadedMethodInfo PathPointGetTangentMethodInfo PathPoint where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.PathPoint.pathPointGetTangent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-PathPoint.html#v:pathPointGetTangent"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolvePathPointMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolvePathPointMethod "compare" o = PathPointCompareMethodInfo
    ResolvePathPointMethod "copy" o = PathPointCopyMethodInfo
    ResolvePathPointMethod "equal" o = PathPointEqualMethodInfo
    ResolvePathPointMethod "free" o = PathPointFreeMethodInfo
    ResolvePathPointMethod "getCurvature" o = PathPointGetCurvatureMethodInfo
    ResolvePathPointMethod "getDistance" o = PathPointGetDistanceMethodInfo
    ResolvePathPointMethod "getPosition" o = PathPointGetPositionMethodInfo
    ResolvePathPointMethod "getRotation" o = PathPointGetRotationMethodInfo
    ResolvePathPointMethod "getTangent" o = PathPointGetTangentMethodInfo
    ResolvePathPointMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif