{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Objects.BrightnessContrastEffect
(
BrightnessContrastEffect(..) ,
IsBrightnessContrastEffect ,
toBrightnessContrastEffect ,
#if defined(ENABLE_OVERLOADING)
ResolveBrightnessContrastEffectMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
BrightnessContrastEffectGetBrightnessMethodInfo,
#endif
brightnessContrastEffectGetBrightness ,
#if defined(ENABLE_OVERLOADING)
BrightnessContrastEffectGetContrastMethodInfo,
#endif
brightnessContrastEffectGetContrast ,
brightnessContrastEffectNew ,
#if defined(ENABLE_OVERLOADING)
BrightnessContrastEffectSetBrightnessMethodInfo,
#endif
brightnessContrastEffectSetBrightness ,
#if defined(ENABLE_OVERLOADING)
BrightnessContrastEffectSetBrightnessFullMethodInfo,
#endif
brightnessContrastEffectSetBrightnessFull,
#if defined(ENABLE_OVERLOADING)
BrightnessContrastEffectSetContrastMethodInfo,
#endif
brightnessContrastEffectSetContrast ,
#if defined(ENABLE_OVERLOADING)
BrightnessContrastEffectSetContrastFullMethodInfo,
#endif
brightnessContrastEffectSetContrastFull ,
#if defined(ENABLE_OVERLOADING)
BrightnessContrastEffectBrightnessPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
brightnessContrastEffectBrightness ,
#endif
clearBrightnessContrastEffectBrightness ,
constructBrightnessContrastEffectBrightness,
getBrightnessContrastEffectBrightness ,
setBrightnessContrastEffectBrightness ,
#if defined(ENABLE_OVERLOADING)
BrightnessContrastEffectContrastPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
brightnessContrastEffectContrast ,
#endif
clearBrightnessContrastEffectContrast ,
constructBrightnessContrastEffectContrast,
getBrightnessContrastEffectContrast ,
setBrightnessContrastEffectContrast ,
) 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.Objects.OffscreenEffect as Clutter.OffscreenEffect
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import qualified GI.GObject.Objects.Object as GObject.Object
newtype BrightnessContrastEffect = BrightnessContrastEffect (SP.ManagedPtr BrightnessContrastEffect)
deriving (BrightnessContrastEffect -> BrightnessContrastEffect -> Bool
(BrightnessContrastEffect -> BrightnessContrastEffect -> Bool)
-> (BrightnessContrastEffect -> BrightnessContrastEffect -> Bool)
-> Eq BrightnessContrastEffect
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BrightnessContrastEffect -> BrightnessContrastEffect -> Bool
== :: BrightnessContrastEffect -> BrightnessContrastEffect -> Bool
$c/= :: BrightnessContrastEffect -> BrightnessContrastEffect -> Bool
/= :: BrightnessContrastEffect -> BrightnessContrastEffect -> Bool
Eq)
instance SP.ManagedPtrNewtype BrightnessContrastEffect where
toManagedPtr :: BrightnessContrastEffect -> ManagedPtr BrightnessContrastEffect
toManagedPtr (BrightnessContrastEffect ManagedPtr BrightnessContrastEffect
p) = ManagedPtr BrightnessContrastEffect
p
foreign import ccall "clutter_brightness_contrast_effect_get_type"
c_clutter_brightness_contrast_effect_get_type :: IO B.Types.GType
instance B.Types.TypedObject BrightnessContrastEffect where
glibType :: IO GType
glibType = IO GType
c_clutter_brightness_contrast_effect_get_type
instance B.Types.GObject BrightnessContrastEffect
class (SP.GObject o, O.IsDescendantOf BrightnessContrastEffect o) => IsBrightnessContrastEffect o
instance (SP.GObject o, O.IsDescendantOf BrightnessContrastEffect o) => IsBrightnessContrastEffect o
instance O.HasParentTypes BrightnessContrastEffect
type instance O.ParentTypes BrightnessContrastEffect = '[Clutter.OffscreenEffect.OffscreenEffect, Clutter.Effect.Effect, Clutter.ActorMeta.ActorMeta, GObject.Object.Object]
toBrightnessContrastEffect :: (MIO.MonadIO m, IsBrightnessContrastEffect o) => o -> m BrightnessContrastEffect
toBrightnessContrastEffect :: forall (m :: * -> *) o.
(MonadIO m, IsBrightnessContrastEffect o) =>
o -> m BrightnessContrastEffect
toBrightnessContrastEffect = IO BrightnessContrastEffect -> m BrightnessContrastEffect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO BrightnessContrastEffect -> m BrightnessContrastEffect)
-> (o -> IO BrightnessContrastEffect)
-> o
-> m BrightnessContrastEffect
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr BrightnessContrastEffect -> BrightnessContrastEffect)
-> o -> IO BrightnessContrastEffect
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr BrightnessContrastEffect -> BrightnessContrastEffect
BrightnessContrastEffect
instance B.GValue.IsGValue (Maybe BrightnessContrastEffect) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_brightness_contrast_effect_get_type
gvalueSet_ :: Ptr GValue -> Maybe BrightnessContrastEffect -> IO ()
gvalueSet_ Ptr GValue
gv Maybe BrightnessContrastEffect
P.Nothing = Ptr GValue -> Ptr BrightnessContrastEffect -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr BrightnessContrastEffect
forall a. Ptr a
FP.nullPtr :: FP.Ptr BrightnessContrastEffect)
gvalueSet_ Ptr GValue
gv (P.Just BrightnessContrastEffect
obj) = BrightnessContrastEffect
-> (Ptr BrightnessContrastEffect -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BrightnessContrastEffect
obj (Ptr GValue -> Ptr BrightnessContrastEffect -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe BrightnessContrastEffect)
gvalueGet_ Ptr GValue
gv = do
Ptr BrightnessContrastEffect
ptr <- Ptr GValue -> IO (Ptr BrightnessContrastEffect)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr BrightnessContrastEffect)
if Ptr BrightnessContrastEffect
ptr Ptr BrightnessContrastEffect
-> Ptr BrightnessContrastEffect -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr BrightnessContrastEffect
forall a. Ptr a
FP.nullPtr
then BrightnessContrastEffect -> Maybe BrightnessContrastEffect
forall a. a -> Maybe a
P.Just (BrightnessContrastEffect -> Maybe BrightnessContrastEffect)
-> IO BrightnessContrastEffect
-> IO (Maybe BrightnessContrastEffect)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr BrightnessContrastEffect -> BrightnessContrastEffect)
-> Ptr BrightnessContrastEffect -> IO BrightnessContrastEffect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr BrightnessContrastEffect -> BrightnessContrastEffect
BrightnessContrastEffect Ptr BrightnessContrastEffect
ptr
else Maybe BrightnessContrastEffect
-> IO (Maybe BrightnessContrastEffect)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BrightnessContrastEffect
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveBrightnessContrastEffectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveBrightnessContrastEffectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveBrightnessContrastEffectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveBrightnessContrastEffectMethod "createTexture" o = Clutter.OffscreenEffect.OffscreenEffectCreateTextureMethodInfo
ResolveBrightnessContrastEffectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveBrightnessContrastEffectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveBrightnessContrastEffectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveBrightnessContrastEffectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveBrightnessContrastEffectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveBrightnessContrastEffectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveBrightnessContrastEffectMethod "paintTarget" o = Clutter.OffscreenEffect.OffscreenEffectPaintTargetMethodInfo
ResolveBrightnessContrastEffectMethod "queueRepaint" o = Clutter.Effect.EffectQueueRepaintMethodInfo
ResolveBrightnessContrastEffectMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveBrightnessContrastEffectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveBrightnessContrastEffectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveBrightnessContrastEffectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveBrightnessContrastEffectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveBrightnessContrastEffectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveBrightnessContrastEffectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveBrightnessContrastEffectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveBrightnessContrastEffectMethod "getActor" o = Clutter.ActorMeta.ActorMetaGetActorMethodInfo
ResolveBrightnessContrastEffectMethod "getBrightness" o = BrightnessContrastEffectGetBrightnessMethodInfo
ResolveBrightnessContrastEffectMethod "getContrast" o = BrightnessContrastEffectGetContrastMethodInfo
ResolveBrightnessContrastEffectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveBrightnessContrastEffectMethod "getEnabled" o = Clutter.ActorMeta.ActorMetaGetEnabledMethodInfo
ResolveBrightnessContrastEffectMethod "getName" o = Clutter.ActorMeta.ActorMetaGetNameMethodInfo
ResolveBrightnessContrastEffectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveBrightnessContrastEffectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveBrightnessContrastEffectMethod "getTarget" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetMethodInfo
ResolveBrightnessContrastEffectMethod "getTargetRect" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetRectMethodInfo
ResolveBrightnessContrastEffectMethod "getTargetSize" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetSizeMethodInfo
ResolveBrightnessContrastEffectMethod "getTexture" o = Clutter.OffscreenEffect.OffscreenEffectGetTextureMethodInfo
ResolveBrightnessContrastEffectMethod "setBrightness" o = BrightnessContrastEffectSetBrightnessMethodInfo
ResolveBrightnessContrastEffectMethod "setBrightnessFull" o = BrightnessContrastEffectSetBrightnessFullMethodInfo
ResolveBrightnessContrastEffectMethod "setContrast" o = BrightnessContrastEffectSetContrastMethodInfo
ResolveBrightnessContrastEffectMethod "setContrastFull" o = BrightnessContrastEffectSetContrastFullMethodInfo
ResolveBrightnessContrastEffectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveBrightnessContrastEffectMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveBrightnessContrastEffectMethod "setEnabled" o = Clutter.ActorMeta.ActorMetaSetEnabledMethodInfo
ResolveBrightnessContrastEffectMethod "setName" o = Clutter.ActorMeta.ActorMetaSetNameMethodInfo
ResolveBrightnessContrastEffectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveBrightnessContrastEffectMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBrightnessContrastEffectMethod t BrightnessContrastEffect, O.OverloadedMethod info BrightnessContrastEffect p) => OL.IsLabel t (BrightnessContrastEffect -> 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 ~ ResolveBrightnessContrastEffectMethod t BrightnessContrastEffect, O.OverloadedMethod info BrightnessContrastEffect p, R.HasField t BrightnessContrastEffect p) => R.HasField t BrightnessContrastEffect p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveBrightnessContrastEffectMethod t BrightnessContrastEffect, O.OverloadedMethodInfo info BrightnessContrastEffect) => OL.IsLabel t (O.MethodProxy info BrightnessContrastEffect) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getBrightnessContrastEffectBrightness :: (MonadIO m, IsBrightnessContrastEffect o) => o -> m (Maybe Clutter.Color.Color)
getBrightnessContrastEffectBrightness :: forall (m :: * -> *) o.
(MonadIO m, IsBrightnessContrastEffect o) =>
o -> m (Maybe Color)
getBrightnessContrastEffectBrightness o
obj = IO (Maybe Color) -> m (Maybe Color)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Color) -> m (Maybe Color))
-> IO (Maybe Color) -> m (Maybe Color)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Color -> Color) -> IO (Maybe Color)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"brightness" ManagedPtr Color -> Color
Clutter.Color.Color
setBrightnessContrastEffectBrightness :: (MonadIO m, IsBrightnessContrastEffect o) => o -> Clutter.Color.Color -> m ()
setBrightnessContrastEffectBrightness :: forall (m :: * -> *) o.
(MonadIO m, IsBrightnessContrastEffect o) =>
o -> Color -> m ()
setBrightnessContrastEffectBrightness o
obj Color
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 Color -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"brightness" (Color -> Maybe Color
forall a. a -> Maybe a
Just Color
val)
constructBrightnessContrastEffectBrightness :: (IsBrightnessContrastEffect o, MIO.MonadIO m) => Clutter.Color.Color -> m (GValueConstruct o)
constructBrightnessContrastEffectBrightness :: forall o (m :: * -> *).
(IsBrightnessContrastEffect o, MonadIO m) =>
Color -> m (GValueConstruct o)
constructBrightnessContrastEffectBrightness Color
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 Color -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"brightness" (Color -> Maybe Color
forall a. a -> Maybe a
P.Just Color
val)
clearBrightnessContrastEffectBrightness :: (MonadIO m, IsBrightnessContrastEffect o) => o -> m ()
clearBrightnessContrastEffectBrightness :: forall (m :: * -> *) o.
(MonadIO m, IsBrightnessContrastEffect o) =>
o -> m ()
clearBrightnessContrastEffectBrightness 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 Color -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"brightness" (Maybe Color
forall a. Maybe a
Nothing :: Maybe Clutter.Color.Color)
#if defined(ENABLE_OVERLOADING)
data BrightnessContrastEffectBrightnessPropertyInfo
instance AttrInfo BrightnessContrastEffectBrightnessPropertyInfo where
type AttrAllowedOps BrightnessContrastEffectBrightnessPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint BrightnessContrastEffectBrightnessPropertyInfo = IsBrightnessContrastEffect
type AttrSetTypeConstraint BrightnessContrastEffectBrightnessPropertyInfo = (~) Clutter.Color.Color
type AttrTransferTypeConstraint BrightnessContrastEffectBrightnessPropertyInfo = (~) Clutter.Color.Color
type AttrTransferType BrightnessContrastEffectBrightnessPropertyInfo = Clutter.Color.Color
type AttrGetType BrightnessContrastEffectBrightnessPropertyInfo = (Maybe Clutter.Color.Color)
type AttrLabel BrightnessContrastEffectBrightnessPropertyInfo = "brightness"
type AttrOrigin BrightnessContrastEffectBrightnessPropertyInfo = BrightnessContrastEffect
attrGet = getBrightnessContrastEffectBrightness
attrSet = setBrightnessContrastEffectBrightness
attrTransfer _ v = do
return v
attrConstruct = constructBrightnessContrastEffectBrightness
attrClear = clearBrightnessContrastEffectBrightness
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BrightnessContrastEffect.brightness"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BrightnessContrastEffect.html#g:attr:brightness"
})
#endif
getBrightnessContrastEffectContrast :: (MonadIO m, IsBrightnessContrastEffect o) => o -> m (Maybe Clutter.Color.Color)
getBrightnessContrastEffectContrast :: forall (m :: * -> *) o.
(MonadIO m, IsBrightnessContrastEffect o) =>
o -> m (Maybe Color)
getBrightnessContrastEffectContrast o
obj = IO (Maybe Color) -> m (Maybe Color)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Color) -> m (Maybe Color))
-> IO (Maybe Color) -> m (Maybe Color)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Color -> Color) -> IO (Maybe Color)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"contrast" ManagedPtr Color -> Color
Clutter.Color.Color
setBrightnessContrastEffectContrast :: (MonadIO m, IsBrightnessContrastEffect o) => o -> Clutter.Color.Color -> m ()
setBrightnessContrastEffectContrast :: forall (m :: * -> *) o.
(MonadIO m, IsBrightnessContrastEffect o) =>
o -> Color -> m ()
setBrightnessContrastEffectContrast o
obj Color
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 Color -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"contrast" (Color -> Maybe Color
forall a. a -> Maybe a
Just Color
val)
constructBrightnessContrastEffectContrast :: (IsBrightnessContrastEffect o, MIO.MonadIO m) => Clutter.Color.Color -> m (GValueConstruct o)
constructBrightnessContrastEffectContrast :: forall o (m :: * -> *).
(IsBrightnessContrastEffect o, MonadIO m) =>
Color -> m (GValueConstruct o)
constructBrightnessContrastEffectContrast Color
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 Color -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"contrast" (Color -> Maybe Color
forall a. a -> Maybe a
P.Just Color
val)
clearBrightnessContrastEffectContrast :: (MonadIO m, IsBrightnessContrastEffect o) => o -> m ()
clearBrightnessContrastEffectContrast :: forall (m :: * -> *) o.
(MonadIO m, IsBrightnessContrastEffect o) =>
o -> m ()
clearBrightnessContrastEffectContrast 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 Color -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"contrast" (Maybe Color
forall a. Maybe a
Nothing :: Maybe Clutter.Color.Color)
#if defined(ENABLE_OVERLOADING)
data BrightnessContrastEffectContrastPropertyInfo
instance AttrInfo BrightnessContrastEffectContrastPropertyInfo where
type AttrAllowedOps BrightnessContrastEffectContrastPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint BrightnessContrastEffectContrastPropertyInfo = IsBrightnessContrastEffect
type AttrSetTypeConstraint BrightnessContrastEffectContrastPropertyInfo = (~) Clutter.Color.Color
type AttrTransferTypeConstraint BrightnessContrastEffectContrastPropertyInfo = (~) Clutter.Color.Color
type AttrTransferType BrightnessContrastEffectContrastPropertyInfo = Clutter.Color.Color
type AttrGetType BrightnessContrastEffectContrastPropertyInfo = (Maybe Clutter.Color.Color)
type AttrLabel BrightnessContrastEffectContrastPropertyInfo = "contrast"
type AttrOrigin BrightnessContrastEffectContrastPropertyInfo = BrightnessContrastEffect
attrGet = getBrightnessContrastEffectContrast
attrSet = setBrightnessContrastEffectContrast
attrTransfer _ v = do
return v
attrConstruct = constructBrightnessContrastEffectContrast
attrClear = clearBrightnessContrastEffectContrast
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BrightnessContrastEffect.contrast"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BrightnessContrastEffect.html#g:attr:contrast"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BrightnessContrastEffect
type instance O.AttributeList BrightnessContrastEffect = BrightnessContrastEffectAttributeList
type BrightnessContrastEffectAttributeList = ('[ '("actor", Clutter.ActorMeta.ActorMetaActorPropertyInfo), '("brightness", BrightnessContrastEffectBrightnessPropertyInfo), '("contrast", BrightnessContrastEffectContrastPropertyInfo), '("enabled", Clutter.ActorMeta.ActorMetaEnabledPropertyInfo), '("name", Clutter.ActorMeta.ActorMetaNamePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
brightnessContrastEffectBrightness :: AttrLabelProxy "brightness"
brightnessContrastEffectBrightness = AttrLabelProxy
brightnessContrastEffectContrast :: AttrLabelProxy "contrast"
brightnessContrastEffectContrast = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList BrightnessContrastEffect = BrightnessContrastEffectSignalList
type BrightnessContrastEffectSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "clutter_brightness_contrast_effect_new" clutter_brightness_contrast_effect_new ::
IO (Ptr BrightnessContrastEffect)
brightnessContrastEffectNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m BrightnessContrastEffect
brightnessContrastEffectNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m BrightnessContrastEffect
brightnessContrastEffectNew = IO BrightnessContrastEffect -> m BrightnessContrastEffect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BrightnessContrastEffect -> m BrightnessContrastEffect)
-> IO BrightnessContrastEffect -> m BrightnessContrastEffect
forall a b. (a -> b) -> a -> b
$ do
Ptr BrightnessContrastEffect
result <- IO (Ptr BrightnessContrastEffect)
clutter_brightness_contrast_effect_new
Text -> Ptr BrightnessContrastEffect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"brightnessContrastEffectNew" Ptr BrightnessContrastEffect
result
BrightnessContrastEffect
result' <- ((ManagedPtr BrightnessContrastEffect -> BrightnessContrastEffect)
-> Ptr BrightnessContrastEffect -> IO BrightnessContrastEffect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr BrightnessContrastEffect -> BrightnessContrastEffect
BrightnessContrastEffect) Ptr BrightnessContrastEffect
result
BrightnessContrastEffect -> IO BrightnessContrastEffect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BrightnessContrastEffect
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_brightness_contrast_effect_get_brightness" clutter_brightness_contrast_effect_get_brightness ::
Ptr BrightnessContrastEffect ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
IO ()
brightnessContrastEffectGetBrightness ::
(B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a
-> m ((Float, Float, Float))
brightnessContrastEffectGetBrightness :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a -> m (Float, Float, Float)
brightnessContrastEffectGetBrightness a
effect = IO (Float, Float, Float) -> m (Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float) -> m (Float, Float, Float))
-> IO (Float, Float, Float) -> m (Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
Ptr BrightnessContrastEffect
effect' <- a -> IO (Ptr BrightnessContrastEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
Ptr CFloat
red <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
green <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
blue <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr BrightnessContrastEffect
-> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_brightness_contrast_effect_get_brightness Ptr BrightnessContrastEffect
effect' Ptr CFloat
red Ptr CFloat
green Ptr CFloat
blue
CFloat
red' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
red
let red'' :: Float
red'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
red'
CFloat
green' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
green
let green'' :: Float
green'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
green'
CFloat
blue' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
blue
let blue'' :: Float
blue'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
blue'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
red
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
green
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
blue
(Float, Float, Float) -> IO (Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
red'', Float
green'', Float
blue'')
#if defined(ENABLE_OVERLOADING)
data BrightnessContrastEffectGetBrightnessMethodInfo
instance (signature ~ (m ((Float, Float, Float))), MonadIO m, IsBrightnessContrastEffect a) => O.OverloadedMethod BrightnessContrastEffectGetBrightnessMethodInfo a signature where
overloadedMethod = brightnessContrastEffectGetBrightness
instance O.OverloadedMethodInfo BrightnessContrastEffectGetBrightnessMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BrightnessContrastEffect.brightnessContrastEffectGetBrightness",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BrightnessContrastEffect.html#v:brightnessContrastEffectGetBrightness"
})
#endif
foreign import ccall "clutter_brightness_contrast_effect_get_contrast" clutter_brightness_contrast_effect_get_contrast ::
Ptr BrightnessContrastEffect ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
IO ()
brightnessContrastEffectGetContrast ::
(B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a
-> m ((Float, Float, Float))
brightnessContrastEffectGetContrast :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a -> m (Float, Float, Float)
brightnessContrastEffectGetContrast a
effect = IO (Float, Float, Float) -> m (Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float) -> m (Float, Float, Float))
-> IO (Float, Float, Float) -> m (Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
Ptr BrightnessContrastEffect
effect' <- a -> IO (Ptr BrightnessContrastEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
Ptr CFloat
red <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
green <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
blue <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr BrightnessContrastEffect
-> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_brightness_contrast_effect_get_contrast Ptr BrightnessContrastEffect
effect' Ptr CFloat
red Ptr CFloat
green Ptr CFloat
blue
CFloat
red' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
red
let red'' :: Float
red'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
red'
CFloat
green' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
green
let green'' :: Float
green'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
green'
CFloat
blue' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
blue
let blue'' :: Float
blue'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
blue'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
red
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
green
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
blue
(Float, Float, Float) -> IO (Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
red'', Float
green'', Float
blue'')
#if defined(ENABLE_OVERLOADING)
data BrightnessContrastEffectGetContrastMethodInfo
instance (signature ~ (m ((Float, Float, Float))), MonadIO m, IsBrightnessContrastEffect a) => O.OverloadedMethod BrightnessContrastEffectGetContrastMethodInfo a signature where
overloadedMethod = brightnessContrastEffectGetContrast
instance O.OverloadedMethodInfo BrightnessContrastEffectGetContrastMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BrightnessContrastEffect.brightnessContrastEffectGetContrast",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BrightnessContrastEffect.html#v:brightnessContrastEffectGetContrast"
})
#endif
foreign import ccall "clutter_brightness_contrast_effect_set_brightness" clutter_brightness_contrast_effect_set_brightness ::
Ptr BrightnessContrastEffect ->
CFloat ->
IO ()
brightnessContrastEffectSetBrightness ::
(B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a
-> Float
-> m ()
brightnessContrastEffectSetBrightness :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a -> Float -> m ()
brightnessContrastEffectSetBrightness a
effect Float
brightness = 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 BrightnessContrastEffect
effect' <- a -> IO (Ptr BrightnessContrastEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
let brightness' :: CFloat
brightness' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
brightness
Ptr BrightnessContrastEffect -> CFloat -> IO ()
clutter_brightness_contrast_effect_set_brightness Ptr BrightnessContrastEffect
effect' CFloat
brightness'
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 BrightnessContrastEffectSetBrightnessMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsBrightnessContrastEffect a) => O.OverloadedMethod BrightnessContrastEffectSetBrightnessMethodInfo a signature where
overloadedMethod = brightnessContrastEffectSetBrightness
instance O.OverloadedMethodInfo BrightnessContrastEffectSetBrightnessMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BrightnessContrastEffect.brightnessContrastEffectSetBrightness",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BrightnessContrastEffect.html#v:brightnessContrastEffectSetBrightness"
})
#endif
foreign import ccall "clutter_brightness_contrast_effect_set_brightness_full" clutter_brightness_contrast_effect_set_brightness_full ::
Ptr BrightnessContrastEffect ->
CFloat ->
CFloat ->
CFloat ->
IO ()
brightnessContrastEffectSetBrightnessFull ::
(B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a
-> Float
-> Float
-> Float
-> m ()
brightnessContrastEffectSetBrightnessFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a -> Float -> Float -> Float -> m ()
brightnessContrastEffectSetBrightnessFull a
effect Float
red Float
green Float
blue = 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 BrightnessContrastEffect
effect' <- a -> IO (Ptr BrightnessContrastEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
let red' :: CFloat
red' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
red
let green' :: CFloat
green' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
green
let blue' :: CFloat
blue' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blue
Ptr BrightnessContrastEffect -> CFloat -> CFloat -> CFloat -> IO ()
clutter_brightness_contrast_effect_set_brightness_full Ptr BrightnessContrastEffect
effect' CFloat
red' CFloat
green' CFloat
blue'
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 BrightnessContrastEffectSetBrightnessFullMethodInfo
instance (signature ~ (Float -> Float -> Float -> m ()), MonadIO m, IsBrightnessContrastEffect a) => O.OverloadedMethod BrightnessContrastEffectSetBrightnessFullMethodInfo a signature where
overloadedMethod = brightnessContrastEffectSetBrightnessFull
instance O.OverloadedMethodInfo BrightnessContrastEffectSetBrightnessFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BrightnessContrastEffect.brightnessContrastEffectSetBrightnessFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BrightnessContrastEffect.html#v:brightnessContrastEffectSetBrightnessFull"
})
#endif
foreign import ccall "clutter_brightness_contrast_effect_set_contrast" clutter_brightness_contrast_effect_set_contrast ::
Ptr BrightnessContrastEffect ->
CFloat ->
IO ()
brightnessContrastEffectSetContrast ::
(B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a
-> Float
-> m ()
brightnessContrastEffectSetContrast :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a -> Float -> m ()
brightnessContrastEffectSetContrast a
effect Float
contrast = 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 BrightnessContrastEffect
effect' <- a -> IO (Ptr BrightnessContrastEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
let contrast' :: CFloat
contrast' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
contrast
Ptr BrightnessContrastEffect -> CFloat -> IO ()
clutter_brightness_contrast_effect_set_contrast Ptr BrightnessContrastEffect
effect' CFloat
contrast'
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 BrightnessContrastEffectSetContrastMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsBrightnessContrastEffect a) => O.OverloadedMethod BrightnessContrastEffectSetContrastMethodInfo a signature where
overloadedMethod = brightnessContrastEffectSetContrast
instance O.OverloadedMethodInfo BrightnessContrastEffectSetContrastMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BrightnessContrastEffect.brightnessContrastEffectSetContrast",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BrightnessContrastEffect.html#v:brightnessContrastEffectSetContrast"
})
#endif
foreign import ccall "clutter_brightness_contrast_effect_set_contrast_full" clutter_brightness_contrast_effect_set_contrast_full ::
Ptr BrightnessContrastEffect ->
CFloat ->
CFloat ->
CFloat ->
IO ()
brightnessContrastEffectSetContrastFull ::
(B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a
-> Float
-> Float
-> Float
-> m ()
brightnessContrastEffectSetContrastFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
a -> Float -> Float -> Float -> m ()
brightnessContrastEffectSetContrastFull a
effect Float
red Float
green Float
blue = 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 BrightnessContrastEffect
effect' <- a -> IO (Ptr BrightnessContrastEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
let red' :: CFloat
red' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
red
let green' :: CFloat
green' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
green
let blue' :: CFloat
blue' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blue
Ptr BrightnessContrastEffect -> CFloat -> CFloat -> CFloat -> IO ()
clutter_brightness_contrast_effect_set_contrast_full Ptr BrightnessContrastEffect
effect' CFloat
red' CFloat
green' CFloat
blue'
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 BrightnessContrastEffectSetContrastFullMethodInfo
instance (signature ~ (Float -> Float -> Float -> m ()), MonadIO m, IsBrightnessContrastEffect a) => O.OverloadedMethod BrightnessContrastEffectSetContrastFullMethodInfo a signature where
overloadedMethod = brightnessContrastEffectSetContrastFull
instance O.OverloadedMethodInfo BrightnessContrastEffectSetContrastFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BrightnessContrastEffect.brightnessContrastEffectSetContrastFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BrightnessContrastEffect.html#v:brightnessContrastEffectSetContrastFull"
})
#endif