{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

'GI.Gst.Objects.Object.Object' provides a root for the object hierarchy tree filed in by the
GStreamer library.  It is currently a thin wrapper on top of
'GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned'. It is an abstract class that is not very usable on its own.

'GI.Gst.Objects.Object.Object' gives us basic refcounting, parenting functionality and locking.
Most of the functions are just extended for special GStreamer needs and can be
found under the same name in the base class of 'GI.Gst.Objects.Object.Object' which is 'GI.GObject.Objects.Object.Object'
(e.g. 'GI.GObject.Objects.Object.objectRef' becomes 'GI.Gst.Objects.Object.objectRef').

Since 'GI.Gst.Objects.Object.Object' derives from 'GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned', it also inherits the
floating reference. Be aware that functions such as 'GI.Gst.Objects.Bin.binAdd' and
'GI.Gst.Objects.Element.elementAddPad' take ownership of the floating reference.

In contrast to 'GI.GObject.Objects.Object.Object' instances, 'GI.Gst.Objects.Object.Object' adds a name property. The functions
'GI.Gst.Objects.Object.objectSetName' and 'GI.Gst.Objects.Object.objectGetName' are used to set\/get the name
of the object.

== controlled properties

Controlled properties offers a lightweight way to adjust gobject properties
over stream-time. It works by using time-stamped value pairs that are queued
for element-properties. At run-time the elements continuously pull value
changes for the current stream-time.

What needs to be changed in a 'GI.Gst.Objects.Element.Element'?
Very little - it is just two steps to make a plugin controllable!

  * mark gobject-properties paramspecs that make sense to be controlled,
    by GST_PARAM_CONTROLLABLE.

  * when processing data (get, chain, loop function) at the beginning call
    gst_object_sync_values(element,timestamp).
    This will make the controller update all GObject properties that are
    under its control with the current values based on the timestamp.

What needs to be done in applications? Again it\'s not a lot to change.

  * create a 'GI.Gst.Objects.ControlSource.ControlSource'.
    csource = gst_interpolation_control_source_new ();
    g_object_set (csource, \"mode\", GST_INTERPOLATION_MODE_LINEAR, NULL);

  * Attach the 'GI.Gst.Objects.ControlSource.ControlSource' on the controller to a property.
    gst_object_add_control_binding (object, gst_direct_control_binding_new (object, \"prop1\", csource));

  * Set the control values
    gst_timed_value_control_source_set ((GstTimedValueControlSource *)csource,0 * GST_SECOND, value1);
    gst_timed_value_control_source_set ((GstTimedValueControlSource *)csource,1 * GST_SECOND, value2);

  * start your pipeline
-}

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

module GI.Gst.Objects.Object
    (

-- * Exported types
    Object(..)                              ,
    IsObject                                ,
    toObject                                ,
    noObject                                ,


 -- * Methods
-- ** addControlBinding #method:addControlBinding#

#if ENABLE_OVERLOADING
    ObjectAddControlBindingMethodInfo       ,
#endif
    objectAddControlBinding                 ,


-- ** checkUniqueness #method:checkUniqueness#

    objectCheckUniqueness                   ,


-- ** defaultDeepNotify #method:defaultDeepNotify#

    objectDefaultDeepNotify                 ,


-- ** defaultError #method:defaultError#

#if ENABLE_OVERLOADING
    ObjectDefaultErrorMethodInfo            ,
#endif
    objectDefaultError                      ,


-- ** getControlBinding #method:getControlBinding#

#if ENABLE_OVERLOADING
    ObjectGetControlBindingMethodInfo       ,
#endif
    objectGetControlBinding                 ,


-- ** getControlRate #method:getControlRate#

#if ENABLE_OVERLOADING
    ObjectGetControlRateMethodInfo          ,
#endif
    objectGetControlRate                    ,


-- ** getGValueArray #method:getGValueArray#

#if ENABLE_OVERLOADING
    ObjectGetGValueArrayMethodInfo          ,
#endif
    objectGetGValueArray                    ,


-- ** getName #method:getName#

#if ENABLE_OVERLOADING
    ObjectGetNameMethodInfo                 ,
#endif
    objectGetName                           ,


-- ** getParent #method:getParent#

#if ENABLE_OVERLOADING
    ObjectGetParentMethodInfo               ,
#endif
    objectGetParent                         ,


-- ** getPathString #method:getPathString#

#if ENABLE_OVERLOADING
    ObjectGetPathStringMethodInfo           ,
#endif
    objectGetPathString                     ,


-- ** getValue #method:getValue#

#if ENABLE_OVERLOADING
    ObjectGetValueMethodInfo                ,
#endif
    objectGetValue                          ,


-- ** hasActiveControlBindings #method:hasActiveControlBindings#

#if ENABLE_OVERLOADING
    ObjectHasActiveControlBindingsMethodInfo,
#endif
    objectHasActiveControlBindings          ,


-- ** hasAncestor #method:hasAncestor#

#if ENABLE_OVERLOADING
    ObjectHasAncestorMethodInfo             ,
#endif
    objectHasAncestor                       ,


-- ** hasAsAncestor #method:hasAsAncestor#

#if ENABLE_OVERLOADING
    ObjectHasAsAncestorMethodInfo           ,
#endif
    objectHasAsAncestor                     ,


-- ** hasAsParent #method:hasAsParent#

#if ENABLE_OVERLOADING
    ObjectHasAsParentMethodInfo             ,
#endif
    objectHasAsParent                       ,


-- ** ref #method:ref#

#if ENABLE_OVERLOADING
    ObjectRefMethodInfo                     ,
#endif
    objectRef                               ,


-- ** removeControlBinding #method:removeControlBinding#

#if ENABLE_OVERLOADING
    ObjectRemoveControlBindingMethodInfo    ,
#endif
    objectRemoveControlBinding              ,


-- ** replace #method:replace#

    objectReplace                           ,


-- ** setControlBindingDisabled #method:setControlBindingDisabled#

#if ENABLE_OVERLOADING
    ObjectSetControlBindingDisabledMethodInfo,
#endif
    objectSetControlBindingDisabled         ,


-- ** setControlBindingsDisabled #method:setControlBindingsDisabled#

#if ENABLE_OVERLOADING
    ObjectSetControlBindingsDisabledMethodInfo,
#endif
    objectSetControlBindingsDisabled        ,


-- ** setControlRate #method:setControlRate#

#if ENABLE_OVERLOADING
    ObjectSetControlRateMethodInfo          ,
#endif
    objectSetControlRate                    ,


-- ** setName #method:setName#

#if ENABLE_OVERLOADING
    ObjectSetNameMethodInfo                 ,
#endif
    objectSetName                           ,


-- ** setParent #method:setParent#

#if ENABLE_OVERLOADING
    ObjectSetParentMethodInfo               ,
#endif
    objectSetParent                         ,


-- ** suggestNextSync #method:suggestNextSync#

#if ENABLE_OVERLOADING
    ObjectSuggestNextSyncMethodInfo         ,
#endif
    objectSuggestNextSync                   ,


-- ** syncValues #method:syncValues#

#if ENABLE_OVERLOADING
    ObjectSyncValuesMethodInfo              ,
#endif
    objectSyncValues                        ,


-- ** unparent #method:unparent#

#if ENABLE_OVERLOADING
    ObjectUnparentMethodInfo                ,
#endif
    objectUnparent                          ,


-- ** unref #method:unref#

#if ENABLE_OVERLOADING
    ObjectUnrefMethodInfo                   ,
#endif
    objectUnref                             ,




 -- * Properties
-- ** name #attr:name#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectNamePropertyInfo                  ,
#endif
    clearObjectName                         ,
    constructObjectName                     ,
    getObjectName                           ,
#if ENABLE_OVERLOADING
    objectName                              ,
#endif
    setObjectName                           ,


-- ** parent #attr:parent#
{- | The parent of the object. Please note, that when changing the \'parent\'
property, we don\'t emit 'GI.GObject.Objects.Object.Object'::@/notify/@ and 'GI.Gst.Objects.Object.Object'::@/deep-notify/@
signals due to locking issues. In some cases one can use
'GI.Gst.Objects.Bin.Bin'::@/element-added/@ or 'GI.Gst.Objects.Bin.Bin'::@/element-removed/@ signals on the parent to
achieve a similar effect.
-}
#if ENABLE_OVERLOADING
    ObjectParentPropertyInfo                ,
#endif
    clearObjectParent                       ,
    constructObjectParent                   ,
    getObjectParent                         ,
#if ENABLE_OVERLOADING
    objectParent                            ,
#endif
    setObjectParent                         ,




 -- * Signals
-- ** deepNotify #signal:deepNotify#

    C_ObjectDeepNotifyCallback              ,
    ObjectDeepNotifyCallback                ,
#if ENABLE_OVERLOADING
    ObjectDeepNotifySignalInfo              ,
#endif
    afterObjectDeepNotify                   ,
    genClosure_ObjectDeepNotify             ,
    mk_ObjectDeepNotifyCallback             ,
    noObjectDeepNotifyCallback              ,
    onObjectDeepNotify                      ,
    wrap_ObjectDeepNotifyCallback           ,




    ) 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.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.Gst.Objects.ControlBinding as Gst.ControlBinding

-- | Memory-managed wrapper type.
newtype Object = Object (ManagedPtr Object)
foreign import ccall "gst_object_get_type"
    c_gst_object_get_type :: IO GType

instance GObject Object where
    gobjectType = c_gst_object_get_type


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

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

-- | Cast to `Object`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toObject :: (MonadIO m, IsObject o) => o -> m Object
toObject = liftIO . unsafeCastTo Object

-- | A convenience alias for `Nothing` :: `Maybe` `Object`.
noObject :: Maybe Object
noObject = Nothing

#if ENABLE_OVERLOADING
type family ResolveObjectMethod (t :: Symbol) (o :: *) :: * where
    ResolveObjectMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
    ResolveObjectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveObjectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveObjectMethod "defaultError" o = ObjectDefaultErrorMethodInfo
    ResolveObjectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveObjectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveObjectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveObjectMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
    ResolveObjectMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
    ResolveObjectMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
    ResolveObjectMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
    ResolveObjectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveObjectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveObjectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveObjectMethod "ref" o = ObjectRefMethodInfo
    ResolveObjectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveObjectMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
    ResolveObjectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveObjectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveObjectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveObjectMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
    ResolveObjectMethod "syncValues" o = ObjectSyncValuesMethodInfo
    ResolveObjectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveObjectMethod "unparent" o = ObjectUnparentMethodInfo
    ResolveObjectMethod "unref" o = ObjectUnrefMethodInfo
    ResolveObjectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveObjectMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
    ResolveObjectMethod "getControlRate" o = ObjectGetControlRateMethodInfo
    ResolveObjectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveObjectMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
    ResolveObjectMethod "getName" o = ObjectGetNameMethodInfo
    ResolveObjectMethod "getParent" o = ObjectGetParentMethodInfo
    ResolveObjectMethod "getPathString" o = ObjectGetPathStringMethodInfo
    ResolveObjectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveObjectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveObjectMethod "getValue" o = ObjectGetValueMethodInfo
    ResolveObjectMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
    ResolveObjectMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
    ResolveObjectMethod "setControlRate" o = ObjectSetControlRateMethodInfo
    ResolveObjectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveObjectMethod "setName" o = ObjectSetNameMethodInfo
    ResolveObjectMethod "setParent" o = ObjectSetParentMethodInfo
    ResolveObjectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveObjectMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal Object::deep-notify
{- |
The deep notify signal is used to be notified of property changes. It is
typically attached to the toplevel bin to receive notifications from all
the elements contained in that bin.
-}
type ObjectDeepNotifyCallback =
    Object
    {- ^ /@propObject@/: the object that originated the signal -}
    -> GParamSpec
    {- ^ /@prop@/: the property that changed -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectDeepNotifyCallback`@.
noObjectDeepNotifyCallback :: Maybe ObjectDeepNotifyCallback
noObjectDeepNotifyCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_ObjectDeepNotify :: MonadIO m => ObjectDeepNotifyCallback -> m (GClosure C_ObjectDeepNotifyCallback)
genClosure_ObjectDeepNotify cb = liftIO $ do
    let cb' = wrap_ObjectDeepNotifyCallback cb
    mk_ObjectDeepNotifyCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectDeepNotifyCallback` into a `C_ObjectDeepNotifyCallback`.
wrap_ObjectDeepNotifyCallback ::
    ObjectDeepNotifyCallback ->
    C_ObjectDeepNotifyCallback
wrap_ObjectDeepNotifyCallback _cb _ propObject prop _ = do
    propObject' <- (newObject Object) propObject
    prop' <- B.GParamSpec.newGParamSpecFromPtr prop
    _cb  propObject' prop'


{- |
Connect a signal handler for the “@deep-notify@” 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' object #deepNotify callback
@
-}
onObjectDeepNotify :: (IsObject a, MonadIO m) => a -> ObjectDeepNotifyCallback -> m SignalHandlerId
onObjectDeepNotify obj cb = liftIO $ do
    let cb' = wrap_ObjectDeepNotifyCallback cb
    cb'' <- mk_ObjectDeepNotifyCallback cb'
    connectSignalFunPtr obj "deep-notify" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@deep-notify@” 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' object #deepNotify callback
@
-}
afterObjectDeepNotify :: (IsObject a, MonadIO m) => a -> ObjectDeepNotifyCallback -> m SignalHandlerId
afterObjectDeepNotify obj cb = liftIO $ do
    let cb' = wrap_ObjectDeepNotifyCallback cb
    cb'' <- mk_ObjectDeepNotifyCallback cb'
    connectSignalFunPtr obj "deep-notify" cb'' SignalConnectAfter


-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@name@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' object #name
@
-}
getObjectName :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
getObjectName obj = liftIO $ B.Properties.getObjectPropertyString obj "name"

{- |
Set the value of the “@name@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' object [ #name 'Data.GI.Base.Attributes.:=' value ]
@
-}
setObjectName :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
setObjectName obj val = liftIO $ B.Properties.setObjectPropertyString obj "name" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructObjectName :: (IsObject o) => T.Text -> IO (GValueConstruct o)
constructObjectName val = B.Properties.constructObjectPropertyString "name" (Just val)

{- |
Set the value of the “@name@” 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' #name
@
-}
clearObjectName :: (MonadIO m, IsObject o) => o -> m ()
clearObjectName obj = liftIO $ B.Properties.setObjectPropertyString obj "name" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data ObjectNamePropertyInfo
instance AttrInfo ObjectNamePropertyInfo where
    type AttrAllowedOps ObjectNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ObjectNamePropertyInfo = IsObject
    type AttrGetType ObjectNamePropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectNamePropertyInfo = "name"
    type AttrOrigin ObjectNamePropertyInfo = Object
    attrGet _ = getObjectName
    attrSet _ = setObjectName
    attrConstruct _ = constructObjectName
    attrClear _ = clearObjectName
#endif

-- VVV Prop "parent"
   -- Type: TInterface (Name {namespace = "Gst", name = "Object"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@parent@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' object #parent
@
-}
getObjectParent :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
getObjectParent obj = liftIO $ B.Properties.getObjectPropertyObject obj "parent" Object

{- |
Set the value of the “@parent@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' object [ #parent 'Data.GI.Base.Attributes.:=' value ]
@
-}
setObjectParent :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
setObjectParent obj val = liftIO $ B.Properties.setObjectPropertyObject obj "parent" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@parent@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructObjectParent :: (IsObject o, IsObject a) => a -> IO (GValueConstruct o)
constructObjectParent val = B.Properties.constructObjectPropertyObject "parent" (Just val)

{- |
Set the value of the “@parent@” 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' #parent
@
-}
clearObjectParent :: (MonadIO m, IsObject o) => o -> m ()
clearObjectParent obj = liftIO $ B.Properties.setObjectPropertyObject obj "parent" (Nothing :: Maybe Object)

#if ENABLE_OVERLOADING
data ObjectParentPropertyInfo
instance AttrInfo ObjectParentPropertyInfo where
    type AttrAllowedOps ObjectParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectParentPropertyInfo = IsObject
    type AttrBaseTypeConstraint ObjectParentPropertyInfo = IsObject
    type AttrGetType ObjectParentPropertyInfo = (Maybe Object)
    type AttrLabel ObjectParentPropertyInfo = "parent"
    type AttrOrigin ObjectParentPropertyInfo = Object
    attrGet _ = getObjectParent
    attrSet _ = setObjectParent
    attrConstruct _ = constructObjectParent
    attrClear _ = clearObjectParent
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList Object
type instance O.AttributeList Object = ObjectAttributeList
type ObjectAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
objectName :: AttrLabelProxy "name"
objectName = AttrLabelProxy

objectParent :: AttrLabelProxy "parent"
objectParent = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data ObjectDeepNotifySignalInfo
instance SignalInfo ObjectDeepNotifySignalInfo where
    type HaskellCallbackType ObjectDeepNotifySignalInfo = ObjectDeepNotifyCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ObjectDeepNotifyCallback cb
        cb'' <- mk_ObjectDeepNotifyCallback cb'
        connectSignalFunPtr obj "deep-notify" cb'' connectMode

type instance O.SignalList Object = ObjectSignalList
type ObjectSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Object::add_control_binding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the controller object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface (Name {namespace = "Gst", name = "ControlBinding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstControlBinding that should be used", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_add_control_binding" gst_object_add_control_binding ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    Ptr Gst.ControlBinding.ControlBinding -> -- binding : TInterface (Name {namespace = "Gst", name = "ControlBinding"})
    IO CInt

{- |
Attach the 'GI.Gst.Objects.ControlBinding.ControlBinding' to the object. If there already was a
'GI.Gst.Objects.ControlBinding.ControlBinding' for this property it will be replaced.

The object\'s reference count will be incremented, and any floating
reference will be removed (see @/gst_object_ref_sink()/@)
-}
objectAddControlBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, Gst.ControlBinding.IsControlBinding b) =>
    a
    {- ^ /@object@/: the controller object -}
    -> b
    {- ^ /@binding@/: the 'GI.Gst.Objects.ControlBinding.ControlBinding' that should be used -}
    -> m Bool
    {- ^ __Returns:__ 'False' if the given /@binding@/ has not been setup for this object or
has been setup for a non suitable property, 'True' otherwise. -}
objectAddControlBinding object binding = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    binding' <- unsafeManagedPtrCastPtr binding
    result <- gst_object_add_control_binding object' binding'
    let result' = (/= 0) result
    touchManagedPtr object
    touchManagedPtr binding
    return result'

#if ENABLE_OVERLOADING
data ObjectAddControlBindingMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsObject a, Gst.ControlBinding.IsControlBinding b) => O.MethodInfo ObjectAddControlBindingMethodInfo a signature where
    overloadedMethod _ = objectAddControlBinding

#endif

-- method Object::default_error
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "source", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstObject that initiated the error.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the GError.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an additional debug information string, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_default_error" gst_object_default_error ::
    Ptr Object ->                           -- source : TInterface (Name {namespace = "Gst", name = "Object"})
    Ptr GError ->                           -- error : TError
    CString ->                              -- debug : TBasicType TUTF8
    IO ()

{- |
A default error function that uses @/g_printerr()/@ to display the error message
and the optional debug string..

The default handler will simply print the error string using g_print.
-}
objectDefaultError ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@source@/: the 'GI.Gst.Objects.Object.Object' that initiated the error. -}
    -> GError
    {- ^ /@error@/: the GError. -}
    -> Maybe (T.Text)
    {- ^ /@debug@/: an additional debug information string, or 'Nothing' -}
    -> m ()
objectDefaultError source error_ debug = liftIO $ do
    source' <- unsafeManagedPtrCastPtr source
    error_' <- unsafeManagedPtrGetPtr error_
    maybeDebug <- case debug of
        Nothing -> return nullPtr
        Just jDebug -> do
            jDebug' <- textToCString jDebug
            return jDebug'
    gst_object_default_error source' error_' maybeDebug
    touchManagedPtr source
    touchManagedPtr error_
    freeMem maybeDebug
    return ()

#if ENABLE_OVERLOADING
data ObjectDefaultErrorMethodInfo
instance (signature ~ (GError -> Maybe (T.Text) -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectDefaultErrorMethodInfo a signature where
    overloadedMethod _ = objectDefaultError

#endif

-- method Object::get_control_binding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "ControlBinding"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_get_control_binding" gst_object_get_control_binding ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO (Ptr Gst.ControlBinding.ControlBinding)

{- |
Gets the corresponding 'GI.Gst.Objects.ControlBinding.ControlBinding' for the property. This should be
unreferenced again after use.
-}
objectGetControlBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object -}
    -> T.Text
    {- ^ /@propertyName@/: name of the property -}
    -> m (Maybe Gst.ControlBinding.ControlBinding)
    {- ^ __Returns:__ the 'GI.Gst.Objects.ControlBinding.ControlBinding' for
/@propertyName@/ or 'Nothing' if the property is not controlled. -}
objectGetControlBinding object propertyName = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    propertyName' <- textToCString propertyName
    result <- gst_object_get_control_binding object' propertyName'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject Gst.ControlBinding.ControlBinding) result'
        return result''
    touchManagedPtr object
    freeMem propertyName'
    return maybeResult

#if ENABLE_OVERLOADING
data ObjectGetControlBindingMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.ControlBinding.ControlBinding)), MonadIO m, IsObject a) => O.MethodInfo ObjectGetControlBindingMethodInfo a signature where
    overloadedMethod _ = objectGetControlBinding

#endif

-- method Object::get_control_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object that has controlled properties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_get_control_rate" gst_object_get_control_rate ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    IO Word64

{- |
Obtain the control-rate for this /@object@/. Audio processing 'GI.Gst.Objects.Element.Element'
objects will use this rate to sub-divide their processing loop and call
'GI.Gst.Objects.Object.objectSyncValues' in between. The length of the processing segment
should be up to /@control@/-rate nanoseconds.

If the /@object@/ is not under property control, this will return
'GI.Gst.Constants.CLOCK_TIME_NONE'. This allows the element to avoid the sub-dividing.

The control-rate is not expected to change if the element is in
'GI.Gst.Enums.StatePaused' or 'GI.Gst.Enums.StatePlaying'.
-}
objectGetControlRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object that has controlled properties -}
    -> m Word64
    {- ^ __Returns:__ the control rate in nanoseconds -}
objectGetControlRate object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    result <- gst_object_get_control_rate object'
    touchManagedPtr object
    return result

#if ENABLE_OVERLOADING
data ObjectGetControlRateMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsObject a) => O.MethodInfo ObjectGetControlRateMethodInfo a signature where
    overloadedMethod _ = objectGetControlRate

#endif

-- method Object::get_g_value_array
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object that has controlled properties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the property to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the time that should be processed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the time spacing between subsequent values", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of values", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "values", argType = TCArray False (-1) 4 (TInterface (Name {namespace = "GObject", name = "Value"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "array to put control-values in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "n_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of values", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_get_g_value_array" gst_object_get_g_value_array ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    CString ->                              -- property_name : TBasicType TUTF8
    Word64 ->                               -- timestamp : TBasicType TUInt64
    Word64 ->                               -- interval : TBasicType TUInt64
    Word32 ->                               -- n_values : TBasicType TUInt
    Ptr GValue ->                           -- values : TCArray False (-1) 4 (TInterface (Name {namespace = "GObject", name = "Value"}))
    IO CInt

{- |
Gets a number of @/GValues/@ for the given controlled property starting at the
requested time. The array /@values@/ need to hold enough space for /@nValues@/ of
'GI.GObject.Structs.Value.Value'.

This function is useful if one wants to e.g. draw a graph of the control
curve or apply a control curve sample by sample.
-}
objectGetGValueArray ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object that has controlled properties -}
    -> T.Text
    {- ^ /@propertyName@/: the name of the property to get -}
    -> Word64
    {- ^ /@timestamp@/: the time that should be processed -}
    -> Word64
    {- ^ /@interval@/: the time spacing between subsequent values -}
    -> [GValue]
    {- ^ /@values@/: array to put control-values in -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the given array could be filled, 'False' otherwise -}
objectGetGValueArray object propertyName timestamp interval values = liftIO $ do
    let nValues = fromIntegral $ length values
    object' <- unsafeManagedPtrCastPtr object
    propertyName' <- textToCString propertyName
    values' <- mapM unsafeManagedPtrGetPtr values
    values'' <- packBlockArray 24 values'
    result <- gst_object_get_g_value_array object' propertyName' timestamp interval nValues values''
    let result' = (/= 0) result
    touchManagedPtr object
    mapM_ touchManagedPtr values
    freeMem propertyName'
    freeMem values''
    return result'

#if ENABLE_OVERLOADING
data ObjectGetGValueArrayMethodInfo
instance (signature ~ (T.Text -> Word64 -> Word64 -> [GValue] -> m Bool), MonadIO m, IsObject a) => O.MethodInfo ObjectGetGValueArrayMethodInfo a signature where
    overloadedMethod _ = objectGetGValueArray

#endif

-- method Object::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_get_name" gst_object_get_name ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    IO CString

{- |
Returns a copy of the name of /@object@/.
Caller should 'GI.GLib.Functions.free' the return value after usage.
For a nameless object, this returns 'Nothing', which you can safely 'GI.GLib.Functions.free'
as well.

Free-function: g_free
-}
objectGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the name of /@object@/. 'GI.GLib.Functions.free'
after usage.

MT safe. This function grabs and releases /@object@/\'s LOCK. -}
objectGetName object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    result <- gst_object_get_name object'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        freeMem result'
        return result''
    touchManagedPtr object
    return maybeResult

#if ENABLE_OVERLOADING
data ObjectGetNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsObject a) => O.MethodInfo ObjectGetNameMethodInfo a signature where
    overloadedMethod _ = objectGetName

#endif

-- method Object::get_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Object"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_get_parent" gst_object_get_parent ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    IO (Ptr Object)

{- |
Returns the parent of /@object@/. This function increases the refcount
of the parent object so you should 'GI.Gst.Objects.Object.objectUnref' it after usage.
-}
objectGetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' -}
    -> m (Maybe Object)
    {- ^ __Returns:__ parent of /@object@/, this can be
  'Nothing' if /@object@/ has no parent. unref after usage.

MT safe. Grabs and releases /@object@/\'s LOCK. -}
objectGetParent object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    result <- gst_object_get_parent object'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject Object) result'
        return result''
    touchManagedPtr object
    return maybeResult

#if ENABLE_OVERLOADING
data ObjectGetParentMethodInfo
instance (signature ~ (m (Maybe Object)), MonadIO m, IsObject a) => O.MethodInfo ObjectGetParentMethodInfo a signature where
    overloadedMethod _ = objectGetParent

#endif

-- method Object::get_path_string
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_get_path_string" gst_object_get_path_string ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    IO CString

{- |
Generates a string describing the path of /@object@/ in
the object hierarchy. Only useful (or used) for debugging.

Free-function: g_free
-}
objectGetPathString ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' -}
    -> m T.Text
    {- ^ __Returns:__ a string describing the path of /@object@/. You must
         'GI.GLib.Functions.free' the string after usage.

MT safe. Grabs and releases the 'GI.Gst.Objects.Object.Object'\'s LOCK for all objects
         in the hierarchy. -}
objectGetPathString object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    result <- gst_object_get_path_string object'
    checkUnexpectedReturnNULL "objectGetPathString" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr object
    return result'

#if ENABLE_OVERLOADING
data ObjectGetPathStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.MethodInfo ObjectGetPathStringMethodInfo a signature where
    overloadedMethod _ = objectGetPathString

#endif

-- method Object::get_value
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object that has controlled properties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the property to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the time the control-change should be read from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_get_value" gst_object_get_value ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    CString ->                              -- property_name : TBasicType TUTF8
    Word64 ->                               -- timestamp : TBasicType TUInt64
    IO (Ptr GValue)

{- |
Gets the value for the given controlled property at the requested time.
-}
objectGetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object that has controlled properties -}
    -> T.Text
    {- ^ /@propertyName@/: the name of the property to get -}
    -> Word64
    {- ^ /@timestamp@/: the time the control-change should be read from -}
    -> m (Maybe GValue)
    {- ^ __Returns:__ the GValue of the property at the given time,
or 'Nothing' if the property isn\'t controlled. -}
objectGetValue object propertyName timestamp = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    propertyName' <- textToCString propertyName
    result <- gst_object_get_value object' propertyName' timestamp
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed GValue) result'
        return result''
    touchManagedPtr object
    freeMem propertyName'
    return maybeResult

#if ENABLE_OVERLOADING
data ObjectGetValueMethodInfo
instance (signature ~ (T.Text -> Word64 -> m (Maybe GValue)), MonadIO m, IsObject a) => O.MethodInfo ObjectGetValueMethodInfo a signature where
    overloadedMethod _ = objectGetValue

#endif

-- method Object::has_active_control_bindings
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object that has controlled properties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_has_active_control_bindings" gst_object_has_active_control_bindings ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    IO CInt

{- |
Check if the /@object@/ has active controlled properties.
-}
objectHasActiveControlBindings ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object that has controlled properties -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the object has active controlled properties -}
objectHasActiveControlBindings object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    result <- gst_object_has_active_control_bindings object'
    let result' = (/= 0) result
    touchManagedPtr object
    return result'

#if ENABLE_OVERLOADING
data ObjectHasActiveControlBindingsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsObject a) => O.MethodInfo ObjectHasActiveControlBindingsMethodInfo a signature where
    overloadedMethod _ = objectHasActiveControlBindings

#endif

-- method Object::has_ancestor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ancestor", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject to check as ancestor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_has_ancestor" gst_object_has_ancestor ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    Ptr Object ->                           -- ancestor : TInterface (Name {namespace = "Gst", name = "Object"})
    IO CInt

{-# DEPRECATED objectHasAncestor ["Use 'GI.Gst.Objects.Object.objectHasAsAncestor' instead.","","MT safe. Grabs and releases /@object@/\\'s locks."] #-}
{- |
Check if /@object@/ has an ancestor /@ancestor@/ somewhere up in
the hierarchy. One can e.g. check if a 'GI.Gst.Objects.Element.Element' is inside a 'GI.Gst.Objects.Pipeline.Pipeline'.
-}
objectHasAncestor ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' to check -}
    -> b
    {- ^ /@ancestor@/: a 'GI.Gst.Objects.Object.Object' to check as ancestor -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@ancestor@/ is an ancestor of /@object@/. -}
objectHasAncestor object ancestor = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    ancestor' <- unsafeManagedPtrCastPtr ancestor
    result <- gst_object_has_ancestor object' ancestor'
    let result' = (/= 0) result
    touchManagedPtr object
    touchManagedPtr ancestor
    return result'

#if ENABLE_OVERLOADING
data ObjectHasAncestorMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectHasAncestorMethodInfo a signature where
    overloadedMethod _ = objectHasAncestor

#endif

-- method Object::has_as_ancestor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ancestor", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject to check as ancestor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_has_as_ancestor" gst_object_has_as_ancestor ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    Ptr Object ->                           -- ancestor : TInterface (Name {namespace = "Gst", name = "Object"})
    IO CInt

{- |
Check if /@object@/ has an ancestor /@ancestor@/ somewhere up in
the hierarchy. One can e.g. check if a 'GI.Gst.Objects.Element.Element' is inside a 'GI.Gst.Objects.Pipeline.Pipeline'.
-}
objectHasAsAncestor ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' to check -}
    -> b
    {- ^ /@ancestor@/: a 'GI.Gst.Objects.Object.Object' to check as ancestor -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@ancestor@/ is an ancestor of /@object@/.

MT safe. Grabs and releases /@object@/\'s locks. -}
objectHasAsAncestor object ancestor = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    ancestor' <- unsafeManagedPtrCastPtr ancestor
    result <- gst_object_has_as_ancestor object' ancestor'
    let result' = (/= 0) result
    touchManagedPtr object
    touchManagedPtr ancestor
    return result'

#if ENABLE_OVERLOADING
data ObjectHasAsAncestorMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectHasAsAncestorMethodInfo a signature where
    overloadedMethod _ = objectHasAsAncestor

#endif

-- method Object::has_as_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject to check as parent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_has_as_parent" gst_object_has_as_parent ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    Ptr Object ->                           -- parent : TInterface (Name {namespace = "Gst", name = "Object"})
    IO CInt

{- |
Check if /@parent@/ is the parent of /@object@/.
E.g. a 'GI.Gst.Objects.Element.Element' can check if it owns a given 'GI.Gst.Objects.Pad.Pad'.

/Since: 1.6/
-}
objectHasAsParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' to check -}
    -> b
    {- ^ /@parent@/: a 'GI.Gst.Objects.Object.Object' to check as parent -}
    -> m Bool
    {- ^ __Returns:__ 'False' if either /@object@/ or /@parent@/ is 'Nothing'. 'True' if /@parent@/ is
         the parent of /@object@/. Otherwise 'False'.

MT safe. Grabs and releases /@object@/\'s locks. -}
objectHasAsParent object parent = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    parent' <- unsafeManagedPtrCastPtr parent
    result <- gst_object_has_as_parent object' parent'
    let result' = (/= 0) result
    touchManagedPtr object
    touchManagedPtr parent
    return result'

#if ENABLE_OVERLOADING
data ObjectHasAsParentMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectHasAsParentMethodInfo a signature where
    overloadedMethod _ = objectHasAsParent

#endif

-- method Object::ref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject to reference", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Object"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_ref" gst_object_ref ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    IO (Ptr Object)

{- |
Increments the reference count on /@object@/. This function
does not take the lock on /@object@/ because it relies on
atomic refcounting.

This object returns the input parameter to ease writing
constructs like :
 result = gst_object_ref (object->parent);
-}
objectRef ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' to reference -}
    -> m Object
    {- ^ __Returns:__ A pointer to /@object@/ -}
objectRef object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    result <- gst_object_ref object'
    checkUnexpectedReturnNULL "objectRef" result
    result' <- (wrapObject Object) result
    touchManagedPtr object
    return result'

#if ENABLE_OVERLOADING
data ObjectRefMethodInfo
instance (signature ~ (m Object), MonadIO m, IsObject a) => O.MethodInfo ObjectRefMethodInfo a signature where
    overloadedMethod _ = objectRef

#endif

-- method Object::remove_control_binding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface (Name {namespace = "Gst", name = "ControlBinding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the binding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_remove_control_binding" gst_object_remove_control_binding ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    Ptr Gst.ControlBinding.ControlBinding -> -- binding : TInterface (Name {namespace = "Gst", name = "ControlBinding"})
    IO CInt

{- |
Removes the corresponding 'GI.Gst.Objects.ControlBinding.ControlBinding'. If it was the
last ref of the binding, it will be disposed.
-}
objectRemoveControlBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, Gst.ControlBinding.IsControlBinding b) =>
    a
    {- ^ /@object@/: the object -}
    -> b
    {- ^ /@binding@/: the binding -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the binding could be removed. -}
objectRemoveControlBinding object binding = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    binding' <- unsafeManagedPtrCastPtr binding
    result <- gst_object_remove_control_binding object' binding'
    let result' = (/= 0) result
    touchManagedPtr object
    touchManagedPtr binding
    return result'

#if ENABLE_OVERLOADING
data ObjectRemoveControlBindingMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsObject a, Gst.ControlBinding.IsControlBinding b) => O.MethodInfo ObjectRemoveControlBindingMethodInfo a signature where
    overloadedMethod _ = objectRemoveControlBinding

#endif

-- method Object::set_control_binding_disabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object that has controlled properties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "property to disable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "boolean that specifies whether to disable the controller\nor not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_set_control_binding_disabled" gst_object_set_control_binding_disabled ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    CString ->                              -- property_name : TBasicType TUTF8
    CInt ->                                 -- disabled : TBasicType TBoolean
    IO ()

{- |
This function is used to disable the control bindings on a property for
some time, i.e. 'GI.Gst.Objects.Object.objectSyncValues' will do nothing for the
property.
-}
objectSetControlBindingDisabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object that has controlled properties -}
    -> T.Text
    {- ^ /@propertyName@/: property to disable -}
    -> Bool
    {- ^ /@disabled@/: boolean that specifies whether to disable the controller
or not. -}
    -> m ()
objectSetControlBindingDisabled object propertyName disabled = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    propertyName' <- textToCString propertyName
    let disabled' = (fromIntegral . fromEnum) disabled
    gst_object_set_control_binding_disabled object' propertyName' disabled'
    touchManagedPtr object
    freeMem propertyName'
    return ()

#if ENABLE_OVERLOADING
data ObjectSetControlBindingDisabledMethodInfo
instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetControlBindingDisabledMethodInfo a signature where
    overloadedMethod _ = objectSetControlBindingDisabled

#endif

-- method Object::set_control_bindings_disabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object that has controlled properties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "boolean that specifies whether to disable the controller\nor not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_set_control_bindings_disabled" gst_object_set_control_bindings_disabled ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    CInt ->                                 -- disabled : TBasicType TBoolean
    IO ()

{- |
This function is used to disable all controlled properties of the /@object@/ for
some time, i.e. 'GI.Gst.Objects.Object.objectSyncValues' will do nothing.
-}
objectSetControlBindingsDisabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object that has controlled properties -}
    -> Bool
    {- ^ /@disabled@/: boolean that specifies whether to disable the controller
or not. -}
    -> m ()
objectSetControlBindingsDisabled object disabled = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    let disabled' = (fromIntegral . fromEnum) disabled
    gst_object_set_control_bindings_disabled object' disabled'
    touchManagedPtr object
    return ()

#if ENABLE_OVERLOADING
data ObjectSetControlBindingsDisabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetControlBindingsDisabledMethodInfo a signature where
    overloadedMethod _ = objectSetControlBindingsDisabled

#endif

-- method Object::set_control_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object that has controlled properties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "control_rate", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new control-rate in nanoseconds.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_set_control_rate" gst_object_set_control_rate ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    Word64 ->                               -- control_rate : TBasicType TUInt64
    IO ()

{- |
Change the control-rate for this /@object@/. Audio processing 'GI.Gst.Objects.Element.Element'
objects will use this rate to sub-divide their processing loop and call
'GI.Gst.Objects.Object.objectSyncValues' in between. The length of the processing segment
should be up to /@control@/-rate nanoseconds.

The control-rate should not change if the element is in 'GI.Gst.Enums.StatePaused' or
'GI.Gst.Enums.StatePlaying'.
-}
objectSetControlRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object that has controlled properties -}
    -> Word64
    {- ^ /@controlRate@/: the new control-rate in nanoseconds. -}
    -> m ()
objectSetControlRate object controlRate = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    gst_object_set_control_rate object' controlRate
    touchManagedPtr object
    return ()

#if ENABLE_OVERLOADING
data ObjectSetControlRateMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetControlRateMethodInfo a signature where
    overloadedMethod _ = objectSetControlRate

#endif

-- method Object::set_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "new name of object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_set_name" gst_object_set_name ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    CString ->                              -- name : TBasicType TUTF8
    IO CInt

{- |
Sets the name of /@object@/, or gives /@object@/ a guaranteed unique
name (if /@name@/ is 'Nothing').
This function makes a copy of the provided name, so the caller
retains ownership of the name it sent.
-}
objectSetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' -}
    -> Maybe (T.Text)
    {- ^ /@name@/: new name of object -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the name could be set. Since Objects that have
a parent cannot be renamed, this function returns 'False' in those
cases.

MT safe.  This function grabs and releases /@object@/\'s LOCK. -}
objectSetName object name = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    maybeName <- case name of
        Nothing -> return nullPtr
        Just jName -> do
            jName' <- textToCString jName
            return jName'
    result <- gst_object_set_name object' maybeName
    let result' = (/= 0) result
    touchManagedPtr object
    freeMem maybeName
    return result'

#if ENABLE_OVERLOADING
data ObjectSetNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m, IsObject a) => O.MethodInfo ObjectSetNameMethodInfo a signature where
    overloadedMethod _ = objectSetName

#endif

-- method Object::set_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new parent of object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_set_parent" gst_object_set_parent ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    Ptr Object ->                           -- parent : TInterface (Name {namespace = "Gst", name = "Object"})
    IO CInt

{- |
Sets the parent of /@object@/ to /@parent@/. The object\'s reference count will
be incremented, and any floating reference will be removed (see @/gst_object_ref_sink()/@).
-}
objectSetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' -}
    -> b
    {- ^ /@parent@/: new parent of object -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@parent@/ could be set or 'False' when /@object@/
already had a parent or /@object@/ and /@parent@/ are the same.

MT safe. Grabs and releases /@object@/\'s LOCK. -}
objectSetParent object parent = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    parent' <- unsafeManagedPtrCastPtr parent
    result <- gst_object_set_parent object' parent'
    let result' = (/= 0) result
    touchManagedPtr object
    touchManagedPtr parent
    return result'

#if ENABLE_OVERLOADING
data ObjectSetParentMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectSetParentMethodInfo a signature where
    overloadedMethod _ = objectSetParent

#endif

-- method Object::suggest_next_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object that has controlled properties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_suggest_next_sync" gst_object_suggest_next_sync ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    IO Word64

{- |
Returns a suggestion for timestamps where buffers should be split
to get best controller results.
-}
objectSuggestNextSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object that has controlled properties -}
    -> m Word64
    {- ^ __Returns:__ Returns the suggested timestamp or 'GI.Gst.Constants.CLOCK_TIME_NONE'
if no control-rate was set. -}
objectSuggestNextSync object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    result <- gst_object_suggest_next_sync object'
    touchManagedPtr object
    return result

#if ENABLE_OVERLOADING
data ObjectSuggestNextSyncMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsObject a) => O.MethodInfo ObjectSuggestNextSyncMethodInfo a signature where
    overloadedMethod _ = objectSuggestNextSync

#endif

-- method Object::sync_values
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object that has controlled properties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the time that should be processed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_sync_values" gst_object_sync_values ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    Word64 ->                               -- timestamp : TBasicType TUInt64
    IO CInt

{- |
Sets the properties of the object, according to the @/GstControlSources/@ that
(maybe) handle them and for the given timestamp.

If this function fails, it is most likely the application developers fault.
Most probably the control sources are not setup correctly.
-}
objectSyncValues ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: the object that has controlled properties -}
    -> Word64
    {- ^ /@timestamp@/: the time that should be processed -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the controller values could be applied to the object
properties, 'False' otherwise -}
objectSyncValues object timestamp = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    result <- gst_object_sync_values object' timestamp
    let result' = (/= 0) result
    touchManagedPtr object
    return result'

#if ENABLE_OVERLOADING
data ObjectSyncValuesMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsObject a) => O.MethodInfo ObjectSyncValuesMethodInfo a signature where
    overloadedMethod _ = objectSyncValues

#endif

-- method Object::unparent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject to unparent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_unparent" gst_object_unparent ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    IO ()

{- |
Clear the parent of /@object@/, removing the associated reference.
This function decreases the refcount of /@object@/.

MT safe. Grabs and releases /@object@/\'s lock.
-}
objectUnparent ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' to unparent -}
    -> m ()
objectUnparent object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    gst_object_unparent object'
    touchManagedPtr object
    return ()

#if ENABLE_OVERLOADING
data ObjectUnparentMethodInfo
instance (signature ~ (m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectUnparentMethodInfo a signature where
    overloadedMethod _ = objectUnparent

#endif

-- method Object::unref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject to unreference", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_unref" gst_object_unref ::
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Gst", name = "Object"})
    IO ()

{- |
Decrements the reference count on /@object@/.  If reference count hits
zero, destroy /@object@/. This function does not take the lock
on /@object@/ as it relies on atomic refcounting.

The unref method should never be called with the LOCK held since
this might deadlock the dispose function.
-}
objectUnref ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@object@/: a 'GI.Gst.Objects.Object.Object' to unreference -}
    -> m ()
objectUnref object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    gst_object_unref object'
    touchManagedPtr object
    return ()

#if ENABLE_OVERLOADING
data ObjectUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectUnrefMethodInfo a signature where
    overloadedMethod _ = objectUnref

#endif

-- method Object::check_uniqueness
-- method type : MemberFunction
-- Args : [Arg {argCName = "list", argType = TGList (TInterface (Name {namespace = "Gst", name = "Object"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a list of #GstObject to\n     check through", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name to search for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_check_uniqueness" gst_object_check_uniqueness ::
    Ptr (GList (Ptr Object)) ->             -- list : TGList (TInterface (Name {namespace = "Gst", name = "Object"}))
    CString ->                              -- name : TBasicType TUTF8
    IO CInt

{- |
Checks to see if there is any object named /@name@/ in /@list@/. This function
does not do any locking of any kind. You might want to protect the
provided list with the lock of the owner of the list. This function
will lock each 'GI.Gst.Objects.Object.Object' in the list to compare the name, so be
careful when passing a list with a locked object.
-}
objectCheckUniqueness ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    [a]
    {- ^ /@list@/: a list of 'GI.Gst.Objects.Object.Object' to
     check through -}
    -> T.Text
    {- ^ /@name@/: the name to search for -}
    -> m Bool
    {- ^ __Returns:__ 'True' if a 'GI.Gst.Objects.Object.Object' named /@name@/ does not appear in /@list@/,
'False' if it does.

MT safe. Grabs and releases the LOCK of each object in the list. -}
objectCheckUniqueness list name = liftIO $ do
    list' <- mapM unsafeManagedPtrCastPtr list
    list'' <- packGList list'
    name' <- textToCString name
    result <- gst_object_check_uniqueness list'' name'
    let result' = (/= 0) result
    mapM_ touchManagedPtr list
    g_list_free list''
    freeMem name'
    return result'

#if ENABLE_OVERLOADING
#endif

-- method Object::default_deep_notify
-- method type : MemberFunction
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GObject that signalled the notify.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orig", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstObject that initiated the notify.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GParamSpec of the property.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "excluded_props", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\n    a set of user-specified properties to exclude or %NULL to show\n    all changes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_default_deep_notify" gst_object_default_deep_notify ::
    Ptr GObject.Object.Object ->            -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr Object ->                           -- orig : TInterface (Name {namespace = "Gst", name = "Object"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    Ptr CString ->                          -- excluded_props : TCArray True (-1) (-1) (TBasicType TUTF8)
    IO ()

{- |
A default deep_notify signal callback for an object. The user data
should contain a pointer to an array of strings that should be excluded
from the notify. The default handler will print the new value of the property
using g_print.

MT safe. This function grabs and releases /@object@/\'s LOCK for getting its
         path string.
-}
objectDefaultDeepNotify ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a, IsObject b) =>
    a
    {- ^ /@object@/: the 'GI.GObject.Objects.Object.Object' that signalled the notify. -}
    -> b
    {- ^ /@orig@/: a 'GI.Gst.Objects.Object.Object' that initiated the notify. -}
    -> GParamSpec
    {- ^ /@pspec@/: a 'GI.GObject.Objects.ParamSpec.ParamSpec' of the property. -}
    -> Maybe ([T.Text])
    {- ^ /@excludedProps@/: 
    a set of user-specified properties to exclude or 'Nothing' to show
    all changes. -}
    -> m ()
objectDefaultDeepNotify object orig pspec excludedProps = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    orig' <- unsafeManagedPtrCastPtr orig
    pspec' <- unsafeManagedPtrGetPtr pspec
    maybeExcludedProps <- case excludedProps of
        Nothing -> return nullPtr
        Just jExcludedProps -> do
            jExcludedProps' <- packZeroTerminatedUTF8CArray jExcludedProps
            return jExcludedProps'
    gst_object_default_deep_notify object' orig' pspec' maybeExcludedProps
    touchManagedPtr object
    touchManagedPtr orig
    touchManagedPtr pspec
    mapZeroTerminatedCArray freeMem maybeExcludedProps
    freeMem maybeExcludedProps
    return ()

#if ENABLE_OVERLOADING
#endif

-- method Object::replace
-- method type : MemberFunction
-- Args : [Arg {argCName = "oldobj", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionInout, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointer to a place of\n    a #GstObject to replace", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "newobj", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a new #GstObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_object_replace" gst_object_replace ::
    Ptr (Ptr Object) ->                     -- oldobj : TInterface (Name {namespace = "Gst", name = "Object"})
    Ptr Object ->                           -- newobj : TInterface (Name {namespace = "Gst", name = "Object"})
    IO CInt

{- |
Atomically modifies a pointer to point to a new object.
The reference count of /@oldobj@/ is decreased and the reference count of
/@newobj@/ is increased.

Either /@newobj@/ and the value pointed to by /@oldobj@/ may be 'Nothing'.
-}
objectReplace ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    Maybe (a)
    {- ^ /@oldobj@/: pointer to a place of
    a 'GI.Gst.Objects.Object.Object' to replace -}
    -> Maybe (b)
    {- ^ /@newobj@/: a new 'GI.Gst.Objects.Object.Object' -}
    -> m ((Bool, Maybe Object))
    {- ^ __Returns:__ 'True' if /@newobj@/ was different from /@oldobj@/ -}
objectReplace oldobj newobj = liftIO $ do
    maybeOldobj <- case oldobj of
        Nothing -> return nullPtr
        Just jOldobj -> do
            jOldobj' <- B.ManagedPtr.disownObject jOldobj
            return jOldobj'
    maybeOldobj' <- allocMem :: IO (Ptr (Ptr Object))
    poke maybeOldobj' maybeOldobj
    maybeNewobj <- case newobj of
        Nothing -> return nullPtr
        Just jNewobj -> do
            jNewobj' <- unsafeManagedPtrCastPtr jNewobj
            return jNewobj'
    result <- gst_object_replace maybeOldobj' maybeNewobj
    let result' = (/= 0) result
    maybeOldobj'' <- peek maybeOldobj'
    maybeMaybeOldobj'' <- convertIfNonNull maybeOldobj'' $ \maybeOldobj''' -> do
        maybeOldobj'''' <- (wrapObject Object) maybeOldobj'''
        return maybeOldobj''''
    whenJust oldobj touchManagedPtr
    whenJust newobj touchManagedPtr
    freeMem maybeOldobj'
    return (result', maybeMaybeOldobj'')

#if ENABLE_OVERLOADING
#endif