{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gsk.Objects.RepeatingLinearGradientNode
(
RepeatingLinearGradientNode(..) ,
IsRepeatingLinearGradientNode ,
toRepeatingLinearGradientNode ,
#if defined(ENABLE_OVERLOADING)
ResolveRepeatingLinearGradientNodeMethod,
#endif
repeatingLinearGradientNodeNew ,
) 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.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.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 RepeatingLinearGradientNode = RepeatingLinearGradientNode (SP.ManagedPtr RepeatingLinearGradientNode)
deriving (RepeatingLinearGradientNode -> RepeatingLinearGradientNode -> Bool
(RepeatingLinearGradientNode
-> RepeatingLinearGradientNode -> Bool)
-> (RepeatingLinearGradientNode
-> RepeatingLinearGradientNode -> Bool)
-> Eq RepeatingLinearGradientNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepeatingLinearGradientNode -> RepeatingLinearGradientNode -> Bool
$c/= :: RepeatingLinearGradientNode -> RepeatingLinearGradientNode -> Bool
== :: RepeatingLinearGradientNode -> RepeatingLinearGradientNode -> Bool
$c== :: RepeatingLinearGradientNode -> RepeatingLinearGradientNode -> Bool
Eq)
instance SP.ManagedPtrNewtype RepeatingLinearGradientNode where
toManagedPtr :: RepeatingLinearGradientNode
-> ManagedPtr RepeatingLinearGradientNode
toManagedPtr (RepeatingLinearGradientNode ManagedPtr RepeatingLinearGradientNode
p) = ManagedPtr RepeatingLinearGradientNode
p
foreign import ccall "gsk_repeating_linear_gradient_node_get_type"
c_gsk_repeating_linear_gradient_node_get_type :: IO B.Types.GType
instance B.Types.TypedObject RepeatingLinearGradientNode where
glibType :: IO GType
glibType = IO GType
c_gsk_repeating_linear_gradient_node_get_type
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf RepeatingLinearGradientNode o) => IsRepeatingLinearGradientNode o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf RepeatingLinearGradientNode o) => IsRepeatingLinearGradientNode o
instance O.HasParentTypes RepeatingLinearGradientNode
type instance O.ParentTypes RepeatingLinearGradientNode = '[Gsk.RenderNode.RenderNode]
toRepeatingLinearGradientNode :: (MIO.MonadIO m, IsRepeatingLinearGradientNode o) => o -> m RepeatingLinearGradientNode
toRepeatingLinearGradientNode :: forall (m :: * -> *) o.
(MonadIO m, IsRepeatingLinearGradientNode o) =>
o -> m RepeatingLinearGradientNode
toRepeatingLinearGradientNode = IO RepeatingLinearGradientNode -> m RepeatingLinearGradientNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO RepeatingLinearGradientNode -> m RepeatingLinearGradientNode)
-> (o -> IO RepeatingLinearGradientNode)
-> o
-> m RepeatingLinearGradientNode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr RepeatingLinearGradientNode
-> RepeatingLinearGradientNode)
-> o -> IO RepeatingLinearGradientNode
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr RepeatingLinearGradientNode
-> RepeatingLinearGradientNode
RepeatingLinearGradientNode
#if defined(ENABLE_OVERLOADING)
type family ResolveRepeatingLinearGradientNodeMethod (t :: Symbol) (o :: *) :: * where
ResolveRepeatingLinearGradientNodeMethod "draw" o = Gsk.RenderNode.RenderNodeDrawMethodInfo
ResolveRepeatingLinearGradientNodeMethod "ref" o = Gsk.RenderNode.RenderNodeRefMethodInfo
ResolveRepeatingLinearGradientNodeMethod "serialize" o = Gsk.RenderNode.RenderNodeSerializeMethodInfo
ResolveRepeatingLinearGradientNodeMethod "unref" o = Gsk.RenderNode.RenderNodeUnrefMethodInfo
ResolveRepeatingLinearGradientNodeMethod "writeToFile" o = Gsk.RenderNode.RenderNodeWriteToFileMethodInfo
ResolveRepeatingLinearGradientNodeMethod "getBounds" o = Gsk.RenderNode.RenderNodeGetBoundsMethodInfo
ResolveRepeatingLinearGradientNodeMethod "getNodeType" o = Gsk.RenderNode.RenderNodeGetNodeTypeMethodInfo
ResolveRepeatingLinearGradientNodeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRepeatingLinearGradientNodeMethod t RepeatingLinearGradientNode, O.OverloadedMethod info RepeatingLinearGradientNode p) => OL.IsLabel t (RepeatingLinearGradientNode -> 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 ~ ResolveRepeatingLinearGradientNodeMethod t RepeatingLinearGradientNode, O.OverloadedMethod info RepeatingLinearGradientNode p, R.HasField t RepeatingLinearGradientNode p) => R.HasField t RepeatingLinearGradientNode p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveRepeatingLinearGradientNodeMethod t RepeatingLinearGradientNode, O.OverloadedMethodInfo info RepeatingLinearGradientNode) => OL.IsLabel t (O.MethodProxy info RepeatingLinearGradientNode) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
instance BoxedPtr RepeatingLinearGradientNode where
boxedPtrCopy :: RepeatingLinearGradientNode -> IO RepeatingLinearGradientNode
boxedPtrCopy = RepeatingLinearGradientNode -> IO RepeatingLinearGradientNode
forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: RepeatingLinearGradientNode -> IO ()
boxedPtrFree = \RepeatingLinearGradientNode
_x -> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "gsk_repeating_linear_gradient_node_new" gsk_repeating_linear_gradient_node_new ::
Ptr Graphene.Rect.Rect ->
Ptr Graphene.Point.Point ->
Ptr Graphene.Point.Point ->
Ptr Gsk.ColorStop.ColorStop ->
Word64 ->
IO (Ptr RepeatingLinearGradientNode)
repeatingLinearGradientNodeNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Graphene.Rect.Rect
-> Graphene.Point.Point
-> Graphene.Point.Point
-> [Gsk.ColorStop.ColorStop]
-> m RepeatingLinearGradientNode
repeatingLinearGradientNodeNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rect
-> Point -> Point -> [ColorStop] -> m RepeatingLinearGradientNode
repeatingLinearGradientNodeNew Rect
bounds Point
start Point
end [ColorStop]
colorStops = IO RepeatingLinearGradientNode -> m RepeatingLinearGradientNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RepeatingLinearGradientNode -> m RepeatingLinearGradientNode)
-> IO RepeatingLinearGradientNode -> m RepeatingLinearGradientNode
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 (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
start' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
start
Ptr Point
end' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
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)
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 RepeatingLinearGradientNode
result <- Ptr Rect
-> Ptr Point
-> Ptr Point
-> Ptr ColorStop
-> Word64
-> IO (Ptr RepeatingLinearGradientNode)
gsk_repeating_linear_gradient_node_new Ptr Rect
bounds' Ptr Point
start' Ptr Point
end' Ptr ColorStop
colorStops'' Word64
nColorStops
Text -> Ptr RepeatingLinearGradientNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repeatingLinearGradientNodeNew" Ptr RepeatingLinearGradientNode
result
RepeatingLinearGradientNode
result' <- ((ManagedPtr RepeatingLinearGradientNode
-> RepeatingLinearGradientNode)
-> Ptr RepeatingLinearGradientNode
-> IO RepeatingLinearGradientNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr RepeatingLinearGradientNode
-> RepeatingLinearGradientNode
RepeatingLinearGradientNode) Ptr RepeatingLinearGradientNode
result
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
bounds
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
start
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
end
(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''
RepeatingLinearGradientNode -> IO RepeatingLinearGradientNode
forall (m :: * -> *) a. Monad m => a -> m a
return RepeatingLinearGradientNode
result'
#if defined(ENABLE_OVERLOADING)
#endif