{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Gsk.Objects.OutsetShadowNode
    ( 

-- * Exported types
    OutsetShadowNode(..)                    ,
    IsOutsetShadowNode                      ,
    toOutsetShadowNode                      ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveOutsetShadowNodeMethod           ,
#endif


-- ** getBlurRadius #method:getBlurRadius#

#if defined(ENABLE_OVERLOADING)
    OutsetShadowNodeGetBlurRadiusMethodInfo ,
#endif
    outsetShadowNodeGetBlurRadius           ,


-- ** getDx #method:getDx#

#if defined(ENABLE_OVERLOADING)
    OutsetShadowNodeGetDxMethodInfo         ,
#endif
    outsetShadowNodeGetDx                   ,


-- ** getDy #method:getDy#

#if defined(ENABLE_OVERLOADING)
    OutsetShadowNodeGetDyMethodInfo         ,
#endif
    outsetShadowNodeGetDy                   ,


-- ** getSpread #method:getSpread#

#if defined(ENABLE_OVERLOADING)
    OutsetShadowNodeGetSpreadMethodInfo     ,
#endif
    outsetShadowNodeGetSpread               ,


-- ** new #method:new#

    outsetShadowNodeNew                     ,


-- ** peekColor #method:peekColor#

#if defined(ENABLE_OVERLOADING)
    OutsetShadowNodePeekColorMethodInfo     ,
#endif
    outsetShadowNodePeekColor               ,


-- ** peekOutline #method:peekOutline#

#if defined(ENABLE_OVERLOADING)
    OutsetShadowNodePeekOutlineMethodInfo   ,
#endif
    outsetShadowNodePeekOutline             ,




    ) 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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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.Text as T
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 GI.Gdk.Structs.RGBA as Gdk.RGBA
import {-# SOURCE #-} qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
import {-# SOURCE #-} qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect

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

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

foreign import ccall "gsk_outset_shadow_node_get_type"
    c_gsk_outset_shadow_node_get_type :: IO B.Types.GType

instance B.Types.TypedObject OutsetShadowNode where
    glibType :: IO GType
glibType = IO GType
c_gsk_outset_shadow_node_get_type

-- | Type class for types which can be safely cast to `OutsetShadowNode`, for instance with `toOutsetShadowNode`.
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf OutsetShadowNode o) => IsOutsetShadowNode o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf OutsetShadowNode o) => IsOutsetShadowNode o

instance O.HasParentTypes OutsetShadowNode
type instance O.ParentTypes OutsetShadowNode = '[Gsk.RenderNode.RenderNode]

-- | Cast to `OutsetShadowNode`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toOutsetShadowNode :: (MonadIO m, IsOutsetShadowNode o) => o -> m OutsetShadowNode
toOutsetShadowNode :: o -> m OutsetShadowNode
toOutsetShadowNode = IO OutsetShadowNode -> m OutsetShadowNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO OutsetShadowNode -> m OutsetShadowNode)
-> (o -> IO OutsetShadowNode) -> o -> m OutsetShadowNode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr OutsetShadowNode -> OutsetShadowNode)
-> o -> IO OutsetShadowNode
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr OutsetShadowNode -> OutsetShadowNode
OutsetShadowNode

#if defined(ENABLE_OVERLOADING)
type family ResolveOutsetShadowNodeMethod (t :: Symbol) (o :: *) :: * where
    ResolveOutsetShadowNodeMethod "draw" o = Gsk.RenderNode.RenderNodeDrawMethodInfo
    ResolveOutsetShadowNodeMethod "peekColor" o = OutsetShadowNodePeekColorMethodInfo
    ResolveOutsetShadowNodeMethod "peekOutline" o = OutsetShadowNodePeekOutlineMethodInfo
    ResolveOutsetShadowNodeMethod "ref" o = Gsk.RenderNode.RenderNodeRefMethodInfo
    ResolveOutsetShadowNodeMethod "serialize" o = Gsk.RenderNode.RenderNodeSerializeMethodInfo
    ResolveOutsetShadowNodeMethod "unref" o = Gsk.RenderNode.RenderNodeUnrefMethodInfo
    ResolveOutsetShadowNodeMethod "writeToFile" o = Gsk.RenderNode.RenderNodeWriteToFileMethodInfo
    ResolveOutsetShadowNodeMethod "getBlurRadius" o = OutsetShadowNodeGetBlurRadiusMethodInfo
    ResolveOutsetShadowNodeMethod "getBounds" o = Gsk.RenderNode.RenderNodeGetBoundsMethodInfo
    ResolveOutsetShadowNodeMethod "getDx" o = OutsetShadowNodeGetDxMethodInfo
    ResolveOutsetShadowNodeMethod "getDy" o = OutsetShadowNodeGetDyMethodInfo
    ResolveOutsetShadowNodeMethod "getNodeType" o = Gsk.RenderNode.RenderNodeGetNodeTypeMethodInfo
    ResolveOutsetShadowNodeMethod "getSpread" o = OutsetShadowNodeGetSpreadMethodInfo
    ResolveOutsetShadowNodeMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveOutsetShadowNodeMethod t OutsetShadowNode, O.MethodInfo info OutsetShadowNode p) => OL.IsLabel t (OutsetShadowNode -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance BoxedPtr OutsetShadowNode where
    boxedPtrCopy :: OutsetShadowNode -> IO OutsetShadowNode
boxedPtrCopy = OutsetShadowNode -> IO OutsetShadowNode
forall (m :: * -> *) a. Monad m => a -> m a
return
    boxedPtrFree :: OutsetShadowNode -> IO ()
boxedPtrFree = \OutsetShadowNode
_x -> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- method OutsetShadowNode::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "outline"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RoundedRect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "outline of the region surrounded by shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "color of the shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dx"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "horizontal offset of shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dy"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "vertical offset of shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spread"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "how far the shadow spreads towards the inside"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "blur_radius"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "how much blur to apply to the shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gsk" , name = "OutsetShadowNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_new" gsk_outset_shadow_node_new :: 
    Ptr Gsk.RoundedRect.RoundedRect ->      -- outline : TInterface (Name {namespace = "Gsk", name = "RoundedRect"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    CFloat ->                               -- dx : TBasicType TFloat
    CFloat ->                               -- dy : TBasicType TFloat
    CFloat ->                               -- spread : TBasicType TFloat
    CFloat ->                               -- blur_radius : TBasicType TFloat
    IO (Ptr OutsetShadowNode)

-- | Creates a t'GI.Gsk.Objects.RenderNode.RenderNode' that will render an outset shadow
-- around the box given by /@outline@/.
outsetShadowNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RoundedRect.RoundedRect
    -- ^ /@outline@/: outline of the region surrounded by shadow
    -> Gdk.RGBA.RGBA
    -- ^ /@color@/: color of the shadow
    -> Float
    -- ^ /@dx@/: horizontal offset of shadow
    -> Float
    -- ^ /@dy@/: vertical offset of shadow
    -> Float
    -- ^ /@spread@/: how far the shadow spreads towards the inside
    -> Float
    -- ^ /@blurRadius@/: how much blur to apply to the shadow
    -> m OutsetShadowNode
    -- ^ __Returns:__ A new t'GI.Gsk.Objects.RenderNode.RenderNode'
outsetShadowNodeNew :: RoundedRect
-> RGBA -> Float -> Float -> Float -> Float -> m OutsetShadowNode
outsetShadowNodeNew RoundedRect
outline RGBA
color Float
dx Float
dy Float
spread Float
blurRadius = IO OutsetShadowNode -> m OutsetShadowNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO OutsetShadowNode -> m OutsetShadowNode)
-> IO OutsetShadowNode -> m OutsetShadowNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RoundedRect
outline' <- RoundedRect -> IO (Ptr RoundedRect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RoundedRect
outline
    Ptr RGBA
color' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
color
    let dx' :: CFloat
dx' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dx
    let dy' :: CFloat
dy' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dy
    let spread' :: CFloat
spread' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
spread
    let blurRadius' :: CFloat
blurRadius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blurRadius
    Ptr OutsetShadowNode
result <- Ptr RoundedRect
-> Ptr RGBA
-> CFloat
-> CFloat
-> CFloat
-> CFloat
-> IO (Ptr OutsetShadowNode)
gsk_outset_shadow_node_new Ptr RoundedRect
outline' Ptr RGBA
color' CFloat
dx' CFloat
dy' CFloat
spread' CFloat
blurRadius'
    Text -> Ptr OutsetShadowNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"outsetShadowNodeNew" Ptr OutsetShadowNode
result
    OutsetShadowNode
result' <- ((ManagedPtr OutsetShadowNode -> OutsetShadowNode)
-> Ptr OutsetShadowNode -> IO OutsetShadowNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr OutsetShadowNode -> OutsetShadowNode
OutsetShadowNode) Ptr OutsetShadowNode
result
    RoundedRect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RoundedRect
outline
    RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RGBA
color
    OutsetShadowNode -> IO OutsetShadowNode
forall (m :: * -> *) a. Monad m => a -> m a
return OutsetShadowNode
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method OutsetShadowNode::get_blur_radius
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "OutsetShadowNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GskRenderNode for an outset shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_get_blur_radius" gsk_outset_shadow_node_get_blur_radius :: 
    Ptr OutsetShadowNode ->                 -- node : TInterface (Name {namespace = "Gsk", name = "OutsetShadowNode"})
    IO CFloat

-- | Retrieves the blur radius of the shadow.
outsetShadowNodeGetBlurRadius ::
    (B.CallStack.HasCallStack, MonadIO m, IsOutsetShadowNode a) =>
    a
    -- ^ /@node@/: a t'GI.Gsk.Objects.RenderNode.RenderNode' for an outset shadow
    -> m Float
    -- ^ __Returns:__ the blur radius, in pixels
outsetShadowNodeGetBlurRadius :: a -> m Float
outsetShadowNodeGetBlurRadius a
node = IO Float -> m Float
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 OutsetShadowNode
node' <- a -> IO (Ptr OutsetShadowNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    CFloat
result <- Ptr OutsetShadowNode -> IO CFloat
gsk_outset_shadow_node_get_blur_radius Ptr OutsetShadowNode
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 (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data OutsetShadowNodeGetBlurRadiusMethodInfo
instance (signature ~ (m Float), MonadIO m, IsOutsetShadowNode a) => O.MethodInfo OutsetShadowNodeGetBlurRadiusMethodInfo a signature where
    overloadedMethod = outsetShadowNodeGetBlurRadius

#endif

-- method OutsetShadowNode::get_dx
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "OutsetShadowNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GskRenderNode for an outset shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_get_dx" gsk_outset_shadow_node_get_dx :: 
    Ptr OutsetShadowNode ->                 -- node : TInterface (Name {namespace = "Gsk", name = "OutsetShadowNode"})
    IO CFloat

-- | Retrieves the horizontal offset of the outset shadow.
outsetShadowNodeGetDx ::
    (B.CallStack.HasCallStack, MonadIO m, IsOutsetShadowNode a) =>
    a
    -- ^ /@node@/: a t'GI.Gsk.Objects.RenderNode.RenderNode' for an outset shadow
    -> m Float
    -- ^ __Returns:__ an offset, in pixels
outsetShadowNodeGetDx :: a -> m Float
outsetShadowNodeGetDx a
node = IO Float -> m Float
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 OutsetShadowNode
node' <- a -> IO (Ptr OutsetShadowNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    CFloat
result <- Ptr OutsetShadowNode -> IO CFloat
gsk_outset_shadow_node_get_dx Ptr OutsetShadowNode
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 (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data OutsetShadowNodeGetDxMethodInfo
instance (signature ~ (m Float), MonadIO m, IsOutsetShadowNode a) => O.MethodInfo OutsetShadowNodeGetDxMethodInfo a signature where
    overloadedMethod = outsetShadowNodeGetDx

#endif

-- method OutsetShadowNode::get_dy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "OutsetShadowNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GskRenderNode for an outset shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_get_dy" gsk_outset_shadow_node_get_dy :: 
    Ptr OutsetShadowNode ->                 -- node : TInterface (Name {namespace = "Gsk", name = "OutsetShadowNode"})
    IO CFloat

-- | Retrieves the vertical offset of the outset shadow.
outsetShadowNodeGetDy ::
    (B.CallStack.HasCallStack, MonadIO m, IsOutsetShadowNode a) =>
    a
    -- ^ /@node@/: a t'GI.Gsk.Objects.RenderNode.RenderNode' for an outset shadow
    -> m Float
    -- ^ __Returns:__ an offset, in pixels
outsetShadowNodeGetDy :: a -> m Float
outsetShadowNodeGetDy a
node = IO Float -> m Float
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 OutsetShadowNode
node' <- a -> IO (Ptr OutsetShadowNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    CFloat
result <- Ptr OutsetShadowNode -> IO CFloat
gsk_outset_shadow_node_get_dy Ptr OutsetShadowNode
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 (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data OutsetShadowNodeGetDyMethodInfo
instance (signature ~ (m Float), MonadIO m, IsOutsetShadowNode a) => O.MethodInfo OutsetShadowNodeGetDyMethodInfo a signature where
    overloadedMethod = outsetShadowNodeGetDy

#endif

-- method OutsetShadowNode::get_spread
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "OutsetShadowNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GskRenderNode for an outset shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_get_spread" gsk_outset_shadow_node_get_spread :: 
    Ptr OutsetShadowNode ->                 -- node : TInterface (Name {namespace = "Gsk", name = "OutsetShadowNode"})
    IO CFloat

-- | Retrieves how much the shadow spreads outwards.
outsetShadowNodeGetSpread ::
    (B.CallStack.HasCallStack, MonadIO m, IsOutsetShadowNode a) =>
    a
    -- ^ /@node@/: a t'GI.Gsk.Objects.RenderNode.RenderNode' for an outset shadow
    -> m Float
    -- ^ __Returns:__ the size of the shadow, in pixels
outsetShadowNodeGetSpread :: a -> m Float
outsetShadowNodeGetSpread a
node = IO Float -> m Float
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 OutsetShadowNode
node' <- a -> IO (Ptr OutsetShadowNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    CFloat
result <- Ptr OutsetShadowNode -> IO CFloat
gsk_outset_shadow_node_get_spread Ptr OutsetShadowNode
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 (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data OutsetShadowNodeGetSpreadMethodInfo
instance (signature ~ (m Float), MonadIO m, IsOutsetShadowNode a) => O.MethodInfo OutsetShadowNodeGetSpreadMethodInfo a signature where
    overloadedMethod = outsetShadowNodeGetSpread

#endif

-- method OutsetShadowNode::peek_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "OutsetShadowNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GskRenderNode for an outset shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "RGBA" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_peek_color" gsk_outset_shadow_node_peek_color :: 
    Ptr OutsetShadowNode ->                 -- node : TInterface (Name {namespace = "Gsk", name = "OutsetShadowNode"})
    IO (Ptr Gdk.RGBA.RGBA)

-- | Retrieves the color of the outset shadow.
outsetShadowNodePeekColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsOutsetShadowNode a) =>
    a
    -- ^ /@node@/: a t'GI.Gsk.Objects.RenderNode.RenderNode' for an outset shadow
    -> m Gdk.RGBA.RGBA
    -- ^ __Returns:__ a color
outsetShadowNodePeekColor :: a -> m RGBA
outsetShadowNodePeekColor a
node = IO RGBA -> m RGBA
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr OutsetShadowNode
node' <- a -> IO (Ptr OutsetShadowNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    Ptr RGBA
result <- Ptr OutsetShadowNode -> IO (Ptr RGBA)
gsk_outset_shadow_node_peek_color Ptr OutsetShadowNode
node'
    Text -> Ptr RGBA -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"outsetShadowNodePeekColor" Ptr RGBA
result
    RGBA
result' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
    RGBA -> IO RGBA
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
result'

#if defined(ENABLE_OVERLOADING)
data OutsetShadowNodePeekColorMethodInfo
instance (signature ~ (m Gdk.RGBA.RGBA), MonadIO m, IsOutsetShadowNode a) => O.MethodInfo OutsetShadowNodePeekColorMethodInfo a signature where
    overloadedMethod = outsetShadowNodePeekColor

#endif

-- method OutsetShadowNode::peek_outline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "OutsetShadowNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GskRenderNode for an outset shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RoundedRect" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_peek_outline" gsk_outset_shadow_node_peek_outline :: 
    Ptr OutsetShadowNode ->                 -- node : TInterface (Name {namespace = "Gsk", name = "OutsetShadowNode"})
    IO (Ptr Gsk.RoundedRect.RoundedRect)

-- | Retrieves the outline rectangle of the outset shadow.
outsetShadowNodePeekOutline ::
    (B.CallStack.HasCallStack, MonadIO m, IsOutsetShadowNode a) =>
    a
    -- ^ /@node@/: a t'GI.Gsk.Objects.RenderNode.RenderNode' for an outset shadow
    -> m Gsk.RoundedRect.RoundedRect
    -- ^ __Returns:__ a rounded rectangle
outsetShadowNodePeekOutline :: a -> m RoundedRect
outsetShadowNodePeekOutline a
node = IO RoundedRect -> m RoundedRect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RoundedRect -> m RoundedRect)
-> IO RoundedRect -> m RoundedRect
forall a b. (a -> b) -> a -> b
$ do
    Ptr OutsetShadowNode
node' <- a -> IO (Ptr OutsetShadowNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    Ptr RoundedRect
result <- Ptr OutsetShadowNode -> IO (Ptr RoundedRect)
gsk_outset_shadow_node_peek_outline Ptr OutsetShadowNode
node'
    Text -> Ptr RoundedRect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"outsetShadowNodePeekOutline" Ptr RoundedRect
result
    RoundedRect
result' <- ((ManagedPtr RoundedRect -> RoundedRect)
-> Ptr RoundedRect -> IO RoundedRect
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr RoundedRect -> RoundedRect
Gsk.RoundedRect.RoundedRect) Ptr RoundedRect
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
    RoundedRect -> IO RoundedRect
forall (m :: * -> *) a. Monad m => a -> m a
return RoundedRect
result'

#if defined(ENABLE_OVERLOADING)
data OutsetShadowNodePeekOutlineMethodInfo
instance (signature ~ (m Gsk.RoundedRect.RoundedRect), MonadIO m, IsOutsetShadowNode a) => O.MethodInfo OutsetShadowNodePeekOutlineMethodInfo a signature where
    overloadedMethod = outsetShadowNodePeekOutline

#endif