{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Structs.Gradient
(
Gradient(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveGradientMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
GradientAddColorStopMethodInfo ,
#endif
gradientAddColorStop ,
gradientNewLinear ,
gradientNewRadial ,
#if defined(ENABLE_OVERLOADING)
GradientRefMethodInfo ,
#endif
gradientRef ,
#if defined(ENABLE_OVERLOADING)
GradientResolveMethodInfo ,
#endif
gradientResolve ,
#if defined(ENABLE_OVERLOADING)
GradientResolveForContextMethodInfo ,
#endif
gradientResolveForContext ,
#if defined(ENABLE_OVERLOADING)
GradientToStringMethodInfo ,
#endif
gradientToString ,
#if defined(ENABLE_OVERLOADING)
GradientUnrefMethodInfo ,
#endif
gradientUnref ,
) 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.Cairo.Structs.Pattern as Cairo.Pattern
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleProperties as Gtk.StyleProperties
import {-# SOURCE #-} qualified GI.Gtk.Structs.SymbolicColor as Gtk.SymbolicColor
newtype Gradient = Gradient (SP.ManagedPtr Gradient)
deriving (Gradient -> Gradient -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Gradient -> Gradient -> Bool
$c/= :: Gradient -> Gradient -> Bool
== :: Gradient -> Gradient -> Bool
$c== :: Gradient -> Gradient -> Bool
Eq)
instance SP.ManagedPtrNewtype Gradient where
toManagedPtr :: Gradient -> ManagedPtr Gradient
toManagedPtr (Gradient ManagedPtr Gradient
p) = ManagedPtr Gradient
p
foreign import ccall "gtk_gradient_get_type" c_gtk_gradient_get_type ::
IO GType
type instance O.ParentTypes Gradient = '[]
instance O.HasParentTypes Gradient
instance B.Types.TypedObject Gradient where
glibType :: IO GType
glibType = IO GType
c_gtk_gradient_get_type
instance B.Types.GBoxed Gradient
instance B.GValue.IsGValue (Maybe Gradient) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_gradient_get_type
gvalueSet_ :: Ptr GValue -> Maybe Gradient -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Gradient
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr Gradient)
gvalueSet_ Ptr GValue
gv (P.Just Gradient
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Gradient
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Gradient)
gvalueGet_ Ptr GValue
gv = do
Ptr Gradient
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Gradient)
if Ptr Gradient
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Gradient -> Gradient
Gradient Ptr Gradient
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Gradient
type instance O.AttributeList Gradient = GradientAttributeList
type GradientAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gtk_gradient_new_linear" gtk_gradient_new_linear ::
CDouble ->
CDouble ->
CDouble ->
CDouble ->
IO (Ptr Gradient)
{-# DEPRECATED gradientNewLinear ["(Since version 3.8)","t'GI.Gtk.Structs.Gradient.Gradient' is deprecated."] #-}
gradientNewLinear ::
(B.CallStack.HasCallStack, MonadIO m) =>
Double
-> Double
-> Double
-> Double
-> m Gradient
gradientNewLinear :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Double -> Double -> Double -> Double -> m Gradient
gradientNewLinear Double
x0 Double
y0 Double
x1 Double
y1 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let x0' :: CDouble
x0' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
x0
let y0' :: CDouble
y0' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
y0
let x1' :: CDouble
x1' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
x1
let y1' :: CDouble
y1' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
y1
Ptr Gradient
result <- CDouble -> CDouble -> CDouble -> CDouble -> IO (Ptr Gradient)
gtk_gradient_new_linear CDouble
x0' CDouble
y0' CDouble
x1' CDouble
y1'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gradientNewLinear" Ptr Gradient
result
Gradient
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Gradient -> Gradient
Gradient) Ptr Gradient
result
forall (m :: * -> *) a. Monad m => a -> m a
return Gradient
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_gradient_new_radial" gtk_gradient_new_radial ::
CDouble ->
CDouble ->
CDouble ->
CDouble ->
CDouble ->
CDouble ->
IO (Ptr Gradient)
{-# DEPRECATED gradientNewRadial ["(Since version 3.8)","t'GI.Gtk.Structs.Gradient.Gradient' is deprecated."] #-}
gradientNewRadial ::
(B.CallStack.HasCallStack, MonadIO m) =>
Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> m Gradient
gradientNewRadial :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Double
-> Double -> Double -> Double -> Double -> Double -> m Gradient
gradientNewRadial Double
x0 Double
y0 Double
radius0 Double
x1 Double
y1 Double
radius1 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let x0' :: CDouble
x0' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
x0
let y0' :: CDouble
y0' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
y0
let radius0' :: CDouble
radius0' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
radius0
let x1' :: CDouble
x1' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
x1
let y1' :: CDouble
y1' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
y1
let radius1' :: CDouble
radius1' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
radius1
Ptr Gradient
result <- CDouble
-> CDouble
-> CDouble
-> CDouble
-> CDouble
-> CDouble
-> IO (Ptr Gradient)
gtk_gradient_new_radial CDouble
x0' CDouble
y0' CDouble
radius0' CDouble
x1' CDouble
y1' CDouble
radius1'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gradientNewRadial" Ptr Gradient
result
Gradient
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Gradient -> Gradient
Gradient) Ptr Gradient
result
forall (m :: * -> *) a. Monad m => a -> m a
return Gradient
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_gradient_add_color_stop" gtk_gradient_add_color_stop ::
Ptr Gradient ->
CDouble ->
Ptr Gtk.SymbolicColor.SymbolicColor ->
IO ()
{-# DEPRECATED gradientAddColorStop ["(Since version 3.8)","t'GI.Gtk.Structs.Gradient.Gradient' is deprecated."] #-}
gradientAddColorStop ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gradient
-> Double
-> Gtk.SymbolicColor.SymbolicColor
-> m ()
gradientAddColorStop :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Gradient -> Double -> SymbolicColor -> m ()
gradientAddColorStop Gradient
gradient Double
offset SymbolicColor
color = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Gradient
gradient' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Gradient
gradient
let offset' :: CDouble
offset' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
offset
Ptr SymbolicColor
color' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SymbolicColor
color
Ptr Gradient -> CDouble -> Ptr SymbolicColor -> IO ()
gtk_gradient_add_color_stop Ptr Gradient
gradient' CDouble
offset' Ptr SymbolicColor
color'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Gradient
gradient
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SymbolicColor
color
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data GradientAddColorStopMethodInfo
instance (signature ~ (Double -> Gtk.SymbolicColor.SymbolicColor -> m ()), MonadIO m) => O.OverloadedMethod GradientAddColorStopMethodInfo Gradient signature where
overloadedMethod = gradientAddColorStop
instance O.OverloadedMethodInfo GradientAddColorStopMethodInfo Gradient where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.Gradient.gradientAddColorStop",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-Gradient.html#v:gradientAddColorStop"
})
#endif
foreign import ccall "gtk_gradient_ref" gtk_gradient_ref ::
Ptr Gradient ->
IO (Ptr Gradient)
{-# DEPRECATED gradientRef ["(Since version 3.8)","t'GI.Gtk.Structs.Gradient.Gradient' is deprecated."] #-}
gradientRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gradient
-> m Gradient
gradientRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Gradient -> m Gradient
gradientRef Gradient
gradient = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Gradient
gradient' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Gradient
gradient
Ptr Gradient
result <- Ptr Gradient -> IO (Ptr Gradient)
gtk_gradient_ref Ptr Gradient
gradient'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gradientRef" Ptr Gradient
result
Gradient
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Gradient -> Gradient
Gradient) Ptr Gradient
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Gradient
gradient
forall (m :: * -> *) a. Monad m => a -> m a
return Gradient
result'
#if defined(ENABLE_OVERLOADING)
data GradientRefMethodInfo
instance (signature ~ (m Gradient), MonadIO m) => O.OverloadedMethod GradientRefMethodInfo Gradient signature where
overloadedMethod = gradientRef
instance O.OverloadedMethodInfo GradientRefMethodInfo Gradient where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.Gradient.gradientRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-Gradient.html#v:gradientRef"
})
#endif
foreign import ccall "gtk_gradient_resolve" gtk_gradient_resolve ::
Ptr Gradient ->
Ptr Gtk.StyleProperties.StyleProperties ->
Ptr (Ptr Cairo.Pattern.Pattern) ->
IO CInt
{-# DEPRECATED gradientResolve ["(Since version 3.8)","t'GI.Gtk.Structs.Gradient.Gradient' is deprecated."] #-}
gradientResolve ::
(B.CallStack.HasCallStack, MonadIO m, Gtk.StyleProperties.IsStyleProperties a) =>
Gradient
-> a
-> m ((Bool, Cairo.Pattern.Pattern))
gradientResolve :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStyleProperties a) =>
Gradient -> a -> m (Bool, Pattern)
gradientResolve Gradient
gradient a
props = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Gradient
gradient' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Gradient
gradient
Ptr StyleProperties
props' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
props
Ptr (Ptr Pattern)
resolvedGradient <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Cairo.Pattern.Pattern))
CInt
result <- Ptr Gradient -> Ptr StyleProperties -> Ptr (Ptr Pattern) -> IO CInt
gtk_gradient_resolve Ptr Gradient
gradient' Ptr StyleProperties
props' Ptr (Ptr Pattern)
resolvedGradient
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Pattern
resolvedGradient' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Pattern)
resolvedGradient
Pattern
resolvedGradient'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Pattern -> Pattern
Cairo.Pattern.Pattern) Ptr Pattern
resolvedGradient'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Gradient
gradient
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
props
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Pattern)
resolvedGradient
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Pattern
resolvedGradient'')
#if defined(ENABLE_OVERLOADING)
data GradientResolveMethodInfo
instance (signature ~ (a -> m ((Bool, Cairo.Pattern.Pattern))), MonadIO m, Gtk.StyleProperties.IsStyleProperties a) => O.OverloadedMethod GradientResolveMethodInfo Gradient signature where
overloadedMethod = gradientResolve
instance O.OverloadedMethodInfo GradientResolveMethodInfo Gradient where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.Gradient.gradientResolve",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-Gradient.html#v:gradientResolve"
})
#endif
foreign import ccall "gtk_gradient_resolve_for_context" gtk_gradient_resolve_for_context ::
Ptr Gradient ->
Ptr Gtk.StyleContext.StyleContext ->
IO (Ptr Cairo.Pattern.Pattern)
gradientResolveForContext ::
(B.CallStack.HasCallStack, MonadIO m, Gtk.StyleContext.IsStyleContext a) =>
Gradient
-> a
-> m Cairo.Pattern.Pattern
gradientResolveForContext :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStyleContext a) =>
Gradient -> a -> m Pattern
gradientResolveForContext Gradient
gradient a
context = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Gradient
gradient' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Gradient
gradient
Ptr StyleContext
context' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr Pattern
result <- Ptr Gradient -> Ptr StyleContext -> IO (Ptr Pattern)
gtk_gradient_resolve_for_context Ptr Gradient
gradient' Ptr StyleContext
context'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gradientResolveForContext" Ptr Pattern
result
Pattern
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Pattern -> Pattern
Cairo.Pattern.Pattern) Ptr Pattern
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Gradient
gradient
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
forall (m :: * -> *) a. Monad m => a -> m a
return Pattern
result'
#if defined(ENABLE_OVERLOADING)
data GradientResolveForContextMethodInfo
instance (signature ~ (a -> m Cairo.Pattern.Pattern), MonadIO m, Gtk.StyleContext.IsStyleContext a) => O.OverloadedMethod GradientResolveForContextMethodInfo Gradient signature where
overloadedMethod = gradientResolveForContext
instance O.OverloadedMethodInfo GradientResolveForContextMethodInfo Gradient where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.Gradient.gradientResolveForContext",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-Gradient.html#v:gradientResolveForContext"
})
#endif
foreign import ccall "gtk_gradient_to_string" gtk_gradient_to_string ::
Ptr Gradient ->
IO CString
{-# DEPRECATED gradientToString ["(Since version 3.8)","t'GI.Gtk.Structs.Gradient.Gradient' is deprecated."] #-}
gradientToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gradient
-> m T.Text
gradientToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Gradient -> m Text
gradientToString Gradient
gradient = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Gradient
gradient' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Gradient
gradient
CString
result <- Ptr Gradient -> IO CString
gtk_gradient_to_string Ptr Gradient
gradient'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gradientToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. Ptr a -> IO ()
freeMem CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Gradient
gradient
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data GradientToStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod GradientToStringMethodInfo Gradient signature where
overloadedMethod = gradientToString
instance O.OverloadedMethodInfo GradientToStringMethodInfo Gradient where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.Gradient.gradientToString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-Gradient.html#v:gradientToString"
})
#endif
foreign import ccall "gtk_gradient_unref" gtk_gradient_unref ::
Ptr Gradient ->
IO ()
{-# DEPRECATED gradientUnref ["(Since version 3.8)","t'GI.Gtk.Structs.Gradient.Gradient' is deprecated."] #-}
gradientUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gradient
-> m ()
gradientUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Gradient -> m ()
gradientUnref Gradient
gradient = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Gradient
gradient' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Gradient
gradient
Ptr Gradient -> IO ()
gtk_gradient_unref Ptr Gradient
gradient'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Gradient
gradient
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data GradientUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod GradientUnrefMethodInfo Gradient signature where
overloadedMethod = gradientUnref
instance O.OverloadedMethodInfo GradientUnrefMethodInfo Gradient where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.Gradient.gradientUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-Gradient.html#v:gradientUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveGradientMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveGradientMethod "addColorStop" o = GradientAddColorStopMethodInfo
ResolveGradientMethod "ref" o = GradientRefMethodInfo
ResolveGradientMethod "resolve" o = GradientResolveMethodInfo
ResolveGradientMethod "resolveForContext" o = GradientResolveForContextMethodInfo
ResolveGradientMethod "toString" o = GradientToStringMethodInfo
ResolveGradientMethod "unref" o = GradientUnrefMethodInfo
ResolveGradientMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveGradientMethod t Gradient, O.OverloadedMethod info Gradient p) => OL.IsLabel t (Gradient -> 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 ~ ResolveGradientMethod t Gradient, O.OverloadedMethod info Gradient p, R.HasField t Gradient p) => R.HasField t Gradient p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveGradientMethod t Gradient, O.OverloadedMethodInfo info Gradient) => OL.IsLabel t (O.MethodProxy info Gradient) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif