{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Describes lines and curves that are more complex than simple rectangles.
-- 
-- Paths can used for rendering (filling or stroking) and for animations
-- (e.g. as trajectories).
-- 
-- @GskPath@ is an immutable, opaque, reference-counted struct.
-- After creation, you cannot change the types it represents. Instead,
-- new @GskPath@ objects have to be created. The t'GI.Gsk.Structs.PathBuilder.PathBuilder'
-- structure is meant to help in this endeavor.
-- 
-- Conceptually, a path consists of zero or more contours (continuous, connected
-- curves), each of which may or may not be closed. Contours are typically
-- constructed from Bézier segments.
-- 
-- \<picture>
--   \<source srcset=\"path-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img alt=\"A Path\" src=\"path-light.png\">
-- \<\/picture>
-- 
-- /Since: 4.14/

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

module GI.Gsk.Structs.Path
    ( 

-- * Exported types
    Path(..)                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [equal]("GI.Gsk.Structs.Path#g:method:equal"), [foreach]("GI.Gsk.Structs.Path#g:method:foreach"), [foreachIntersection]("GI.Gsk.Structs.Path#g:method:foreachIntersection"), [inFill]("GI.Gsk.Structs.Path#g:method:inFill"), [isClosed]("GI.Gsk.Structs.Path#g:method:isClosed"), [isEmpty]("GI.Gsk.Structs.Path#g:method:isEmpty"), [print]("GI.Gsk.Structs.Path#g:method:print"), [ref]("GI.Gsk.Structs.Path#g:method:ref"), [toCairo]("GI.Gsk.Structs.Path#g:method:toCairo"), [toString]("GI.Gsk.Structs.Path#g:method:toString"), [unref]("GI.Gsk.Structs.Path#g:method:unref").
-- 
-- ==== Getters
-- [getBounds]("GI.Gsk.Structs.Path#g:method:getBounds"), [getStrokeBounds]("GI.Gsk.Structs.Path#g:method:getStrokeBounds"), [getTightBounds]("GI.Gsk.Structs.Path#g:method:getTightBounds").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolvePathMethod                       ,
#endif

-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    PathEqualMethodInfo                     ,
#endif
    pathEqual                               ,


-- ** foreach #method:foreach#

#if defined(ENABLE_OVERLOADING)
    PathForeachMethodInfo                   ,
#endif
    pathForeach                             ,


-- ** foreachIntersection #method:foreachIntersection#

#if defined(ENABLE_OVERLOADING)
    PathForeachIntersectionMethodInfo       ,
#endif
    pathForeachIntersection                 ,


-- ** getBounds #method:getBounds#

#if defined(ENABLE_OVERLOADING)
    PathGetBoundsMethodInfo                 ,
#endif
    pathGetBounds                           ,


-- ** getStrokeBounds #method:getStrokeBounds#

#if defined(ENABLE_OVERLOADING)
    PathGetStrokeBoundsMethodInfo           ,
#endif
    pathGetStrokeBounds                     ,


-- ** getTightBounds #method:getTightBounds#

#if defined(ENABLE_OVERLOADING)
    PathGetTightBoundsMethodInfo            ,
#endif
    pathGetTightBounds                      ,


-- ** inFill #method:inFill#

#if defined(ENABLE_OVERLOADING)
    PathInFillMethodInfo                    ,
#endif
    pathInFill                              ,


-- ** isClosed #method:isClosed#

#if defined(ENABLE_OVERLOADING)
    PathIsClosedMethodInfo                  ,
#endif
    pathIsClosed                            ,


-- ** isEmpty #method:isEmpty#

#if defined(ENABLE_OVERLOADING)
    PathIsEmptyMethodInfo                   ,
#endif
    pathIsEmpty                             ,


-- ** parse #method:parse#

    pathParse                               ,


-- ** print #method:print#

#if defined(ENABLE_OVERLOADING)
    PathPrintMethodInfo                     ,
#endif
    pathPrint                               ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    PathRefMethodInfo                       ,
#endif
    pathRef                                 ,


-- ** toCairo #method:toCairo#

#if defined(ENABLE_OVERLOADING)
    PathToCairoMethodInfo                   ,
#endif
    pathToCairo                             ,


-- ** toString #method:toString#

#if defined(ENABLE_OVERLOADING)
    PathToStringMethodInfo                  ,
#endif
    pathToString                            ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    PathUnrefMethodInfo                     ,
#endif
    pathUnref                               ,




    ) 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.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.Stroke as Gsk.Stroke

#else
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.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.Stroke as Gsk.Stroke

#endif

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

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

foreign import ccall "gsk_path_get_type" c_gsk_path_get_type :: 
    IO GType

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

instance B.Types.TypedObject Path where
    glibType :: IO GType
glibType = IO GType
c_gsk_path_get_type

instance B.Types.GBoxed Path

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


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

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

-- | Returns whether two paths have identical structure.
-- 
-- Note that it is possible to construct paths that render
-- identical even though they don\'t have the same structure.
-- 
-- /Since: 4.22/
pathEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@path1@/: a path
    -> Path
    -- ^ /@path2@/: another path
    -> m Bool
    -- ^ __Returns:__ true if /@path1@/ and /@path2@/ have identical structure
pathEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Path -> Path -> m Bool
pathEqual Path
path1 Path
path2 = 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
    path1' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
path1
    path2' <- unsafeManagedPtrGetPtr path2
    result <- gsk_path_equal path1' path2'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr path1
    touchManagedPtr path2
    return result'

#if defined(ENABLE_OVERLOADING)
data PathEqualMethodInfo
instance (signature ~ (Path -> m Bool), MonadIO m) => O.OverloadedMethod PathEqualMethodInfo Path signature where
    overloadedMethod = pathEqual

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


#endif

-- method Path::foreach
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathForeachFlags" }
--           , argCType = Just "GskPathForeachFlags"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags to pass to the foreach function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathForeachFunc" }
--           , argCType = Just "GskPathForeachFunc"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the function to call for operations"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , argCType = Just "gpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data passed to @func"
--                 , 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_foreach" gsk_path_foreach :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gsk", name = "PathForeachFlags"})
    FunPtr Gsk.Callbacks.C_PathForeachFunc -> -- func : TInterface (Name {namespace = "Gsk", name = "PathForeachFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO CInt

-- | Calls /@func@/ for every operation of the path.
-- 
-- Note that this may only approximate /@self@/, because paths can contain
-- optimizations for various specialized contours, and depending on the
-- /@flags@/, the path may be decomposed into simpler curves than the ones
-- that it contained originally.
-- 
-- This function serves two purposes:
-- 
-- * When the /@flags@/ allow everything, it provides access to the raw,
--   unmodified data of the path.
-- * When the /@flags@/ disallow certain operations, it provides
--   an approximation of the path using just the allowed operations.
-- 
-- 
-- /Since: 4.14/
pathForeach ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> [Gsk.Flags.PathForeachFlags]
    -- ^ /@flags@/: flags to pass to the foreach function
    -> Gsk.Callbacks.PathForeachFunc
    -- ^ /@func@/: the function to call for operations
    -> m Bool
    -- ^ __Returns:__ false if /@func@/ returned false, true otherwise.
pathForeach :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Path -> [PathForeachFlags] -> PathForeachFunc -> m Bool
pathForeach Path
self [PathForeachFlags]
flags PathForeachFunc
func = 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
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    let flags' = [PathForeachFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PathForeachFlags]
flags
    func' <- Gsk.Callbacks.mk_PathForeachFunc (Gsk.Callbacks.wrap_PathForeachFunc Nothing (Gsk.Callbacks.drop_closures_PathForeachFunc func))
    let userData = Ptr a
forall a. Ptr a
nullPtr
    result <- gsk_path_foreach self' flags' func' userData
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    safeFreeFunPtr $ castFunPtrToPtr func'
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data PathForeachMethodInfo
instance (signature ~ ([Gsk.Flags.PathForeachFlags] -> Gsk.Callbacks.PathForeachFunc -> m Bool), MonadIO m) => O.OverloadedMethod PathForeachMethodInfo Path signature where
    overloadedMethod = pathForeach

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


#endif

-- method Path::foreach_intersection
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "path1"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the first path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path2"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the second path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface
--                 Name { namespace = "Gsk" , name = "PathIntersectionFunc" }
--           , argCType = Just "GskPathIntersectionFunc"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the function to call for intersections"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , argCType = Just "gpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data passed to @func"
--                 , 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_foreach_intersection" gsk_path_foreach_intersection :: 
    Ptr Path ->                             -- path1 : TInterface (Name {namespace = "Gsk", name = "Path"})
    Ptr Path ->                             -- path2 : TInterface (Name {namespace = "Gsk", name = "Path"})
    FunPtr Gsk.Callbacks.C_PathIntersectionFunc -> -- func : TInterface (Name {namespace = "Gsk", name = "PathIntersectionFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO CInt

-- | Finds intersections between two paths.
-- 
-- This function finds intersections between /@path1@/ and /@path2@/,
-- and calls /@func@/ for each of them, in increasing order for /@path1@/.
-- 
-- If /@path2@/ is not provided or equal to /@path1@/, the function finds
-- non-trivial self-intersections of /@path1@/.
-- 
-- When segments of the paths coincide, the callback is called once
-- for the start of the segment, with /@gSKPATHINTERSECTIONSTART@/, and
-- once for the end of the segment, with /@gSKPATHINTERSECTIONEND@/.
-- Note that other intersections may occur between the start and end
-- of such a segment.
-- 
-- If /@func@/ returns @FALSE@, the iteration is stopped.
-- 
-- /Since: 4.20/
pathForeachIntersection ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@path1@/: the first path
    -> Maybe (Path)
    -- ^ /@path2@/: the second path
    -> Gsk.Callbacks.PathIntersectionFunc
    -- ^ /@func@/: the function to call for intersections
    -> m Bool
    -- ^ __Returns:__ @FALSE@ if /@func@/ returned FALSE@, @TRUE\` otherwise.
pathForeachIntersection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Path -> Maybe Path -> PathIntersectionFunc -> m Bool
pathForeachIntersection Path
path1 Maybe Path
path2 PathIntersectionFunc
func = 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
    path1' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
path1
    maybePath2 <- case path2 of
        Maybe Path
Nothing -> Ptr Path -> IO (Ptr Path)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Path
forall a. Ptr a
FP.nullPtr
        Just Path
jPath2 -> do
            jPath2' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
jPath2
            return jPath2'
    func' <- Gsk.Callbacks.mk_PathIntersectionFunc (Gsk.Callbacks.wrap_PathIntersectionFunc Nothing (Gsk.Callbacks.drop_closures_PathIntersectionFunc func))
    let userData = Ptr a
forall a. Ptr a
nullPtr
    result <- gsk_path_foreach_intersection path1' maybePath2 func' userData
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    safeFreeFunPtr $ castFunPtrToPtr func'
    touchManagedPtr path1
    whenJust path2 touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING)
data PathForeachIntersectionMethodInfo
instance (signature ~ (Maybe (Path) -> Gsk.Callbacks.PathIntersectionFunc -> m Bool), MonadIO m) => O.OverloadedMethod PathForeachIntersectionMethodInfo Path signature where
    overloadedMethod = pathForeachIntersection

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


#endif

-- method Path::get_bounds
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the bounds"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_path_get_bounds" gsk_path_get_bounds :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CInt

-- | Computes the bounds of the given path.
-- 
-- The returned bounds may be larger than necessary, because this
-- function aims to be fast, not accurate. The bounds are guaranteed
-- to contain the path. For accurate bounds, use
-- 'GI.Gsk.Structs.Path.pathGetTightBounds'.
-- 
-- It is possible that the returned rectangle has 0 width and\/or height.
-- This can happen when the path only describes a point or an
-- axis-aligned line.
-- 
-- If the path is empty, false is returned and /@bounds@/ are set to
-- 'GI.Graphene.Functions.rectZero'. This is different from the case where the path
-- is a single point at the origin, where the /@bounds@/ will also be set to
-- the zero rectangle but true will be returned.
-- 
-- /Since: 4.14/
pathGetBounds ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> m ((Bool, Graphene.Rect.Rect))
    -- ^ __Returns:__ true if the path has bounds, false if the path is known
    --   to be empty and have no bounds
pathGetBounds :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Path -> m (Bool, Rect)
pathGetBounds Path
self = IO (Bool, Rect) -> m (Bool, Rect)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Rect) -> m (Bool, Rect))
-> IO (Bool, Rect) -> m (Bool, Rect)
forall a b. (a -> b) -> a -> b
$ do
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    bounds <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
    result <- gsk_path_get_bounds self' bounds
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    bounds' <- (wrapBoxed Graphene.Rect.Rect) bounds
    touchManagedPtr self
    return (result', bounds')

#if defined(ENABLE_OVERLOADING)
data PathGetBoundsMethodInfo
instance (signature ~ (m ((Bool, Graphene.Rect.Rect))), MonadIO m) => O.OverloadedMethod PathGetBoundsMethodInfo Path signature where
    overloadedMethod = pathGetBounds

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


#endif

-- XXX Could not generate method Path::get_closest_point
-- Not implemented: Don't know how to allocate "result" of type TInterface (Name {namespace = "Gsk", name = "PathPoint"})
-- XXX Could not generate method Path::get_end_point
-- Not implemented: Don't know how to allocate "result" of type TInterface (Name {namespace = "Gsk", name = "PathPoint"})
-- XXX Could not generate method Path::get_next
-- Bad introspection data: C type for argument ‘point’ is not a pointer to a pointer
-- XXX Could not generate method Path::get_previous
-- Bad introspection data: C type for argument ‘point’ is not a pointer to a pointer
-- XXX Could not generate method Path::get_start_point
-- Not implemented: Don't know how to allocate "result" of type TInterface (Name {namespace = "Gsk", name = "PathPoint"})
-- method Path::get_stroke_bounds
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stroke"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Stroke" }
--           , argCType = Just "const GskStroke*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "stroke parameters" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the bounds to fill in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_path_get_stroke_bounds" gsk_path_get_stroke_bounds :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    Ptr Gsk.Stroke.Stroke ->                -- stroke : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CInt

-- | Computes the bounds for stroking the given path with the
-- given parameters.
-- 
-- The returned bounds may be larger than necessary, because this
-- function aims to be fast, not accurate. The bounds are guaranteed
-- to contain the area affected by the stroke, including protrusions
-- like miters.
-- 
-- /Since: 4.14/
pathGetStrokeBounds ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> Gsk.Stroke.Stroke
    -- ^ /@stroke@/: stroke parameters
    -> m ((Bool, Graphene.Rect.Rect))
    -- ^ __Returns:__ true if the path has bounds, false if the path is known
    --   to be empty and have no bounds.
pathGetStrokeBounds :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Path -> Stroke -> m (Bool, Rect)
pathGetStrokeBounds Path
self Stroke
stroke = IO (Bool, Rect) -> m (Bool, Rect)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Rect) -> m (Bool, Rect))
-> IO (Bool, Rect) -> m (Bool, Rect)
forall a b. (a -> b) -> a -> b
$ do
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    stroke' <- unsafeManagedPtrGetPtr stroke
    bounds <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
    result <- gsk_path_get_stroke_bounds self' stroke' bounds
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    bounds' <- (wrapBoxed Graphene.Rect.Rect) bounds
    touchManagedPtr self
    touchManagedPtr stroke
    return (result', bounds')

#if defined(ENABLE_OVERLOADING)
data PathGetStrokeBoundsMethodInfo
instance (signature ~ (Gsk.Stroke.Stroke -> m ((Bool, Graphene.Rect.Rect))), MonadIO m) => O.OverloadedMethod PathGetStrokeBoundsMethodInfo Path signature where
    overloadedMethod = pathGetStrokeBounds

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


#endif

-- method Path::get_tight_bounds
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the bounds"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_path_get_tight_bounds" gsk_path_get_tight_bounds :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO CInt

-- | Computes the tight bounds of the given path.
-- 
-- This function works harder than 'GI.Gsk.Structs.Path.pathGetBounds' to
-- produce the smallest possible bounds.
-- 
-- /Since: 4.22/
pathGetTightBounds ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> m ((Bool, Graphene.Rect.Rect))
    -- ^ __Returns:__ true if the path has bounds, false if the path is known
    --   to be empty and have no bounds
pathGetTightBounds :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Path -> m (Bool, Rect)
pathGetTightBounds Path
self = IO (Bool, Rect) -> m (Bool, Rect)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Rect) -> m (Bool, Rect))
-> IO (Bool, Rect) -> m (Bool, Rect)
forall a b. (a -> b) -> a -> b
$ do
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    bounds <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
    result <- gsk_path_get_tight_bounds self' bounds
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    bounds' <- (wrapBoxed Graphene.Rect.Rect) bounds
    touchManagedPtr self
    return (result', bounds')

#if defined(ENABLE_OVERLOADING)
data PathGetTightBoundsMethodInfo
instance (signature ~ (m ((Bool, Graphene.Rect.Rect))), MonadIO m) => O.OverloadedMethod PathGetTightBoundsMethodInfo Path signature where
    overloadedMethod = pathGetTightBounds

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


#endif

-- method Path::in_fill
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "const graphene_point_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the point to test" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "fill_rule"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "FillRule" }
--           , argCType = Just "GskFillRule"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the fill rule to follow"
--                 , 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_in_fill" gsk_path_in_fill :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    Ptr Graphene.Point.Point ->             -- point : TInterface (Name {namespace = "Graphene", name = "Point"})
    CUInt ->                                -- fill_rule : TInterface (Name {namespace = "Gsk", name = "FillRule"})
    IO CInt

-- | Returns whether a point is inside the fill area of a path.
-- 
-- Note that this function assumes that filling a contour
-- implicitly closes it.
-- 
-- /Since: 4.14/
pathInFill ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> Graphene.Point.Point
    -- ^ /@point@/: the point to test
    -> Gsk.Enums.FillRule
    -- ^ /@fillRule@/: the fill rule to follow
    -> m Bool
    -- ^ __Returns:__ true if /@point@/ is inside
pathInFill :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Path -> Point -> FillRule -> m Bool
pathInFill Path
self Point
point FillRule
fillRule = 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
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    point' <- unsafeManagedPtrGetPtr point
    let fillRule' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (FillRule -> Int) -> FillRule -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FillRule -> Int
forall a. Enum a => a -> Int
fromEnum) FillRule
fillRule
    result <- gsk_path_in_fill self' point' fillRule'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr self
    touchManagedPtr point
    return result'

#if defined(ENABLE_OVERLOADING)
data PathInFillMethodInfo
instance (signature ~ (Graphene.Point.Point -> Gsk.Enums.FillRule -> m Bool), MonadIO m) => O.OverloadedMethod PathInFillMethodInfo Path signature where
    overloadedMethod = pathInFill

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


#endif

-- method Path::is_closed
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , 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_is_closed" gsk_path_is_closed :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    IO CInt

-- | Returns if the path represents a single closed contour.
-- 
-- /Since: 4.14/
pathIsClosed ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> m Bool
    -- ^ __Returns:__ true if the path is closed
pathIsClosed :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Path -> m Bool
pathIsClosed Path
self = 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
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    result <- gsk_path_is_closed self'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data PathIsClosedMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod PathIsClosedMethodInfo Path signature where
    overloadedMethod = pathIsClosed

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


#endif

-- method Path::is_empty
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , 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_is_empty" gsk_path_is_empty :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    IO CInt

-- | Checks if the path is empty, i.e. contains no lines or curves.
-- 
-- /Since: 4.14/
pathIsEmpty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> m Bool
    -- ^ __Returns:__ true if the path is empty
pathIsEmpty :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Path -> m Bool
pathIsEmpty Path
self = 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
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    result <- gsk_path_is_empty self'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data PathIsEmptyMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod PathIsEmptyMethodInfo Path signature where
    overloadedMethod = pathIsEmpty

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


#endif

-- method Path::print
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string to print into"
--                 , 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_print" gsk_path_print :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    Ptr GLib.String.String ->               -- string : TInterface (Name {namespace = "GLib", name = "String"})
    IO ()

-- | Converts the path into a human-readable representation.
-- 
-- The string is compatible with (a superset of)
-- <https://www.w3.org/TR/SVG11/paths.html#PathData SVG path syntax>,
-- see 'GI.Gsk.Structs.Path.pathParse' for a summary of the syntax.
-- 
-- /Since: 4.14/
pathPrint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> GLib.String.String
    -- ^ /@string@/: the string to print into
    -> m ()
pathPrint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Path -> String -> m ()
pathPrint Path
self String
string = 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
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    string' <- unsafeManagedPtrGetPtr string
    gsk_path_print self' string'
    touchManagedPtr self
    touchManagedPtr string
    return ()

#if defined(ENABLE_OVERLOADING)
data PathPrintMethodInfo
instance (signature ~ (GLib.String.String -> m ()), MonadIO m) => O.OverloadedMethod PathPrintMethodInfo Path signature where
    overloadedMethod = pathPrint

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


#endif

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

foreign import ccall "gsk_path_ref" gsk_path_ref :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    IO (Ptr Path)

-- | Increases the reference count of a path by one.
-- 
-- /Since: 4.14/
pathRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> m Path
    -- ^ __Returns:__ the passed in @GskPath@
pathRef :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Path -> m Path
pathRef Path
self = IO Path -> m Path
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Path -> m Path) -> IO Path -> m Path
forall a b. (a -> b) -> a -> b
$ do
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    result <- gsk_path_ref self'
    checkUnexpectedReturnNULL "pathRef" result
    result' <- (wrapBoxed Path) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data PathRefMethodInfo
instance (signature ~ (m Path), MonadIO m) => O.OverloadedMethod PathRefMethodInfo Path signature where
    overloadedMethod = pathRef

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


#endif

-- method Path::to_cairo
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cr"
--           , argType =
--               TInterface Name { namespace = "cairo" , name = "Context" }
--           , argCType = Just "cairo_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a cairo context" , 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_to_cairo" gsk_path_to_cairo :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    Ptr Cairo.Context.Context ->            -- cr : TInterface (Name {namespace = "cairo", name = "Context"})
    IO ()

-- | Appends the path to a cairo context for drawing with Cairo.
-- 
-- This may cause some suboptimal conversions to be performed as
-- Cairo does not support all features of @GskPath@.
-- 
-- This function does not clear the existing Cairo path. Call
-- @/cairo_new_path()/@ if you want this.
-- 
-- /Since: 4.14/
pathToCairo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> Cairo.Context.Context
    -- ^ /@cr@/: a cairo context
    -> m ()
pathToCairo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Path -> Context -> m ()
pathToCairo Path
self Context
cr = 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
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    cr' <- unsafeManagedPtrGetPtr cr
    gsk_path_to_cairo self' cr'
    touchManagedPtr self
    touchManagedPtr cr
    return ()

#if defined(ENABLE_OVERLOADING)
data PathToCairoMethodInfo
instance (signature ~ (Cairo.Context.Context -> m ()), MonadIO m) => O.OverloadedMethod PathToCairoMethodInfo Path signature where
    overloadedMethod = pathToCairo

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


#endif

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

foreign import ccall "gsk_path_to_string" gsk_path_to_string :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    IO CString

-- | Converts the path into a human-readable string.
-- 
-- You can use this function in a debugger to get a quick overview
-- of the path.
-- 
-- This is a wrapper around 'GI.Gsk.Structs.Path.pathPrint', see that function
-- for details.
-- 
-- /Since: 4.14/
pathToString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> m T.Text
    -- ^ __Returns:__ a new string for /@self@/
pathToString :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Path -> m Text
pathToString Path
self = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    result <- gsk_path_to_string self'
    checkUnexpectedReturnNULL "pathToString" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data PathToStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod PathToStringMethodInfo Path signature where
    overloadedMethod = pathToString

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


#endif

-- method Path::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Path" }
--           , argCType = Just "GskPath*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path" , 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_unref" gsk_path_unref :: 
    Ptr Path ->                             -- self : TInterface (Name {namespace = "Gsk", name = "Path"})
    IO ()

-- | Decreases the reference count of a path by one.
-- 
-- If the resulting reference count is zero, frees the path.
-- 
-- /Since: 4.14/
pathUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Path
    -- ^ /@self@/: a path
    -> m ()
pathUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Path -> m ()
pathUnref Path
self = 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
    self' <- Path -> IO (Ptr Path)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Path
self
    gsk_path_unref self'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod PathUnrefMethodInfo Path signature where
    overloadedMethod = pathUnref

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


#endif

-- method Path::parse
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "string"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Path" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_path_parse" gsk_path_parse :: 
    CString ->                              -- string : TBasicType TUTF8
    IO (Ptr Path)

-- | Constructs a path from a serialized form.
-- 
-- The string is expected to be in (a superset of)
-- <https://www.w3.org/TR/SVG11/paths.html#PathData SVG path syntax>,
-- as e.g. produced by 'GI.Gsk.Structs.Path.pathToString'.
-- 
-- A high-level summary of the syntax:
-- 
-- * @M x y@ Move to @(x, y)@
-- * @L x y@ Add a line from the current point to @(x, y)@
-- * @Q x1 y1 x2 y2@ Add a quadratic Bézier from the current point to @(x2, y2)@, with control point @(x1, y1)@
-- * @C x1 y1 x2 y2 x3 y3@ Add a cubic Bézier from the current point to @(x3, y3)@, with control points @(x1, y1)@ and @(x2, y2)@
-- * @Z@ Close the contour by drawing a line back to the start point
-- * @H x@ Add a horizontal line from the current point to the given x value
-- * @V y@ Add a vertical line from the current point to the given y value
-- * @T x2 y2@ Add a quadratic Bézier, using the reflection of the previous segments\' control point as control point
-- * @S x2 y2 x3 y3@ Add a cubic Bézier, using the reflection of the previous segments\' second control point as first control point
-- * @A rx ry r l s x y@ Add an elliptical arc from the current point to @(x, y)@ with radii rx and ry. See the SVG documentation for how the other parameters influence the arc.
-- * @O x1 y1 x2 y2 w@ Add a rational quadratic Bézier from the current point to @(x2, y2)@ with control point @(x1, y1)@ and weight @w@.
-- 
-- 
-- All the commands have lowercase variants that interpret coordinates
-- relative to the current point.
-- 
-- The @O@ command is an extension that is not supported in SVG.
-- 
-- /Since: 4.14/
pathParse ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@string@/: a string
    -> m (Maybe Path)
    -- ^ __Returns:__ a new @GskPath@, or @NULL@ if /@string@/ could not be parsed
pathParse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Path)
pathParse Text
string = IO (Maybe Path) -> m (Maybe Path)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Path) -> m (Maybe Path))
-> IO (Maybe Path) -> m (Maybe Path)
forall a b. (a -> b) -> a -> b
$ do
    string' <- Text -> IO CString
textToCString Text
string
    result <- gsk_path_parse string'
    maybeResult <- convertIfNonNull result $ \Ptr Path
result' -> do
        result'' <- ((ManagedPtr Path -> Path) -> Ptr Path -> IO Path
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Path -> Path
Path) Ptr Path
result'
        return result''
    freeMem string'
    return maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolvePathMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolvePathMethod "equal" o = PathEqualMethodInfo
    ResolvePathMethod "foreach" o = PathForeachMethodInfo
    ResolvePathMethod "foreachIntersection" o = PathForeachIntersectionMethodInfo
    ResolvePathMethod "inFill" o = PathInFillMethodInfo
    ResolvePathMethod "isClosed" o = PathIsClosedMethodInfo
    ResolvePathMethod "isEmpty" o = PathIsEmptyMethodInfo
    ResolvePathMethod "print" o = PathPrintMethodInfo
    ResolvePathMethod "ref" o = PathRefMethodInfo
    ResolvePathMethod "toCairo" o = PathToCairoMethodInfo
    ResolvePathMethod "toString" o = PathToStringMethodInfo
    ResolvePathMethod "unref" o = PathUnrefMethodInfo
    ResolvePathMethod "getBounds" o = PathGetBoundsMethodInfo
    ResolvePathMethod "getStrokeBounds" o = PathGetStrokeBoundsMethodInfo
    ResolvePathMethod "getTightBounds" o = PathGetTightBoundsMethodInfo
    ResolvePathMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif