{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' object represents a parameter
-- for modifying the color balance implemented by an element providing the
-- t'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' interface. For example, Hue or Saturation.

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

module GI.GstVideo.Objects.ColorBalanceChannel
    ( 

-- * Exported types
    ColorBalanceChannel(..)                 ,
    IsColorBalanceChannel                   ,
    toColorBalanceChannel                   ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveColorBalanceChannelMethod        ,
#endif




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

    C_ColorBalanceChannelValueChangedCallback,
    ColorBalanceChannelValueChangedCallback ,
#if defined(ENABLE_OVERLOADING)
    ColorBalanceChannelValueChangedSignalInfo,
#endif
    afterColorBalanceChannelValueChanged    ,
    genClosure_ColorBalanceChannelValueChanged,
    mk_ColorBalanceChannelValueChangedCallback,
    noColorBalanceChannelValueChangedCallback,
    onColorBalanceChannelValueChanged       ,
    wrap_ColorBalanceChannelValueChangedCallback,




    ) 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.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 Control.Monad.IO.Class as MIO
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

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

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

foreign import ccall "gst_color_balance_channel_get_type"
    c_gst_color_balance_channel_get_type :: IO B.Types.GType

instance B.Types.TypedObject ColorBalanceChannel where
    glibType :: IO GType
glibType = IO GType
c_gst_color_balance_channel_get_type

instance B.Types.GObject ColorBalanceChannel

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

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

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

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

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

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

#endif

-- signal ColorBalanceChannel::value-changed
-- | Fired when the value of the indicated channel has changed.
type ColorBalanceChannelValueChangedCallback =
    Int32
    -- ^ /@value@/: The new value
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ColorBalanceChannelValueChangedCallback`@.
noColorBalanceChannelValueChangedCallback :: Maybe ColorBalanceChannelValueChangedCallback
noColorBalanceChannelValueChangedCallback :: Maybe ColorBalanceChannelValueChangedCallback
noColorBalanceChannelValueChangedCallback = Maybe ColorBalanceChannelValueChangedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_ColorBalanceChannelValueChanged :: MonadIO m => ColorBalanceChannelValueChangedCallback -> m (GClosure C_ColorBalanceChannelValueChangedCallback)
genClosure_ColorBalanceChannelValueChanged :: ColorBalanceChannelValueChangedCallback
-> m (GClosure C_ColorBalanceChannelValueChangedCallback)
genClosure_ColorBalanceChannelValueChanged ColorBalanceChannelValueChangedCallback
cb = IO (GClosure C_ColorBalanceChannelValueChangedCallback)
-> m (GClosure C_ColorBalanceChannelValueChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ColorBalanceChannelValueChangedCallback)
 -> m (GClosure C_ColorBalanceChannelValueChangedCallback))
-> IO (GClosure C_ColorBalanceChannelValueChangedCallback)
-> m (GClosure C_ColorBalanceChannelValueChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ColorBalanceChannelValueChangedCallback
cb' = ColorBalanceChannelValueChangedCallback
-> C_ColorBalanceChannelValueChangedCallback
wrap_ColorBalanceChannelValueChangedCallback ColorBalanceChannelValueChangedCallback
cb
    C_ColorBalanceChannelValueChangedCallback
-> IO (FunPtr C_ColorBalanceChannelValueChangedCallback)
mk_ColorBalanceChannelValueChangedCallback C_ColorBalanceChannelValueChangedCallback
cb' IO (FunPtr C_ColorBalanceChannelValueChangedCallback)
-> (FunPtr C_ColorBalanceChannelValueChangedCallback
    -> IO (GClosure C_ColorBalanceChannelValueChangedCallback))
-> IO (GClosure C_ColorBalanceChannelValueChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ColorBalanceChannelValueChangedCallback
-> IO (GClosure C_ColorBalanceChannelValueChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ColorBalanceChannelValueChangedCallback` into a `C_ColorBalanceChannelValueChangedCallback`.
wrap_ColorBalanceChannelValueChangedCallback ::
    ColorBalanceChannelValueChangedCallback ->
    C_ColorBalanceChannelValueChangedCallback
wrap_ColorBalanceChannelValueChangedCallback :: ColorBalanceChannelValueChangedCallback
-> C_ColorBalanceChannelValueChangedCallback
wrap_ColorBalanceChannelValueChangedCallback ColorBalanceChannelValueChangedCallback
_cb Ptr ()
_ Int32
value Ptr ()
_ = do
    ColorBalanceChannelValueChangedCallback
_cb  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' colorBalanceChannel #valueChanged callback
-- @
-- 
-- 
onColorBalanceChannelValueChanged :: (IsColorBalanceChannel a, MonadIO m) => a -> ColorBalanceChannelValueChangedCallback -> m SignalHandlerId
onColorBalanceChannelValueChanged :: a -> ColorBalanceChannelValueChangedCallback -> m SignalHandlerId
onColorBalanceChannelValueChanged a
obj ColorBalanceChannelValueChangedCallback
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_ColorBalanceChannelValueChangedCallback
cb' = ColorBalanceChannelValueChangedCallback
-> C_ColorBalanceChannelValueChangedCallback
wrap_ColorBalanceChannelValueChangedCallback ColorBalanceChannelValueChangedCallback
cb
    FunPtr C_ColorBalanceChannelValueChangedCallback
cb'' <- C_ColorBalanceChannelValueChangedCallback
-> IO (FunPtr C_ColorBalanceChannelValueChangedCallback)
mk_ColorBalanceChannelValueChangedCallback C_ColorBalanceChannelValueChangedCallback
cb'
    a
-> Text
-> FunPtr C_ColorBalanceChannelValueChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"value-changed" FunPtr C_ColorBalanceChannelValueChangedCallback
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' colorBalanceChannel #valueChanged callback
-- @
-- 
-- 
afterColorBalanceChannelValueChanged :: (IsColorBalanceChannel a, MonadIO m) => a -> ColorBalanceChannelValueChangedCallback -> m SignalHandlerId
afterColorBalanceChannelValueChanged :: a -> ColorBalanceChannelValueChangedCallback -> m SignalHandlerId
afterColorBalanceChannelValueChanged a
obj ColorBalanceChannelValueChangedCallback
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_ColorBalanceChannelValueChangedCallback
cb' = ColorBalanceChannelValueChangedCallback
-> C_ColorBalanceChannelValueChangedCallback
wrap_ColorBalanceChannelValueChangedCallback ColorBalanceChannelValueChangedCallback
cb
    FunPtr C_ColorBalanceChannelValueChangedCallback
cb'' <- C_ColorBalanceChannelValueChangedCallback
-> IO (FunPtr C_ColorBalanceChannelValueChangedCallback)
mk_ColorBalanceChannelValueChangedCallback C_ColorBalanceChannelValueChangedCallback
cb'
    a
-> Text
-> FunPtr C_ColorBalanceChannelValueChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"value-changed" FunPtr C_ColorBalanceChannelValueChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ColorBalanceChannelValueChangedSignalInfo
instance SignalInfo ColorBalanceChannelValueChangedSignalInfo where
    type HaskellCallbackType ColorBalanceChannelValueChangedSignalInfo = ColorBalanceChannelValueChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ColorBalanceChannelValueChangedCallback cb
        cb'' <- mk_ColorBalanceChannelValueChangedCallback cb'
        connectSignalFunPtr obj "value-changed" cb'' connectMode detail

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

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

#endif