{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Clutter.Objects.Shader.Shader' structure contains only private data
-- and should be accessed using the provided API
-- 
-- /Since: 0.6/

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

module GI.Clutter.Objects.Shader
    ( 

-- * Exported types
    Shader(..)                              ,
    IsShader                                ,
    toShader                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [compile]("GI.Clutter.Objects.Shader#g:method:compile"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isCompiled]("GI.Clutter.Objects.Shader#g:method:isCompiled"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [release]("GI.Clutter.Objects.Shader#g:method:release"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getCoglFragmentShader]("GI.Clutter.Objects.Shader#g:method:getCoglFragmentShader"), [getCoglProgram]("GI.Clutter.Objects.Shader#g:method:getCoglProgram"), [getCoglVertexShader]("GI.Clutter.Objects.Shader#g:method:getCoglVertexShader"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFragmentSource]("GI.Clutter.Objects.Shader#g:method:getFragmentSource"), [getIsEnabled]("GI.Clutter.Objects.Shader#g:method:getIsEnabled"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getVertexSource]("GI.Clutter.Objects.Shader#g:method:getVertexSource").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFragmentSource]("GI.Clutter.Objects.Shader#g:method:setFragmentSource"), [setIsEnabled]("GI.Clutter.Objects.Shader#g:method:setIsEnabled"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setUniform]("GI.Clutter.Objects.Shader#g:method:setUniform"), [setVertexSource]("GI.Clutter.Objects.Shader#g:method:setVertexSource").

#if defined(ENABLE_OVERLOADING)
    ResolveShaderMethod                     ,
#endif

-- ** compile #method:compile#

#if defined(ENABLE_OVERLOADING)
    ShaderCompileMethodInfo                 ,
#endif
    shaderCompile                           ,


-- ** getCoglFragmentShader #method:getCoglFragmentShader#

#if defined(ENABLE_OVERLOADING)
    ShaderGetCoglFragmentShaderMethodInfo   ,
#endif
    shaderGetCoglFragmentShader             ,


-- ** getCoglProgram #method:getCoglProgram#

#if defined(ENABLE_OVERLOADING)
    ShaderGetCoglProgramMethodInfo          ,
#endif
    shaderGetCoglProgram                    ,


-- ** getCoglVertexShader #method:getCoglVertexShader#

#if defined(ENABLE_OVERLOADING)
    ShaderGetCoglVertexShaderMethodInfo     ,
#endif
    shaderGetCoglVertexShader               ,


-- ** getFragmentSource #method:getFragmentSource#

#if defined(ENABLE_OVERLOADING)
    ShaderGetFragmentSourceMethodInfo       ,
#endif
    shaderGetFragmentSource                 ,


-- ** getIsEnabled #method:getIsEnabled#

#if defined(ENABLE_OVERLOADING)
    ShaderGetIsEnabledMethodInfo            ,
#endif
    shaderGetIsEnabled                      ,


-- ** getVertexSource #method:getVertexSource#

#if defined(ENABLE_OVERLOADING)
    ShaderGetVertexSourceMethodInfo         ,
#endif
    shaderGetVertexSource                   ,


-- ** isCompiled #method:isCompiled#

#if defined(ENABLE_OVERLOADING)
    ShaderIsCompiledMethodInfo              ,
#endif
    shaderIsCompiled                        ,


-- ** new #method:new#

    shaderNew                               ,


-- ** release #method:release#

#if defined(ENABLE_OVERLOADING)
    ShaderReleaseMethodInfo                 ,
#endif
    shaderRelease                           ,


-- ** setFragmentSource #method:setFragmentSource#

#if defined(ENABLE_OVERLOADING)
    ShaderSetFragmentSourceMethodInfo       ,
#endif
    shaderSetFragmentSource                 ,


-- ** setIsEnabled #method:setIsEnabled#

#if defined(ENABLE_OVERLOADING)
    ShaderSetIsEnabledMethodInfo            ,
#endif
    shaderSetIsEnabled                      ,


-- ** setUniform #method:setUniform#

#if defined(ENABLE_OVERLOADING)
    ShaderSetUniformMethodInfo              ,
#endif
    shaderSetUniform                        ,


-- ** setVertexSource #method:setVertexSource#

#if defined(ENABLE_OVERLOADING)
    ShaderSetVertexSourceMethodInfo         ,
#endif
    shaderSetVertexSource                   ,




 -- * Properties


-- ** compiled #attr:compiled#
-- | Whether the shader is compiled and linked, ready for use
-- in the GL context.
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ShaderCompiledPropertyInfo              ,
#endif
    getShaderCompiled                       ,
#if defined(ENABLE_OVERLOADING)
    shaderCompiled                          ,
#endif


-- ** enabled #attr:enabled#
-- | Whether the shader is currently used in the GL rendering pipeline.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ShaderEnabledPropertyInfo               ,
#endif
    constructShaderEnabled                  ,
    getShaderEnabled                        ,
    setShaderEnabled                        ,
#if defined(ENABLE_OVERLOADING)
    shaderEnabled                           ,
#endif


-- ** fragmentSource #attr:fragmentSource#
-- | GLSL source code for the fragment shader part of the shader program.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ShaderFragmentSourcePropertyInfo        ,
#endif
    clearShaderFragmentSource               ,
    constructShaderFragmentSource           ,
    getShaderFragmentSource                 ,
    setShaderFragmentSource                 ,
#if defined(ENABLE_OVERLOADING)
    shaderFragmentSource                    ,
#endif


-- ** vertexSource #attr:vertexSource#
-- | GLSL source code for the vertex shader part of the shader
-- program, if any
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ShaderVertexSourcePropertyInfo          ,
#endif
    clearShaderVertexSource                 ,
    constructShaderVertexSource             ,
    getShaderVertexSource                   ,
    setShaderVertexSource                   ,
#if defined(ENABLE_OVERLOADING)
    shaderVertexSource                      ,
#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.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "clutter_shader_get_type"
    c_clutter_shader_get_type :: IO B.Types.GType

instance B.Types.TypedObject Shader where
    glibType :: IO GType
glibType = IO GType
c_clutter_shader_get_type

instance B.Types.GObject Shader

-- | Type class for types which can be safely cast to `Shader`, for instance with `toShader`.
class (SP.GObject o, O.IsDescendantOf Shader o) => IsShader o
instance (SP.GObject o, O.IsDescendantOf Shader o) => IsShader o

instance O.HasParentTypes Shader
type instance O.ParentTypes Shader = '[GObject.Object.Object]

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

-- | Convert 'Shader' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Shader) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_shader_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Shader -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Shader
P.Nothing = Ptr GValue -> Ptr Shader -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Shader
forall a. Ptr a
FP.nullPtr :: FP.Ptr Shader)
    gvalueSet_ Ptr GValue
gv (P.Just Shader
obj) = Shader -> (Ptr Shader -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Shader
obj (Ptr GValue -> Ptr Shader -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Shader)
gvalueGet_ Ptr GValue
gv = do
        Ptr Shader
ptr <- Ptr GValue -> IO (Ptr Shader)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Shader)
        if Ptr Shader
ptr Ptr Shader -> Ptr Shader -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Shader
forall a. Ptr a
FP.nullPtr
        then Shader -> Maybe Shader
forall a. a -> Maybe a
P.Just (Shader -> Maybe Shader) -> IO Shader -> IO (Maybe Shader)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Shader -> Shader) -> Ptr Shader -> IO Shader
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Shader -> Shader
Shader Ptr Shader
ptr
        else Maybe Shader -> IO (Maybe Shader)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Shader
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveShaderMethod (t :: Symbol) (o :: *) :: * where
    ResolveShaderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveShaderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveShaderMethod "compile" o = ShaderCompileMethodInfo
    ResolveShaderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveShaderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveShaderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveShaderMethod "isCompiled" o = ShaderIsCompiledMethodInfo
    ResolveShaderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveShaderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveShaderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveShaderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveShaderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveShaderMethod "release" o = ShaderReleaseMethodInfo
    ResolveShaderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveShaderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveShaderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveShaderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveShaderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveShaderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveShaderMethod "getCoglFragmentShader" o = ShaderGetCoglFragmentShaderMethodInfo
    ResolveShaderMethod "getCoglProgram" o = ShaderGetCoglProgramMethodInfo
    ResolveShaderMethod "getCoglVertexShader" o = ShaderGetCoglVertexShaderMethodInfo
    ResolveShaderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveShaderMethod "getFragmentSource" o = ShaderGetFragmentSourceMethodInfo
    ResolveShaderMethod "getIsEnabled" o = ShaderGetIsEnabledMethodInfo
    ResolveShaderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveShaderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveShaderMethod "getVertexSource" o = ShaderGetVertexSourceMethodInfo
    ResolveShaderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveShaderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveShaderMethod "setFragmentSource" o = ShaderSetFragmentSourceMethodInfo
    ResolveShaderMethod "setIsEnabled" o = ShaderSetIsEnabledMethodInfo
    ResolveShaderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveShaderMethod "setUniform" o = ShaderSetUniformMethodInfo
    ResolveShaderMethod "setVertexSource" o = ShaderSetVertexSourceMethodInfo
    ResolveShaderMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- VVV Prop "compiled"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@compiled@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' shader #compiled
-- @
getShaderCompiled :: (MonadIO m, IsShader o) => o -> m Bool
getShaderCompiled :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m Bool
getShaderCompiled o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"compiled"

#if defined(ENABLE_OVERLOADING)
data ShaderCompiledPropertyInfo
instance AttrInfo ShaderCompiledPropertyInfo where
    type AttrAllowedOps ShaderCompiledPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ShaderCompiledPropertyInfo = IsShader
    type AttrSetTypeConstraint ShaderCompiledPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ShaderCompiledPropertyInfo = (~) ()
    type AttrTransferType ShaderCompiledPropertyInfo = ()
    type AttrGetType ShaderCompiledPropertyInfo = Bool
    type AttrLabel ShaderCompiledPropertyInfo = "compiled"
    type AttrOrigin ShaderCompiledPropertyInfo = Shader
    attrGet = getShaderCompiled
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.compiled"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#g:attr:compiled"
        })
#endif

-- VVV Prop "enabled"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@enabled@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' shader #enabled
-- @
getShaderEnabled :: (MonadIO m, IsShader o) => o -> m Bool
getShaderEnabled :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m Bool
getShaderEnabled o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"enabled"

-- | Set the value of the “@enabled@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' shader [ #enabled 'Data.GI.Base.Attributes.:=' value ]
-- @
setShaderEnabled :: (MonadIO m, IsShader o) => o -> Bool -> m ()
setShaderEnabled :: forall (m :: * -> *) o.
(MonadIO m, IsShader o) =>
o -> Bool -> m ()
setShaderEnabled o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"enabled" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructShaderEnabled :: (IsShader o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructShaderEnabled :: forall o (m :: * -> *).
(IsShader o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructShaderEnabled Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"enabled" Bool
val

#if defined(ENABLE_OVERLOADING)
data ShaderEnabledPropertyInfo
instance AttrInfo ShaderEnabledPropertyInfo where
    type AttrAllowedOps ShaderEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ShaderEnabledPropertyInfo = IsShader
    type AttrSetTypeConstraint ShaderEnabledPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ShaderEnabledPropertyInfo = (~) Bool
    type AttrTransferType ShaderEnabledPropertyInfo = Bool
    type AttrGetType ShaderEnabledPropertyInfo = Bool
    type AttrLabel ShaderEnabledPropertyInfo = "enabled"
    type AttrOrigin ShaderEnabledPropertyInfo = Shader
    attrGet = getShaderEnabled
    attrSet = setShaderEnabled
    attrTransfer _ v = do
        return v
    attrConstruct = constructShaderEnabled
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.enabled"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#g:attr:enabled"
        })
#endif

-- VVV Prop "fragment-source"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@fragment-source@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' shader #fragmentSource
-- @
getShaderFragmentSource :: (MonadIO m, IsShader o) => o -> m T.Text
getShaderFragmentSource :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m Text
getShaderFragmentSource o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getShaderFragmentSource" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"fragment-source"

-- | Set the value of the “@fragment-source@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' shader [ #fragmentSource 'Data.GI.Base.Attributes.:=' value ]
-- @
setShaderFragmentSource :: (MonadIO m, IsShader o) => o -> T.Text -> m ()
setShaderFragmentSource :: forall (m :: * -> *) o.
(MonadIO m, IsShader o) =>
o -> Text -> m ()
setShaderFragmentSource o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"fragment-source" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@fragment-source@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructShaderFragmentSource :: (IsShader o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructShaderFragmentSource :: forall o (m :: * -> *).
(IsShader o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructShaderFragmentSource Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"fragment-source" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@fragment-source@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #fragmentSource
-- @
clearShaderFragmentSource :: (MonadIO m, IsShader o) => o -> m ()
clearShaderFragmentSource :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m ()
clearShaderFragmentSource o
obj = 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
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"fragment-source" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data ShaderFragmentSourcePropertyInfo
instance AttrInfo ShaderFragmentSourcePropertyInfo where
    type AttrAllowedOps ShaderFragmentSourcePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ShaderFragmentSourcePropertyInfo = IsShader
    type AttrSetTypeConstraint ShaderFragmentSourcePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ShaderFragmentSourcePropertyInfo = (~) T.Text
    type AttrTransferType ShaderFragmentSourcePropertyInfo = T.Text
    type AttrGetType ShaderFragmentSourcePropertyInfo = T.Text
    type AttrLabel ShaderFragmentSourcePropertyInfo = "fragment-source"
    type AttrOrigin ShaderFragmentSourcePropertyInfo = Shader
    attrGet = getShaderFragmentSource
    attrSet = setShaderFragmentSource
    attrTransfer _ v = do
        return v
    attrConstruct = constructShaderFragmentSource
    attrClear = clearShaderFragmentSource
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.fragmentSource"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#g:attr:fragmentSource"
        })
#endif

-- VVV Prop "vertex-source"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@vertex-source@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' shader #vertexSource
-- @
getShaderVertexSource :: (MonadIO m, IsShader o) => o -> m T.Text
getShaderVertexSource :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m Text
getShaderVertexSource o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getShaderVertexSource" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"vertex-source"

-- | Set the value of the “@vertex-source@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' shader [ #vertexSource 'Data.GI.Base.Attributes.:=' value ]
-- @
setShaderVertexSource :: (MonadIO m, IsShader o) => o -> T.Text -> m ()
setShaderVertexSource :: forall (m :: * -> *) o.
(MonadIO m, IsShader o) =>
o -> Text -> m ()
setShaderVertexSource o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"vertex-source" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@vertex-source@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructShaderVertexSource :: (IsShader o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructShaderVertexSource :: forall o (m :: * -> *).
(IsShader o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructShaderVertexSource Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"vertex-source" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@vertex-source@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #vertexSource
-- @
clearShaderVertexSource :: (MonadIO m, IsShader o) => o -> m ()
clearShaderVertexSource :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m ()
clearShaderVertexSource o
obj = 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
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"vertex-source" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data ShaderVertexSourcePropertyInfo
instance AttrInfo ShaderVertexSourcePropertyInfo where
    type AttrAllowedOps ShaderVertexSourcePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ShaderVertexSourcePropertyInfo = IsShader
    type AttrSetTypeConstraint ShaderVertexSourcePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ShaderVertexSourcePropertyInfo = (~) T.Text
    type AttrTransferType ShaderVertexSourcePropertyInfo = T.Text
    type AttrGetType ShaderVertexSourcePropertyInfo = T.Text
    type AttrLabel ShaderVertexSourcePropertyInfo = "vertex-source"
    type AttrOrigin ShaderVertexSourcePropertyInfo = Shader
    attrGet = getShaderVertexSource
    attrSet = setShaderVertexSource
    attrTransfer _ v = do
        return v
    attrConstruct = constructShaderVertexSource
    attrClear = clearShaderVertexSource
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.vertexSource"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#g:attr:vertexSource"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Shader
type instance O.AttributeList Shader = ShaderAttributeList
type ShaderAttributeList = ('[ '("compiled", ShaderCompiledPropertyInfo), '("enabled", ShaderEnabledPropertyInfo), '("fragmentSource", ShaderFragmentSourcePropertyInfo), '("vertexSource", ShaderVertexSourcePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
shaderCompiled :: AttrLabelProxy "compiled"
shaderCompiled = AttrLabelProxy

shaderEnabled :: AttrLabelProxy "enabled"
shaderEnabled = AttrLabelProxy

shaderFragmentSource :: AttrLabelProxy "fragmentSource"
shaderFragmentSource = AttrLabelProxy

shaderVertexSource :: AttrLabelProxy "vertexSource"
shaderVertexSource = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Shader = ShaderSignalList
type ShaderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Shader::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Shader" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_new" clutter_shader_new :: 
    IO (Ptr Shader)

{-# DEPRECATED shaderNew ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Create a new t'GI.Clutter.Objects.Shader.Shader' instance.
-- 
-- /Since: 0.6/
shaderNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Shader
    -- ^ __Returns:__ a new t'GI.Clutter.Objects.Shader.Shader'.
shaderNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Shader
shaderNew  = IO Shader -> m Shader
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Shader -> m Shader) -> IO Shader -> m Shader
forall a b. (a -> b) -> a -> b
$ do
    Ptr Shader
result <- IO (Ptr Shader)
clutter_shader_new
    Text -> Ptr Shader -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"shaderNew" Ptr Shader
result
    Shader
result' <- ((ManagedPtr Shader -> Shader) -> Ptr Shader -> IO Shader
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Shader -> Shader
Shader) Ptr Shader
result
    Shader -> IO Shader
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Shader
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Shader::compile
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "clutter_shader_compile" clutter_shader_compile :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED shaderCompile ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Compiles and links GLSL sources set for vertex and fragment shaders for
-- a t'GI.Clutter.Objects.Shader.Shader'. If the compilation fails and a t'GError' return location is
-- provided the error will contain the errors from the compiler, if any.
-- 
-- /Since: 0.8/
shaderCompile ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
shaderCompile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m ()
shaderCompile a
shader = 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
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Shader -> Ptr (Ptr GError) -> IO CInt
clutter_shader_compile Ptr Shader
shader'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ShaderCompileMethodInfo
instance (signature ~ (m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderCompileMethodInfo a signature where
    overloadedMethod = shaderCompile

instance O.OverloadedMethodInfo ShaderCompileMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderCompile",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderCompile"
        })


#endif

-- method Shader::get_cogl_fragment_shader
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_get_cogl_fragment_shader" clutter_shader_get_cogl_fragment_shader :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    IO (Ptr ())

{-# DEPRECATED shaderGetCoglFragmentShader ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Retrieves the underlying @/CoglHandle/@ for the fragment shader.
-- 
-- /Since: 1.0/
shaderGetCoglFragmentShader ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> m (Ptr ())
    -- ^ __Returns:__ A @/CoglHandle/@ for the fragment
    --   shader, or 'P.Nothing'. The handle is owned by the t'GI.Clutter.Objects.Shader.Shader'
    --   and it should not be unreferenced
shaderGetCoglFragmentShader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m (Ptr ())
shaderGetCoglFragmentShader a
shader = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    Ptr ()
result <- Ptr Shader -> IO (Ptr ())
clutter_shader_get_cogl_fragment_shader Ptr Shader
shader'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data ShaderGetCoglFragmentShaderMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetCoglFragmentShaderMethodInfo a signature where
    overloadedMethod = shaderGetCoglFragmentShader

instance O.OverloadedMethodInfo ShaderGetCoglFragmentShaderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetCoglFragmentShader",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetCoglFragmentShader"
        })


#endif

-- method Shader::get_cogl_program
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_get_cogl_program" clutter_shader_get_cogl_program :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    IO (Ptr ())

{-# DEPRECATED shaderGetCoglProgram ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Retrieves the underlying @/CoglHandle/@ for the shader program.
-- 
-- /Since: 1.0/
shaderGetCoglProgram ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> m (Ptr ())
    -- ^ __Returns:__ A @/CoglHandle/@ for the shader program,
    --   or 'P.Nothing'. The handle is owned by the t'GI.Clutter.Objects.Shader.Shader' and it should
    --   not be unreferenced
shaderGetCoglProgram :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m (Ptr ())
shaderGetCoglProgram a
shader = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    Ptr ()
result <- Ptr Shader -> IO (Ptr ())
clutter_shader_get_cogl_program Ptr Shader
shader'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data ShaderGetCoglProgramMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetCoglProgramMethodInfo a signature where
    overloadedMethod = shaderGetCoglProgram

instance O.OverloadedMethodInfo ShaderGetCoglProgramMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetCoglProgram",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetCoglProgram"
        })


#endif

-- method Shader::get_cogl_vertex_shader
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_get_cogl_vertex_shader" clutter_shader_get_cogl_vertex_shader :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    IO (Ptr ())

{-# DEPRECATED shaderGetCoglVertexShader ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Retrieves the underlying @/CoglHandle/@ for the vertex shader.
-- 
-- /Since: 1.0/
shaderGetCoglVertexShader ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> m (Ptr ())
    -- ^ __Returns:__ A @/CoglHandle/@ for the vertex
    --   shader, or 'P.Nothing'. The handle is owned by the t'GI.Clutter.Objects.Shader.Shader'
    --   and it should not be unreferenced
shaderGetCoglVertexShader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m (Ptr ())
shaderGetCoglVertexShader a
shader = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    Ptr ()
result <- Ptr Shader -> IO (Ptr ())
clutter_shader_get_cogl_vertex_shader Ptr Shader
shader'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data ShaderGetCoglVertexShaderMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetCoglVertexShaderMethodInfo a signature where
    overloadedMethod = shaderGetCoglVertexShader

instance O.OverloadedMethodInfo ShaderGetCoglVertexShaderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetCoglVertexShader",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetCoglVertexShader"
        })


#endif

-- method Shader::get_fragment_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_get_fragment_source" clutter_shader_get_fragment_source :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    IO CString

{-# DEPRECATED shaderGetFragmentSource ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Query the current GLSL fragment source set on /@shader@/.
-- 
-- /Since: 0.6/
shaderGetFragmentSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> m T.Text
    -- ^ __Returns:__ the source of the fragment shader for this
    -- ClutterShader object or 'P.Nothing'. The returned string is owned by the
    -- shader object and should never be modified or freed
shaderGetFragmentSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m Text
shaderGetFragmentSource a
shader = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    CString
result <- Ptr Shader -> IO CString
clutter_shader_get_fragment_source Ptr Shader
shader'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"shaderGetFragmentSource" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data ShaderGetFragmentSourceMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetFragmentSourceMethodInfo a signature where
    overloadedMethod = shaderGetFragmentSource

instance O.OverloadedMethodInfo ShaderGetFragmentSourceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetFragmentSource",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetFragmentSource"
        })


#endif

-- method Shader::get_is_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_get_is_enabled" clutter_shader_get_is_enabled :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    IO CInt

{-# DEPRECATED shaderGetIsEnabled ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Checks whether /@shader@/ is enabled.
-- 
-- /Since: 0.6/
shaderGetIsEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the shader is enabled.
shaderGetIsEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m Bool
shaderGetIsEnabled a
shader = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    CInt
result <- Ptr Shader -> IO CInt
clutter_shader_get_is_enabled Ptr Shader
shader'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ShaderGetIsEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetIsEnabledMethodInfo a signature where
    overloadedMethod = shaderGetIsEnabled

instance O.OverloadedMethodInfo ShaderGetIsEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetIsEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetIsEnabled"
        })


#endif

-- method Shader::get_vertex_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_get_vertex_source" clutter_shader_get_vertex_source :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    IO CString

{-# DEPRECATED shaderGetVertexSource ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Query the current GLSL vertex source set on /@shader@/.
-- 
-- /Since: 0.6/
shaderGetVertexSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> m T.Text
    -- ^ __Returns:__ the source of the vertex shader for this
    -- ClutterShader object or 'P.Nothing'. The returned string is owned by the
    -- shader object and should never be modified or freed
shaderGetVertexSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m Text
shaderGetVertexSource a
shader = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    CString
result <- Ptr Shader -> IO CString
clutter_shader_get_vertex_source Ptr Shader
shader'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"shaderGetVertexSource" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data ShaderGetVertexSourceMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetVertexSourceMethodInfo a signature where
    overloadedMethod = shaderGetVertexSource

instance O.OverloadedMethodInfo ShaderGetVertexSourceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetVertexSource",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetVertexSource"
        })


#endif

-- method Shader::is_compiled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_is_compiled" clutter_shader_is_compiled :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    IO CInt

{-# DEPRECATED shaderIsCompiled ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Checks whether /@shader@/ is is currently compiled, linked and bound
-- to the GL context.
-- 
-- /Since: 0.8/
shaderIsCompiled ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the shader is compiled, linked and ready for use.
shaderIsCompiled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m Bool
shaderIsCompiled a
shader = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    CInt
result <- Ptr Shader -> IO CInt
clutter_shader_is_compiled Ptr Shader
shader'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ShaderIsCompiledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsShader a) => O.OverloadedMethod ShaderIsCompiledMethodInfo a signature where
    overloadedMethod = shaderIsCompiled

instance O.OverloadedMethodInfo ShaderIsCompiledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderIsCompiled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderIsCompiled"
        })


#endif

-- method Shader::release
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_release" clutter_shader_release :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    IO ()

{-# DEPRECATED shaderRelease ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Frees up any GL context resources held by the shader.
-- 
-- /Since: 0.6/
shaderRelease ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> m ()
shaderRelease :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m ()
shaderRelease a
shader = 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
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    Ptr Shader -> IO ()
clutter_shader_release Ptr Shader
shader'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ShaderReleaseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderReleaseMethodInfo a signature where
    overloadedMethod = shaderRelease

instance O.OverloadedMethodInfo ShaderReleaseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderRelease",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderRelease"
        })


#endif

-- method Shader::set_fragment_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GLSL source code." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "length of source buffer (currently ignored)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_set_fragment_source" clutter_shader_set_fragment_source :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    CString ->                              -- data : TBasicType TUTF8
    Int64 ->                                -- length : TBasicType TInt64
    IO ()

{-# DEPRECATED shaderSetFragmentSource ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Sets the GLSL source code to be used by a t'GI.Clutter.Objects.Shader.Shader' for the fragment
-- program.
-- 
-- /Since: 0.6/
shaderSetFragmentSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> T.Text
    -- ^ /@data@/: GLSL source code.
    -> Int64
    -- ^ /@length@/: length of source buffer (currently ignored)
    -> m ()
shaderSetFragmentSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> Text -> Int64 -> m ()
shaderSetFragmentSource a
shader Text
data_ Int64
length_ = 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
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    CString
data_' <- Text -> IO CString
textToCString Text
data_
    Ptr Shader -> CString -> Int64 -> IO ()
clutter_shader_set_fragment_source Ptr Shader
shader' CString
data_' Int64
length_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ShaderSetFragmentSourceMethodInfo
instance (signature ~ (T.Text -> Int64 -> m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderSetFragmentSourceMethodInfo a signature where
    overloadedMethod = shaderSetFragmentSource

instance O.OverloadedMethodInfo ShaderSetFragmentSourceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderSetFragmentSource",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderSetFragmentSource"
        })


#endif

-- method Shader::set_is_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enabled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new state of the shader."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_set_is_enabled" clutter_shader_set_is_enabled :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{-# DEPRECATED shaderSetIsEnabled ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Enables a shader. This function will attempt to compile and link
-- the shader, if it isn\'t already.
-- 
-- When /@enabled@/ is 'P.False' the default state of the GL pipeline will be
-- used instead.
-- 
-- /Since: 0.6/
shaderSetIsEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> Bool
    -- ^ /@enabled@/: The new state of the shader.
    -> m ()
shaderSetIsEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> Bool -> m ()
shaderSetIsEnabled a
shader Bool
enabled = 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
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enabled
    Ptr Shader -> CInt -> IO ()
clutter_shader_set_is_enabled Ptr Shader
shader' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ShaderSetIsEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderSetIsEnabledMethodInfo a signature where
    overloadedMethod = shaderSetIsEnabled

instance O.OverloadedMethodInfo ShaderSetIsEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderSetIsEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderSetIsEnabled"
        })


#endif

-- method Shader::set_uniform
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "name of uniform in GLSL shader program to set."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterShaderFloat, #ClutterShaderInt or #ClutterShaderMatrix\n        #GValue."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_set_uniform" clutter_shader_set_uniform :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr GValue ->                           -- value : TGValue
    IO ()

{-# DEPRECATED shaderSetUniform ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Sets a user configurable variable in the GLSL shader programs attached to
-- a t'GI.Clutter.Objects.Shader.Shader'.
-- 
-- /Since: 1.0/
shaderSetUniform ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'.
    -> T.Text
    -- ^ /@name@/: name of uniform in GLSL shader program to set.
    -> GValue
    -- ^ /@value@/: a t'GI.Clutter.Objects.ShaderFloat.ShaderFloat', t'GI.Clutter.Objects.ShaderInt.ShaderInt' or t'GI.Clutter.Objects.ShaderMatrix.ShaderMatrix'
    --         t'GI.GObject.Structs.Value.Value'.
    -> m ()
shaderSetUniform :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> Text -> GValue -> m ()
shaderSetUniform a
shader Text
name GValue
value = 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
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    Ptr Shader -> CString -> Ptr GValue -> IO ()
clutter_shader_set_uniform Ptr Shader
shader' CString
name' Ptr GValue
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ShaderSetUniformMethodInfo
instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderSetUniformMethodInfo a signature where
    overloadedMethod = shaderSetUniform

instance O.OverloadedMethodInfo ShaderSetUniformMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderSetUniform",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderSetUniform"
        })


#endif

-- method Shader::set_vertex_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterShader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GLSL source code." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "length of source buffer (currently ignored)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_shader_set_vertex_source" clutter_shader_set_vertex_source :: 
    Ptr Shader ->                           -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    CString ->                              -- data : TBasicType TUTF8
    Int64 ->                                -- length : TBasicType TInt64
    IO ()

{-# DEPRECATED shaderSetVertexSource ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
-- | Sets the GLSL source code to be used by a t'GI.Clutter.Objects.Shader.Shader' for the vertex
-- program.
-- 
-- /Since: 0.6/
shaderSetVertexSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
    a
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader'
    -> T.Text
    -- ^ /@data@/: GLSL source code.
    -> Int64
    -- ^ /@length@/: length of source buffer (currently ignored)
    -> m ()
shaderSetVertexSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> Text -> Int64 -> m ()
shaderSetVertexSource a
shader Text
data_ Int64
length_ = 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
$ do
    Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
    CString
data_' <- Text -> IO CString
textToCString Text
data_
    Ptr Shader -> CString -> Int64 -> IO ()
clutter_shader_set_vertex_source Ptr Shader
shader' CString
data_' Int64
length_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ShaderSetVertexSourceMethodInfo
instance (signature ~ (T.Text -> Int64 -> m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderSetVertexSourceMethodInfo a signature where
    overloadedMethod = shaderSetVertexSource

instance O.OverloadedMethodInfo ShaderSetVertexSourceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderSetVertexSource",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderSetVertexSource"
        })


#endif