{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Clutter.Objects.BrightnessContrastEffect.BrightnessContrastEffect' is an opaque structure
-- whose members cannot be directly accessed
-- 
-- /Since: 1.10/

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

module GI.Clutter.Objects.BrightnessContrastEffect
    ( 

-- * Exported types
    BrightnessContrastEffect(..)            ,
    IsBrightnessContrastEffect              ,
    toBrightnessContrastEffect              ,


 -- * 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"), [getBrightness]("GI.Clutter.Objects.BrightnessContrastEffect#g:method:getBrightness"), [getContrast]("GI.Clutter.Objects.BrightnessContrastEffect#g:method:getContrast"), [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
-- [setBrightness]("GI.Clutter.Objects.BrightnessContrastEffect#g:method:setBrightness"), [setBrightnessFull]("GI.Clutter.Objects.BrightnessContrastEffect#g:method:setBrightnessFull"), [setContrast]("GI.Clutter.Objects.BrightnessContrastEffect#g:method:setContrast"), [setContrastFull]("GI.Clutter.Objects.BrightnessContrastEffect#g:method:setContrastFull"), [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)
    ResolveBrightnessContrastEffectMethod   ,
#endif

-- ** getBrightness #method:getBrightness#

#if defined(ENABLE_OVERLOADING)
    BrightnessContrastEffectGetBrightnessMethodInfo,
#endif
    brightnessContrastEffectGetBrightness   ,


-- ** getContrast #method:getContrast#

#if defined(ENABLE_OVERLOADING)
    BrightnessContrastEffectGetContrastMethodInfo,
#endif
    brightnessContrastEffectGetContrast     ,


-- ** new #method:new#

    brightnessContrastEffectNew             ,


-- ** setBrightness #method:setBrightness#

#if defined(ENABLE_OVERLOADING)
    BrightnessContrastEffectSetBrightnessMethodInfo,
#endif
    brightnessContrastEffectSetBrightness   ,


-- ** setBrightnessFull #method:setBrightnessFull#

#if defined(ENABLE_OVERLOADING)
    BrightnessContrastEffectSetBrightnessFullMethodInfo,
#endif
    brightnessContrastEffectSetBrightnessFull,


-- ** setContrast #method:setContrast#

#if defined(ENABLE_OVERLOADING)
    BrightnessContrastEffectSetContrastMethodInfo,
#endif
    brightnessContrastEffectSetContrast     ,


-- ** setContrastFull #method:setContrastFull#

#if defined(ENABLE_OVERLOADING)
    BrightnessContrastEffectSetContrastFullMethodInfo,
#endif
    brightnessContrastEffectSetContrastFull ,




 -- * Properties


-- ** brightness #attr:brightness#
-- | The brightness change to apply to the effect.
-- 
-- This property uses a t'GI.Clutter.Structs.Color.Color' to represent the changes to each
-- color channel. The range is [ 0, 255 ], with 127 as the value used
-- to indicate no change; values smaller than 127 indicate a decrease
-- in brightness, and values larger than 127 indicate an increase in
-- brightness.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    BrightnessContrastEffectBrightnessPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    brightnessContrastEffectBrightness      ,
#endif
    clearBrightnessContrastEffectBrightness ,
    constructBrightnessContrastEffectBrightness,
    getBrightnessContrastEffectBrightness   ,
    setBrightnessContrastEffectBrightness   ,


-- ** contrast #attr:contrast#
-- | The contrast change to apply to the effect.
-- 
-- This property uses a t'GI.Clutter.Structs.Color.Color' to represent the changes to each
-- color channel. The range is [ 0, 255 ], with 127 as the value used
-- to indicate no change; values smaller than 127 indicate a decrease
-- in contrast, and values larger than 127 indicate an increase in
-- contrast.
-- 
-- /Since: 1.10/

#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

-- | Memory-managed wrapper type.
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

-- | Type class for types which can be safely cast to `BrightnessContrastEffect`, for instance with `toBrightnessContrastEffect`.
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]

-- | Cast to `BrightnessContrastEffect`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
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

-- | Convert 'BrightnessContrastEffect' 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 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

-- VVV Prop "brightness"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Color"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@brightness@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' brightnessContrastEffect #brightness
-- @
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

-- | Set the value of the “@brightness@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' brightnessContrastEffect [ #brightness 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Construct a `GValueConstruct` with valid value for the “@brightness@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
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)

-- | Set the value of the “@brightness@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #brightness
-- @
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

-- VVV Prop "contrast"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Color"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@contrast@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' brightnessContrastEffect #contrast
-- @
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

-- | Set the value of the “@contrast@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' brightnessContrastEffect [ #contrast 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Construct a `GValueConstruct` with valid value for the “@contrast@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
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)

-- | Set the value of the “@contrast@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #contrast
-- @
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

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

foreign import ccall "clutter_brightness_contrast_effect_new" clutter_brightness_contrast_effect_new :: 
    IO (Ptr BrightnessContrastEffect)

-- | Creates a new t'GI.Clutter.Objects.BrightnessContrastEffect.BrightnessContrastEffect' to be used with
-- 'GI.Clutter.Objects.Actor.actorAddEffect'
-- 
-- /Since: 1.10/
brightnessContrastEffectNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m BrightnessContrastEffect
    -- ^ __Returns:__ the newly created
    --   t'GI.Clutter.Objects.BrightnessContrastEffect.BrightnessContrastEffect' or 'P.Nothing'.  Use 'GI.GObject.Objects.Object.objectUnref' when
    --   done.
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

-- method BrightnessContrastEffect::get_brightness
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "BrightnessContrastEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterBrightnessContrastEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "red"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for red component of the\n   change in brightness"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "green"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for green component of the\n   change in brightness"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "blue"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for blue component of the\n   change in brightness"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_brightness_contrast_effect_get_brightness" clutter_brightness_contrast_effect_get_brightness :: 
    Ptr BrightnessContrastEffect ->         -- effect : TInterface (Name {namespace = "Clutter", name = "BrightnessContrastEffect"})
    Ptr CFloat ->                           -- red : TBasicType TFloat
    Ptr CFloat ->                           -- green : TBasicType TFloat
    Ptr CFloat ->                           -- blue : TBasicType TFloat
    IO ()

-- | Retrieves the change in brightness used by /@effect@/.
-- 
-- /Since: 1.10/
brightnessContrastEffectGetBrightness ::
    (B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.BrightnessContrastEffect.BrightnessContrastEffect'
    -> 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

-- method BrightnessContrastEffect::get_contrast
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "BrightnessContrastEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterBrightnessContrastEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "red"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for red component of the\n   change in contrast"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "green"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for green component of the\n   change in contrast"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "blue"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for blue component of the\n   change in contrast"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_brightness_contrast_effect_get_contrast" clutter_brightness_contrast_effect_get_contrast :: 
    Ptr BrightnessContrastEffect ->         -- effect : TInterface (Name {namespace = "Clutter", name = "BrightnessContrastEffect"})
    Ptr CFloat ->                           -- red : TBasicType TFloat
    Ptr CFloat ->                           -- green : TBasicType TFloat
    Ptr CFloat ->                           -- blue : TBasicType TFloat
    IO ()

-- | Retrieves the contrast value used by /@effect@/.
-- 
-- /Since: 1.10/
brightnessContrastEffectGetContrast ::
    (B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.BrightnessContrastEffect.BrightnessContrastEffect'
    -> 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

-- method BrightnessContrastEffect::set_brightness
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "BrightnessContrastEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterBrightnessContrastEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "brightness"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the brightness change for all three components (r, g, b)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_brightness_contrast_effect_set_brightness" clutter_brightness_contrast_effect_set_brightness :: 
    Ptr BrightnessContrastEffect ->         -- effect : TInterface (Name {namespace = "Clutter", name = "BrightnessContrastEffect"})
    CFloat ->                               -- brightness : TBasicType TFloat
    IO ()

-- | The range of /@brightness@/ is [-1.0, 1.0], where 0.0 designates no change;
-- a value below 0.0 indicates a decrease in brightness; and a value
-- above 0.0 indicates an increase of brightness.
-- 
-- /Since: 1.10/
brightnessContrastEffectSetBrightness ::
    (B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.BrightnessContrastEffect.BrightnessContrastEffect'
    -> Float
    -- ^ /@brightness@/: the brightness change for all three components (r, g, b)
    -> 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

-- method BrightnessContrastEffect::set_brightness_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "BrightnessContrastEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterBrightnessContrastEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "red"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "red component of the change in brightness"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "green"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "green component of the change in brightness"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "blue"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "blue component of the change in brightness"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_brightness_contrast_effect_set_brightness_full" clutter_brightness_contrast_effect_set_brightness_full :: 
    Ptr BrightnessContrastEffect ->         -- effect : TInterface (Name {namespace = "Clutter", name = "BrightnessContrastEffect"})
    CFloat ->                               -- red : TBasicType TFloat
    CFloat ->                               -- green : TBasicType TFloat
    CFloat ->                               -- blue : TBasicType TFloat
    IO ()

-- | The range for each component is [-1.0, 1.0] where 0.0 designates no change,
-- values below 0.0 mean a decrease in brightness, and values above indicate
-- an increase.
-- 
-- /Since: 1.10/
brightnessContrastEffectSetBrightnessFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.BrightnessContrastEffect.BrightnessContrastEffect'
    -> Float
    -- ^ /@red@/: red component of the change in brightness
    -> Float
    -- ^ /@green@/: green component of the change in brightness
    -> Float
    -- ^ /@blue@/: blue component of the change in brightness
    -> 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

-- method BrightnessContrastEffect::set_contrast
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "BrightnessContrastEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterBrightnessContrastEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "contrast"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "contrast change for all three channels"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_brightness_contrast_effect_set_contrast" clutter_brightness_contrast_effect_set_contrast :: 
    Ptr BrightnessContrastEffect ->         -- effect : TInterface (Name {namespace = "Clutter", name = "BrightnessContrastEffect"})
    CFloat ->                               -- contrast : TBasicType TFloat
    IO ()

-- | The range for /@contrast@/ is [-1.0, 1.0], where 0.0 designates no change;
-- a value below 0.0 indicates a decrease in contrast; and a value above
-- 0.0 indicates an increase.
-- 
-- /Since: 1.10/
brightnessContrastEffectSetContrast ::
    (B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.BrightnessContrastEffect.BrightnessContrastEffect'
    -> Float
    -- ^ /@contrast@/: contrast change for all three channels
    -> 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

-- method BrightnessContrastEffect::set_contrast_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "BrightnessContrastEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterBrightnessContrastEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "red"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "red component of the change in contrast"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "green"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "green component of the change in contrast"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "blue"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "blue component of the change in contrast"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_brightness_contrast_effect_set_contrast_full" clutter_brightness_contrast_effect_set_contrast_full :: 
    Ptr BrightnessContrastEffect ->         -- effect : TInterface (Name {namespace = "Clutter", name = "BrightnessContrastEffect"})
    CFloat ->                               -- red : TBasicType TFloat
    CFloat ->                               -- green : TBasicType TFloat
    CFloat ->                               -- blue : TBasicType TFloat
    IO ()

-- | The range for each component is [-1.0, 1.0] where 0.0 designates no change,
-- values below 0.0 mean a decrease in contrast, and values above indicate
-- an increase.
-- 
-- /Since: 1.10/
brightnessContrastEffectSetContrastFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsBrightnessContrastEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.BrightnessContrastEffect.BrightnessContrastEffect'
    -> Float
    -- ^ /@red@/: red component of the change in contrast
    -> Float
    -- ^ /@green@/: green component of the change in contrast
    -> Float
    -- ^ /@blue@/: blue component of the change in contrast
    -> 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