{-# 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.OffscreenEffect.OffscreenEffect' structure contains only private data
-- and should be accessed using the provided API
-- 
-- /Since: 1.4/

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

module GI.Clutter.Objects.OffscreenEffect
    ( 

-- * Exported types
    OffscreenEffect(..)                     ,
    IsOffscreenEffect                       ,
    toOffscreenEffect                       ,


 -- * 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"), [createTexture]("GI.Clutter.Objects.OffscreenEffect#g:method:createTexture"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paintTarget]("GI.Clutter.Objects.OffscreenEffect#g:method:paintTarget"), [queueRepaint]("GI.Clutter.Objects.Effect#g:method:queueRepaint"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [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
-- [getActor]("GI.Clutter.Objects.ActorMeta#g:method:getActor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getEnabled]("GI.Clutter.Objects.ActorMeta#g:method:getEnabled"), [getName]("GI.Clutter.Objects.ActorMeta#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getTarget]("GI.Clutter.Objects.OffscreenEffect#g:method:getTarget"), [getTargetRect]("GI.Clutter.Objects.OffscreenEffect#g:method:getTargetRect"), [getTargetSize]("GI.Clutter.Objects.OffscreenEffect#g:method:getTargetSize"), [getTexture]("GI.Clutter.Objects.OffscreenEffect#g:method:getTexture").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setEnabled]("GI.Clutter.Objects.ActorMeta#g:method:setEnabled"), [setName]("GI.Clutter.Objects.ActorMeta#g:method:setName"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveOffscreenEffectMethod            ,
#endif

-- ** createTexture #method:createTexture#

#if defined(ENABLE_OVERLOADING)
    OffscreenEffectCreateTextureMethodInfo  ,
#endif
    offscreenEffectCreateTexture            ,


-- ** getTarget #method:getTarget#

#if defined(ENABLE_OVERLOADING)
    OffscreenEffectGetTargetMethodInfo      ,
#endif
    offscreenEffectGetTarget                ,


-- ** getTargetRect #method:getTargetRect#

#if defined(ENABLE_OVERLOADING)
    OffscreenEffectGetTargetRectMethodInfo  ,
#endif
    offscreenEffectGetTargetRect            ,


-- ** getTargetSize #method:getTargetSize#

#if defined(ENABLE_OVERLOADING)
    OffscreenEffectGetTargetSizeMethodInfo  ,
#endif
    offscreenEffectGetTargetSize            ,


-- ** getTexture #method:getTexture#

#if defined(ENABLE_OVERLOADING)
    OffscreenEffectGetTextureMethodInfo     ,
#endif
    offscreenEffectGetTexture               ,


-- ** paintTarget #method:paintTarget#

#if defined(ENABLE_OVERLOADING)
    OffscreenEffectPaintTargetMethodInfo    ,
#endif
    offscreenEffectPaintTarget              ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Structs.Rect as Clutter.Rect
import qualified GI.Cogl.Structs.Material as Cogl.Material
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "clutter_offscreen_effect_get_type"
    c_clutter_offscreen_effect_get_type :: IO B.Types.GType

instance B.Types.TypedObject OffscreenEffect where
    glibType :: IO GType
glibType = IO GType
c_clutter_offscreen_effect_get_type

instance B.Types.GObject OffscreenEffect

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

instance O.HasParentTypes OffscreenEffect
type instance O.ParentTypes OffscreenEffect = '[Clutter.Effect.Effect, Clutter.ActorMeta.ActorMeta, GObject.Object.Object]

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

-- | Convert 'OffscreenEffect' 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 OffscreenEffect) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_offscreen_effect_get_type
    gvalueSet_ :: Ptr GValue -> Maybe OffscreenEffect -> IO ()
gvalueSet_ Ptr GValue
gv Maybe OffscreenEffect
P.Nothing = Ptr GValue -> Ptr OffscreenEffect -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr OffscreenEffect
forall a. Ptr a
FP.nullPtr :: FP.Ptr OffscreenEffect)
    gvalueSet_ Ptr GValue
gv (P.Just OffscreenEffect
obj) = OffscreenEffect -> (Ptr OffscreenEffect -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr OffscreenEffect
obj (Ptr GValue -> Ptr OffscreenEffect -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe OffscreenEffect)
gvalueGet_ Ptr GValue
gv = do
        Ptr OffscreenEffect
ptr <- Ptr GValue -> IO (Ptr OffscreenEffect)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr OffscreenEffect)
        if Ptr OffscreenEffect
ptr Ptr OffscreenEffect -> Ptr OffscreenEffect -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr OffscreenEffect
forall a. Ptr a
FP.nullPtr
        then OffscreenEffect -> Maybe OffscreenEffect
forall a. a -> Maybe a
P.Just (OffscreenEffect -> Maybe OffscreenEffect)
-> IO OffscreenEffect -> IO (Maybe OffscreenEffect)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr OffscreenEffect -> OffscreenEffect)
-> Ptr OffscreenEffect -> IO OffscreenEffect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr OffscreenEffect -> OffscreenEffect
OffscreenEffect Ptr OffscreenEffect
ptr
        else Maybe OffscreenEffect -> IO (Maybe OffscreenEffect)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OffscreenEffect
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveOffscreenEffectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveOffscreenEffectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveOffscreenEffectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveOffscreenEffectMethod "createTexture" o = OffscreenEffectCreateTextureMethodInfo
    ResolveOffscreenEffectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveOffscreenEffectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveOffscreenEffectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveOffscreenEffectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveOffscreenEffectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveOffscreenEffectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveOffscreenEffectMethod "paintTarget" o = OffscreenEffectPaintTargetMethodInfo
    ResolveOffscreenEffectMethod "queueRepaint" o = Clutter.Effect.EffectQueueRepaintMethodInfo
    ResolveOffscreenEffectMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveOffscreenEffectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveOffscreenEffectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveOffscreenEffectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveOffscreenEffectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveOffscreenEffectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveOffscreenEffectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveOffscreenEffectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveOffscreenEffectMethod "getActor" o = Clutter.ActorMeta.ActorMetaGetActorMethodInfo
    ResolveOffscreenEffectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveOffscreenEffectMethod "getEnabled" o = Clutter.ActorMeta.ActorMetaGetEnabledMethodInfo
    ResolveOffscreenEffectMethod "getName" o = Clutter.ActorMeta.ActorMetaGetNameMethodInfo
    ResolveOffscreenEffectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveOffscreenEffectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveOffscreenEffectMethod "getTarget" o = OffscreenEffectGetTargetMethodInfo
    ResolveOffscreenEffectMethod "getTargetRect" o = OffscreenEffectGetTargetRectMethodInfo
    ResolveOffscreenEffectMethod "getTargetSize" o = OffscreenEffectGetTargetSizeMethodInfo
    ResolveOffscreenEffectMethod "getTexture" o = OffscreenEffectGetTextureMethodInfo
    ResolveOffscreenEffectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveOffscreenEffectMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveOffscreenEffectMethod "setEnabled" o = Clutter.ActorMeta.ActorMetaSetEnabledMethodInfo
    ResolveOffscreenEffectMethod "setName" o = Clutter.ActorMeta.ActorMetaSetNameMethodInfo
    ResolveOffscreenEffectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveOffscreenEffectMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList OffscreenEffect
type instance O.AttributeList OffscreenEffect = OffscreenEffectAttributeList
type OffscreenEffectAttributeList = ('[ '("actor", Clutter.ActorMeta.ActorMetaActorPropertyInfo), '("enabled", Clutter.ActorMeta.ActorMetaEnabledPropertyInfo), '("name", Clutter.ActorMeta.ActorMetaNamePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList OffscreenEffect = OffscreenEffectSignalList
type OffscreenEffectSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method OffscreenEffect::create_texture
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "OffscreenEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterOffscreenEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the minimum width of the target texture"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the minimum height of the target texture"
--                 , 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_offscreen_effect_create_texture" clutter_offscreen_effect_create_texture :: 
    Ptr OffscreenEffect ->                  -- effect : TInterface (Name {namespace = "Clutter", name = "OffscreenEffect"})
    CFloat ->                               -- width : TBasicType TFloat
    CFloat ->                               -- height : TBasicType TFloat
    IO (Ptr ())

-- | Calls the @/create_texture()/@ virtual function of the /@effect@/
-- 
-- /Since: 1.4/
offscreenEffectCreateTexture ::
    (B.CallStack.HasCallStack, MonadIO m, IsOffscreenEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.OffscreenEffect.OffscreenEffect'
    -> Float
    -- ^ /@width@/: the minimum width of the target texture
    -> Float
    -- ^ /@height@/: the minimum height of the target texture
    -> m (Ptr ())
    -- ^ __Returns:__ a handle to a Cogl texture, or
    --   @/COGL_INVALID_HANDLE/@. The returned handle has its reference
    --   count increased.
offscreenEffectCreateTexture :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOffscreenEffect a) =>
a -> Float -> Float -> m (Ptr ())
offscreenEffectCreateTexture a
effect Float
width Float
height = 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 OffscreenEffect
effect' <- a -> IO (Ptr OffscreenEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    let width' :: CFloat
width' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
width
    let height' :: CFloat
height' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
height
    Ptr ()
result <- Ptr OffscreenEffect -> CFloat -> CFloat -> IO (Ptr ())
clutter_offscreen_effect_create_texture Ptr OffscreenEffect
effect' CFloat
width' CFloat
height'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data OffscreenEffectCreateTextureMethodInfo
instance (signature ~ (Float -> Float -> m (Ptr ())), MonadIO m, IsOffscreenEffect a) => O.OverloadedMethod OffscreenEffectCreateTextureMethodInfo a signature where
    overloadedMethod = offscreenEffectCreateTexture

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


#endif

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

foreign import ccall "clutter_offscreen_effect_get_target" clutter_offscreen_effect_get_target :: 
    Ptr OffscreenEffect ->                  -- effect : TInterface (Name {namespace = "Clutter", name = "OffscreenEffect"})
    IO (Ptr Cogl.Material.Material)

-- | Retrieves the material used as a render target for the offscreen
-- buffer created by /@effect@/
-- 
-- You should only use the returned t'GI.Cogl.Structs.Material.Material' when painting. The
-- returned material might change between different frames.
-- 
-- /Since: 1.4/
offscreenEffectGetTarget ::
    (B.CallStack.HasCallStack, MonadIO m, IsOffscreenEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.OffscreenEffect.OffscreenEffect'
    -> m Cogl.Material.Material
    -- ^ __Returns:__ a t'GI.Cogl.Structs.Material.Material' or 'P.Nothing'. The
    --   returned material is owned by Clutter and it should not be
    --   modified or freed
offscreenEffectGetTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOffscreenEffect a) =>
a -> m Material
offscreenEffectGetTarget a
effect = IO Material -> m Material
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Material -> m Material) -> IO Material -> m Material
forall a b. (a -> b) -> a -> b
$ do
    Ptr OffscreenEffect
effect' <- a -> IO (Ptr OffscreenEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    Ptr Material
result <- Ptr OffscreenEffect -> IO (Ptr Material)
clutter_offscreen_effect_get_target Ptr OffscreenEffect
effect'
    Text -> Ptr Material -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"offscreenEffectGetTarget" Ptr Material
result
    Material
result' <- ((ManagedPtr Material -> Material) -> Ptr Material -> IO Material
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Material -> Material
Cogl.Material.Material) Ptr Material
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    Material -> IO Material
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Material
result'

#if defined(ENABLE_OVERLOADING)
data OffscreenEffectGetTargetMethodInfo
instance (signature ~ (m Cogl.Material.Material), MonadIO m, IsOffscreenEffect a) => O.OverloadedMethod OffscreenEffectGetTargetMethodInfo a signature where
    overloadedMethod = offscreenEffectGetTarget

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


#endif

-- method OffscreenEffect::get_target_rect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "OffscreenEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterOffscreenEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rect"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Rect" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the target area"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_offscreen_effect_get_target_rect" clutter_offscreen_effect_get_target_rect :: 
    Ptr OffscreenEffect ->                  -- effect : TInterface (Name {namespace = "Clutter", name = "OffscreenEffect"})
    Ptr Clutter.Rect.Rect ->                -- rect : TInterface (Name {namespace = "Clutter", name = "Rect"})
    IO CInt

-- | Retrieves the origin and size of the offscreen buffer used by /@effect@/ to
-- paint the actor to which it has been applied.
-- 
-- This function should only be called by t'GI.Clutter.Objects.OffscreenEffect.OffscreenEffect'
-- implementations, from within the t'GI.Clutter.Structs.OffscreenEffectClass.OffscreenEffectClass'.@/paint_target/@()
-- virtual function.
-- 
-- /Since: 1.14/
offscreenEffectGetTargetRect ::
    (B.CallStack.HasCallStack, MonadIO m, IsOffscreenEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.OffscreenEffect.OffscreenEffect'
    -> m ((Bool, Clutter.Rect.Rect))
    -- ^ __Returns:__ 'P.True' if the offscreen buffer has a valid rectangle,
    --   and 'P.False' otherwise
offscreenEffectGetTargetRect :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOffscreenEffect a) =>
a -> m (Bool, Rect)
offscreenEffectGetTargetRect a
effect = IO (Bool, Rect) -> m (Bool, Rect)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Rect) -> m (Bool, Rect))
-> IO (Bool, Rect) -> m (Bool, Rect)
forall a b. (a -> b) -> a -> b
$ do
    Ptr OffscreenEffect
effect' <- a -> IO (Ptr OffscreenEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    Ptr Rect
rect <- Int -> IO (Ptr Rect)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Clutter.Rect.Rect)
    CInt
result <- Ptr OffscreenEffect -> Ptr Rect -> IO CInt
clutter_offscreen_effect_get_target_rect Ptr OffscreenEffect
effect' Ptr Rect
rect
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Rect
rect' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Clutter.Rect.Rect) Ptr Rect
rect
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    (Bool, Rect) -> IO (Bool, Rect)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Rect
rect')

#if defined(ENABLE_OVERLOADING)
data OffscreenEffectGetTargetRectMethodInfo
instance (signature ~ (m ((Bool, Clutter.Rect.Rect))), MonadIO m, IsOffscreenEffect a) => O.OverloadedMethod OffscreenEffectGetTargetRectMethodInfo a signature where
    overloadedMethod = offscreenEffectGetTargetRect

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


#endif

-- method OffscreenEffect::get_target_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "OffscreenEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterOffscreenEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the target width, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the target height, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_offscreen_effect_get_target_size" clutter_offscreen_effect_get_target_size :: 
    Ptr OffscreenEffect ->                  -- effect : TInterface (Name {namespace = "Clutter", name = "OffscreenEffect"})
    Ptr CFloat ->                           -- width : TBasicType TFloat
    Ptr CFloat ->                           -- height : TBasicType TFloat
    IO CInt

{-# DEPRECATED offscreenEffectGetTargetSize ["(Since version 1.14)","Use 'GI.Clutter.Objects.OffscreenEffect.offscreenEffectGetTargetRect' instead"] #-}
-- | Retrieves the size of the offscreen buffer used by /@effect@/ to
-- paint the actor to which it has been applied.
-- 
-- This function should only be called by t'GI.Clutter.Objects.OffscreenEffect.OffscreenEffect'
-- implementations, from within the t'GI.Clutter.Structs.OffscreenEffectClass.OffscreenEffectClass'.@/paint_target/@()
-- virtual function.
-- 
-- /Since: 1.8/
offscreenEffectGetTargetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsOffscreenEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.OffscreenEffect.OffscreenEffect'
    -> m ((Bool, Float, Float))
    -- ^ __Returns:__ 'P.True' if the offscreen buffer has a valid size,
    --   and 'P.False' otherwise
offscreenEffectGetTargetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOffscreenEffect a) =>
a -> m (Bool, Float, Float)
offscreenEffectGetTargetSize a
effect = IO (Bool, Float, Float) -> m (Bool, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Float, Float) -> m (Bool, Float, Float))
-> IO (Bool, Float, Float) -> m (Bool, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr OffscreenEffect
effect' <- a -> IO (Ptr OffscreenEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    Ptr CFloat
width <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
height <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    CInt
result <- Ptr OffscreenEffect -> Ptr CFloat -> Ptr CFloat -> IO CInt
clutter_offscreen_effect_get_target_size Ptr OffscreenEffect
effect' Ptr CFloat
width Ptr CFloat
height
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CFloat
width' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
width
    let width'' :: Float
width'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
width'
    CFloat
height' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
height
    let height'' :: Float
height'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
height'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
width
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
height
    (Bool, Float, Float) -> IO (Bool, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Float
width'', Float
height'')

#if defined(ENABLE_OVERLOADING)
data OffscreenEffectGetTargetSizeMethodInfo
instance (signature ~ (m ((Bool, Float, Float))), MonadIO m, IsOffscreenEffect a) => O.OverloadedMethod OffscreenEffectGetTargetSizeMethodInfo a signature where
    overloadedMethod = offscreenEffectGetTargetSize

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


#endif

-- method OffscreenEffect::get_texture
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "OffscreenEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterOffscreenEffect"
--                 , 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_offscreen_effect_get_texture" clutter_offscreen_effect_get_texture :: 
    Ptr OffscreenEffect ->                  -- effect : TInterface (Name {namespace = "Clutter", name = "OffscreenEffect"})
    IO (Ptr ())

-- | Retrieves the texture used as a render target for the offscreen
-- buffer created by /@effect@/
-- 
-- You should only use the returned texture when painting. The texture
-- may change after ClutterEffect[pre_paint](#g:signal:pre_paint) is called so the effect
-- implementation should update any references to the texture after
-- chaining-up to the parent\'s pre_paint implementation. This can be
-- used instead of 'GI.Clutter.Objects.OffscreenEffect.offscreenEffectGetTarget' when the
-- effect subclass wants to paint using its own material.
-- 
-- /Since: 1.10/
offscreenEffectGetTexture ::
    (B.CallStack.HasCallStack, MonadIO m, IsOffscreenEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.OffscreenEffect.OffscreenEffect'
    -> m (Ptr ())
    -- ^ __Returns:__ a @/CoglHandle/@ or @/COGL_INVALID_HANDLE/@. The
    --   returned texture is owned by Clutter and it should not be
    --   modified or freed
offscreenEffectGetTexture :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOffscreenEffect a) =>
a -> m (Ptr ())
offscreenEffectGetTexture a
effect = 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 OffscreenEffect
effect' <- a -> IO (Ptr OffscreenEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    Ptr ()
result <- Ptr OffscreenEffect -> IO (Ptr ())
clutter_offscreen_effect_get_texture Ptr OffscreenEffect
effect'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data OffscreenEffectGetTextureMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsOffscreenEffect a) => O.OverloadedMethod OffscreenEffectGetTextureMethodInfo a signature where
    overloadedMethod = offscreenEffectGetTexture

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


#endif

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

foreign import ccall "clutter_offscreen_effect_paint_target" clutter_offscreen_effect_paint_target :: 
    Ptr OffscreenEffect ->                  -- effect : TInterface (Name {namespace = "Clutter", name = "OffscreenEffect"})
    IO ()

-- | Calls the @/paint_target()/@ virtual function of the /@effect@/
-- 
-- /Since: 1.4/
offscreenEffectPaintTarget ::
    (B.CallStack.HasCallStack, MonadIO m, IsOffscreenEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.OffscreenEffect.OffscreenEffect'
    -> m ()
offscreenEffectPaintTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOffscreenEffect a) =>
a -> m ()
offscreenEffectPaintTarget a
effect = 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 OffscreenEffect
effect' <- a -> IO (Ptr OffscreenEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    Ptr OffscreenEffect -> IO ()
clutter_offscreen_effect_paint_target Ptr OffscreenEffect
effect'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OffscreenEffectPaintTargetMethodInfo
instance (signature ~ (m ()), MonadIO m, IsOffscreenEffect a) => O.OverloadedMethod OffscreenEffectPaintTargetMethodInfo a signature where
    overloadedMethod = offscreenEffectPaintTarget

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


#endif