{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Objects.BlurEffect
(
BlurEffect(..) ,
IsBlurEffect ,
toBlurEffect ,
#if defined(ENABLE_OVERLOADING)
ResolveBlurEffectMethod ,
#endif
blurEffectNew ,
) 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 {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Objects.OffscreenEffect as Clutter.OffscreenEffect
import qualified GI.GObject.Objects.Object as GObject.Object
newtype BlurEffect = BlurEffect (SP.ManagedPtr BlurEffect)
deriving (BlurEffect -> BlurEffect -> Bool
(BlurEffect -> BlurEffect -> Bool)
-> (BlurEffect -> BlurEffect -> Bool) -> Eq BlurEffect
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlurEffect -> BlurEffect -> Bool
== :: BlurEffect -> BlurEffect -> Bool
$c/= :: BlurEffect -> BlurEffect -> Bool
/= :: BlurEffect -> BlurEffect -> Bool
Eq)
instance SP.ManagedPtrNewtype BlurEffect where
toManagedPtr :: BlurEffect -> ManagedPtr BlurEffect
toManagedPtr (BlurEffect ManagedPtr BlurEffect
p) = ManagedPtr BlurEffect
p
foreign import ccall "clutter_blur_effect_get_type"
c_clutter_blur_effect_get_type :: IO B.Types.GType
instance B.Types.TypedObject BlurEffect where
glibType :: IO GType
glibType = IO GType
c_clutter_blur_effect_get_type
instance B.Types.GObject BlurEffect
class (SP.GObject o, O.IsDescendantOf BlurEffect o) => IsBlurEffect o
instance (SP.GObject o, O.IsDescendantOf BlurEffect o) => IsBlurEffect o
instance O.HasParentTypes BlurEffect
type instance O.ParentTypes BlurEffect = '[Clutter.OffscreenEffect.OffscreenEffect, Clutter.Effect.Effect, Clutter.ActorMeta.ActorMeta, GObject.Object.Object]
toBlurEffect :: (MIO.MonadIO m, IsBlurEffect o) => o -> m BlurEffect
toBlurEffect :: forall (m :: * -> *) o.
(MonadIO m, IsBlurEffect o) =>
o -> m BlurEffect
toBlurEffect = IO BlurEffect -> m BlurEffect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO BlurEffect -> m BlurEffect)
-> (o -> IO BlurEffect) -> o -> m BlurEffect
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr BlurEffect -> BlurEffect) -> o -> IO BlurEffect
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr BlurEffect -> BlurEffect
BlurEffect
instance B.GValue.IsGValue (Maybe BlurEffect) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_blur_effect_get_type
gvalueSet_ :: Ptr GValue -> Maybe BlurEffect -> IO ()
gvalueSet_ Ptr GValue
gv Maybe BlurEffect
P.Nothing = Ptr GValue -> Ptr BlurEffect -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr BlurEffect
forall a. Ptr a
FP.nullPtr :: FP.Ptr BlurEffect)
gvalueSet_ Ptr GValue
gv (P.Just BlurEffect
obj) = BlurEffect -> (Ptr BlurEffect -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BlurEffect
obj (Ptr GValue -> Ptr BlurEffect -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe BlurEffect)
gvalueGet_ Ptr GValue
gv = do
Ptr BlurEffect
ptr <- Ptr GValue -> IO (Ptr BlurEffect)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr BlurEffect)
if Ptr BlurEffect
ptr Ptr BlurEffect -> Ptr BlurEffect -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr BlurEffect
forall a. Ptr a
FP.nullPtr
then BlurEffect -> Maybe BlurEffect
forall a. a -> Maybe a
P.Just (BlurEffect -> Maybe BlurEffect)
-> IO BlurEffect -> IO (Maybe BlurEffect)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr BlurEffect -> BlurEffect)
-> Ptr BlurEffect -> IO BlurEffect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr BlurEffect -> BlurEffect
BlurEffect Ptr BlurEffect
ptr
else Maybe BlurEffect -> IO (Maybe BlurEffect)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BlurEffect
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveBlurEffectMethod (t :: Symbol) (o :: *) :: * where
ResolveBlurEffectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveBlurEffectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveBlurEffectMethod "createTexture" o = Clutter.OffscreenEffect.OffscreenEffectCreateTextureMethodInfo
ResolveBlurEffectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveBlurEffectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveBlurEffectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveBlurEffectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveBlurEffectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveBlurEffectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveBlurEffectMethod "paintTarget" o = Clutter.OffscreenEffect.OffscreenEffectPaintTargetMethodInfo
ResolveBlurEffectMethod "queueRepaint" o = Clutter.Effect.EffectQueueRepaintMethodInfo
ResolveBlurEffectMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveBlurEffectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveBlurEffectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveBlurEffectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveBlurEffectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveBlurEffectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveBlurEffectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveBlurEffectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveBlurEffectMethod "getActor" o = Clutter.ActorMeta.ActorMetaGetActorMethodInfo
ResolveBlurEffectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveBlurEffectMethod "getEnabled" o = Clutter.ActorMeta.ActorMetaGetEnabledMethodInfo
ResolveBlurEffectMethod "getName" o = Clutter.ActorMeta.ActorMetaGetNameMethodInfo
ResolveBlurEffectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveBlurEffectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveBlurEffectMethod "getTarget" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetMethodInfo
ResolveBlurEffectMethod "getTargetRect" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetRectMethodInfo
ResolveBlurEffectMethod "getTargetSize" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetSizeMethodInfo
ResolveBlurEffectMethod "getTexture" o = Clutter.OffscreenEffect.OffscreenEffectGetTextureMethodInfo
ResolveBlurEffectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveBlurEffectMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveBlurEffectMethod "setEnabled" o = Clutter.ActorMeta.ActorMetaSetEnabledMethodInfo
ResolveBlurEffectMethod "setName" o = Clutter.ActorMeta.ActorMetaSetNameMethodInfo
ResolveBlurEffectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveBlurEffectMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBlurEffectMethod t BlurEffect, O.OverloadedMethod info BlurEffect p) => OL.IsLabel t (BlurEffect -> 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 ~ ResolveBlurEffectMethod t BlurEffect, O.OverloadedMethod info BlurEffect p, R.HasField t BlurEffect p) => R.HasField t BlurEffect p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveBlurEffectMethod t BlurEffect, O.OverloadedMethodInfo info BlurEffect) => OL.IsLabel t (O.MethodProxy info BlurEffect) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BlurEffect
type instance O.AttributeList BlurEffect = BlurEffectAttributeList
type BlurEffectAttributeList = ('[ '("actor", Clutter.ActorMeta.ActorMetaActorPropertyInfo), '("enabled", Clutter.ActorMeta.ActorMetaEnabledPropertyInfo), '("name", Clutter.ActorMeta.ActorMetaNamePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList BlurEffect = BlurEffectSignalList
type BlurEffectSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "clutter_blur_effect_new" clutter_blur_effect_new ::
IO (Ptr BlurEffect)
blurEffectNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m BlurEffect
blurEffectNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m BlurEffect
blurEffectNew = IO BlurEffect -> m BlurEffect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BlurEffect -> m BlurEffect) -> IO BlurEffect -> m BlurEffect
forall a b. (a -> b) -> a -> b
$ do
Ptr BlurEffect
result <- IO (Ptr BlurEffect)
clutter_blur_effect_new
Text -> Ptr BlurEffect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"blurEffectNew" Ptr BlurEffect
result
BlurEffect
result' <- ((ManagedPtr BlurEffect -> BlurEffect)
-> Ptr BlurEffect -> IO BlurEffect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BlurEffect -> BlurEffect
BlurEffect) Ptr BlurEffect
result
BlurEffect -> IO BlurEffect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BlurEffect
result'
#if defined(ENABLE_OVERLOADING)
#endif