{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gsk.Objects.RadialGradientNode
(
RadialGradientNode(..) ,
IsRadialGradientNode ,
toRadialGradientNode ,
#if defined(ENABLE_OVERLOADING)
ResolveRadialGradientNodeMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
RadialGradientNodeGetCenterMethodInfo ,
#endif
radialGradientNodeGetCenter ,
#if defined(ENABLE_OVERLOADING)
RadialGradientNodeGetColorStopsMethodInfo,
#endif
radialGradientNodeGetColorStops ,
#if defined(ENABLE_OVERLOADING)
RadialGradientNodeGetEndMethodInfo ,
#endif
radialGradientNodeGetEnd ,
#if defined(ENABLE_OVERLOADING)
RadialGradientNodeGetHradiusMethodInfo ,
#endif
radialGradientNodeGetHradius ,
#if defined(ENABLE_OVERLOADING)
RadialGradientNodeGetNColorStopsMethodInfo,
#endif
radialGradientNodeGetNColorStops ,
#if defined(ENABLE_OVERLOADING)
RadialGradientNodeGetStartMethodInfo ,
#endif
radialGradientNodeGetStart ,
#if defined(ENABLE_OVERLOADING)
RadialGradientNodeGetVradiusMethodInfo ,
#endif
radialGradientNodeGetVradius ,
radialGradientNodeNew ,
) 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 GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import {-# SOURCE #-} qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
import {-# SOURCE #-} qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
newtype RadialGradientNode = RadialGradientNode (SP.ManagedPtr RadialGradientNode)
deriving (RadialGradientNode -> RadialGradientNode -> Bool
(RadialGradientNode -> RadialGradientNode -> Bool)
-> (RadialGradientNode -> RadialGradientNode -> Bool)
-> Eq RadialGradientNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RadialGradientNode -> RadialGradientNode -> Bool
== :: RadialGradientNode -> RadialGradientNode -> Bool
$c/= :: RadialGradientNode -> RadialGradientNode -> Bool
/= :: RadialGradientNode -> RadialGradientNode -> Bool
Eq)
instance SP.ManagedPtrNewtype RadialGradientNode where
toManagedPtr :: RadialGradientNode -> ManagedPtr RadialGradientNode
toManagedPtr (RadialGradientNode ManagedPtr RadialGradientNode
p) = ManagedPtr RadialGradientNode
p
foreign import ccall "gsk_radial_gradient_node_get_type"
c_gsk_radial_gradient_node_get_type :: IO B.Types.GType
instance B.Types.TypedObject RadialGradientNode where
glibType :: IO GType
glibType = IO GType
c_gsk_radial_gradient_node_get_type
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf RadialGradientNode o) => IsRadialGradientNode o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf RadialGradientNode o) => IsRadialGradientNode o
instance O.HasParentTypes RadialGradientNode
type instance O.ParentTypes RadialGradientNode = '[Gsk.RenderNode.RenderNode]
toRadialGradientNode :: (MIO.MonadIO m, IsRadialGradientNode o) => o -> m RadialGradientNode
toRadialGradientNode :: forall (m :: * -> *) o.
(MonadIO m, IsRadialGradientNode o) =>
o -> m RadialGradientNode
toRadialGradientNode = IO RadialGradientNode -> m RadialGradientNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO RadialGradientNode -> m RadialGradientNode)
-> (o -> IO RadialGradientNode) -> o -> m RadialGradientNode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr RadialGradientNode -> RadialGradientNode)
-> o -> IO RadialGradientNode
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr RadialGradientNode -> RadialGradientNode
RadialGradientNode
#if defined(ENABLE_OVERLOADING)
type family ResolveRadialGradientNodeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveRadialGradientNodeMethod "draw" o = Gsk.RenderNode.RenderNodeDrawMethodInfo
ResolveRadialGradientNodeMethod "ref" o = Gsk.RenderNode.RenderNodeRefMethodInfo
ResolveRadialGradientNodeMethod "serialize" o = Gsk.RenderNode.RenderNodeSerializeMethodInfo
ResolveRadialGradientNodeMethod "unref" o = Gsk.RenderNode.RenderNodeUnrefMethodInfo
ResolveRadialGradientNodeMethod "writeToFile" o = Gsk.RenderNode.RenderNodeWriteToFileMethodInfo
ResolveRadialGradientNodeMethod "getBounds" o = Gsk.RenderNode.RenderNodeGetBoundsMethodInfo
ResolveRadialGradientNodeMethod "getCenter" o = RadialGradientNodeGetCenterMethodInfo
ResolveRadialGradientNodeMethod "getColorStops" o = RadialGradientNodeGetColorStopsMethodInfo
ResolveRadialGradientNodeMethod "getEnd" o = RadialGradientNodeGetEndMethodInfo
ResolveRadialGradientNodeMethod "getHradius" o = RadialGradientNodeGetHradiusMethodInfo
ResolveRadialGradientNodeMethod "getNColorStops" o = RadialGradientNodeGetNColorStopsMethodInfo
ResolveRadialGradientNodeMethod "getNodeType" o = Gsk.RenderNode.RenderNodeGetNodeTypeMethodInfo
ResolveRadialGradientNodeMethod "getStart" o = RadialGradientNodeGetStartMethodInfo
ResolveRadialGradientNodeMethod "getVradius" o = RadialGradientNodeGetVradiusMethodInfo
ResolveRadialGradientNodeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRadialGradientNodeMethod t RadialGradientNode, O.OverloadedMethod info RadialGradientNode p) => OL.IsLabel t (RadialGradientNode -> 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 ~ ResolveRadialGradientNodeMethod t RadialGradientNode, O.OverloadedMethod info RadialGradientNode p, R.HasField t RadialGradientNode p) => R.HasField t RadialGradientNode p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveRadialGradientNodeMethod t RadialGradientNode, O.OverloadedMethodInfo info RadialGradientNode) => OL.IsLabel t (O.MethodProxy info RadialGradientNode) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
instance BoxedPtr RadialGradientNode where
boxedPtrCopy :: RadialGradientNode -> IO RadialGradientNode
boxedPtrCopy = RadialGradientNode -> IO RadialGradientNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: RadialGradientNode -> IO ()
boxedPtrFree = \RadialGradientNode
_x -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "gsk_radial_gradient_node_new" gsk_radial_gradient_node_new ::
Ptr Graphene.Rect.Rect ->
Ptr Graphene.Point.Point ->
CFloat ->
CFloat ->
CFloat ->
CFloat ->
Ptr Gsk.ColorStop.ColorStop ->
Word64 ->
IO (Ptr RadialGradientNode)
radialGradientNodeNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Graphene.Rect.Rect
-> Graphene.Point.Point
-> Float
-> Float
-> Float
-> Float
-> [Gsk.ColorStop.ColorStop]
-> m RadialGradientNode
radialGradientNodeNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect
-> Point
-> Float
-> Float
-> Float
-> Float
-> [ColorStop]
-> m RadialGradientNode
radialGradientNodeNew Rect
bounds Point
center Float
hradius Float
vradius Float
start Float
end [ColorStop]
colorStops = IO RadialGradientNode -> m RadialGradientNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RadialGradientNode -> m RadialGradientNode)
-> IO RadialGradientNode -> m RadialGradientNode
forall a b. (a -> b) -> a -> b
$ do
let nColorStops :: Word64
nColorStops = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ [ColorStop] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [ColorStop]
colorStops
Ptr Rect
bounds' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
bounds
Ptr Point
center' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
center
let hradius' :: CFloat
hradius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
hradius
let vradius' :: CFloat
vradius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
vradius
let start' :: CFloat
start' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
start
let end' :: CFloat
end' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
end
[Ptr ColorStop]
colorStops' <- (ColorStop -> IO (Ptr ColorStop))
-> [ColorStop] -> IO [Ptr ColorStop]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ColorStop -> IO (Ptr ColorStop)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [ColorStop]
colorStops
Ptr ColorStop
colorStops'' <- Int -> [Ptr ColorStop] -> IO (Ptr ColorStop)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray Int
20 [Ptr ColorStop]
colorStops'
Ptr RadialGradientNode
result <- Ptr Rect
-> Ptr Point
-> CFloat
-> CFloat
-> CFloat
-> CFloat
-> Ptr ColorStop
-> Word64
-> IO (Ptr RadialGradientNode)
gsk_radial_gradient_node_new Ptr Rect
bounds' Ptr Point
center' CFloat
hradius' CFloat
vradius' CFloat
start' CFloat
end' Ptr ColorStop
colorStops'' Word64
nColorStops
Text -> Ptr RadialGradientNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"radialGradientNodeNew" Ptr RadialGradientNode
result
RadialGradientNode
result' <- ((ManagedPtr RadialGradientNode -> RadialGradientNode)
-> Ptr RadialGradientNode -> IO RadialGradientNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr RadialGradientNode -> RadialGradientNode
RadialGradientNode) Ptr RadialGradientNode
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
bounds
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
center
(ColorStop -> IO ()) -> [ColorStop] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ColorStop -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [ColorStop]
colorStops
Ptr ColorStop -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr ColorStop
colorStops''
RadialGradientNode -> IO RadialGradientNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RadialGradientNode
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gsk_radial_gradient_node_get_center" gsk_radial_gradient_node_get_center ::
Ptr RadialGradientNode ->
IO (Ptr Graphene.Point.Point)
radialGradientNodeGetCenter ::
(B.CallStack.HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a
-> m Graphene.Point.Point
radialGradientNodeGetCenter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a -> m Point
radialGradientNodeGetCenter a
node = 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
Ptr RadialGradientNode
node' <- a -> IO (Ptr RadialGradientNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr Point
result <- Ptr RadialGradientNode -> IO (Ptr Point)
gsk_radial_gradient_node_get_center Ptr RadialGradientNode
node'
Text -> Ptr Point -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"radialGradientNodeGetCenter" Ptr Point
result
Point
result' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Point -> Point
Graphene.Point.Point) Ptr Point
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
Point -> IO Point
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Point
result'
#if defined(ENABLE_OVERLOADING)
data RadialGradientNodeGetCenterMethodInfo
instance (signature ~ (m Graphene.Point.Point), MonadIO m, IsRadialGradientNode a) => O.OverloadedMethod RadialGradientNodeGetCenterMethodInfo a signature where
overloadedMethod = radialGradientNodeGetCenter
instance O.OverloadedMethodInfo RadialGradientNodeGetCenterMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.RadialGradientNode.radialGradientNodeGetCenter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.7/docs/GI-Gsk-Objects-RadialGradientNode.html#v:radialGradientNodeGetCenter"
})
#endif
foreign import ccall "gsk_radial_gradient_node_get_color_stops" gsk_radial_gradient_node_get_color_stops ::
Ptr RadialGradientNode ->
Ptr Word64 ->
IO (Ptr Gsk.ColorStop.ColorStop)
radialGradientNodeGetColorStops ::
(B.CallStack.HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a
-> m [Gsk.ColorStop.ColorStop]
radialGradientNodeGetColorStops :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a -> m [ColorStop]
radialGradientNodeGetColorStops a
node = IO [ColorStop] -> m [ColorStop]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ColorStop] -> m [ColorStop])
-> IO [ColorStop] -> m [ColorStop]
forall a b. (a -> b) -> a -> b
$ do
Ptr RadialGradientNode
node' <- a -> IO (Ptr RadialGradientNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr Word64
nStops <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr ColorStop
result <- Ptr RadialGradientNode -> Ptr Word64 -> IO (Ptr ColorStop)
gsk_radial_gradient_node_get_color_stops Ptr RadialGradientNode
node' Ptr Word64
nStops
Word64
nStops' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
nStops
Text -> Ptr ColorStop -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"radialGradientNodeGetColorStops" Ptr ColorStop
result
[Ptr ColorStop]
result' <- (Int -> Word64 -> Ptr ColorStop -> IO [Ptr ColorStop]
forall a b. Integral a => Int -> a -> Ptr b -> IO [Ptr b]
unpackBlockArrayWithLength Int
20 Word64
nStops') Ptr ColorStop
result
[ColorStop]
result'' <- (Ptr ColorStop -> IO ColorStop)
-> [Ptr ColorStop] -> IO [ColorStop]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr ColorStop -> ColorStop)
-> Ptr ColorStop -> IO ColorStop
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ColorStop -> ColorStop
Gsk.ColorStop.ColorStop) [Ptr ColorStop]
result'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
nStops
[ColorStop] -> IO [ColorStop]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [ColorStop]
result''
#if defined(ENABLE_OVERLOADING)
data RadialGradientNodeGetColorStopsMethodInfo
instance (signature ~ (m [Gsk.ColorStop.ColorStop]), MonadIO m, IsRadialGradientNode a) => O.OverloadedMethod RadialGradientNodeGetColorStopsMethodInfo a signature where
overloadedMethod = radialGradientNodeGetColorStops
instance O.OverloadedMethodInfo RadialGradientNodeGetColorStopsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.RadialGradientNode.radialGradientNodeGetColorStops",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.7/docs/GI-Gsk-Objects-RadialGradientNode.html#v:radialGradientNodeGetColorStops"
})
#endif
foreign import ccall "gsk_radial_gradient_node_get_end" gsk_radial_gradient_node_get_end ::
Ptr RadialGradientNode ->
IO CFloat
radialGradientNodeGetEnd ::
(B.CallStack.HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a
-> m Float
radialGradientNodeGetEnd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a -> m Float
radialGradientNodeGetEnd a
node = 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
Ptr RadialGradientNode
node' <- a -> IO (Ptr RadialGradientNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
CFloat
result <- Ptr RadialGradientNode -> IO CFloat
gsk_radial_gradient_node_get_end Ptr RadialGradientNode
node'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data RadialGradientNodeGetEndMethodInfo
instance (signature ~ (m Float), MonadIO m, IsRadialGradientNode a) => O.OverloadedMethod RadialGradientNodeGetEndMethodInfo a signature where
overloadedMethod = radialGradientNodeGetEnd
instance O.OverloadedMethodInfo RadialGradientNodeGetEndMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.RadialGradientNode.radialGradientNodeGetEnd",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.7/docs/GI-Gsk-Objects-RadialGradientNode.html#v:radialGradientNodeGetEnd"
})
#endif
foreign import ccall "gsk_radial_gradient_node_get_hradius" gsk_radial_gradient_node_get_hradius ::
Ptr RadialGradientNode ->
IO CFloat
radialGradientNodeGetHradius ::
(B.CallStack.HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a
-> m Float
radialGradientNodeGetHradius :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a -> m Float
radialGradientNodeGetHradius a
node = 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
Ptr RadialGradientNode
node' <- a -> IO (Ptr RadialGradientNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
CFloat
result <- Ptr RadialGradientNode -> IO CFloat
gsk_radial_gradient_node_get_hradius Ptr RadialGradientNode
node'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data RadialGradientNodeGetHradiusMethodInfo
instance (signature ~ (m Float), MonadIO m, IsRadialGradientNode a) => O.OverloadedMethod RadialGradientNodeGetHradiusMethodInfo a signature where
overloadedMethod = radialGradientNodeGetHradius
instance O.OverloadedMethodInfo RadialGradientNodeGetHradiusMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.RadialGradientNode.radialGradientNodeGetHradius",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.7/docs/GI-Gsk-Objects-RadialGradientNode.html#v:radialGradientNodeGetHradius"
})
#endif
foreign import ccall "gsk_radial_gradient_node_get_n_color_stops" gsk_radial_gradient_node_get_n_color_stops ::
Ptr RadialGradientNode ->
IO Word64
radialGradientNodeGetNColorStops ::
(B.CallStack.HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a
-> m Word64
radialGradientNodeGetNColorStops :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a -> m Word64
radialGradientNodeGetNColorStops a
node = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr RadialGradientNode
node' <- a -> IO (Ptr RadialGradientNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Word64
result <- Ptr RadialGradientNode -> IO Word64
gsk_radial_gradient_node_get_n_color_stops Ptr RadialGradientNode
node'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data RadialGradientNodeGetNColorStopsMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsRadialGradientNode a) => O.OverloadedMethod RadialGradientNodeGetNColorStopsMethodInfo a signature where
overloadedMethod = radialGradientNodeGetNColorStops
instance O.OverloadedMethodInfo RadialGradientNodeGetNColorStopsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.RadialGradientNode.radialGradientNodeGetNColorStops",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.7/docs/GI-Gsk-Objects-RadialGradientNode.html#v:radialGradientNodeGetNColorStops"
})
#endif
foreign import ccall "gsk_radial_gradient_node_get_start" gsk_radial_gradient_node_get_start ::
Ptr RadialGradientNode ->
IO CFloat
radialGradientNodeGetStart ::
(B.CallStack.HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a
-> m Float
radialGradientNodeGetStart :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a -> m Float
radialGradientNodeGetStart a
node = 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
Ptr RadialGradientNode
node' <- a -> IO (Ptr RadialGradientNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
CFloat
result <- Ptr RadialGradientNode -> IO CFloat
gsk_radial_gradient_node_get_start Ptr RadialGradientNode
node'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data RadialGradientNodeGetStartMethodInfo
instance (signature ~ (m Float), MonadIO m, IsRadialGradientNode a) => O.OverloadedMethod RadialGradientNodeGetStartMethodInfo a signature where
overloadedMethod = radialGradientNodeGetStart
instance O.OverloadedMethodInfo RadialGradientNodeGetStartMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.RadialGradientNode.radialGradientNodeGetStart",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.7/docs/GI-Gsk-Objects-RadialGradientNode.html#v:radialGradientNodeGetStart"
})
#endif
foreign import ccall "gsk_radial_gradient_node_get_vradius" gsk_radial_gradient_node_get_vradius ::
Ptr RadialGradientNode ->
IO CFloat
radialGradientNodeGetVradius ::
(B.CallStack.HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a
-> m Float
radialGradientNodeGetVradius :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRadialGradientNode a) =>
a -> m Float
radialGradientNodeGetVradius a
node = 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
Ptr RadialGradientNode
node' <- a -> IO (Ptr RadialGradientNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
CFloat
result <- Ptr RadialGradientNode -> IO CFloat
gsk_radial_gradient_node_get_vradius Ptr RadialGradientNode
node'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data RadialGradientNodeGetVradiusMethodInfo
instance (signature ~ (m Float), MonadIO m, IsRadialGradientNode a) => O.OverloadedMethod RadialGradientNodeGetVradiusMethodInfo a signature where
overloadedMethod = radialGradientNodeGetVradius
instance O.OverloadedMethodInfo RadialGradientNodeGetVradiusMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.RadialGradientNode.radialGradientNodeGetVradius",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.7/docs/GI-Gsk-Objects-RadialGradientNode.html#v:radialGradientNodeGetVradius"
})
#endif