{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Element interface that allows setting of media metadata.
-- 
-- Elements that support changing a stream\'s metadata will implement this
-- interface. Examples of such elements are \'vorbisenc\', \'theoraenc\' and
-- \'id3v2mux\'.
-- 
-- If you just want to retrieve metadata in your application then all you
-- need to do is watch for tag messages on your pipeline\'s bus. This
-- interface is only for setting metadata, not for extracting it. To set tags
-- from the application, find tagsetter elements and set tags using e.g.
-- 'GI.Gst.Interfaces.TagSetter.tagSetterMergeTags' or @/gst_tag_setter_add_tags()/@. Also consider
-- setting the t'GI.Gst.Enums.TagMergeMode' that is used for tag events that arrive at the
-- tagsetter element (default mode is to keep existing tags).
-- The application should do that before the element goes to 'GI.Gst.Enums.StatePaused'.
-- 
-- Elements implementing the t'GI.Gst.Interfaces.TagSetter.TagSetter' interface often have to merge
-- any tags received from upstream and the tags set by the application via
-- the interface. This can be done like this:
-- 
-- 
-- === /C code/
-- >
-- >GstTagMergeMode merge_mode;
-- >const GstTagList *application_tags;
-- >const GstTagList *event_tags;
-- >GstTagSetter *tagsetter;
-- >GstTagList *result;
-- >
-- >tagsetter = GST_TAG_SETTER (element);
-- >
-- >merge_mode = gst_tag_setter_get_tag_merge_mode (tagsetter);
-- >application_tags = gst_tag_setter_get_tag_list (tagsetter);
-- >event_tags = (const GstTagList *) element->event_tags;
-- >
-- >GST_LOG_OBJECT (tagsetter, "merging tags, merge mode = %d", merge_mode);
-- >GST_LOG_OBJECT (tagsetter, "event tags: %" GST_PTR_FORMAT, event_tags);
-- >GST_LOG_OBJECT (tagsetter, "set   tags: %" GST_PTR_FORMAT, application_tags);
-- >
-- >result = gst_tag_list_merge (application_tags, event_tags, merge_mode);
-- >
-- >GST_LOG_OBJECT (tagsetter, "final tags: %" GST_PTR_FORMAT, result);
-- 

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

module GI.Gst.Interfaces.TagSetter
    ( 

-- * Exported types
    TagSetter(..)                           ,
    IsTagSetter                             ,
    toTagSetter                             ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveTagSetterMethod                  ,
#endif


-- ** addTagValue #method:addTagValue#

#if defined(ENABLE_OVERLOADING)
    TagSetterAddTagValueMethodInfo          ,
#endif
    tagSetterAddTagValue                    ,


-- ** getTagList #method:getTagList#

#if defined(ENABLE_OVERLOADING)
    TagSetterGetTagListMethodInfo           ,
#endif
    tagSetterGetTagList                     ,


-- ** getTagMergeMode #method:getTagMergeMode#

#if defined(ENABLE_OVERLOADING)
    TagSetterGetTagMergeModeMethodInfo      ,
#endif
    tagSetterGetTagMergeMode                ,


-- ** mergeTags #method:mergeTags#

#if defined(ENABLE_OVERLOADING)
    TagSetterMergeTagsMethodInfo            ,
#endif
    tagSetterMergeTags                      ,


-- ** resetTags #method:resetTags#

#if defined(ENABLE_OVERLOADING)
    TagSetterResetTagsMethodInfo            ,
#endif
    tagSetterResetTags                      ,


-- ** setTagMergeMode #method:setTagMergeMode#

#if defined(ENABLE_OVERLOADING)
    TagSetterSetTagMergeModeMethodInfo      ,
#endif
    tagSetterSetTagMergeMode                ,




    ) 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
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Objects.Element as Gst.Element
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Structs.TagList as Gst.TagList

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

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

foreign import ccall "gst_tag_setter_get_type"
    c_gst_tag_setter_get_type :: IO B.Types.GType

instance B.Types.TypedObject TagSetter where
    glibType :: IO GType
glibType = IO GType
c_gst_tag_setter_get_type

instance B.Types.GObject TagSetter

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

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

instance O.HasParentTypes TagSetter
type instance O.ParentTypes TagSetter = '[Gst.Element.Element, Gst.Object.Object, GObject.Object.Object]

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

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveTagSetterMethod (t :: Symbol) (o :: *) :: * where
    ResolveTagSetterMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo
    ResolveTagSetterMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveTagSetterMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo
    ResolveTagSetterMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo
    ResolveTagSetterMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo
    ResolveTagSetterMethod "addTagValue" o = TagSetterAddTagValueMethodInfo
    ResolveTagSetterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTagSetterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTagSetterMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo
    ResolveTagSetterMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo
    ResolveTagSetterMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo
    ResolveTagSetterMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo
    ResolveTagSetterMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveTagSetterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTagSetterMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo
    ResolveTagSetterMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo
    ResolveTagSetterMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo
    ResolveTagSetterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTagSetterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTagSetterMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveTagSetterMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveTagSetterMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveTagSetterMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveTagSetterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTagSetterMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo
    ResolveTagSetterMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo
    ResolveTagSetterMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo
    ResolveTagSetterMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo
    ResolveTagSetterMethod "link" o = Gst.Element.ElementLinkMethodInfo
    ResolveTagSetterMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo
    ResolveTagSetterMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo
    ResolveTagSetterMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo
    ResolveTagSetterMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo
    ResolveTagSetterMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo
    ResolveTagSetterMethod "mergeTags" o = TagSetterMergeTagsMethodInfo
    ResolveTagSetterMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo
    ResolveTagSetterMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo
    ResolveTagSetterMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo
    ResolveTagSetterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTagSetterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTagSetterMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo
    ResolveTagSetterMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo
    ResolveTagSetterMethod "query" o = Gst.Element.ElementQueryMethodInfo
    ResolveTagSetterMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo
    ResolveTagSetterMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo
    ResolveTagSetterMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo
    ResolveTagSetterMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveTagSetterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTagSetterMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo
    ResolveTagSetterMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveTagSetterMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo
    ResolveTagSetterMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo
    ResolveTagSetterMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo
    ResolveTagSetterMethod "resetTags" o = TagSetterResetTagsMethodInfo
    ResolveTagSetterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTagSetterMethod "seek" o = Gst.Element.ElementSeekMethodInfo
    ResolveTagSetterMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo
    ResolveTagSetterMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo
    ResolveTagSetterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTagSetterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTagSetterMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveTagSetterMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo
    ResolveTagSetterMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveTagSetterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTagSetterMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo
    ResolveTagSetterMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo
    ResolveTagSetterMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveTagSetterMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveTagSetterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTagSetterMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo
    ResolveTagSetterMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo
    ResolveTagSetterMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo
    ResolveTagSetterMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo
    ResolveTagSetterMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo
    ResolveTagSetterMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo
    ResolveTagSetterMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo
    ResolveTagSetterMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo
    ResolveTagSetterMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveTagSetterMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveTagSetterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTagSetterMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo
    ResolveTagSetterMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveTagSetterMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo
    ResolveTagSetterMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveTagSetterMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo
    ResolveTagSetterMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo
    ResolveTagSetterMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveTagSetterMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveTagSetterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTagSetterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTagSetterMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo
    ResolveTagSetterMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo
    ResolveTagSetterMethod "getState" o = Gst.Element.ElementGetStateMethodInfo
    ResolveTagSetterMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo
    ResolveTagSetterMethod "getTagList" o = TagSetterGetTagListMethodInfo
    ResolveTagSetterMethod "getTagMergeMode" o = TagSetterGetTagMergeModeMethodInfo
    ResolveTagSetterMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveTagSetterMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo
    ResolveTagSetterMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo
    ResolveTagSetterMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo
    ResolveTagSetterMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo
    ResolveTagSetterMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveTagSetterMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveTagSetterMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveTagSetterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTagSetterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTagSetterMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo
    ResolveTagSetterMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveTagSetterMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveTagSetterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTagSetterMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo
    ResolveTagSetterMethod "setState" o = Gst.Element.ElementSetStateMethodInfo
    ResolveTagSetterMethod "setTagMergeMode" o = TagSetterSetTagMergeModeMethodInfo
    ResolveTagSetterMethod l o = O.MethodResolutionFailed l o

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

#endif

-- method TagSetter::add_tag_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setter"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TagSetter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstTagSetter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TagMergeMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the mode to use" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "tag to set" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GValue to set for the tag"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_tag_setter_add_tag_value" gst_tag_setter_add_tag_value :: 
    Ptr TagSetter ->                        -- setter : TInterface (Name {namespace = "Gst", name = "TagSetter"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Gst", name = "TagMergeMode"})
    CString ->                              -- tag : TBasicType TUTF8
    Ptr GValue ->                           -- value : TGValue
    IO ()

-- | Adds the given tag \/ GValue pair on the setter using the given merge mode.
tagSetterAddTagValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsTagSetter a) =>
    a
    -- ^ /@setter@/: a t'GI.Gst.Interfaces.TagSetter.TagSetter'
    -> Gst.Enums.TagMergeMode
    -- ^ /@mode@/: the mode to use
    -> T.Text
    -- ^ /@tag@/: tag to set
    -> GValue
    -- ^ /@value@/: GValue to set for the tag
    -> m ()
tagSetterAddTagValue :: a -> TagMergeMode -> Text -> GValue -> m ()
tagSetterAddTagValue a
setter TagMergeMode
mode Text
tag GValue
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TagSetter
setter' <- a -> IO (Ptr TagSetter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setter
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TagMergeMode -> Int) -> TagMergeMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TagMergeMode -> Int
forall a. Enum a => a -> Int
fromEnum) TagMergeMode
mode
    CString
tag' <- Text -> IO CString
textToCString Text
tag
    Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    Ptr TagSetter -> CUInt -> CString -> Ptr GValue -> IO ()
gst_tag_setter_add_tag_value Ptr TagSetter
setter' CUInt
mode' CString
tag' Ptr GValue
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setter
    GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
    Ptr GValue -> IO ()
B.GValue.unsetGValue Ptr GValue
value'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TagSetterAddTagValueMethodInfo
instance (signature ~ (Gst.Enums.TagMergeMode -> T.Text -> GValue -> m ()), MonadIO m, IsTagSetter a) => O.MethodInfo TagSetterAddTagValueMethodInfo a signature where
    overloadedMethod = tagSetterAddTagValue

#endif

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

foreign import ccall "gst_tag_setter_get_tag_list" gst_tag_setter_get_tag_list :: 
    Ptr TagSetter ->                        -- setter : TInterface (Name {namespace = "Gst", name = "TagSetter"})
    IO (Ptr Gst.TagList.TagList)

-- | Returns the current list of tags the setter uses.  The list should not be
-- modified or freed.
-- 
-- This function is not thread-safe.
tagSetterGetTagList ::
    (B.CallStack.HasCallStack, MonadIO m, IsTagSetter a) =>
    a
    -- ^ /@setter@/: a t'GI.Gst.Interfaces.TagSetter.TagSetter'
    -> m (Maybe Gst.TagList.TagList)
    -- ^ __Returns:__ a current snapshot of the
    --          taglist used in the setter or 'P.Nothing' if none is used.
tagSetterGetTagList :: a -> m (Maybe TagList)
tagSetterGetTagList a
setter = IO (Maybe TagList) -> m (Maybe TagList)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TagList) -> m (Maybe TagList))
-> IO (Maybe TagList) -> m (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TagSetter
setter' <- a -> IO (Ptr TagSetter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setter
    Ptr TagList
result <- Ptr TagSetter -> IO (Ptr TagList)
gst_tag_setter_get_tag_list Ptr TagSetter
setter'
    Maybe TagList
maybeResult <- Ptr TagList -> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TagList
result ((Ptr TagList -> IO TagList) -> IO (Maybe TagList))
-> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
result' -> do
        TagList
result'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result'
        TagList -> IO TagList
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setter
    Maybe TagList -> IO (Maybe TagList)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TagList
maybeResult

#if defined(ENABLE_OVERLOADING)
data TagSetterGetTagListMethodInfo
instance (signature ~ (m (Maybe Gst.TagList.TagList)), MonadIO m, IsTagSetter a) => O.MethodInfo TagSetterGetTagListMethodInfo a signature where
    overloadedMethod = tagSetterGetTagList

#endif

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

foreign import ccall "gst_tag_setter_get_tag_merge_mode" gst_tag_setter_get_tag_merge_mode :: 
    Ptr TagSetter ->                        -- setter : TInterface (Name {namespace = "Gst", name = "TagSetter"})
    IO CUInt

-- | Queries the mode by which tags inside the setter are overwritten by tags
-- from events
tagSetterGetTagMergeMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTagSetter a) =>
    a
    -- ^ /@setter@/: a t'GI.Gst.Interfaces.TagSetter.TagSetter'
    -> m Gst.Enums.TagMergeMode
    -- ^ __Returns:__ the merge mode used inside the element.
tagSetterGetTagMergeMode :: a -> m TagMergeMode
tagSetterGetTagMergeMode a
setter = IO TagMergeMode -> m TagMergeMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TagMergeMode -> m TagMergeMode)
-> IO TagMergeMode -> m TagMergeMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr TagSetter
setter' <- a -> IO (Ptr TagSetter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setter
    CUInt
result <- Ptr TagSetter -> IO CUInt
gst_tag_setter_get_tag_merge_mode Ptr TagSetter
setter'
    let result' :: TagMergeMode
result' = (Int -> TagMergeMode
forall a. Enum a => Int -> a
toEnum (Int -> TagMergeMode) -> (CUInt -> Int) -> CUInt -> TagMergeMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setter
    TagMergeMode -> IO TagMergeMode
forall (m :: * -> *) a. Monad m => a -> m a
return TagMergeMode
result'

#if defined(ENABLE_OVERLOADING)
data TagSetterGetTagMergeModeMethodInfo
instance (signature ~ (m Gst.Enums.TagMergeMode), MonadIO m, IsTagSetter a) => O.MethodInfo TagSetterGetTagMergeModeMethodInfo a signature where
    overloadedMethod = tagSetterGetTagMergeMode

#endif

-- method TagSetter::merge_tags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setter"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TagSetter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstTagSetter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "list"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TagList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tag list to merge from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TagMergeMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the mode to merge with"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_tag_setter_merge_tags" gst_tag_setter_merge_tags :: 
    Ptr TagSetter ->                        -- setter : TInterface (Name {namespace = "Gst", name = "TagSetter"})
    Ptr Gst.TagList.TagList ->              -- list : TInterface (Name {namespace = "Gst", name = "TagList"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Gst", name = "TagMergeMode"})
    IO ()

-- | Merges the given list into the setter\'s list using the given mode.
tagSetterMergeTags ::
    (B.CallStack.HasCallStack, MonadIO m, IsTagSetter a) =>
    a
    -- ^ /@setter@/: a t'GI.Gst.Interfaces.TagSetter.TagSetter'
    -> Gst.TagList.TagList
    -- ^ /@list@/: a tag list to merge from
    -> Gst.Enums.TagMergeMode
    -- ^ /@mode@/: the mode to merge with
    -> m ()
tagSetterMergeTags :: a -> TagList -> TagMergeMode -> m ()
tagSetterMergeTags a
setter TagList
list TagMergeMode
mode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TagSetter
setter' <- a -> IO (Ptr TagSetter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setter
    Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TagMergeMode -> Int) -> TagMergeMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TagMergeMode -> Int
forall a. Enum a => a -> Int
fromEnum) TagMergeMode
mode
    Ptr TagSetter -> Ptr TagList -> CUInt -> IO ()
gst_tag_setter_merge_tags Ptr TagSetter
setter' Ptr TagList
list' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setter
    TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TagSetterMergeTagsMethodInfo
instance (signature ~ (Gst.TagList.TagList -> Gst.Enums.TagMergeMode -> m ()), MonadIO m, IsTagSetter a) => O.MethodInfo TagSetterMergeTagsMethodInfo a signature where
    overloadedMethod = tagSetterMergeTags

#endif

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

foreign import ccall "gst_tag_setter_reset_tags" gst_tag_setter_reset_tags :: 
    Ptr TagSetter ->                        -- setter : TInterface (Name {namespace = "Gst", name = "TagSetter"})
    IO ()

-- | Reset the internal taglist. Elements should call this from within the
-- state-change handler.
tagSetterResetTags ::
    (B.CallStack.HasCallStack, MonadIO m, IsTagSetter a) =>
    a
    -- ^ /@setter@/: a t'GI.Gst.Interfaces.TagSetter.TagSetter'
    -> m ()
tagSetterResetTags :: a -> m ()
tagSetterResetTags a
setter = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TagSetter
setter' <- a -> IO (Ptr TagSetter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setter
    Ptr TagSetter -> IO ()
gst_tag_setter_reset_tags Ptr TagSetter
setter'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TagSetterResetTagsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTagSetter a) => O.MethodInfo TagSetterResetTagsMethodInfo a signature where
    overloadedMethod = tagSetterResetTags

#endif

-- method TagSetter::set_tag_merge_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "setter"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TagSetter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstTagSetter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TagMergeMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The mode with which tags are added"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_tag_setter_set_tag_merge_mode" gst_tag_setter_set_tag_merge_mode :: 
    Ptr TagSetter ->                        -- setter : TInterface (Name {namespace = "Gst", name = "TagSetter"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Gst", name = "TagMergeMode"})
    IO ()

-- | Sets the given merge mode that is used for adding tags from events to tags
-- specified by this interface. The default is @/GST_TAG_MERGE_KEEP/@, which keeps
-- the tags set with this interface and discards tags from events.
tagSetterSetTagMergeMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTagSetter a) =>
    a
    -- ^ /@setter@/: a t'GI.Gst.Interfaces.TagSetter.TagSetter'
    -> Gst.Enums.TagMergeMode
    -- ^ /@mode@/: The mode with which tags are added
    -> m ()
tagSetterSetTagMergeMode :: a -> TagMergeMode -> m ()
tagSetterSetTagMergeMode a
setter TagMergeMode
mode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TagSetter
setter' <- a -> IO (Ptr TagSetter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setter
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TagMergeMode -> Int) -> TagMergeMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TagMergeMode -> Int
forall a. Enum a => a -> Int
fromEnum) TagMergeMode
mode
    Ptr TagSetter -> CUInt -> IO ()
gst_tag_setter_set_tag_merge_mode Ptr TagSetter
setter' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TagSetterSetTagMergeModeMethodInfo
instance (signature ~ (Gst.Enums.TagMergeMode -> m ()), MonadIO m, IsTagSetter a) => O.MethodInfo TagSetterSetTagMergeModeMethodInfo a signature where
    overloadedMethod = tagSetterSetTagMergeMode

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TagSetter = TagSetterSignalList
type TagSetterSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])

#endif