{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Constructs @GskPath@ objects.
-- 
-- A path is constructed like this:
-- 
-- 
-- === /c code/
-- >GskPath *
-- >construct_path (void)
-- >{
-- >  GskPathBuilder *builder;
-- >
-- >  builder = gsk_path_builder_new ();
-- >
-- >  // add contours to the path here
-- >
-- >  return gsk_path_builder_free_to_path (builder);
-- 
-- 
-- Adding contours to the path can be done in two ways.
-- The easiest option is to use the @gsk_path_builder_add_*@ group
-- of functions that add predefined contours to the current path,
-- either common shapes like 'GI.Gsk.Structs.PathBuilder.pathBuilderAddCircle'
-- or by adding from other paths like 'GI.Gsk.Structs.PathBuilder.pathBuilderAddPath'.
-- 
-- The @gsk_path_builder_add_*@ methods always add complete contours,
-- and do not use or modify the current point.
-- 
-- The other option is to define each line and curve manually with
-- the @gsk_path_builder_*_to@ group of functions. You start with
-- a call to 'GI.Gsk.Structs.PathBuilder.pathBuilderMoveTo' to set the starting point
-- and then use multiple calls to any of the drawing functions to
-- move the pen along the plane. Once you are done, you can call
-- 'GI.Gsk.Structs.PathBuilder.pathBuilderClose' to close the path by connecting it
-- back with a line to the starting point.
-- 
-- This is similar to how paths are drawn in Cairo.
-- 
-- Note that @GskPathBuilder@ will reduce the degree of added Bézier
-- curves as much as possible, to simplify rendering.
-- 
-- /Since: 4.14/

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

module GI.Gsk.Structs.PathBuilder
    ( 

-- * Exported types
    PathBuilder(..)                         ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addCairoPath]("GI.Gsk.Structs.PathBuilder#g:method:addCairoPath"), [addCircle]("GI.Gsk.Structs.PathBuilder#g:method:addCircle"), [addLayout]("GI.Gsk.Structs.PathBuilder#g:method:addLayout"), [addPath]("GI.Gsk.Structs.PathBuilder#g:method:addPath"), [addRect]("GI.Gsk.Structs.PathBuilder#g:method:addRect"), [addReversePath]("GI.Gsk.Structs.PathBuilder#g:method:addReversePath"), [addRoundedRect]("GI.Gsk.Structs.PathBuilder#g:method:addRoundedRect"), [addSegment]("GI.Gsk.Structs.PathBuilder#g:method:addSegment"), [arcTo]("GI.Gsk.Structs.PathBuilder#g:method:arcTo"), [close]("GI.Gsk.Structs.PathBuilder#g:method:close"), [conicTo]("GI.Gsk.Structs.PathBuilder#g:method:conicTo"), [cubicTo]("GI.Gsk.Structs.PathBuilder#g:method:cubicTo"), [htmlArcTo]("GI.Gsk.Structs.PathBuilder#g:method:htmlArcTo"), [lineTo]("GI.Gsk.Structs.PathBuilder#g:method:lineTo"), [moveTo]("GI.Gsk.Structs.PathBuilder#g:method:moveTo"), [quadTo]("GI.Gsk.Structs.PathBuilder#g:method:quadTo"), [ref]("GI.Gsk.Structs.PathBuilder#g:method:ref"), [relArcTo]("GI.Gsk.Structs.PathBuilder#g:method:relArcTo"), [relConicTo]("GI.Gsk.Structs.PathBuilder#g:method:relConicTo"), [relCubicTo]("GI.Gsk.Structs.PathBuilder#g:method:relCubicTo"), [relHtmlArcTo]("GI.Gsk.Structs.PathBuilder#g:method:relHtmlArcTo"), [relLineTo]("GI.Gsk.Structs.PathBuilder#g:method:relLineTo"), [relMoveTo]("GI.Gsk.Structs.PathBuilder#g:method:relMoveTo"), [relQuadTo]("GI.Gsk.Structs.PathBuilder#g:method:relQuadTo"), [relSvgArcTo]("GI.Gsk.Structs.PathBuilder#g:method:relSvgArcTo"), [svgArcTo]("GI.Gsk.Structs.PathBuilder#g:method:svgArcTo"), [toPath]("GI.Gsk.Structs.PathBuilder#g:method:toPath"), [unref]("GI.Gsk.Structs.PathBuilder#g:method:unref").
-- 
-- ==== Getters
-- [getCurrentPoint]("GI.Gsk.Structs.PathBuilder#g:method:getCurrentPoint").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolvePathBuilderMethod                ,
#endif

-- ** addCairoPath #method:addCairoPath#

#if defined(ENABLE_OVERLOADING)
    PathBuilderAddCairoPathMethodInfo       ,
#endif
    pathBuilderAddCairoPath                 ,


-- ** addCircle #method:addCircle#

#if defined(ENABLE_OVERLOADING)
    PathBuilderAddCircleMethodInfo          ,
#endif
    pathBuilderAddCircle                    ,


-- ** addLayout #method:addLayout#

#if defined(ENABLE_OVERLOADING)
    PathBuilderAddLayoutMethodInfo          ,
#endif
    pathBuilderAddLayout                    ,


-- ** addPath #method:addPath#

#if defined(ENABLE_OVERLOADING)
    PathBuilderAddPathMethodInfo            ,
#endif
    pathBuilderAddPath                      ,


-- ** addRect #method:addRect#

#if defined(ENABLE_OVERLOADING)
    PathBuilderAddRectMethodInfo            ,
#endif
    pathBuilderAddRect                      ,


-- ** addReversePath #method:addReversePath#

#if defined(ENABLE_OVERLOADING)
    PathBuilderAddReversePathMethodInfo     ,
#endif
    pathBuilderAddReversePath               ,


-- ** addRoundedRect #method:addRoundedRect#

#if defined(ENABLE_OVERLOADING)
    PathBuilderAddRoundedRectMethodInfo     ,
#endif
    pathBuilderAddRoundedRect               ,


-- ** addSegment #method:addSegment#

#if defined(ENABLE_OVERLOADING)
    PathBuilderAddSegmentMethodInfo         ,
#endif
    pathBuilderAddSegment                   ,


-- ** arcTo #method:arcTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderArcToMethodInfo              ,
#endif
    pathBuilderArcTo                        ,


-- ** close #method:close#

#if defined(ENABLE_OVERLOADING)
    PathBuilderCloseMethodInfo              ,
#endif
    pathBuilderClose                        ,


-- ** conicTo #method:conicTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderConicToMethodInfo            ,
#endif
    pathBuilderConicTo                      ,


-- ** cubicTo #method:cubicTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderCubicToMethodInfo            ,
#endif
    pathBuilderCubicTo                      ,


-- ** getCurrentPoint #method:getCurrentPoint#

#if defined(ENABLE_OVERLOADING)
    PathBuilderGetCurrentPointMethodInfo    ,
#endif
    pathBuilderGetCurrentPoint              ,


-- ** htmlArcTo #method:htmlArcTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderHtmlArcToMethodInfo          ,
#endif
    pathBuilderHtmlArcTo                    ,


-- ** lineTo #method:lineTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderLineToMethodInfo             ,
#endif
    pathBuilderLineTo                       ,


-- ** moveTo #method:moveTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderMoveToMethodInfo             ,
#endif
    pathBuilderMoveTo                       ,


-- ** new #method:new#

    pathBuilderNew                          ,


-- ** quadTo #method:quadTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderQuadToMethodInfo             ,
#endif
    pathBuilderQuadTo                       ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    PathBuilderRefMethodInfo                ,
#endif
    pathBuilderRef                          ,


-- ** relArcTo #method:relArcTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderRelArcToMethodInfo           ,
#endif
    pathBuilderRelArcTo                     ,


-- ** relConicTo #method:relConicTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderRelConicToMethodInfo         ,
#endif
    pathBuilderRelConicTo                   ,


-- ** relCubicTo #method:relCubicTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderRelCubicToMethodInfo         ,
#endif
    pathBuilderRelCubicTo                   ,


-- ** relHtmlArcTo #method:relHtmlArcTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderRelHtmlArcToMethodInfo       ,
#endif
    pathBuilderRelHtmlArcTo                 ,


-- ** relLineTo #method:relLineTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderRelLineToMethodInfo          ,
#endif
    pathBuilderRelLineTo                    ,


-- ** relMoveTo #method:relMoveTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderRelMoveToMethodInfo          ,
#endif
    pathBuilderRelMoveTo                    ,


-- ** relQuadTo #method:relQuadTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderRelQuadToMethodInfo          ,
#endif
    pathBuilderRelQuadTo                    ,


-- ** relSvgArcTo #method:relSvgArcTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderRelSvgArcToMethodInfo        ,
#endif
    pathBuilderRelSvgArcTo                  ,


-- ** svgArcTo #method:svgArcTo#

#if defined(ENABLE_OVERLOADING)
    PathBuilderSvgArcToMethodInfo           ,
#endif
    pathBuilderSvgArcTo                     ,


-- ** toPath #method:toPath#

#if defined(ENABLE_OVERLOADING)
    PathBuilderToPathMethodInfo             ,
#endif
    pathBuilderToPath                       ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    PathBuilderUnrefMethodInfo              ,
#endif
    pathBuilderUnref                        ,




    ) 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.Cairo.Structs.Path as Cairo.Path
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.Size as Graphene.Size
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.PathPoint as Gsk.PathPoint
import {-# SOURCE #-} qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
import {-# SOURCE #-} qualified GI.Gsk.Structs.Stroke as Gsk.Stroke
import qualified GI.Pango.Objects.Layout as Pango.Layout

#else
import qualified GI.Cairo.Structs.Path as Cairo.Path
import qualified GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import {-# SOURCE #-} qualified GI.Gsk.Structs.Path as Gsk.Path
import {-# SOURCE #-} qualified GI.Gsk.Structs.PathPoint as Gsk.PathPoint
import {-# SOURCE #-} qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
import qualified GI.Pango.Objects.Layout as Pango.Layout

#endif

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

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

foreign import ccall "gsk_path_builder_get_type" c_gsk_path_builder_get_type :: 
    IO GType

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

instance B.Types.TypedObject PathBuilder where
    glibType :: IO GType
glibType = IO GType
c_gsk_path_builder_get_type

instance B.Types.GBoxed PathBuilder

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


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

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

foreign import ccall "gsk_path_builder_new" gsk_path_builder_new :: 
    IO (Ptr PathBuilder)

-- | Create a new @GskPathBuilder@ object.
-- 
-- The resulting builder would create an empty @GskPath@.
-- Use addition functions to add types to it.
-- 
-- /Since: 4.14/
pathBuilderNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m PathBuilder
    -- ^ __Returns:__ a new @GskPathBuilder@
pathBuilderNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m PathBuilder
pathBuilderNew  = IO PathBuilder -> m PathBuilder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PathBuilder -> m PathBuilder)
-> IO PathBuilder -> m PathBuilder
forall a b. (a -> b) -> a -> b
$ do
    result <- IO (Ptr PathBuilder)
gsk_path_builder_new
    checkUnexpectedReturnNULL "pathBuilderNew" result
    result' <- (wrapBoxed PathBuilder) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method PathBuilder::add_cairo_path
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TInterface Name { namespace = "cairo" , name = "Path" }
--           , argCType = Just "const cairo_path_t*"
--           , 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_builder_add_cairo_path" gsk_path_builder_add_cairo_path :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    Ptr Cairo.Path.Path ->                  -- path : TInterface (Name {namespace = "cairo", name = "Path"})
    IO ()

-- | Adds a Cairo path to the builder.
-- 
-- You can use @/cairo_copy_path()/@ to access the path
-- from a Cairo context.
-- 
-- /Since: 4.14/
pathBuilderAddCairoPath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Cairo.Path.Path
    -- ^ /@path@/: a path
    -> m ()
pathBuilderAddCairoPath :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Path -> m ()
pathBuilderAddCairoPath PathBuilder
self Path
path = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    path' <- unsafeManagedPtrGetPtr path
    gsk_path_builder_add_cairo_path self' path'
    touchManagedPtr self
    touchManagedPtr path
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderAddCairoPathMethodInfo
instance (signature ~ (Cairo.Path.Path -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderAddCairoPathMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderAddCairoPath

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


#endif

-- method PathBuilder::add_circle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , 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 "const graphene_point_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the center of the circle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "radius"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the radius of the circle"
--                 , 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_builder_add_circle" gsk_path_builder_add_circle :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    Ptr Graphene.Point.Point ->             -- center : TInterface (Name {namespace = "Graphene", name = "Point"})
    CFloat ->                               -- radius : TBasicType TFloat
    IO ()

-- | Adds a circle as a new contour.
-- 
-- The path is going around the circle in clockwise direction.
-- 
-- If /@radius@/ is zero, the contour will be a closed point.
-- 
-- /Since: 4.14/
pathBuilderAddCircle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Graphene.Point.Point
    -- ^ /@center@/: the center of the circle
    -> Float
    -- ^ /@radius@/: the radius of the circle
    -> m ()
pathBuilderAddCircle :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Point -> Float -> m ()
pathBuilderAddCircle PathBuilder
self Point
center Float
radius = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    center' <- unsafeManagedPtrGetPtr center
    let radius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
radius
    gsk_path_builder_add_circle self' center' radius'
    touchManagedPtr self
    touchManagedPtr center
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderAddCircleMethodInfo
instance (signature ~ (Graphene.Point.Point -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderAddCircleMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderAddCircle

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


#endif

-- method PathBuilder::add_layout
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "layout"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "Layout" }
--           , argCType = Just "PangoLayout*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pango layout to add"
--                 , 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_builder_add_layout" gsk_path_builder_add_layout :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    Ptr Pango.Layout.Layout ->              -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
    IO ()

-- | Adds the outlines for the glyphs in /@layout@/ to the builder.
-- 
-- /Since: 4.14/
pathBuilderAddLayout ::
    (B.CallStack.HasCallStack, MonadIO m, Pango.Layout.IsLayout a) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> a
    -- ^ /@layout@/: the pango layout to add
    -> m ()
pathBuilderAddLayout :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLayout a) =>
PathBuilder -> a -> m ()
pathBuilderAddLayout PathBuilder
self a
layout = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    layout' <- unsafeManagedPtrCastPtr layout
    gsk_path_builder_add_layout self' layout'
    touchManagedPtr self
    touchManagedPtr layout
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderAddLayoutMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Pango.Layout.IsLayout a) => O.OverloadedMethod PathBuilderAddLayoutMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderAddLayout

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


#endif

-- method PathBuilder::add_path
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , 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 to append" , 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_builder_add_path" gsk_path_builder_add_path :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    Ptr Gsk.Path.Path ->                    -- path : TInterface (Name {namespace = "Gsk", name = "Path"})
    IO ()

-- | Appends all of /@path@/ to the builder.
-- 
-- /Since: 4.14/
pathBuilderAddPath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Gsk.Path.Path
    -- ^ /@path@/: the path to append
    -> m ()
pathBuilderAddPath :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Path -> m ()
pathBuilderAddPath PathBuilder
self Path
path = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    path' <- unsafeManagedPtrGetPtr path
    gsk_path_builder_add_path self' path'
    touchManagedPtr self
    touchManagedPtr path
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderAddPathMethodInfo
instance (signature ~ (Gsk.Path.Path -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderAddPathMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderAddPath

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


#endif

-- method PathBuilder::add_rect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rect"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rectangle to create a path for"
--                 , 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_builder_add_rect" gsk_path_builder_add_rect :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    Ptr Graphene.Rect.Rect ->               -- rect : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Adds a rectangle as a new contour.
-- 
-- The path is going around the rectangle in clockwise direction.
-- 
-- If the the width or height are 0, the path will be a closed
-- horizontal or vertical line. If both are 0, it\'ll be a closed dot.
-- 
-- /Since: 4.14/
pathBuilderAddRect ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Graphene.Rect.Rect
    -- ^ /@rect@/: the rectangle to create a path for
    -> m ()
pathBuilderAddRect :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Rect -> m ()
pathBuilderAddRect PathBuilder
self Rect
rect = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    rect' <- unsafeManagedPtrGetPtr rect
    gsk_path_builder_add_rect self' rect'
    touchManagedPtr self
    touchManagedPtr rect
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderAddRectMethodInfo
instance (signature ~ (Graphene.Rect.Rect -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderAddRectMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderAddRect

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


#endif

-- method PathBuilder::add_reverse_path
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , 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 to append" , 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_builder_add_reverse_path" gsk_path_builder_add_reverse_path :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    Ptr Gsk.Path.Path ->                    -- path : TInterface (Name {namespace = "Gsk", name = "Path"})
    IO ()

-- | Appends all of /@path@/ to the builder, in reverse order.
-- 
-- /Since: 4.14/
pathBuilderAddReversePath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Gsk.Path.Path
    -- ^ /@path@/: the path to append
    -> m ()
pathBuilderAddReversePath :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Path -> m ()
pathBuilderAddReversePath PathBuilder
self Path
path = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    path' <- unsafeManagedPtrGetPtr path
    gsk_path_builder_add_reverse_path self' path'
    touchManagedPtr self
    touchManagedPtr path
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderAddReversePathMethodInfo
instance (signature ~ (Gsk.Path.Path -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderAddReversePathMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderAddReversePath

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


#endif

-- method PathBuilder::add_rounded_rect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rect"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RoundedRect" }
--           , argCType = Just "const GskRoundedRect*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rounded rect" , 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_builder_add_rounded_rect" gsk_path_builder_add_rounded_rect :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    Ptr Gsk.RoundedRect.RoundedRect ->      -- rect : TInterface (Name {namespace = "Gsk", name = "RoundedRect"})
    IO ()

-- | Adds a rounded rectangle as a new contour.
-- 
-- The path is going around the rectangle in clockwise direction.
-- 
-- /Since: 4.14/
pathBuilderAddRoundedRect ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Gsk.RoundedRect.RoundedRect
    -- ^ /@rect@/: the rounded rect
    -> m ()
pathBuilderAddRoundedRect :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> RoundedRect -> m ()
pathBuilderAddRoundedRect PathBuilder
self RoundedRect
rect = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    rect' <- unsafeManagedPtrGetPtr rect
    gsk_path_builder_add_rounded_rect self' rect'
    touchManagedPtr self
    touchManagedPtr rect
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderAddRoundedRectMethodInfo
instance (signature ~ (Gsk.RoundedRect.RoundedRect -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderAddRoundedRectMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderAddRoundedRect

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


#endif

-- method PathBuilder::add_segment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , 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 to take the segment to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the point on @path to start at"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathPoint" }
--           , argCType = Just "const GskPathPoint*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the point on @path to end at"
--                 , 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_builder_add_segment" gsk_path_builder_add_segment :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    Ptr Gsk.Path.Path ->                    -- path : TInterface (Name {namespace = "Gsk", name = "Path"})
    Ptr Gsk.PathPoint.PathPoint ->          -- start : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    Ptr Gsk.PathPoint.PathPoint ->          -- end : TInterface (Name {namespace = "Gsk", name = "PathPoint"})
    IO ()

-- | Adds a segment of a path to the builder.
-- 
-- If /@start@/ is equal to or after /@end@/, the path will first add the
-- segment from /@start@/ to the end of the path, and then add the segment
-- from the beginning to /@end@/. If the path is closed, these segments
-- will be connected.
-- 
-- Note that this method always adds a path with the given start point
-- and end point. To add a closed path, use 'GI.Gsk.Structs.PathBuilder.pathBuilderAddPath'.
-- 
-- /Since: 4.14/
pathBuilderAddSegment ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Gsk.Path.Path
    -- ^ /@path@/: the path to take the segment to
    -> Gsk.PathPoint.PathPoint
    -- ^ /@start@/: the point on /@path@/ to start at
    -> Gsk.PathPoint.PathPoint
    -- ^ /@end@/: the point on /@path@/ to end at
    -> m ()
pathBuilderAddSegment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Path -> PathPoint -> PathPoint -> m ()
pathBuilderAddSegment PathBuilder
self Path
path PathPoint
start PathPoint
end = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    path' <- unsafeManagedPtrGetPtr path
    start' <- unsafeManagedPtrGetPtr start
    end' <- unsafeManagedPtrGetPtr end
    gsk_path_builder_add_segment self' path' start' end'
    touchManagedPtr self
    touchManagedPtr path
    touchManagedPtr start
    touchManagedPtr end
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderAddSegmentMethodInfo
instance (signature ~ (Gsk.Path.Path -> Gsk.PathPoint.PathPoint -> Gsk.PathPoint.PathPoint -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderAddSegmentMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderAddSegment

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


#endif

-- method PathBuilder::arc_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of second control 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_builder_arc_to" gsk_path_builder_arc_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    IO ()

-- | Adds an elliptical arc from the current point to /@x2@/, /@y2@/
-- with /@x1@/, /@y1@/ determining the tangent directions.
-- 
-- After this, /@x2@/, /@y2@/ will be the new current point.
-- 
-- Note: Two points and their tangents do not determine
-- a unique ellipse, so GSK just picks one. If you need more
-- precise control, use 'GI.Gsk.Structs.PathBuilder.pathBuilderConicTo'
-- or 'GI.Gsk.Structs.PathBuilder.pathBuilderSvgArcTo'.
-- 
-- \<picture>
--   \<source srcset=\"arc-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img alt=\"Arc To\" src=\"arc-light.png\">
-- \<\/picture>
-- 
-- /Since: 4.14/
pathBuilderArcTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x coordinate of first control point
    -> Float
    -- ^ /@y1@/: y coordinate of first control point
    -> Float
    -- ^ /@x2@/: x coordinate of second control point
    -> Float
    -- ^ /@y2@/: y coordinate of second control point
    -> m ()
pathBuilderArcTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> Float -> Float -> m ()
pathBuilderArcTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    gsk_path_builder_arc_to self' x1' y1' x2' y2'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderArcToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderArcToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderArcTo

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


#endif

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

-- | Ends the current contour with a line back to the start point.
-- 
-- Note that this is different from calling 'GI.Gsk.Structs.PathBuilder.pathBuilderLineTo'
-- with the start point in that the contour will be closed. A closed
-- contour behaves differently from an open one. When stroking, its
-- start and end point are considered connected, so they will be
-- joined via the line join, and not ended with line caps.
-- 
-- /Since: 4.14/
pathBuilderClose ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> m ()
pathBuilderClose :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> m ()
pathBuilderClose PathBuilder
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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    gsk_path_builder_close self'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderCloseMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod PathBuilderCloseMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderClose

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


#endif

-- method PathBuilder::conic_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of the end of the curve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of the end of the curve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "weight"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "weight of the control point, must be greater than zero"
--                 , 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_builder_conic_to" gsk_path_builder_conic_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    CFloat ->                               -- weight : TBasicType TFloat
    IO ()

-- | Adds a <https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline conic curve>
-- from the current point to /@x2@/, /@y2@/ with the given /@weight@/ and /@x1@/, /@y1@/ as the
-- control point.
-- 
-- The weight determines how strongly the curve is pulled towards the control point.
-- A conic with weight 1 is identical to a quadratic Bézier curve with the same points.
-- 
-- Conic curves can be used to draw ellipses and circles. They are also known as
-- rational quadratic Bézier curves.
-- 
-- After this, /@x2@/, /@y2@/ will be the new current point.
-- 
-- \<picture>
--   \<source srcset=\"conic-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img alt=\"Conic To\" src=\"conic-light.png\">
-- \<\/picture>
-- 
-- /Since: 4.14/
pathBuilderConicTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x coordinate of control point
    -> Float
    -- ^ /@y1@/: y coordinate of control point
    -> Float
    -- ^ /@x2@/: x coordinate of the end of the curve
    -> Float
    -- ^ /@y2@/: y coordinate of the end of the curve
    -> Float
    -- ^ /@weight@/: weight of the control point, must be greater than zero
    -> m ()
pathBuilderConicTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> Float -> Float -> Float -> m ()
pathBuilderConicTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 Float
weight = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    let weight' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
weight
    gsk_path_builder_conic_to self' x1' y1' x2' y2' weight'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderConicToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderConicToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderConicTo

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


#endif

-- method PathBuilder::cubic_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x3"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of the end of the curve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y3"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of the end of the curve"
--                 , 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_builder_cubic_to" gsk_path_builder_cubic_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    CFloat ->                               -- x3 : TBasicType TFloat
    CFloat ->                               -- y3 : TBasicType TFloat
    IO ()

-- | Adds a <https://en.wikipedia.org/wiki/B%C3%A9zier_curve cubic Bézier curve>
-- from the current point to /@x3@/, /@y3@/ with /@x1@/, /@y1@/ and /@x2@/, /@y2@/ as the control
-- points.
-- 
-- After this, /@x3@/, /@y3@/ will be the new current point.
-- 
-- \<picture>
--   \<source srcset=\"cubic-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img alt=\"Cubic To\" src=\"cubic-light.png\">
-- \<\/picture>
-- 
-- /Since: 4.14/
pathBuilderCubicTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x coordinate of first control point
    -> Float
    -- ^ /@y1@/: y coordinate of first control point
    -> Float
    -- ^ /@x2@/: x coordinate of second control point
    -> Float
    -- ^ /@y2@/: y coordinate of second control point
    -> Float
    -- ^ /@x3@/: x coordinate of the end of the curve
    -> Float
    -- ^ /@y3@/: y coordinate of the end of the curve
    -> m ()
pathBuilderCubicTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder
-> Float -> Float -> Float -> Float -> Float -> Float -> m ()
pathBuilderCubicTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 Float
x3 Float
y3 = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    let x3' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x3
    let y3' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y3
    gsk_path_builder_cubic_to self' x1' y1' x2' y2' x3' y3'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderCubicToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderCubicToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderCubicTo

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


#endif

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

foreign import ccall "gsk_path_builder_get_current_point" gsk_path_builder_get_current_point :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    IO (Ptr Graphene.Point.Point)

-- | Gets the current point.
-- 
-- The current point is used for relative drawing commands and
-- updated after every operation.
-- 
-- When the builder is created, the default current point is set
-- to @0, 0@. Note that this is different from cairo, which starts
-- out without a current point.
-- 
-- /Since: 4.14/
pathBuilderGetCurrentPoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> m Graphene.Point.Point
    -- ^ __Returns:__ the current point
pathBuilderGetCurrentPoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> m Point
pathBuilderGetCurrentPoint PathBuilder
self = 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
    self' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    result <- gsk_path_builder_get_current_point self'
    checkUnexpectedReturnNULL "pathBuilderGetCurrentPoint" result
    result' <- (newBoxed Graphene.Point.Point) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data PathBuilderGetCurrentPointMethodInfo
instance (signature ~ (m Graphene.Point.Point), MonadIO m) => O.OverloadedMethod PathBuilderGetCurrentPointMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderGetCurrentPoint

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


#endif

-- method PathBuilder::html_arc_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "radius"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "radius of the circle"
--                 , 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_builder_html_arc_to" gsk_path_builder_html_arc_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    CFloat ->                               -- radius : TBasicType TFloat
    IO ()

-- | Implements arc-to according to the HTML Canvas spec.
-- 
-- A convenience function that implements the
-- <https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-arcto-dev HTML arc_to>
-- functionality.
-- 
-- After this, the current point will be the point where
-- the circle with the given radius touches the line from
-- /@x1@/, /@y1@/ to /@x2@/, /@y2@/.
-- 
-- /Since: 4.14/
pathBuilderHtmlArcTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x coordinate of first control point
    -> Float
    -- ^ /@y1@/: y coordinate of first control point
    -> Float
    -- ^ /@x2@/: x coordinate of second control point
    -> Float
    -- ^ /@y2@/: y coordinate of second control point
    -> Float
    -- ^ /@radius@/: radius of the circle
    -> m ()
pathBuilderHtmlArcTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> Float -> Float -> Float -> m ()
pathBuilderHtmlArcTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 Float
radius = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    let radius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
radius
    gsk_path_builder_html_arc_to self' x1' y1' x2' y2' radius'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderHtmlArcToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderHtmlArcToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderHtmlArcTo

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


#endif

-- method PathBuilder::line_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate" , 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_builder_line_to" gsk_path_builder_line_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO ()

-- | Draws a line from the current point to /@x@/, /@y@/ and makes it
-- the new current point.
-- 
-- \<picture>
--   \<source srcset=\"line-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img alt=\"Line To\" src=\"line-light.png\">
-- \<\/picture>
-- 
-- /Since: 4.14/
pathBuilderLineTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x@/: x coordinate
    -> Float
    -- ^ /@y@/: y coordinate
    -> m ()
pathBuilderLineTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> m ()
pathBuilderLineTo PathBuilder
self Float
x Float
y = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    gsk_path_builder_line_to self' x' y'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderLineToMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderLineToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderLineTo

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


#endif

-- method PathBuilder::move_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate" , 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_builder_move_to" gsk_path_builder_move_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO ()

-- | Starts a new contour by placing the pen at /@x@/, /@y@/.
-- 
-- If this function is called twice in succession, the first
-- call will result in a contour made up of a single point.
-- The second call will start a new contour.
-- 
-- /Since: 4.14/
pathBuilderMoveTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x@/: x coordinate
    -> Float
    -- ^ /@y@/: y coordinate
    -> m ()
pathBuilderMoveTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> m ()
pathBuilderMoveTo PathBuilder
self Float
x Float
y = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    gsk_path_builder_move_to self' x' y'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderMoveToMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderMoveToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderMoveTo

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


#endif

-- method PathBuilder::quad_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of the end of the curve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of the end of the curve"
--                 , 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_builder_quad_to" gsk_path_builder_quad_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    IO ()

-- | Adds a <https://en.wikipedia.org/wiki/B%C3%A9zier_curve quadratic Bézier curve>
-- from the current point to /@x2@/, /@y2@/ with /@x1@/, /@y1@/ as the control point.
-- 
-- After this, /@x2@/, /@y2@/ will be the new current point.
-- 
-- \<picture>
--   \<source srcset=\"quad-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img alt=\"Quad To\" src=\"quad-light.png\">
-- \<\/picture>
-- 
-- /Since: 4.14/
pathBuilderQuadTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x coordinate of control point
    -> Float
    -- ^ /@y1@/: y coordinate of control point
    -> Float
    -- ^ /@x2@/: x coordinate of the end of the curve
    -> Float
    -- ^ /@y2@/: y coordinate of the end of the curve
    -> m ()
pathBuilderQuadTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> Float -> Float -> m ()
pathBuilderQuadTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    gsk_path_builder_quad_to self' x1' y1' x2' y2'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderQuadToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderQuadToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderQuadTo

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


#endif

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

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

-- | Acquires a reference on the given builder.
-- 
-- This function is intended primarily for language bindings.
-- @GskPathBuilder@ objects should not be kept around.
-- 
-- /Since: 4.14/
pathBuilderRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> m PathBuilder
    -- ^ __Returns:__ the given path builder with
    --   its reference count increased
pathBuilderRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> m PathBuilder
pathBuilderRef PathBuilder
self = IO PathBuilder -> m PathBuilder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PathBuilder -> m PathBuilder)
-> IO PathBuilder -> m PathBuilder
forall a b. (a -> b) -> a -> b
$ do
    self' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    result <- gsk_path_builder_ref self'
    checkUnexpectedReturnNULL "pathBuilderRef" result
    result' <- (newBoxed PathBuilder) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data PathBuilderRefMethodInfo
instance (signature ~ (m PathBuilder), MonadIO m) => O.OverloadedMethod PathBuilderRefMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderRef

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


#endif

-- method PathBuilder::rel_arc_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of second control 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_builder_rel_arc_to" gsk_path_builder_rel_arc_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    IO ()

-- | Adds an elliptical arc from the current point to /@x2@/, /@y2@/
-- with /@x1@/, /@y1@/ determining the tangent directions.
-- 
-- All coordinates are given relative to the current point.
-- 
-- This is the relative version of 'GI.Gsk.Structs.PathBuilder.pathBuilderArcTo'.
-- 
-- /Since: 4.14/
pathBuilderRelArcTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x coordinate of first control point
    -> Float
    -- ^ /@y1@/: y coordinate of first control point
    -> Float
    -- ^ /@x2@/: x coordinate of second control point
    -> Float
    -- ^ /@y2@/: y coordinate of second control point
    -> m ()
pathBuilderRelArcTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> Float -> Float -> m ()
pathBuilderRelArcTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    gsk_path_builder_rel_arc_to self' x1' y1' x2' y2'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderRelArcToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderRelArcToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderRelArcTo

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


#endif

-- method PathBuilder::rel_conic_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x offset of control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y offset of control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x offset of the end of the curve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y offset of the end of the curve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "weight"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "weight of the curve, must be greater than zero"
--                 , 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_builder_rel_conic_to" gsk_path_builder_rel_conic_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    CFloat ->                               -- weight : TBasicType TFloat
    IO ()

-- | Adds a <https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline conic curve>
-- from the current point to /@x2@/, /@y2@/ with the given /@weight@/ and /@x1@/, /@y1@/ as the
-- control point.
-- 
-- All coordinates are given relative to the current point.
-- 
-- This is the relative version of 'GI.Gsk.Structs.PathBuilder.pathBuilderConicTo'.
-- 
-- /Since: 4.14/
pathBuilderRelConicTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x offset of control point
    -> Float
    -- ^ /@y1@/: y offset of control point
    -> Float
    -- ^ /@x2@/: x offset of the end of the curve
    -> Float
    -- ^ /@y2@/: y offset of the end of the curve
    -> Float
    -- ^ /@weight@/: weight of the curve, must be greater than zero
    -> m ()
pathBuilderRelConicTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> Float -> Float -> Float -> m ()
pathBuilderRelConicTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 Float
weight = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    let weight' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
weight
    gsk_path_builder_rel_conic_to self' x1' y1' x2' y2' weight'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderRelConicToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderRelConicToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderRelConicTo

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


#endif

-- method PathBuilder::rel_cubic_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x offset of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y offset of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x offset of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y offset of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x3"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x offset of the end of the curve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y3"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y offset of the end of the curve"
--                 , 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_builder_rel_cubic_to" gsk_path_builder_rel_cubic_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    CFloat ->                               -- x3 : TBasicType TFloat
    CFloat ->                               -- y3 : TBasicType TFloat
    IO ()

-- | Adds a <https://en.wikipedia.org/wiki/B%C3%A9zier_curve cubic Bézier curve>
-- from the current point to /@x3@/, /@y3@/ with /@x1@/, /@y1@/ and /@x2@/, /@y2@/ as the control
-- points.
-- 
-- All coordinates are given relative to the current point.
-- 
-- This is the relative version of 'GI.Gsk.Structs.PathBuilder.pathBuilderCubicTo'.
-- 
-- /Since: 4.14/
pathBuilderRelCubicTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x offset of first control point
    -> Float
    -- ^ /@y1@/: y offset of first control point
    -> Float
    -- ^ /@x2@/: x offset of second control point
    -> Float
    -- ^ /@y2@/: y offset of second control point
    -> Float
    -- ^ /@x3@/: x offset of the end of the curve
    -> Float
    -- ^ /@y3@/: y offset of the end of the curve
    -> m ()
pathBuilderRelCubicTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder
-> Float -> Float -> Float -> Float -> Float -> Float -> m ()
pathBuilderRelCubicTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 Float
x3 Float
y3 = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    let x3' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x3
    let y3' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y3
    gsk_path_builder_rel_cubic_to self' x1' y1' x2' y2' x3' y3'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderRelCubicToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderRelCubicToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderRelCubicTo

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


#endif

-- method PathBuilder::rel_html_arc_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of first control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of second control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "radius"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "radius of the circle"
--                 , 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_builder_rel_html_arc_to" gsk_path_builder_rel_html_arc_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    CFloat ->                               -- radius : TBasicType TFloat
    IO ()

-- | Implements arc-to according to the HTML Canvas spec.
-- 
-- All coordinates are given relative to the current point.
-- 
-- This is the relative version of 'GI.Gsk.Structs.PathBuilder.pathBuilderHtmlArcTo'.
-- 
-- /Since: 4.14/
pathBuilderRelHtmlArcTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x coordinate of first control point
    -> Float
    -- ^ /@y1@/: y coordinate of first control point
    -> Float
    -- ^ /@x2@/: x coordinate of second control point
    -> Float
    -- ^ /@y2@/: y coordinate of second control point
    -> Float
    -- ^ /@radius@/: radius of the circle
    -> m ()
pathBuilderRelHtmlArcTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> Float -> Float -> Float -> m ()
pathBuilderRelHtmlArcTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 Float
radius = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    let radius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
radius
    gsk_path_builder_rel_html_arc_to self' x1' y1' x2' y2' radius'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderRelHtmlArcToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderRelHtmlArcToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderRelHtmlArcTo

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


#endif

-- method PathBuilder::rel_line_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x offset" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y offset" , 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_builder_rel_line_to" gsk_path_builder_rel_line_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO ()

-- | Draws a line from the current point to a point offset from it
-- by /@x@/, /@y@/ and makes it the new current point.
-- 
-- This is the relative version of 'GI.Gsk.Structs.PathBuilder.pathBuilderLineTo'.
-- 
-- /Since: 4.14/
pathBuilderRelLineTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x@/: x offset
    -> Float
    -- ^ /@y@/: y offset
    -> m ()
pathBuilderRelLineTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> m ()
pathBuilderRelLineTo PathBuilder
self Float
x Float
y = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    gsk_path_builder_rel_line_to self' x' y'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderRelLineToMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderRelLineToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderRelLineTo

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


#endif

-- method PathBuilder::rel_move_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x offset" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y offset" , 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_builder_rel_move_to" gsk_path_builder_rel_move_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO ()

-- | Starts a new contour by placing the pen at /@x@/, /@y@/
-- relative to the current point.
-- 
-- This is the relative version of 'GI.Gsk.Structs.PathBuilder.pathBuilderMoveTo'.
-- 
-- /Since: 4.14/
pathBuilderRelMoveTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x@/: x offset
    -> Float
    -- ^ /@y@/: y offset
    -> m ()
pathBuilderRelMoveTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> m ()
pathBuilderRelMoveTo PathBuilder
self Float
x Float
y = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    gsk_path_builder_rel_move_to self' x' y'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderRelMoveToMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderRelMoveToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderRelMoveTo

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


#endif

-- method PathBuilder::rel_quad_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x offset of control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y1"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y offset of control point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x offset of the end of the curve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y2"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y offset of the end of the curve"
--                 , 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_builder_rel_quad_to" gsk_path_builder_rel_quad_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- x1 : TBasicType TFloat
    CFloat ->                               -- y1 : TBasicType TFloat
    CFloat ->                               -- x2 : TBasicType TFloat
    CFloat ->                               -- y2 : TBasicType TFloat
    IO ()

-- | Adds a <https://en.wikipedia.org/wiki/B%C3%A9zier_curve quadratic Bézier curve>
-- from the current point to /@x2@/, /@y2@/ with /@x1@/, /@y1@/ the control point.
-- 
-- All coordinates are given relative to the current point.
-- 
-- This is the relative version of 'GI.Gsk.Structs.PathBuilder.pathBuilderQuadTo'.
-- 
-- /Since: 4.14/
pathBuilderRelQuadTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@x1@/: x offset of control point
    -> Float
    -- ^ /@y1@/: y offset of control point
    -> Float
    -- ^ /@x2@/: x offset of the end of the curve
    -> Float
    -- ^ /@y2@/: y offset of the end of the curve
    -> m ()
pathBuilderRelQuadTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> Float -> Float -> Float -> Float -> m ()
pathBuilderRelQuadTo PathBuilder
self Float
x1 Float
y1 Float
x2 Float
y2 = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
    let y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
    let x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
    let y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
    gsk_path_builder_rel_quad_to self' x1' y1' x2' y2'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderRelQuadToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderRelQuadToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderRelQuadTo

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


#endif

-- method PathBuilder::rel_svg_arc_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rx"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x radius" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ry"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y radius" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x_axis_rotation"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rotation of the ellipsis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "large_arc"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to add the large arc"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "positive_sweep"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to sweep in the positive direction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of the endpoint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of the endpoint"
--                 , 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_builder_rel_svg_arc_to" gsk_path_builder_rel_svg_arc_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- rx : TBasicType TFloat
    CFloat ->                               -- ry : TBasicType TFloat
    CFloat ->                               -- x_axis_rotation : TBasicType TFloat
    CInt ->                                 -- large_arc : TBasicType TBoolean
    CInt ->                                 -- positive_sweep : TBasicType TBoolean
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO ()

-- | Implements arc-to according to the SVG spec.
-- 
-- All coordinates are given relative to the current point.
-- 
-- This is the relative version of 'GI.Gsk.Structs.PathBuilder.pathBuilderSvgArcTo'.
-- 
-- /Since: 4.14/
pathBuilderRelSvgArcTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@rx@/: x radius
    -> Float
    -- ^ /@ry@/: y radius
    -> Float
    -- ^ /@xAxisRotation@/: the rotation of the ellipsis
    -> Bool
    -- ^ /@largeArc@/: whether to add the large arc
    -> Bool
    -- ^ /@positiveSweep@/: whether to sweep in the positive direction
    -> Float
    -- ^ /@x@/: x coordinate of the endpoint
    -> Float
    -- ^ /@y@/: y coordinate of the endpoint
    -> m ()
pathBuilderRelSvgArcTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder
-> Float
-> Float
-> Float
-> Bool
-> Bool
-> Float
-> Float
-> m ()
pathBuilderRelSvgArcTo PathBuilder
self Float
rx Float
ry Float
xAxisRotation Bool
largeArc Bool
positiveSweep Float
x Float
y = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let rx' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
rx
    let ry' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
ry
    let xAxisRotation' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xAxisRotation
    let largeArc' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
largeArc
    let positiveSweep' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
positiveSweep
    let x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    gsk_path_builder_rel_svg_arc_to self' rx' ry' xAxisRotation' largeArc' positiveSweep' x' y'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderRelSvgArcToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Bool -> Bool -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderRelSvgArcToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderRelSvgArcTo

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


#endif

-- method PathBuilder::svg_arc_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "PathBuilder" }
--           , argCType = Just "GskPathBuilder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a path builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rx"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x radius" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ry"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y radius" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x_axis_rotation"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rotation of the ellipsis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "large_arc"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to add the large arc"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "positive_sweep"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to sweep in the positive direction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x coordinate of the endpoint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y coordinate of the endpoint"
--                 , 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_builder_svg_arc_to" gsk_path_builder_svg_arc_to :: 
    Ptr PathBuilder ->                      -- self : TInterface (Name {namespace = "Gsk", name = "PathBuilder"})
    CFloat ->                               -- rx : TBasicType TFloat
    CFloat ->                               -- ry : TBasicType TFloat
    CFloat ->                               -- x_axis_rotation : TBasicType TFloat
    CInt ->                                 -- large_arc : TBasicType TBoolean
    CInt ->                                 -- positive_sweep : TBasicType TBoolean
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO ()

-- | Implements arc-to according to the SVG spec.
-- 
-- A convenience function that implements the
-- <https://www.w3.org/TR/SVG11/paths.html#PathDataEllipticalArcCommands SVG arc_to>
-- functionality.
-- 
-- After this, /@x@/, /@y@/ will be the new current point.
-- 
-- /Since: 4.14/
pathBuilderSvgArcTo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> Float
    -- ^ /@rx@/: x radius
    -> Float
    -- ^ /@ry@/: y radius
    -> Float
    -- ^ /@xAxisRotation@/: the rotation of the ellipsis
    -> Bool
    -- ^ /@largeArc@/: whether to add the large arc
    -> Bool
    -- ^ /@positiveSweep@/: whether to sweep in the positive direction
    -> Float
    -- ^ /@x@/: x coordinate of the endpoint
    -> Float
    -- ^ /@y@/: y coordinate of the endpoint
    -> m ()
pathBuilderSvgArcTo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder
-> Float
-> Float
-> Float
-> Bool
-> Bool
-> Float
-> Float
-> m ()
pathBuilderSvgArcTo PathBuilder
self Float
rx Float
ry Float
xAxisRotation Bool
largeArc Bool
positiveSweep Float
x Float
y = 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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    let rx' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
rx
    let ry' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
ry
    let xAxisRotation' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xAxisRotation
    let largeArc' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
largeArc
    let positiveSweep' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
positiveSweep
    let x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    gsk_path_builder_svg_arc_to self' rx' ry' xAxisRotation' largeArc' positiveSweep' x' y'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderSvgArcToMethodInfo
instance (signature ~ (Float -> Float -> Float -> Bool -> Bool -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod PathBuilderSvgArcToMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderSvgArcTo

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


#endif

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

-- | Creates a new path from the given builder.
-- 
-- The given @GskPathBuilder@ is reset to the initial state once this
-- function returns. Calling this function again on the same builder
-- instance will therefore produce an empty path, not a copy of the same
-- path.
-- 
-- This function is intended primarily for language bindings.
-- C code should use t'GI.Gsk.Structs.PathBuilder.PathBuilder'.@/free_to_path/@().
-- 
-- /Since: 4.14/
pathBuilderToPath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> m Gsk.Path.Path
    -- ^ __Returns:__ the newly created path
    --   with all the contours added to the builder
pathBuilderToPath :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> m Path
pathBuilderToPath PathBuilder
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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    result <- gsk_path_builder_to_path self'
    checkUnexpectedReturnNULL "pathBuilderToPath" result
    result' <- (wrapBoxed Gsk.Path.Path) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data PathBuilderToPathMethodInfo
instance (signature ~ (m Gsk.Path.Path), MonadIO m) => O.OverloadedMethod PathBuilderToPathMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderToPath

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


#endif

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

-- | Releases a reference on the given builder.
-- 
-- /Since: 4.14/
pathBuilderUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PathBuilder
    -- ^ /@self@/: a path builder
    -> m ()
pathBuilderUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PathBuilder -> m ()
pathBuilderUnref PathBuilder
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' <- PathBuilder -> IO (Ptr PathBuilder)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PathBuilder
self
    gsk_path_builder_unref self'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PathBuilderUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod PathBuilderUnrefMethodInfo PathBuilder signature where
    overloadedMethod = pathBuilderUnref

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


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolvePathBuilderMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolvePathBuilderMethod "addCairoPath" o = PathBuilderAddCairoPathMethodInfo
    ResolvePathBuilderMethod "addCircle" o = PathBuilderAddCircleMethodInfo
    ResolvePathBuilderMethod "addLayout" o = PathBuilderAddLayoutMethodInfo
    ResolvePathBuilderMethod "addPath" o = PathBuilderAddPathMethodInfo
    ResolvePathBuilderMethod "addRect" o = PathBuilderAddRectMethodInfo
    ResolvePathBuilderMethod "addReversePath" o = PathBuilderAddReversePathMethodInfo
    ResolvePathBuilderMethod "addRoundedRect" o = PathBuilderAddRoundedRectMethodInfo
    ResolvePathBuilderMethod "addSegment" o = PathBuilderAddSegmentMethodInfo
    ResolvePathBuilderMethod "arcTo" o = PathBuilderArcToMethodInfo
    ResolvePathBuilderMethod "close" o = PathBuilderCloseMethodInfo
    ResolvePathBuilderMethod "conicTo" o = PathBuilderConicToMethodInfo
    ResolvePathBuilderMethod "cubicTo" o = PathBuilderCubicToMethodInfo
    ResolvePathBuilderMethod "htmlArcTo" o = PathBuilderHtmlArcToMethodInfo
    ResolvePathBuilderMethod "lineTo" o = PathBuilderLineToMethodInfo
    ResolvePathBuilderMethod "moveTo" o = PathBuilderMoveToMethodInfo
    ResolvePathBuilderMethod "quadTo" o = PathBuilderQuadToMethodInfo
    ResolvePathBuilderMethod "ref" o = PathBuilderRefMethodInfo
    ResolvePathBuilderMethod "relArcTo" o = PathBuilderRelArcToMethodInfo
    ResolvePathBuilderMethod "relConicTo" o = PathBuilderRelConicToMethodInfo
    ResolvePathBuilderMethod "relCubicTo" o = PathBuilderRelCubicToMethodInfo
    ResolvePathBuilderMethod "relHtmlArcTo" o = PathBuilderRelHtmlArcToMethodInfo
    ResolvePathBuilderMethod "relLineTo" o = PathBuilderRelLineToMethodInfo
    ResolvePathBuilderMethod "relMoveTo" o = PathBuilderRelMoveToMethodInfo
    ResolvePathBuilderMethod "relQuadTo" o = PathBuilderRelQuadToMethodInfo
    ResolvePathBuilderMethod "relSvgArcTo" o = PathBuilderRelSvgArcToMethodInfo
    ResolvePathBuilderMethod "svgArcTo" o = PathBuilderSvgArcToMethodInfo
    ResolvePathBuilderMethod "toPath" o = PathBuilderToPathMethodInfo
    ResolvePathBuilderMethod "unref" o = PathBuilderUnrefMethodInfo
    ResolvePathBuilderMethod "getCurrentPoint" o = PathBuilderGetCurrentPointMethodInfo
    ResolvePathBuilderMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif