{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Collects the parameters that are needed when stroking a path.
-- 
-- /Since: 4.14/

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

module GI.Gsk.Structs.Stroke
    ( 

-- * Exported types
    Stroke(..)                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.Gsk.Structs.Stroke#g:method:copy"), [free]("GI.Gsk.Structs.Stroke#g:method:free"), [toCairo]("GI.Gsk.Structs.Stroke#g:method:toCairo").
-- 
-- ==== Getters
-- [getDash]("GI.Gsk.Structs.Stroke#g:method:getDash"), [getDashOffset]("GI.Gsk.Structs.Stroke#g:method:getDashOffset"), [getLineCap]("GI.Gsk.Structs.Stroke#g:method:getLineCap"), [getLineJoin]("GI.Gsk.Structs.Stroke#g:method:getLineJoin"), [getLineWidth]("GI.Gsk.Structs.Stroke#g:method:getLineWidth"), [getMiterLimit]("GI.Gsk.Structs.Stroke#g:method:getMiterLimit").
-- 
-- ==== Setters
-- [setDash]("GI.Gsk.Structs.Stroke#g:method:setDash"), [setDashOffset]("GI.Gsk.Structs.Stroke#g:method:setDashOffset"), [setLineCap]("GI.Gsk.Structs.Stroke#g:method:setLineCap"), [setLineJoin]("GI.Gsk.Structs.Stroke#g:method:setLineJoin"), [setLineWidth]("GI.Gsk.Structs.Stroke#g:method:setLineWidth"), [setMiterLimit]("GI.Gsk.Structs.Stroke#g:method:setMiterLimit").

#if defined(ENABLE_OVERLOADING)
    ResolveStrokeMethod                     ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    StrokeCopyMethodInfo                    ,
#endif
    strokeCopy                              ,


-- ** equal #method:equal#

    strokeEqual                             ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    StrokeFreeMethodInfo                    ,
#endif
    strokeFree                              ,


-- ** getDash #method:getDash#

#if defined(ENABLE_OVERLOADING)
    StrokeGetDashMethodInfo                 ,
#endif
    strokeGetDash                           ,


-- ** getDashOffset #method:getDashOffset#

#if defined(ENABLE_OVERLOADING)
    StrokeGetDashOffsetMethodInfo           ,
#endif
    strokeGetDashOffset                     ,


-- ** getLineCap #method:getLineCap#

#if defined(ENABLE_OVERLOADING)
    StrokeGetLineCapMethodInfo              ,
#endif
    strokeGetLineCap                        ,


-- ** getLineJoin #method:getLineJoin#

#if defined(ENABLE_OVERLOADING)
    StrokeGetLineJoinMethodInfo             ,
#endif
    strokeGetLineJoin                       ,


-- ** getLineWidth #method:getLineWidth#

#if defined(ENABLE_OVERLOADING)
    StrokeGetLineWidthMethodInfo            ,
#endif
    strokeGetLineWidth                      ,


-- ** getMiterLimit #method:getMiterLimit#

#if defined(ENABLE_OVERLOADING)
    StrokeGetMiterLimitMethodInfo           ,
#endif
    strokeGetMiterLimit                     ,


-- ** new #method:new#

    strokeNew                               ,


-- ** setDash #method:setDash#

#if defined(ENABLE_OVERLOADING)
    StrokeSetDashMethodInfo                 ,
#endif
    strokeSetDash                           ,


-- ** setDashOffset #method:setDashOffset#

#if defined(ENABLE_OVERLOADING)
    StrokeSetDashOffsetMethodInfo           ,
#endif
    strokeSetDashOffset                     ,


-- ** setLineCap #method:setLineCap#

#if defined(ENABLE_OVERLOADING)
    StrokeSetLineCapMethodInfo              ,
#endif
    strokeSetLineCap                        ,


-- ** setLineJoin #method:setLineJoin#

#if defined(ENABLE_OVERLOADING)
    StrokeSetLineJoinMethodInfo             ,
#endif
    strokeSetLineJoin                       ,


-- ** setLineWidth #method:setLineWidth#

#if defined(ENABLE_OVERLOADING)
    StrokeSetLineWidthMethodInfo            ,
#endif
    strokeSetLineWidth                      ,


-- ** setMiterLimit #method:setMiterLimit#

#if defined(ENABLE_OVERLOADING)
    StrokeSetMiterLimitMethodInfo           ,
#endif
    strokeSetMiterLimit                     ,


-- ** toCairo #method:toCairo#

#if defined(ENABLE_OVERLOADING)
    StrokeToCairoMethodInfo                 ,
#endif
    strokeToCairo                           ,




    ) 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 {-# SOURCE #-} qualified GI.Gsk.Enums as Gsk.Enums

#else
import qualified GI.Cairo.Structs.Context as Cairo.Context
import {-# SOURCE #-} qualified GI.Gsk.Enums as Gsk.Enums

#endif

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

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

foreign import ccall "gsk_stroke_get_type" c_gsk_stroke_get_type :: 
    IO GType

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

instance B.Types.TypedObject Stroke where
    glibType :: IO GType
glibType = IO GType
c_gsk_stroke_get_type

instance B.Types.GBoxed Stroke

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


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

-- method Stroke::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "line_width"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "line width of the stroke. Must be > 0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Stroke" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_stroke_new" gsk_stroke_new :: 
    CFloat ->                               -- line_width : TBasicType TFloat
    IO (Ptr Stroke)

-- | Creates a new @GskStroke@ with the given /@lineWidth@/.
-- 
-- /Since: 4.14/
strokeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Float
    -- ^ /@lineWidth@/: line width of the stroke. Must be > 0
    -> m Stroke
    -- ^ __Returns:__ a new @GskStroke@
strokeNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Float -> m Stroke
strokeNew Float
lineWidth = IO Stroke -> m Stroke
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Stroke -> m Stroke) -> IO Stroke -> m Stroke
forall a b. (a -> b) -> a -> b
$ do
    let lineWidth' :: CFloat
lineWidth' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
lineWidth
    result <- CFloat -> IO (Ptr Stroke)
gsk_stroke_new CFloat
lineWidth'
    checkUnexpectedReturnNULL "strokeNew" result
    result' <- (wrapBoxed Stroke) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gsk_stroke_copy" gsk_stroke_copy :: 
    Ptr Stroke ->                           -- other : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    IO (Ptr Stroke)

-- | Creates a copy of a @GskStroke@.
-- 
-- /Since: 4.14/
strokeCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@other@/: the stroke to copy
    -> m Stroke
    -- ^ __Returns:__ a new @GskStroke@. Use 'GI.Gsk.Structs.Stroke.strokeFree' to free it
strokeCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> m Stroke
strokeCopy Stroke
other = IO Stroke -> m Stroke
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Stroke -> m Stroke) -> IO Stroke -> m Stroke
forall a b. (a -> b) -> a -> b
$ do
    other' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
other
    result <- gsk_stroke_copy other'
    checkUnexpectedReturnNULL "strokeCopy" result
    result' <- (wrapBoxed Stroke) result
    touchManagedPtr other
    return result'

#if defined(ENABLE_OVERLOADING)
data StrokeCopyMethodInfo
instance (signature ~ (m Stroke), MonadIO m) => O.OverloadedMethod StrokeCopyMethodInfo Stroke signature where
    overloadedMethod = strokeCopy

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


#endif

-- method Stroke::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Stroke" }
--           , argCType = Just "GskStroke*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a stroke" , 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_stroke_free" gsk_stroke_free :: 
    Ptr Stroke ->                           -- self : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    IO ()

-- | Frees a @GskStroke@.
-- 
-- /Since: 4.14/
strokeFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> m ()
strokeFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Stroke -> m ()
strokeFree Stroke
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' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    gsk_stroke_free self'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data StrokeFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod StrokeFreeMethodInfo Stroke signature where
    overloadedMethod = strokeFree

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


#endif

-- method Stroke::get_dash
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Stroke" }
--           , argCType = Just "const GskStroke*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a stroke" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_dash"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "number of elements in the array returned"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_dash"
--              , argType = TBasicType TSize
--              , argCType = Just "gsize*"
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of elements in the array returned"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 1 (TBasicType TFloat))
-- throws : False
-- Skip return : False

foreign import ccall "gsk_stroke_get_dash" gsk_stroke_get_dash :: 
    Ptr Stroke ->                           -- self : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    Ptr FCT.CSize ->                        -- n_dash : TBasicType TSize
    IO (Ptr CFloat)

-- | Gets the dash array in use.
-- 
-- /Since: 4.14/
strokeGetDash ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> m (Maybe [Float])
    -- ^ __Returns:__ 
    --   the dash array or @NULL@ if the dash array is empty
strokeGetDash :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> m (Maybe [Float])
strokeGetDash Stroke
self = IO (Maybe [Float]) -> m (Maybe [Float])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [Float]) -> m (Maybe [Float]))
-> IO (Maybe [Float]) -> m (Maybe [Float])
forall a b. (a -> b) -> a -> b
$ do
    self' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    nDash <- allocMem :: IO (Ptr FCT.CSize)
    result <- gsk_stroke_get_dash self' nDash
    nDash' <- peek nDash
    maybeResult <- convertIfNonNull result $ \Ptr CFloat
result' -> do
        result'' <- ((CFloat -> Float) -> CSize -> Ptr CFloat -> IO [Float]
forall a b c.
(Integral a, Storable b) =>
(b -> c) -> a -> Ptr b -> IO [c]
unpackMapStorableArrayWithLength CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CSize
nDash') Ptr CFloat
result'
        return result''
    touchManagedPtr self
    freeMem nDash
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data StrokeGetDashMethodInfo
instance (signature ~ (m (Maybe [Float])), MonadIO m) => O.OverloadedMethod StrokeGetDashMethodInfo Stroke signature where
    overloadedMethod = strokeGetDash

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


#endif

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

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

-- | Gets the dash offset.
-- 
-- /Since: 4.14/
strokeGetDashOffset ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> m Float
    -- ^ __Returns:__ the dash offset
strokeGetDashOffset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> m Float
strokeGetDashOffset Stroke
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    self' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    result <- gsk_stroke_get_dash_offset self'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data StrokeGetDashOffsetMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod StrokeGetDashOffsetMethodInfo Stroke signature where
    overloadedMethod = strokeGetDashOffset

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


#endif

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

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

-- | Gets the line cap used.
-- 
-- See t'GI.Gsk.Enums.LineCap' for details.
-- 
-- /Since: 4.14/
strokeGetLineCap ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> m Gsk.Enums.LineCap
    -- ^ __Returns:__ the line cap
strokeGetLineCap :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> m LineCap
strokeGetLineCap Stroke
self = IO LineCap -> m LineCap
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LineCap -> m LineCap) -> IO LineCap -> m LineCap
forall a b. (a -> b) -> a -> b
$ do
    self' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    result <- gsk_stroke_get_line_cap self'
    let result' = (Int -> LineCap
forall a. Enum a => Int -> a
toEnum (Int -> LineCap) -> (CUInt -> Int) -> CUInt -> LineCap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data StrokeGetLineCapMethodInfo
instance (signature ~ (m Gsk.Enums.LineCap), MonadIO m) => O.OverloadedMethod StrokeGetLineCapMethodInfo Stroke signature where
    overloadedMethod = strokeGetLineCap

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


#endif

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

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

-- | Gets the line join used.
-- 
-- See t'GI.Gsk.Enums.LineJoin' for details.
-- 
-- /Since: 4.14/
strokeGetLineJoin ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> m Gsk.Enums.LineJoin
    -- ^ __Returns:__ the line join
strokeGetLineJoin :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> m LineJoin
strokeGetLineJoin Stroke
self = IO LineJoin -> m LineJoin
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LineJoin -> m LineJoin) -> IO LineJoin -> m LineJoin
forall a b. (a -> b) -> a -> b
$ do
    self' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    result <- gsk_stroke_get_line_join self'
    let result' = (Int -> LineJoin
forall a. Enum a => Int -> a
toEnum (Int -> LineJoin) -> (CUInt -> Int) -> CUInt -> LineJoin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data StrokeGetLineJoinMethodInfo
instance (signature ~ (m Gsk.Enums.LineJoin), MonadIO m) => O.OverloadedMethod StrokeGetLineJoinMethodInfo Stroke signature where
    overloadedMethod = strokeGetLineJoin

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


#endif

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

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

-- | Gets the line width used.
-- 
-- /Since: 4.14/
strokeGetLineWidth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> m Float
    -- ^ __Returns:__ the line width
strokeGetLineWidth :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> m Float
strokeGetLineWidth Stroke
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    self' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    result <- gsk_stroke_get_line_width self'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data StrokeGetLineWidthMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod StrokeGetLineWidthMethodInfo Stroke signature where
    overloadedMethod = strokeGetLineWidth

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


#endif

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

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

-- | Gets the miter limit.
-- 
-- /Since: 4.14/
strokeGetMiterLimit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> m Float
    -- ^ __Returns:__ the miter limit
strokeGetMiterLimit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> m Float
strokeGetMiterLimit Stroke
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    self' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    result <- gsk_stroke_get_miter_limit self'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data StrokeGetMiterLimitMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod StrokeGetMiterLimitMethodInfo Stroke signature where
    overloadedMethod = strokeGetMiterLimit

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


#endif

-- method Stroke::set_dash
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Stroke" }
--           , argCType = Just "GskStroke*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a stroke" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dash"
--           , argType = TCArray False (-1) 2 (TBasicType TFloat)
--           , argCType = Just "const float*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "\n  the array of dashes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_dash"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "number of elements in @dash"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_dash"
--              , argType = TBasicType TSize
--              , argCType = Just "gsize"
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of elements in @dash"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gsk_stroke_set_dash" gsk_stroke_set_dash :: 
    Ptr Stroke ->                           -- self : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    Ptr CFloat ->                           -- dash : TCArray False (-1) 2 (TBasicType TFloat)
    FCT.CSize ->                            -- n_dash : TBasicType TSize
    IO ()

-- | Sets the dash pattern to use.
-- 
-- A dash pattern is specified by an array of alternating non-negative
-- values. Each value provides the length of alternate \"on\" and \"off\"
-- portions of the stroke.
-- 
-- Each \"on\" segment will have caps applied as if the segment were a
-- separate contour. In particular, it is valid to use an \"on\" length
-- of 0 with 'GI.Gsk.Enums.LineCapRound' or 'GI.Gsk.Enums.LineCapSquare'
-- to draw dots or squares along a path.
-- 
-- If /@nDash@/ is 0, if all elements in /@dash@/ are 0, or if there are
-- negative values in /@dash@/, then dashing is disabled.
-- 
-- If /@nDash@/ is 1, an alternating \"on\" and \"off\" pattern with the
-- single dash length provided is assumed.
-- 
-- If /@nDash@/ is uneven, the dash array will be used with the first
-- element in /@dash@/ defining an \"on\" or \"off\" in alternating passes
-- through the array.
-- 
-- You can specify a starting offset into the dash with
-- 'GI.Gsk.Structs.Stroke.strokeSetDashOffset'.
-- 
-- /Since: 4.14/
strokeSetDash ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> Maybe ([Float])
    -- ^ /@dash@/: 
    --   the array of dashes
    -> m ()
strokeSetDash :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> Maybe [Float] -> m ()
strokeSetDash Stroke
self Maybe [Float]
dash = 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
    let nDash :: CSize
nDash = case Maybe [Float]
dash of
            Maybe [Float]
Nothing -> CSize
0
            Just [Float]
jDash -> Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ [Float] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Float]
jDash
    self' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    maybeDash <- case dash of
        Maybe [Float]
Nothing -> Ptr CFloat -> IO (Ptr CFloat)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CFloat
forall a. Ptr a
FP.nullPtr
        Just [Float]
jDash -> do
            jDash' <- ((Float -> CFloat) -> [Float] -> IO (Ptr CFloat)
forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapStorableArray Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac) [Float]
jDash
            return jDash'
    gsk_stroke_set_dash self' maybeDash nDash
    touchManagedPtr self
    freeMem maybeDash
    return ()

#if defined(ENABLE_OVERLOADING)
data StrokeSetDashMethodInfo
instance (signature ~ (Maybe ([Float]) -> m ()), MonadIO m) => O.OverloadedMethod StrokeSetDashMethodInfo Stroke signature where
    overloadedMethod = strokeSetDash

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


#endif

-- method Stroke::set_dash_offset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Stroke" }
--           , argCType = Just "GskStroke*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a stroke" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "offset"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "offset into the dash pattern"
--                 , 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_stroke_set_dash_offset" gsk_stroke_set_dash_offset :: 
    Ptr Stroke ->                           -- self : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    CFloat ->                               -- offset : TBasicType TFloat
    IO ()

-- | Sets the offset into the dash pattern where dashing should begin.
-- 
-- This is an offset into the length of the path, not an index into
-- the array values of the dash array.
-- 
-- See 'GI.Gsk.Structs.Stroke.strokeSetDash' for more details on dashing.
-- 
-- /Since: 4.14/
strokeSetDashOffset ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> Float
    -- ^ /@offset@/: offset into the dash pattern
    -> m ()
strokeSetDashOffset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> Float -> m ()
strokeSetDashOffset Stroke
self Float
offset = 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' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    let offset' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
offset
    gsk_stroke_set_dash_offset self' offset'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data StrokeSetDashOffsetMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod StrokeSetDashOffsetMethodInfo Stroke signature where
    overloadedMethod = strokeSetDashOffset

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


#endif

-- method Stroke::set_line_cap
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Stroke" }
--           , argCType = Just "GskStroke*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a stroke" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "line_cap"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "LineCap" }
--           , argCType = Just "GskLineCap"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the line cap" , 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_stroke_set_line_cap" gsk_stroke_set_line_cap :: 
    Ptr Stroke ->                           -- self : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    CUInt ->                                -- line_cap : TInterface (Name {namespace = "Gsk", name = "LineCap"})
    IO ()

-- | Sets the line cap to be used when stroking.
-- 
-- See t'GI.Gsk.Enums.LineCap' for details.
-- 
-- /Since: 4.14/
strokeSetLineCap ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> Gsk.Enums.LineCap
    -- ^ /@lineCap@/: the line cap
    -> m ()
strokeSetLineCap :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> LineCap -> m ()
strokeSetLineCap Stroke
self LineCap
lineCap = 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' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    let lineCap' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (LineCap -> Int) -> LineCap -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LineCap -> Int
forall a. Enum a => a -> Int
fromEnum) LineCap
lineCap
    gsk_stroke_set_line_cap self' lineCap'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data StrokeSetLineCapMethodInfo
instance (signature ~ (Gsk.Enums.LineCap -> m ()), MonadIO m) => O.OverloadedMethod StrokeSetLineCapMethodInfo Stroke signature where
    overloadedMethod = strokeSetLineCap

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


#endif

-- method Stroke::set_line_join
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Stroke" }
--           , argCType = Just "GskStroke*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a stroke" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "line_join"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "LineJoin" }
--           , argCType = Just "GskLineJoin"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the line join to use"
--                 , 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_stroke_set_line_join" gsk_stroke_set_line_join :: 
    Ptr Stroke ->                           -- self : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    CUInt ->                                -- line_join : TInterface (Name {namespace = "Gsk", name = "LineJoin"})
    IO ()

-- | Sets the line join to be used when stroking.
-- 
-- See t'GI.Gsk.Enums.LineJoin' for details.
-- 
-- /Since: 4.14/
strokeSetLineJoin ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> Gsk.Enums.LineJoin
    -- ^ /@lineJoin@/: the line join to use
    -> m ()
strokeSetLineJoin :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> LineJoin -> m ()
strokeSetLineJoin Stroke
self LineJoin
lineJoin = 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' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    let lineJoin' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (LineJoin -> Int) -> LineJoin -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LineJoin -> Int
forall a. Enum a => a -> Int
fromEnum) LineJoin
lineJoin
    gsk_stroke_set_line_join self' lineJoin'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data StrokeSetLineJoinMethodInfo
instance (signature ~ (Gsk.Enums.LineJoin -> m ()), MonadIO m) => O.OverloadedMethod StrokeSetLineJoinMethodInfo Stroke signature where
    overloadedMethod = strokeSetLineJoin

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


#endif

-- method Stroke::set_line_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Stroke" }
--           , argCType = Just "GskStroke*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a stroke" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "line_width"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "width of the line in pixels"
--                 , 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_stroke_set_line_width" gsk_stroke_set_line_width :: 
    Ptr Stroke ->                           -- self : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    CFloat ->                               -- line_width : TBasicType TFloat
    IO ()

-- | Sets the line width to be used when stroking.
-- 
-- The line width must be >= 0.
-- 
-- /Since: 4.14/
strokeSetLineWidth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> Float
    -- ^ /@lineWidth@/: width of the line in pixels
    -> m ()
strokeSetLineWidth :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> Float -> m ()
strokeSetLineWidth Stroke
self Float
lineWidth = 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' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    let lineWidth' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
lineWidth
    gsk_stroke_set_line_width self' lineWidth'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data StrokeSetLineWidthMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod StrokeSetLineWidthMethodInfo Stroke signature where
    overloadedMethod = strokeSetLineWidth

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


#endif

-- method Stroke::set_miter_limit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Gsk" , name = "Stroke" }
--           , argCType = Just "GskStroke*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a stroke" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "limit"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the miter limit" , 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_stroke_set_miter_limit" gsk_stroke_set_miter_limit :: 
    Ptr Stroke ->                           -- self : TInterface (Name {namespace = "Gsk", name = "Stroke"})
    CFloat ->                               -- limit : TBasicType TFloat
    IO ()

-- | Sets the miter limit to be used when stroking.
-- 
-- The miter limit is the distance from the corner where sharp
-- turns of joins get cut off.
-- 
-- The limit is specfied in units of line width and must be non-negative.
-- 
-- For joins of type 'GI.Gsk.Enums.LineJoinMiter' that exceed the miter limit,
-- the join gets rendered as if it was of type 'GI.Gsk.Enums.LineJoinBevel'.
-- 
-- /Since: 4.14/
strokeSetMiterLimit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> Float
    -- ^ /@limit@/: the miter limit
    -> m ()
strokeSetMiterLimit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> Float -> m ()
strokeSetMiterLimit Stroke
self Float
limit = 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' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    let limit' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
limit
    gsk_stroke_set_miter_limit self' limit'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data StrokeSetMiterLimitMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod StrokeSetMiterLimitMethodInfo Stroke signature where
    overloadedMethod = strokeSetMiterLimit

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


#endif

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

-- | A helper function that sets the stroke parameters
-- of a cairo context from a @GskStroke@.
-- 
-- /Since: 4.14/
strokeToCairo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Stroke
    -- ^ /@self@/: a stroke
    -> Cairo.Context.Context
    -- ^ /@cr@/: the cairo context to configure
    -> m ()
strokeToCairo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Stroke -> Context -> m ()
strokeToCairo Stroke
self Context
cr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    self' <- Stroke -> IO (Ptr Stroke)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Stroke
self
    cr' <- unsafeManagedPtrGetPtr cr
    gsk_stroke_to_cairo self' cr'
    touchManagedPtr self
    touchManagedPtr cr
    return ()

#if defined(ENABLE_OVERLOADING)
data StrokeToCairoMethodInfo
instance (signature ~ (Cairo.Context.Context -> m ()), MonadIO m) => O.OverloadedMethod StrokeToCairoMethodInfo Stroke signature where
    overloadedMethod = strokeToCairo

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


#endif

-- method Stroke::equal
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "stroke1"
--           , argType = TBasicType TPtr
--           , argCType = Just "gconstpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the first stroke" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stroke2"
--           , argType = TBasicType TPtr
--           , argCType = Just "gconstpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the second stroke" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_stroke_equal" gsk_stroke_equal :: 
    Ptr () ->                               -- stroke1 : TBasicType TPtr
    Ptr () ->                               -- stroke2 : TBasicType TPtr
    IO CInt

-- | Checks if two strokes are identical.
-- 
-- /Since: 4.14/
strokeEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    -- ^ /@stroke1@/: the first stroke
    -> Ptr ()
    -- ^ /@stroke2@/: the second stroke
    -> m Bool
    -- ^ __Returns:__ true if the two strokes are equal, false otherwise
strokeEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Ptr () -> Ptr () -> m Bool
strokeEqual Ptr ()
stroke1 Ptr ()
stroke2 = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    result <- Ptr () -> Ptr () -> IO CInt
gsk_stroke_equal Ptr ()
stroke1 Ptr ()
stroke2
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveStrokeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveStrokeMethod "copy" o = StrokeCopyMethodInfo
    ResolveStrokeMethod "free" o = StrokeFreeMethodInfo
    ResolveStrokeMethod "toCairo" o = StrokeToCairoMethodInfo
    ResolveStrokeMethod "getDash" o = StrokeGetDashMethodInfo
    ResolveStrokeMethod "getDashOffset" o = StrokeGetDashOffsetMethodInfo
    ResolveStrokeMethod "getLineCap" o = StrokeGetLineCapMethodInfo
    ResolveStrokeMethod "getLineJoin" o = StrokeGetLineJoinMethodInfo
    ResolveStrokeMethod "getLineWidth" o = StrokeGetLineWidthMethodInfo
    ResolveStrokeMethod "getMiterLimit" o = StrokeGetMiterLimitMethodInfo
    ResolveStrokeMethod "setDash" o = StrokeSetDashMethodInfo
    ResolveStrokeMethod "setDashOffset" o = StrokeSetDashOffsetMethodInfo
    ResolveStrokeMethod "setLineCap" o = StrokeSetLineCapMethodInfo
    ResolveStrokeMethod "setLineJoin" o = StrokeSetLineJoinMethodInfo
    ResolveStrokeMethod "setLineWidth" o = StrokeSetLineWidthMethodInfo
    ResolveStrokeMethod "setMiterLimit" o = StrokeSetMiterLimitMethodInfo
    ResolveStrokeMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif