{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- This interface is implemented by elements which can perform some color
-- balance operation on video frames they process. For example, modifying
-- the brightness, contrast, hue or saturation.
-- 
-- Example elements are \'xvimagesink\' and \'colorbalance\'

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

module GI.GstVideo.Interfaces.ColorBalance
    ( 

-- * Exported types
    ColorBalance(..)                        ,
    noColorBalance                          ,
    IsColorBalance                          ,
    toColorBalance                          ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveColorBalanceMethod               ,
#endif


-- ** getBalanceType #method:getBalanceType#

#if defined(ENABLE_OVERLOADING)
    ColorBalanceGetBalanceTypeMethodInfo    ,
#endif
    colorBalanceGetBalanceType              ,


-- ** getValue #method:getValue#

#if defined(ENABLE_OVERLOADING)
    ColorBalanceGetValueMethodInfo          ,
#endif
    colorBalanceGetValue                    ,


-- ** listChannels #method:listChannels#

#if defined(ENABLE_OVERLOADING)
    ColorBalanceListChannelsMethodInfo      ,
#endif
    colorBalanceListChannels                ,


-- ** setValue #method:setValue#

#if defined(ENABLE_OVERLOADING)
    ColorBalanceSetValueMethodInfo          ,
#endif
    colorBalanceSetValue                    ,


-- ** valueChanged #method:valueChanged#

#if defined(ENABLE_OVERLOADING)
    ColorBalanceValueChangedMethodInfo      ,
#endif
    colorBalanceValueChanged                ,




 -- * Signals
-- ** valueChanged #signal:valueChanged#

    C_ColorBalanceValueChangedCallback      ,
    ColorBalanceValueChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    ColorBalanceValueChangedSignalInfo      ,
#endif
    afterColorBalanceValueChanged           ,
    genClosure_ColorBalanceValueChanged     ,
    mk_ColorBalanceValueChangedCallback     ,
    noColorBalanceValueChangedCallback      ,
    onColorBalanceValueChanged              ,
    wrap_ColorBalanceValueChangedCallback   ,




    ) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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 Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums
import {-# SOURCE #-} qualified GI.GstVideo.Objects.ColorBalanceChannel as GstVideo.ColorBalanceChannel

-- interface ColorBalance 
-- | Memory-managed wrapper type.
newtype ColorBalance = ColorBalance (ManagedPtr ColorBalance)
    deriving (ColorBalance -> ColorBalance -> Bool
(ColorBalance -> ColorBalance -> Bool)
-> (ColorBalance -> ColorBalance -> Bool) -> Eq ColorBalance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ColorBalance -> ColorBalance -> Bool
$c/= :: ColorBalance -> ColorBalance -> Bool
== :: ColorBalance -> ColorBalance -> Bool
$c== :: ColorBalance -> ColorBalance -> Bool
Eq)
-- | A convenience alias for `Nothing` :: `Maybe` `ColorBalance`.
noColorBalance :: Maybe ColorBalance
noColorBalance :: Maybe ColorBalance
noColorBalance = Maybe ColorBalance
forall a. Maybe a
Nothing

-- signal ColorBalance::value-changed
-- | Fired when the value of the indicated channel has changed.
type ColorBalanceValueChangedCallback =
    GstVideo.ColorBalanceChannel.ColorBalanceChannel
    -- ^ /@channel@/: The t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'
    -> Int32
    -- ^ /@value@/: The new value
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ColorBalanceValueChangedCallback`@.
noColorBalanceValueChangedCallback :: Maybe ColorBalanceValueChangedCallback
noColorBalanceValueChangedCallback :: Maybe ColorBalanceValueChangedCallback
noColorBalanceValueChangedCallback = Maybe ColorBalanceValueChangedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ColorBalanceValueChangedCallback =
    Ptr () ->                               -- object
    Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ColorBalanceValueChangedCallback`.
foreign import ccall "wrapper"
    mk_ColorBalanceValueChangedCallback :: C_ColorBalanceValueChangedCallback -> IO (FunPtr C_ColorBalanceValueChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_ColorBalanceValueChanged :: MonadIO m => ColorBalanceValueChangedCallback -> m (GClosure C_ColorBalanceValueChangedCallback)
genClosure_ColorBalanceValueChanged :: ColorBalanceValueChangedCallback
-> m (GClosure C_ColorBalanceValueChangedCallback)
genClosure_ColorBalanceValueChanged cb :: ColorBalanceValueChangedCallback
cb = IO (GClosure C_ColorBalanceValueChangedCallback)
-> m (GClosure C_ColorBalanceValueChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ColorBalanceValueChangedCallback)
 -> m (GClosure C_ColorBalanceValueChangedCallback))
-> IO (GClosure C_ColorBalanceValueChangedCallback)
-> m (GClosure C_ColorBalanceValueChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ColorBalanceValueChangedCallback
cb' = ColorBalanceValueChangedCallback
-> C_ColorBalanceValueChangedCallback
wrap_ColorBalanceValueChangedCallback ColorBalanceValueChangedCallback
cb
    C_ColorBalanceValueChangedCallback
-> IO (FunPtr C_ColorBalanceValueChangedCallback)
mk_ColorBalanceValueChangedCallback C_ColorBalanceValueChangedCallback
cb' IO (FunPtr C_ColorBalanceValueChangedCallback)
-> (FunPtr C_ColorBalanceValueChangedCallback
    -> IO (GClosure C_ColorBalanceValueChangedCallback))
-> IO (GClosure C_ColorBalanceValueChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ColorBalanceValueChangedCallback
-> IO (GClosure C_ColorBalanceValueChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ColorBalanceValueChangedCallback` into a `C_ColorBalanceValueChangedCallback`.
wrap_ColorBalanceValueChangedCallback ::
    ColorBalanceValueChangedCallback ->
    C_ColorBalanceValueChangedCallback
wrap_ColorBalanceValueChangedCallback :: ColorBalanceValueChangedCallback
-> C_ColorBalanceValueChangedCallback
wrap_ColorBalanceValueChangedCallback _cb :: ColorBalanceValueChangedCallback
_cb _ channel :: Ptr ColorBalanceChannel
channel value :: Int32
value _ = do
    ColorBalanceChannel
channel' <- ((ManagedPtr ColorBalanceChannel -> ColorBalanceChannel)
-> Ptr ColorBalanceChannel -> IO ColorBalanceChannel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ColorBalanceChannel -> ColorBalanceChannel
GstVideo.ColorBalanceChannel.ColorBalanceChannel) Ptr ColorBalanceChannel
channel
    ColorBalanceValueChangedCallback
_cb  ColorBalanceChannel
channel' Int32
value


-- | Connect a signal handler for the [valueChanged](#signal:valueChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' colorBalance #valueChanged callback
-- @
-- 
-- 
onColorBalanceValueChanged :: (IsColorBalance a, MonadIO m) => a -> ColorBalanceValueChangedCallback -> m SignalHandlerId
onColorBalanceValueChanged :: a -> ColorBalanceValueChangedCallback -> m SignalHandlerId
onColorBalanceValueChanged obj :: a
obj cb :: ColorBalanceValueChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ColorBalanceValueChangedCallback
cb' = ColorBalanceValueChangedCallback
-> C_ColorBalanceValueChangedCallback
wrap_ColorBalanceValueChangedCallback ColorBalanceValueChangedCallback
cb
    FunPtr C_ColorBalanceValueChangedCallback
cb'' <- C_ColorBalanceValueChangedCallback
-> IO (FunPtr C_ColorBalanceValueChangedCallback)
mk_ColorBalanceValueChangedCallback C_ColorBalanceValueChangedCallback
cb'
    a
-> Text
-> FunPtr C_ColorBalanceValueChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "value-changed" FunPtr C_ColorBalanceValueChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [valueChanged](#signal:valueChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' colorBalance #valueChanged callback
-- @
-- 
-- 
afterColorBalanceValueChanged :: (IsColorBalance a, MonadIO m) => a -> ColorBalanceValueChangedCallback -> m SignalHandlerId
afterColorBalanceValueChanged :: a -> ColorBalanceValueChangedCallback -> m SignalHandlerId
afterColorBalanceValueChanged obj :: a
obj cb :: ColorBalanceValueChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ColorBalanceValueChangedCallback
cb' = ColorBalanceValueChangedCallback
-> C_ColorBalanceValueChangedCallback
wrap_ColorBalanceValueChangedCallback ColorBalanceValueChangedCallback
cb
    FunPtr C_ColorBalanceValueChangedCallback
cb'' <- C_ColorBalanceValueChangedCallback
-> IO (FunPtr C_ColorBalanceValueChangedCallback)
mk_ColorBalanceValueChangedCallback C_ColorBalanceValueChangedCallback
cb'
    a
-> Text
-> FunPtr C_ColorBalanceValueChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "value-changed" FunPtr C_ColorBalanceValueChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ColorBalanceValueChangedSignalInfo
instance SignalInfo ColorBalanceValueChangedSignalInfo where
    type HaskellCallbackType ColorBalanceValueChangedSignalInfo = ColorBalanceValueChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ColorBalanceValueChangedCallback cb
        cb'' <- mk_ColorBalanceValueChangedCallback cb'
        connectSignalFunPtr obj "value-changed" cb'' connectMode detail

#endif

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

#endif

foreign import ccall "gst_color_balance_get_type"
    c_gst_color_balance_get_type :: IO GType

instance GObject ColorBalance where
    gobjectType :: IO GType
gobjectType = IO GType
c_gst_color_balance_get_type
    

-- | Convert 'ColorBalance' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue ColorBalance where
    toGValue :: ColorBalance -> IO GValue
toGValue o :: ColorBalance
o = do
        GType
gtype <- IO GType
c_gst_color_balance_get_type
        ColorBalance -> (Ptr ColorBalance -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ColorBalance
o (GType
-> (GValue -> Ptr ColorBalance -> IO ())
-> Ptr ColorBalance
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr ColorBalance -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO ColorBalance
fromGValue gv :: GValue
gv = do
        Ptr ColorBalance
ptr <- GValue -> IO (Ptr ColorBalance)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr ColorBalance)
        (ManagedPtr ColorBalance -> ColorBalance)
-> Ptr ColorBalance -> IO ColorBalance
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ColorBalance -> ColorBalance
ColorBalance Ptr ColorBalance
ptr
        
    

-- | Type class for types which can be safely cast to `ColorBalance`, for instance with `toColorBalance`.
class (GObject o, O.IsDescendantOf ColorBalance o) => IsColorBalance o
instance (GObject o, O.IsDescendantOf ColorBalance o) => IsColorBalance o

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

-- | Cast to `ColorBalance`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toColorBalance :: (MonadIO m, IsColorBalance o) => o -> m ColorBalance
toColorBalance :: o -> m ColorBalance
toColorBalance = IO ColorBalance -> m ColorBalance
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ColorBalance -> m ColorBalance)
-> (o -> IO ColorBalance) -> o -> m ColorBalance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ColorBalance -> ColorBalance) -> o -> IO ColorBalance
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr ColorBalance -> ColorBalance
ColorBalance

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ColorBalance
type instance O.AttributeList ColorBalance = ColorBalanceAttributeList
type ColorBalanceAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveColorBalanceMethod (t :: Symbol) (o :: *) :: * where
    ResolveColorBalanceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveColorBalanceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveColorBalanceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveColorBalanceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveColorBalanceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveColorBalanceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveColorBalanceMethod "listChannels" o = ColorBalanceListChannelsMethodInfo
    ResolveColorBalanceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveColorBalanceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveColorBalanceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveColorBalanceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveColorBalanceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveColorBalanceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveColorBalanceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveColorBalanceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveColorBalanceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveColorBalanceMethod "valueChanged" o = ColorBalanceValueChangedMethodInfo
    ResolveColorBalanceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveColorBalanceMethod "getBalanceType" o = ColorBalanceGetBalanceTypeMethodInfo
    ResolveColorBalanceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveColorBalanceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveColorBalanceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveColorBalanceMethod "getValue" o = ColorBalanceGetValueMethodInfo
    ResolveColorBalanceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveColorBalanceMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveColorBalanceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveColorBalanceMethod "setValue" o = ColorBalanceSetValueMethodInfo
    ResolveColorBalanceMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveColorBalanceMethod t ColorBalance, O.MethodInfo info ColorBalance p) => OL.IsLabel t (ColorBalance -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

-- method ColorBalance::get_balance_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "balance"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "ColorBalance" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GstColorBalance implementation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GstVideo" , name = "ColorBalanceType" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_color_balance_get_balance_type" gst_color_balance_get_balance_type :: 
    Ptr ColorBalance ->                     -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"})
    IO CUInt

-- | Get the t'GI.GstVideo.Enums.ColorBalanceType' of this implementation.
colorBalanceGetBalanceType ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a) =>
    a
    -- ^ /@balance@/: The t'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' implementation
    -> m GstVideo.Enums.ColorBalanceType
    -- ^ __Returns:__ A the t'GI.GstVideo.Enums.ColorBalanceType'.
colorBalanceGetBalanceType :: a -> m ColorBalanceType
colorBalanceGetBalanceType balance :: a
balance = IO ColorBalanceType -> m ColorBalanceType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ColorBalanceType -> m ColorBalanceType)
-> IO ColorBalanceType -> m ColorBalanceType
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColorBalance
balance' <- a -> IO (Ptr ColorBalance)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
balance
    CUInt
result <- Ptr ColorBalance -> IO CUInt
gst_color_balance_get_balance_type Ptr ColorBalance
balance'
    let result' :: ColorBalanceType
result' = (Int -> ColorBalanceType
forall a. Enum a => Int -> a
toEnum (Int -> ColorBalanceType)
-> (CUInt -> Int) -> CUInt -> ColorBalanceType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
balance
    ColorBalanceType -> IO ColorBalanceType
forall (m :: * -> *) a. Monad m => a -> m a
return ColorBalanceType
result'

#if defined(ENABLE_OVERLOADING)
data ColorBalanceGetBalanceTypeMethodInfo
instance (signature ~ (m GstVideo.Enums.ColorBalanceType), MonadIO m, IsColorBalance a) => O.MethodInfo ColorBalanceGetBalanceTypeMethodInfo a signature where
    overloadedMethod = colorBalanceGetBalanceType

#endif

-- method ColorBalance::get_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "balance"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "ColorBalance" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GstColorBalance instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "channel"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "ColorBalanceChannel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GstColorBalanceChannel instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gst_color_balance_get_value" gst_color_balance_get_value :: 
    Ptr ColorBalance ->                     -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"})
    Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel -> -- channel : TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"})
    IO Int32

-- | Retrieve the current value of the indicated channel, between min_value
-- and max_value.
-- 
-- See Also: The t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'.@/min_value/@ and
--         t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'.@/max_value/@ members of the
--         t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' object.
colorBalanceGetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) =>
    a
    -- ^ /@balance@/: A t'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' instance
    -> b
    -- ^ /@channel@/: A t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' instance
    -> m Int32
    -- ^ __Returns:__ The current value of the channel.
colorBalanceGetValue :: a -> b -> m Int32
colorBalanceGetValue balance :: a
balance channel :: b
channel = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColorBalance
balance' <- a -> IO (Ptr ColorBalance)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
balance
    Ptr ColorBalanceChannel
channel' <- b -> IO (Ptr ColorBalanceChannel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
channel
    Int32
result <- Ptr ColorBalance -> Ptr ColorBalanceChannel -> IO Int32
gst_color_balance_get_value Ptr ColorBalance
balance' Ptr ColorBalanceChannel
channel'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
balance
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
channel
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ColorBalanceGetValueMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) => O.MethodInfo ColorBalanceGetValueMethodInfo a signature where
    overloadedMethod = colorBalanceGetValue

#endif

-- method ColorBalance::list_channels
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "balance"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "ColorBalance" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GstColorBalance instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface
--                     Name { namespace = "GstVideo" , name = "ColorBalanceChannel" }))
-- throws : False
-- Skip return : False

foreign import ccall "gst_color_balance_list_channels" gst_color_balance_list_channels :: 
    Ptr ColorBalance ->                     -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"})
    IO (Ptr (GList (Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel)))

-- | Retrieve a list of the available channels.
colorBalanceListChannels ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a) =>
    a
    -- ^ /@balance@/: A t'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' instance
    -> m [GstVideo.ColorBalanceChannel.ColorBalanceChannel]
    -- ^ __Returns:__ A
    --          GList containing pointers to t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'
    --          objects. The list is owned by the t'GI.GstVideo.Interfaces.ColorBalance.ColorBalance'
    --          instance and must not be freed.
colorBalanceListChannels :: a -> m [ColorBalanceChannel]
colorBalanceListChannels balance :: a
balance = IO [ColorBalanceChannel] -> m [ColorBalanceChannel]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ColorBalanceChannel] -> m [ColorBalanceChannel])
-> IO [ColorBalanceChannel] -> m [ColorBalanceChannel]
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColorBalance
balance' <- a -> IO (Ptr ColorBalance)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
balance
    Ptr (GList (Ptr ColorBalanceChannel))
result <- Ptr ColorBalance -> IO (Ptr (GList (Ptr ColorBalanceChannel)))
gst_color_balance_list_channels Ptr ColorBalance
balance'
    [Ptr ColorBalanceChannel]
result' <- Ptr (GList (Ptr ColorBalanceChannel))
-> IO [Ptr ColorBalanceChannel]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr ColorBalanceChannel))
result
    [ColorBalanceChannel]
result'' <- (Ptr ColorBalanceChannel -> IO ColorBalanceChannel)
-> [Ptr ColorBalanceChannel] -> IO [ColorBalanceChannel]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr ColorBalanceChannel -> ColorBalanceChannel)
-> Ptr ColorBalanceChannel -> IO ColorBalanceChannel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ColorBalanceChannel -> ColorBalanceChannel
GstVideo.ColorBalanceChannel.ColorBalanceChannel) [Ptr ColorBalanceChannel]
result'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
balance
    [ColorBalanceChannel] -> IO [ColorBalanceChannel]
forall (m :: * -> *) a. Monad m => a -> m a
return [ColorBalanceChannel]
result''

#if defined(ENABLE_OVERLOADING)
data ColorBalanceListChannelsMethodInfo
instance (signature ~ (m [GstVideo.ColorBalanceChannel.ColorBalanceChannel]), MonadIO m, IsColorBalance a) => O.MethodInfo ColorBalanceListChannelsMethodInfo a signature where
    overloadedMethod = colorBalanceListChannels

#endif

-- method ColorBalance::set_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "balance"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "ColorBalance" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GstColorBalance instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "channel"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "ColorBalanceChannel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GstColorBalanceChannel instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new value for the channel."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_color_balance_set_value" gst_color_balance_set_value :: 
    Ptr ColorBalance ->                     -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"})
    Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel -> -- channel : TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"})
    Int32 ->                                -- value : TBasicType TInt
    IO ()

-- | Sets the current value of the channel to the passed value, which must
-- be between min_value and max_value.
-- 
-- See Also: The t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'.@/min_value/@ and
--         t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'.@/max_value/@ members of the
--         t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' object.
colorBalanceSetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) =>
    a
    -- ^ /@balance@/: A t'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' instance
    -> b
    -- ^ /@channel@/: A t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' instance
    -> Int32
    -- ^ /@value@/: The new value for the channel.
    -> m ()
colorBalanceSetValue :: a -> b -> Int32 -> m ()
colorBalanceSetValue balance :: a
balance channel :: b
channel value :: Int32
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColorBalance
balance' <- a -> IO (Ptr ColorBalance)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
balance
    Ptr ColorBalanceChannel
channel' <- b -> IO (Ptr ColorBalanceChannel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
channel
    Ptr ColorBalance -> Ptr ColorBalanceChannel -> Int32 -> IO ()
gst_color_balance_set_value Ptr ColorBalance
balance' Ptr ColorBalanceChannel
channel' Int32
value
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
balance
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
channel
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColorBalanceSetValueMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) => O.MethodInfo ColorBalanceSetValueMethodInfo a signature where
    overloadedMethod = colorBalanceSetValue

#endif

-- method ColorBalance::value_changed
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "balance"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "ColorBalance" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GstColorBalance instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "channel"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "ColorBalanceChannel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A #GstColorBalanceChannel whose value has changed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new value of the channel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_color_balance_value_changed" gst_color_balance_value_changed :: 
    Ptr ColorBalance ->                     -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"})
    Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel -> -- channel : TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"})
    Int32 ->                                -- value : TBasicType TInt
    IO ()

-- | A helper function called by implementations of the GstColorBalance
-- interface. It fires the [valueChanged]("GI.GstVideo.Interfaces.ColorBalance#signal:valueChanged") signal on the
-- instance, and the [valueChanged]("GI.GstVideo.Objects.ColorBalanceChannel#signal:valueChanged") signal on the
-- channel object.
colorBalanceValueChanged ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) =>
    a
    -- ^ /@balance@/: A t'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' instance
    -> b
    -- ^ /@channel@/: A t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' whose value has changed
    -> Int32
    -- ^ /@value@/: The new value of the channel
    -> m ()
colorBalanceValueChanged :: a -> b -> Int32 -> m ()
colorBalanceValueChanged balance :: a
balance channel :: b
channel value :: Int32
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColorBalance
balance' <- a -> IO (Ptr ColorBalance)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
balance
    Ptr ColorBalanceChannel
channel' <- b -> IO (Ptr ColorBalanceChannel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
channel
    Ptr ColorBalance -> Ptr ColorBalanceChannel -> Int32 -> IO ()
gst_color_balance_value_changed Ptr ColorBalance
balance' Ptr ColorBalanceChannel
channel' Int32
value
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
balance
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
channel
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColorBalanceValueChangedMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) => O.MethodInfo ColorBalanceValueChangedMethodInfo a signature where
    overloadedMethod = colorBalanceValueChanged

#endif