{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The shadow parameters in a shadow node.

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

module GI.Gsk.Structs.Shadow
    ( 

-- * Exported types
    Shadow(..)                              ,
    newZeroShadow                           ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveShadowMethod                     ,
#endif



 -- * Properties


-- ** color #attr:color#
-- | the color of the shadow

    getShadowColor                          ,
#if defined(ENABLE_OVERLOADING)
    shadow_color                            ,
#endif


-- ** dx #attr:dx#
-- | the horizontal offset of the shadow

    getShadowDx                             ,
    setShadowDx                             ,
#if defined(ENABLE_OVERLOADING)
    shadow_dx                               ,
#endif


-- ** dy #attr:dy#
-- | the vertical offset of the shadow

    getShadowDy                             ,
    setShadowDy                             ,
#if defined(ENABLE_OVERLOADING)
    shadow_dy                               ,
#endif


-- ** radius #attr:radius#
-- | the radius of the shadow

    getShadowRadius                         ,
    setShadowRadius                         ,
#if defined(ENABLE_OVERLOADING)
    shadow_radius                           ,
#endif




    ) 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.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.Gdk.Structs.RGBA as Gdk.RGBA

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

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

instance BoxedPtr Shadow where
    boxedPtrCopy :: Shadow -> IO Shadow
boxedPtrCopy = \Shadow
p -> Shadow -> (Ptr Shadow -> IO Shadow) -> IO Shadow
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Shadow
p (Int -> Ptr Shadow -> IO (Ptr Shadow)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
28 (Ptr Shadow -> IO (Ptr Shadow))
-> (Ptr Shadow -> IO Shadow) -> Ptr Shadow -> IO Shadow
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr Shadow -> Shadow) -> Ptr Shadow -> IO Shadow
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr Shadow -> Shadow
Shadow)
    boxedPtrFree :: Shadow -> IO ()
boxedPtrFree = \Shadow
x -> Shadow -> (Ptr Shadow -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr Shadow
x Ptr Shadow -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr Shadow where
    boxedPtrCalloc :: IO (Ptr Shadow)
boxedPtrCalloc = Int -> IO (Ptr Shadow)
forall a. Int -> IO (Ptr a)
callocBytes Int
28


-- | Construct a `Shadow` struct initialized to zero.
newZeroShadow :: MonadIO m => m Shadow
newZeroShadow :: forall (m :: * -> *). MonadIO m => m Shadow
newZeroShadow = IO Shadow -> m Shadow
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Shadow -> m Shadow) -> IO Shadow -> m Shadow
forall a b. (a -> b) -> a -> b
$ IO (Ptr Shadow)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr Shadow) -> (Ptr Shadow -> IO Shadow) -> IO Shadow
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Shadow -> Shadow) -> Ptr Shadow -> IO Shadow
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Shadow -> Shadow
Shadow

instance tag ~ 'AttrSet => Constructible Shadow tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Shadow -> Shadow) -> [AttrOp Shadow tag] -> m Shadow
new ManagedPtr Shadow -> Shadow
_ [AttrOp Shadow tag]
attrs = do
        Shadow
o <- m Shadow
forall (m :: * -> *). MonadIO m => m Shadow
newZeroShadow
        Shadow -> [AttrOp Shadow 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Shadow
o [AttrOp Shadow tag]
[AttrOp Shadow 'AttrSet]
attrs
        Shadow -> m Shadow
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Shadow
o


-- | Get the value of the “@color@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' shadow #color
-- @
getShadowColor :: MonadIO m => Shadow -> m Gdk.RGBA.RGBA
getShadowColor :: forall (m :: * -> *). MonadIO m => Shadow -> m RGBA
getShadowColor Shadow
s = IO RGBA -> m RGBA
forall a. IO a -> m a
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
$ Shadow -> (Ptr Shadow -> IO RGBA) -> IO RGBA
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Shadow
s ((Ptr Shadow -> IO RGBA) -> IO RGBA)
-> (Ptr Shadow -> IO RGBA) -> IO RGBA
forall a b. (a -> b) -> a -> b
$ \Ptr Shadow
ptr -> do
    let val :: Ptr RGBA
val = Ptr Shadow
ptr Ptr Shadow -> Int -> Ptr RGBA
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gdk.RGBA.RGBA)
    RGBA
val' <- ((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
val
    RGBA -> IO RGBA
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
val'

#if defined(ENABLE_OVERLOADING)
data ShadowColorFieldInfo
instance AttrInfo ShadowColorFieldInfo where
    type AttrBaseTypeConstraint ShadowColorFieldInfo = (~) Shadow
    type AttrAllowedOps ShadowColorFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ShadowColorFieldInfo = (~) (Ptr Gdk.RGBA.RGBA)
    type AttrTransferTypeConstraint ShadowColorFieldInfo = (~)(Ptr Gdk.RGBA.RGBA)
    type AttrTransferType ShadowColorFieldInfo = (Ptr Gdk.RGBA.RGBA)
    type AttrGetType ShadowColorFieldInfo = Gdk.RGBA.RGBA
    type AttrLabel ShadowColorFieldInfo = "color"
    type AttrOrigin ShadowColorFieldInfo = Shadow
    attrGet = getShadowColor
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.Shadow.color"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Structs-Shadow.html#g:attr:color"
        })

shadow_color :: AttrLabelProxy "color"
shadow_color = AttrLabelProxy

#endif


-- | Get the value of the “@dx@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' shadow #dx
-- @
getShadowDx :: MonadIO m => Shadow -> m Float
getShadowDx :: forall (m :: * -> *). MonadIO m => Shadow -> m Float
getShadowDx Shadow
s = 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
$ Shadow -> (Ptr Shadow -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Shadow
s ((Ptr Shadow -> IO Float) -> IO Float)
-> (Ptr Shadow -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Shadow
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Shadow
ptr Ptr Shadow -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@dx@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' shadow [ #dx 'Data.GI.Base.Attributes.:=' value ]
-- @
setShadowDx :: MonadIO m => Shadow -> Float -> m ()
setShadowDx :: forall (m :: * -> *). MonadIO m => Shadow -> Float -> m ()
setShadowDx Shadow
s Float
val = 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
$ Shadow -> (Ptr Shadow -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Shadow
s ((Ptr Shadow -> IO ()) -> IO ()) -> (Ptr Shadow -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Shadow
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Shadow
ptr Ptr Shadow -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data ShadowDxFieldInfo
instance AttrInfo ShadowDxFieldInfo where
    type AttrBaseTypeConstraint ShadowDxFieldInfo = (~) Shadow
    type AttrAllowedOps ShadowDxFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ShadowDxFieldInfo = (~) Float
    type AttrTransferTypeConstraint ShadowDxFieldInfo = (~)Float
    type AttrTransferType ShadowDxFieldInfo = Float
    type AttrGetType ShadowDxFieldInfo = Float
    type AttrLabel ShadowDxFieldInfo = "dx"
    type AttrOrigin ShadowDxFieldInfo = Shadow
    attrGet = getShadowDx
    attrSet = setShadowDx
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.Shadow.dx"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Structs-Shadow.html#g:attr:dx"
        })

shadow_dx :: AttrLabelProxy "dx"
shadow_dx = AttrLabelProxy

#endif


-- | Get the value of the “@dy@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' shadow #dy
-- @
getShadowDy :: MonadIO m => Shadow -> m Float
getShadowDy :: forall (m :: * -> *). MonadIO m => Shadow -> m Float
getShadowDy Shadow
s = 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
$ Shadow -> (Ptr Shadow -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Shadow
s ((Ptr Shadow -> IO Float) -> IO Float)
-> (Ptr Shadow -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Shadow
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Shadow
ptr Ptr Shadow -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@dy@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' shadow [ #dy 'Data.GI.Base.Attributes.:=' value ]
-- @
setShadowDy :: MonadIO m => Shadow -> Float -> m ()
setShadowDy :: forall (m :: * -> *). MonadIO m => Shadow -> Float -> m ()
setShadowDy Shadow
s Float
val = 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
$ Shadow -> (Ptr Shadow -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Shadow
s ((Ptr Shadow -> IO ()) -> IO ()) -> (Ptr Shadow -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Shadow
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Shadow
ptr Ptr Shadow -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data ShadowDyFieldInfo
instance AttrInfo ShadowDyFieldInfo where
    type AttrBaseTypeConstraint ShadowDyFieldInfo = (~) Shadow
    type AttrAllowedOps ShadowDyFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ShadowDyFieldInfo = (~) Float
    type AttrTransferTypeConstraint ShadowDyFieldInfo = (~)Float
    type AttrTransferType ShadowDyFieldInfo = Float
    type AttrGetType ShadowDyFieldInfo = Float
    type AttrLabel ShadowDyFieldInfo = "dy"
    type AttrOrigin ShadowDyFieldInfo = Shadow
    attrGet = getShadowDy
    attrSet = setShadowDy
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.Shadow.dy"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Structs-Shadow.html#g:attr:dy"
        })

shadow_dy :: AttrLabelProxy "dy"
shadow_dy = AttrLabelProxy

#endif


-- | Get the value of the “@radius@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' shadow #radius
-- @
getShadowRadius :: MonadIO m => Shadow -> m Float
getShadowRadius :: forall (m :: * -> *). MonadIO m => Shadow -> m Float
getShadowRadius Shadow
s = 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
$ Shadow -> (Ptr Shadow -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Shadow
s ((Ptr Shadow -> IO Float) -> IO Float)
-> (Ptr Shadow -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Shadow
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Shadow
ptr Ptr Shadow -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@radius@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' shadow [ #radius 'Data.GI.Base.Attributes.:=' value ]
-- @
setShadowRadius :: MonadIO m => Shadow -> Float -> m ()
setShadowRadius :: forall (m :: * -> *). MonadIO m => Shadow -> Float -> m ()
setShadowRadius Shadow
s Float
val = 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
$ Shadow -> (Ptr Shadow -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Shadow
s ((Ptr Shadow -> IO ()) -> IO ()) -> (Ptr Shadow -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Shadow
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Shadow
ptr Ptr Shadow -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data ShadowRadiusFieldInfo
instance AttrInfo ShadowRadiusFieldInfo where
    type AttrBaseTypeConstraint ShadowRadiusFieldInfo = (~) Shadow
    type AttrAllowedOps ShadowRadiusFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ShadowRadiusFieldInfo = (~) Float
    type AttrTransferTypeConstraint ShadowRadiusFieldInfo = (~)Float
    type AttrTransferType ShadowRadiusFieldInfo = Float
    type AttrGetType ShadowRadiusFieldInfo = Float
    type AttrLabel ShadowRadiusFieldInfo = "radius"
    type AttrOrigin ShadowRadiusFieldInfo = Shadow
    attrGet = getShadowRadius
    attrSet = setShadowRadius
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Structs.Shadow.radius"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Structs-Shadow.html#g:attr:radius"
        })

shadow_radius :: AttrLabelProxy "radius"
shadow_radius = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Shadow
type instance O.AttributeList Shadow = ShadowAttributeList
type ShadowAttributeList = ('[ '("color", ShadowColorFieldInfo), '("dx", ShadowDxFieldInfo), '("dy", ShadowDyFieldInfo), '("radius", ShadowRadiusFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveShadowMethod (t :: Symbol) (o :: *) :: * where
    ResolveShadowMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif