{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gsk.Objects.GLShaderNode
(
GLShaderNode(..) ,
IsGLShaderNode ,
toGLShaderNode ,
#if defined(ENABLE_OVERLOADING)
ResolveGLShaderNodeMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
GLShaderNodeGetArgsMethodInfo ,
#endif
gLShaderNodeGetArgs ,
#if defined(ENABLE_OVERLOADING)
GLShaderNodeGetChildMethodInfo ,
#endif
gLShaderNodeGetChild ,
#if defined(ENABLE_OVERLOADING)
GLShaderNodeGetNChildrenMethodInfo ,
#endif
gLShaderNodeGetNChildren ,
#if defined(ENABLE_OVERLOADING)
GLShaderNodeGetShaderMethodInfo ,
#endif
gLShaderNodeGetShader ,
gLShaderNodeNew ,
) 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.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import {-# SOURCE #-} qualified GI.Gsk.Objects.GLShader as Gsk.GLShader
import {-# SOURCE #-} qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
newtype GLShaderNode = GLShaderNode (SP.ManagedPtr GLShaderNode)
deriving (GLShaderNode -> GLShaderNode -> Bool
(GLShaderNode -> GLShaderNode -> Bool)
-> (GLShaderNode -> GLShaderNode -> Bool) -> Eq GLShaderNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GLShaderNode -> GLShaderNode -> Bool
== :: GLShaderNode -> GLShaderNode -> Bool
$c/= :: GLShaderNode -> GLShaderNode -> Bool
/= :: GLShaderNode -> GLShaderNode -> Bool
Eq)
instance SP.ManagedPtrNewtype GLShaderNode where
toManagedPtr :: GLShaderNode -> ManagedPtr GLShaderNode
toManagedPtr (GLShaderNode ManagedPtr GLShaderNode
p) = ManagedPtr GLShaderNode
p
foreign import ccall "gsk_gl_shader_node_get_type"
c_gsk_gl_shader_node_get_type :: IO B.Types.GType
instance B.Types.TypedObject GLShaderNode where
glibType :: IO GType
glibType = IO GType
c_gsk_gl_shader_node_get_type
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf GLShaderNode o) => IsGLShaderNode o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf GLShaderNode o) => IsGLShaderNode o
instance O.HasParentTypes GLShaderNode
type instance O.ParentTypes GLShaderNode = '[Gsk.RenderNode.RenderNode]
toGLShaderNode :: (MIO.MonadIO m, IsGLShaderNode o) => o -> m GLShaderNode
toGLShaderNode :: forall (m :: * -> *) o.
(MonadIO m, IsGLShaderNode o) =>
o -> m GLShaderNode
toGLShaderNode = IO GLShaderNode -> m GLShaderNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO GLShaderNode -> m GLShaderNode)
-> (o -> IO GLShaderNode) -> o -> m GLShaderNode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr GLShaderNode -> GLShaderNode) -> o -> IO GLShaderNode
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr GLShaderNode -> GLShaderNode
GLShaderNode
#if defined(ENABLE_OVERLOADING)
type family ResolveGLShaderNodeMethod (t :: Symbol) (o :: *) :: * where
ResolveGLShaderNodeMethod "draw" o = Gsk.RenderNode.RenderNodeDrawMethodInfo
ResolveGLShaderNodeMethod "ref" o = Gsk.RenderNode.RenderNodeRefMethodInfo
ResolveGLShaderNodeMethod "serialize" o = Gsk.RenderNode.RenderNodeSerializeMethodInfo
ResolveGLShaderNodeMethod "unref" o = Gsk.RenderNode.RenderNodeUnrefMethodInfo
ResolveGLShaderNodeMethod "writeToFile" o = Gsk.RenderNode.RenderNodeWriteToFileMethodInfo
ResolveGLShaderNodeMethod "getArgs" o = GLShaderNodeGetArgsMethodInfo
ResolveGLShaderNodeMethod "getBounds" o = Gsk.RenderNode.RenderNodeGetBoundsMethodInfo
ResolveGLShaderNodeMethod "getChild" o = GLShaderNodeGetChildMethodInfo
ResolveGLShaderNodeMethod "getNChildren" o = GLShaderNodeGetNChildrenMethodInfo
ResolveGLShaderNodeMethod "getNodeType" o = Gsk.RenderNode.RenderNodeGetNodeTypeMethodInfo
ResolveGLShaderNodeMethod "getShader" o = GLShaderNodeGetShaderMethodInfo
ResolveGLShaderNodeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveGLShaderNodeMethod t GLShaderNode, O.OverloadedMethod info GLShaderNode p) => OL.IsLabel t (GLShaderNode -> 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 ~ ResolveGLShaderNodeMethod t GLShaderNode, O.OverloadedMethod info GLShaderNode p, R.HasField t GLShaderNode p) => R.HasField t GLShaderNode p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveGLShaderNodeMethod t GLShaderNode, O.OverloadedMethodInfo info GLShaderNode) => OL.IsLabel t (O.MethodProxy info GLShaderNode) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
instance BoxedPtr GLShaderNode where
boxedPtrCopy :: GLShaderNode -> IO GLShaderNode
boxedPtrCopy = GLShaderNode -> IO GLShaderNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: GLShaderNode -> IO ()
boxedPtrFree = \GLShaderNode
_x -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "gsk_gl_shader_node_new" gsk_gl_shader_node_new ::
Ptr Gsk.GLShader.GLShader ->
Ptr Graphene.Rect.Rect ->
Ptr GLib.Bytes.Bytes ->
Ptr (Ptr Gsk.RenderNode.RenderNode) ->
Word32 ->
IO (Ptr GLShaderNode)
gLShaderNodeNew ::
(B.CallStack.HasCallStack, MonadIO m, Gsk.GLShader.IsGLShader a) =>
a
-> Graphene.Rect.Rect
-> GLib.Bytes.Bytes
-> Maybe ([Gsk.RenderNode.RenderNode])
-> m GLShaderNode
gLShaderNodeNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGLShader a) =>
a -> Rect -> Bytes -> Maybe [RenderNode] -> m GLShaderNode
gLShaderNodeNew a
shader Rect
bounds Bytes
args Maybe [RenderNode]
children = IO GLShaderNode -> m GLShaderNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLShaderNode -> m GLShaderNode)
-> IO GLShaderNode -> m GLShaderNode
forall a b. (a -> b) -> a -> b
$ do
let nChildren :: Word32
nChildren = case Maybe [RenderNode]
children of
Maybe [RenderNode]
Nothing -> Word32
0
Just [RenderNode]
jChildren -> Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [RenderNode] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [RenderNode]
jChildren
Ptr GLShader
shader' <- a -> IO (Ptr GLShader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
Ptr Rect
bounds' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
bounds
Ptr Bytes
args' <- Bytes -> IO (Ptr Bytes)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
args
Ptr (Ptr RenderNode)
maybeChildren <- case Maybe [RenderNode]
children of
Maybe [RenderNode]
Nothing -> Ptr (Ptr RenderNode) -> IO (Ptr (Ptr RenderNode))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr RenderNode)
forall a. Ptr a
nullPtr
Just [RenderNode]
jChildren -> do
[Ptr RenderNode]
jChildren' <- (RenderNode -> IO (Ptr RenderNode))
-> [RenderNode] -> IO [Ptr RenderNode]
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 RenderNode -> IO (Ptr RenderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [RenderNode]
jChildren
Ptr (Ptr RenderNode)
jChildren'' <- [Ptr RenderNode] -> IO (Ptr (Ptr RenderNode))
forall a. [Ptr a] -> IO (Ptr (Ptr a))
packPtrArray [Ptr RenderNode]
jChildren'
Ptr (Ptr RenderNode) -> IO (Ptr (Ptr RenderNode))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr RenderNode)
jChildren''
Ptr GLShaderNode
result <- Ptr GLShader
-> Ptr Rect
-> Ptr Bytes
-> Ptr (Ptr RenderNode)
-> Word32
-> IO (Ptr GLShaderNode)
gsk_gl_shader_node_new Ptr GLShader
shader' Ptr Rect
bounds' Ptr Bytes
args' Ptr (Ptr RenderNode)
maybeChildren Word32
nChildren
Text -> Ptr GLShaderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gLShaderNodeNew" Ptr GLShaderNode
result
GLShaderNode
result' <- ((ManagedPtr GLShaderNode -> GLShaderNode)
-> Ptr GLShaderNode -> IO GLShaderNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr GLShaderNode -> GLShaderNode
GLShaderNode) Ptr GLShaderNode
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
bounds
Bytes -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
args
Maybe [RenderNode] -> ([RenderNode] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [RenderNode]
children ((RenderNode -> IO ()) -> [RenderNode] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
Ptr (Ptr RenderNode) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr RenderNode)
maybeChildren
GLShaderNode -> IO GLShaderNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GLShaderNode
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gsk_gl_shader_node_get_args" gsk_gl_shader_node_get_args ::
Ptr GLShaderNode ->
IO (Ptr GLib.Bytes.Bytes)
gLShaderNodeGetArgs ::
(B.CallStack.HasCallStack, MonadIO m, IsGLShaderNode a) =>
a
-> m GLib.Bytes.Bytes
gLShaderNodeGetArgs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGLShaderNode a) =>
a -> m Bytes
gLShaderNodeGetArgs a
node = IO Bytes -> m Bytes
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bytes -> m Bytes) -> IO Bytes -> m Bytes
forall a b. (a -> b) -> a -> b
$ do
Ptr GLShaderNode
node' <- a -> IO (Ptr GLShaderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr Bytes
result <- Ptr GLShaderNode -> IO (Ptr Bytes)
gsk_gl_shader_node_get_args Ptr GLShaderNode
node'
Text -> Ptr Bytes -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gLShaderNodeGetArgs" Ptr Bytes
result
Bytes
result' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
Bytes -> IO Bytes
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
result'
#if defined(ENABLE_OVERLOADING)
data GLShaderNodeGetArgsMethodInfo
instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m, IsGLShaderNode a) => O.OverloadedMethod GLShaderNodeGetArgsMethodInfo a signature where
overloadedMethod = gLShaderNodeGetArgs
instance O.OverloadedMethodInfo GLShaderNodeGetArgsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.GLShaderNode.gLShaderNodeGetArgs",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-GLShaderNode.html#v:gLShaderNodeGetArgs"
})
#endif
foreign import ccall "gsk_gl_shader_node_get_child" gsk_gl_shader_node_get_child ::
Ptr GLShaderNode ->
Word32 ->
IO (Ptr Gsk.RenderNode.RenderNode)
gLShaderNodeGetChild ::
(B.CallStack.HasCallStack, MonadIO m, IsGLShaderNode a) =>
a
-> Word32
-> m Gsk.RenderNode.RenderNode
gLShaderNodeGetChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGLShaderNode a) =>
a -> Word32 -> m RenderNode
gLShaderNodeGetChild a
node Word32
idx = IO RenderNode -> m RenderNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
Ptr GLShaderNode
node' <- a -> IO (Ptr GLShaderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr RenderNode
result <- Ptr GLShaderNode -> Word32 -> IO (Ptr RenderNode)
gsk_gl_shader_node_get_child Ptr GLShaderNode
node' Word32
idx
Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gLShaderNodeGetChild" Ptr RenderNode
result
RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
RenderNode -> IO RenderNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'
#if defined(ENABLE_OVERLOADING)
data GLShaderNodeGetChildMethodInfo
instance (signature ~ (Word32 -> m Gsk.RenderNode.RenderNode), MonadIO m, IsGLShaderNode a) => O.OverloadedMethod GLShaderNodeGetChildMethodInfo a signature where
overloadedMethod = gLShaderNodeGetChild
instance O.OverloadedMethodInfo GLShaderNodeGetChildMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.GLShaderNode.gLShaderNodeGetChild",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-GLShaderNode.html#v:gLShaderNodeGetChild"
})
#endif
foreign import ccall "gsk_gl_shader_node_get_n_children" gsk_gl_shader_node_get_n_children ::
Ptr GLShaderNode ->
IO Word32
gLShaderNodeGetNChildren ::
(B.CallStack.HasCallStack, MonadIO m, IsGLShaderNode a) =>
a
-> m Word32
gLShaderNodeGetNChildren :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGLShaderNode a) =>
a -> m Word32
gLShaderNodeGetNChildren a
node = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr GLShaderNode
node' <- a -> IO (Ptr GLShaderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Word32
result <- Ptr GLShaderNode -> IO Word32
gsk_gl_shader_node_get_n_children Ptr GLShaderNode
node'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data GLShaderNodeGetNChildrenMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsGLShaderNode a) => O.OverloadedMethod GLShaderNodeGetNChildrenMethodInfo a signature where
overloadedMethod = gLShaderNodeGetNChildren
instance O.OverloadedMethodInfo GLShaderNodeGetNChildrenMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.GLShaderNode.gLShaderNodeGetNChildren",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-GLShaderNode.html#v:gLShaderNodeGetNChildren"
})
#endif
foreign import ccall "gsk_gl_shader_node_get_shader" gsk_gl_shader_node_get_shader ::
Ptr GLShaderNode ->
IO (Ptr Gsk.GLShader.GLShader)
gLShaderNodeGetShader ::
(B.CallStack.HasCallStack, MonadIO m, IsGLShaderNode a) =>
a
-> m Gsk.GLShader.GLShader
gLShaderNodeGetShader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGLShaderNode a) =>
a -> m GLShader
gLShaderNodeGetShader a
node = IO GLShader -> m GLShader
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLShader -> m GLShader) -> IO GLShader -> m GLShader
forall a b. (a -> b) -> a -> b
$ do
Ptr GLShaderNode
node' <- a -> IO (Ptr GLShaderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr GLShader
result <- Ptr GLShaderNode -> IO (Ptr GLShader)
gsk_gl_shader_node_get_shader Ptr GLShaderNode
node'
Text -> Ptr GLShader -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gLShaderNodeGetShader" Ptr GLShader
result
GLShader
result' <- ((ManagedPtr GLShader -> GLShader) -> Ptr GLShader -> IO GLShader
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr GLShader -> GLShader
Gsk.GLShader.GLShader) Ptr GLShader
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
GLShader -> IO GLShader
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GLShader
result'
#if defined(ENABLE_OVERLOADING)
data GLShaderNodeGetShaderMethodInfo
instance (signature ~ (m Gsk.GLShader.GLShader), MonadIO m, IsGLShaderNode a) => O.OverloadedMethod GLShaderNodeGetShaderMethodInfo a signature where
overloadedMethod = gLShaderNodeGetShader
instance O.OverloadedMethodInfo GLShaderNodeGetShaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gsk.Objects.GLShaderNode.gLShaderNodeGetShader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-GLShaderNode.html#v:gLShaderNodeGetShader"
})
#endif