DOMMediaController.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.WebKit.Objects.DOMMediaController
    ( 

-- * Exported types
    DOMMediaController(..)                  ,
    DOMMediaControllerK                     ,
    toDOMMediaController                    ,
    noDOMMediaController                    ,


 -- * Methods
-- ** dOMMediaControllerGetBuffered
    dOMMediaControllerGetBuffered           ,


-- ** dOMMediaControllerGetCurrentTime
    dOMMediaControllerGetCurrentTime        ,


-- ** dOMMediaControllerGetDefaultPlaybackRate
    dOMMediaControllerGetDefaultPlaybackRate,


-- ** dOMMediaControllerGetDuration
    dOMMediaControllerGetDuration           ,


-- ** dOMMediaControllerGetMuted
    dOMMediaControllerGetMuted              ,


-- ** dOMMediaControllerGetPaused
    dOMMediaControllerGetPaused             ,


-- ** dOMMediaControllerGetPlaybackRate
    dOMMediaControllerGetPlaybackRate       ,


-- ** dOMMediaControllerGetPlaybackState
    dOMMediaControllerGetPlaybackState      ,


-- ** dOMMediaControllerGetPlayed
    dOMMediaControllerGetPlayed             ,


-- ** dOMMediaControllerGetSeekable
    dOMMediaControllerGetSeekable           ,


-- ** dOMMediaControllerGetVolume
    dOMMediaControllerGetVolume             ,


-- ** dOMMediaControllerPause
    dOMMediaControllerPause                 ,


-- ** dOMMediaControllerPlay
    dOMMediaControllerPlay                  ,


-- ** dOMMediaControllerSetCurrentTime
    dOMMediaControllerSetCurrentTime        ,


-- ** dOMMediaControllerSetDefaultPlaybackRate
    dOMMediaControllerSetDefaultPlaybackRate,


-- ** dOMMediaControllerSetMuted
    dOMMediaControllerSetMuted              ,


-- ** dOMMediaControllerSetPlaybackRate
    dOMMediaControllerSetPlaybackRate       ,


-- ** dOMMediaControllerSetVolume
    dOMMediaControllerSetVolume             ,


-- ** dOMMediaControllerUnpause
    dOMMediaControllerUnpause               ,




 -- * Properties
-- ** Buffered
    DOMMediaControllerBufferedPropertyInfo  ,
    getDOMMediaControllerBuffered           ,


-- ** CurrentTime
    DOMMediaControllerCurrentTimePropertyInfo,
    constructDOMMediaControllerCurrentTime  ,
    getDOMMediaControllerCurrentTime        ,
    setDOMMediaControllerCurrentTime        ,


-- ** DefaultPlaybackRate
    DOMMediaControllerDefaultPlaybackRatePropertyInfo,
    constructDOMMediaControllerDefaultPlaybackRate,
    getDOMMediaControllerDefaultPlaybackRate,
    setDOMMediaControllerDefaultPlaybackRate,


-- ** Duration
    DOMMediaControllerDurationPropertyInfo  ,
    getDOMMediaControllerDuration           ,


-- ** Muted
    DOMMediaControllerMutedPropertyInfo     ,
    constructDOMMediaControllerMuted        ,
    getDOMMediaControllerMuted              ,
    setDOMMediaControllerMuted              ,


-- ** Paused
    DOMMediaControllerPausedPropertyInfo    ,
    getDOMMediaControllerPaused             ,


-- ** PlaybackRate
    DOMMediaControllerPlaybackRatePropertyInfo,
    constructDOMMediaControllerPlaybackRate ,
    getDOMMediaControllerPlaybackRate       ,
    setDOMMediaControllerPlaybackRate       ,


-- ** PlaybackState
    DOMMediaControllerPlaybackStatePropertyInfo,
    getDOMMediaControllerPlaybackState      ,


-- ** Played
    DOMMediaControllerPlayedPropertyInfo    ,
    getDOMMediaControllerPlayed             ,


-- ** Seekable
    DOMMediaControllerSeekablePropertyInfo  ,
    getDOMMediaControllerSeekable           ,


-- ** Volume
    DOMMediaControllerVolumePropertyInfo    ,
    constructDOMMediaControllerVolume       ,
    getDOMMediaControllerVolume             ,
    setDOMMediaControllerVolume             ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.WebKit.Types
import GI.WebKit.Callbacks
import qualified GI.GObject as GObject

newtype DOMMediaController = DOMMediaController (ForeignPtr DOMMediaController)
foreign import ccall "webkit_dom_media_controller_get_type"
    c_webkit_dom_media_controller_get_type :: IO GType

type instance ParentTypes DOMMediaController = DOMMediaControllerParentTypes
type DOMMediaControllerParentTypes = '[DOMObject, GObject.Object, DOMEventTarget]

instance GObject DOMMediaController where
    gobjectIsInitiallyUnowned _ = False
    gobjectType _ = c_webkit_dom_media_controller_get_type
    

class GObject o => DOMMediaControllerK o
instance (GObject o, IsDescendantOf DOMMediaController o) => DOMMediaControllerK o

toDOMMediaController :: DOMMediaControllerK o => o -> IO DOMMediaController
toDOMMediaController = unsafeCastTo DOMMediaController

noDOMMediaController :: Maybe DOMMediaController
noDOMMediaController = Nothing

-- VVV Prop "buffered"
   -- Type: TInterface "WebKit" "DOMTimeRanges"
   -- Flags: [PropertyReadable]

getDOMMediaControllerBuffered :: (MonadIO m, DOMMediaControllerK o) => o -> m DOMTimeRanges
getDOMMediaControllerBuffered obj = liftIO $ getObjectPropertyObject obj "buffered" DOMTimeRanges

data DOMMediaControllerBufferedPropertyInfo
instance AttrInfo DOMMediaControllerBufferedPropertyInfo where
    type AttrAllowedOps DOMMediaControllerBufferedPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerBufferedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMMediaControllerBufferedPropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerBufferedPropertyInfo = DOMTimeRanges
    type AttrLabel DOMMediaControllerBufferedPropertyInfo = "DOMMediaController::buffered"
    attrGet _ = getDOMMediaControllerBuffered
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "current-time"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]

getDOMMediaControllerCurrentTime :: (MonadIO m, DOMMediaControllerK o) => o -> m Double
getDOMMediaControllerCurrentTime obj = liftIO $ getObjectPropertyDouble obj "current-time"

setDOMMediaControllerCurrentTime :: (MonadIO m, DOMMediaControllerK o) => o -> Double -> m ()
setDOMMediaControllerCurrentTime obj val = liftIO $ setObjectPropertyDouble obj "current-time" val

constructDOMMediaControllerCurrentTime :: Double -> IO ([Char], GValue)
constructDOMMediaControllerCurrentTime val = constructObjectPropertyDouble "current-time" val

data DOMMediaControllerCurrentTimePropertyInfo
instance AttrInfo DOMMediaControllerCurrentTimePropertyInfo where
    type AttrAllowedOps DOMMediaControllerCurrentTimePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerCurrentTimePropertyInfo = (~) Double
    type AttrBaseTypeConstraint DOMMediaControllerCurrentTimePropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerCurrentTimePropertyInfo = Double
    type AttrLabel DOMMediaControllerCurrentTimePropertyInfo = "DOMMediaController::current-time"
    attrGet _ = getDOMMediaControllerCurrentTime
    attrSet _ = setDOMMediaControllerCurrentTime
    attrConstruct _ = constructDOMMediaControllerCurrentTime

-- VVV Prop "default-playback-rate"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]

getDOMMediaControllerDefaultPlaybackRate :: (MonadIO m, DOMMediaControllerK o) => o -> m Double
getDOMMediaControllerDefaultPlaybackRate obj = liftIO $ getObjectPropertyDouble obj "default-playback-rate"

setDOMMediaControllerDefaultPlaybackRate :: (MonadIO m, DOMMediaControllerK o) => o -> Double -> m ()
setDOMMediaControllerDefaultPlaybackRate obj val = liftIO $ setObjectPropertyDouble obj "default-playback-rate" val

constructDOMMediaControllerDefaultPlaybackRate :: Double -> IO ([Char], GValue)
constructDOMMediaControllerDefaultPlaybackRate val = constructObjectPropertyDouble "default-playback-rate" val

data DOMMediaControllerDefaultPlaybackRatePropertyInfo
instance AttrInfo DOMMediaControllerDefaultPlaybackRatePropertyInfo where
    type AttrAllowedOps DOMMediaControllerDefaultPlaybackRatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerDefaultPlaybackRatePropertyInfo = (~) Double
    type AttrBaseTypeConstraint DOMMediaControllerDefaultPlaybackRatePropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerDefaultPlaybackRatePropertyInfo = Double
    type AttrLabel DOMMediaControllerDefaultPlaybackRatePropertyInfo = "DOMMediaController::default-playback-rate"
    attrGet _ = getDOMMediaControllerDefaultPlaybackRate
    attrSet _ = setDOMMediaControllerDefaultPlaybackRate
    attrConstruct _ = constructDOMMediaControllerDefaultPlaybackRate

-- VVV Prop "duration"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable]

getDOMMediaControllerDuration :: (MonadIO m, DOMMediaControllerK o) => o -> m Double
getDOMMediaControllerDuration obj = liftIO $ getObjectPropertyDouble obj "duration"

data DOMMediaControllerDurationPropertyInfo
instance AttrInfo DOMMediaControllerDurationPropertyInfo where
    type AttrAllowedOps DOMMediaControllerDurationPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerDurationPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMMediaControllerDurationPropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerDurationPropertyInfo = Double
    type AttrLabel DOMMediaControllerDurationPropertyInfo = "DOMMediaController::duration"
    attrGet _ = getDOMMediaControllerDuration
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "muted"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]

getDOMMediaControllerMuted :: (MonadIO m, DOMMediaControllerK o) => o -> m Bool
getDOMMediaControllerMuted obj = liftIO $ getObjectPropertyBool obj "muted"

setDOMMediaControllerMuted :: (MonadIO m, DOMMediaControllerK o) => o -> Bool -> m ()
setDOMMediaControllerMuted obj val = liftIO $ setObjectPropertyBool obj "muted" val

constructDOMMediaControllerMuted :: Bool -> IO ([Char], GValue)
constructDOMMediaControllerMuted val = constructObjectPropertyBool "muted" val

data DOMMediaControllerMutedPropertyInfo
instance AttrInfo DOMMediaControllerMutedPropertyInfo where
    type AttrAllowedOps DOMMediaControllerMutedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerMutedPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMMediaControllerMutedPropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerMutedPropertyInfo = Bool
    type AttrLabel DOMMediaControllerMutedPropertyInfo = "DOMMediaController::muted"
    attrGet _ = getDOMMediaControllerMuted
    attrSet _ = setDOMMediaControllerMuted
    attrConstruct _ = constructDOMMediaControllerMuted

-- VVV Prop "paused"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]

getDOMMediaControllerPaused :: (MonadIO m, DOMMediaControllerK o) => o -> m Bool
getDOMMediaControllerPaused obj = liftIO $ getObjectPropertyBool obj "paused"

data DOMMediaControllerPausedPropertyInfo
instance AttrInfo DOMMediaControllerPausedPropertyInfo where
    type AttrAllowedOps DOMMediaControllerPausedPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerPausedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMMediaControllerPausedPropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerPausedPropertyInfo = Bool
    type AttrLabel DOMMediaControllerPausedPropertyInfo = "DOMMediaController::paused"
    attrGet _ = getDOMMediaControllerPaused
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "playback-rate"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]

getDOMMediaControllerPlaybackRate :: (MonadIO m, DOMMediaControllerK o) => o -> m Double
getDOMMediaControllerPlaybackRate obj = liftIO $ getObjectPropertyDouble obj "playback-rate"

setDOMMediaControllerPlaybackRate :: (MonadIO m, DOMMediaControllerK o) => o -> Double -> m ()
setDOMMediaControllerPlaybackRate obj val = liftIO $ setObjectPropertyDouble obj "playback-rate" val

constructDOMMediaControllerPlaybackRate :: Double -> IO ([Char], GValue)
constructDOMMediaControllerPlaybackRate val = constructObjectPropertyDouble "playback-rate" val

data DOMMediaControllerPlaybackRatePropertyInfo
instance AttrInfo DOMMediaControllerPlaybackRatePropertyInfo where
    type AttrAllowedOps DOMMediaControllerPlaybackRatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerPlaybackRatePropertyInfo = (~) Double
    type AttrBaseTypeConstraint DOMMediaControllerPlaybackRatePropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerPlaybackRatePropertyInfo = Double
    type AttrLabel DOMMediaControllerPlaybackRatePropertyInfo = "DOMMediaController::playback-rate"
    attrGet _ = getDOMMediaControllerPlaybackRate
    attrSet _ = setDOMMediaControllerPlaybackRate
    attrConstruct _ = constructDOMMediaControllerPlaybackRate

-- VVV Prop "playback-state"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]

getDOMMediaControllerPlaybackState :: (MonadIO m, DOMMediaControllerK o) => o -> m T.Text
getDOMMediaControllerPlaybackState obj = liftIO $ getObjectPropertyString obj "playback-state"

data DOMMediaControllerPlaybackStatePropertyInfo
instance AttrInfo DOMMediaControllerPlaybackStatePropertyInfo where
    type AttrAllowedOps DOMMediaControllerPlaybackStatePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerPlaybackStatePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMMediaControllerPlaybackStatePropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerPlaybackStatePropertyInfo = T.Text
    type AttrLabel DOMMediaControllerPlaybackStatePropertyInfo = "DOMMediaController::playback-state"
    attrGet _ = getDOMMediaControllerPlaybackState
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "played"
   -- Type: TInterface "WebKit" "DOMTimeRanges"
   -- Flags: [PropertyReadable]

getDOMMediaControllerPlayed :: (MonadIO m, DOMMediaControllerK o) => o -> m DOMTimeRanges
getDOMMediaControllerPlayed obj = liftIO $ getObjectPropertyObject obj "played" DOMTimeRanges

data DOMMediaControllerPlayedPropertyInfo
instance AttrInfo DOMMediaControllerPlayedPropertyInfo where
    type AttrAllowedOps DOMMediaControllerPlayedPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerPlayedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMMediaControllerPlayedPropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerPlayedPropertyInfo = DOMTimeRanges
    type AttrLabel DOMMediaControllerPlayedPropertyInfo = "DOMMediaController::played"
    attrGet _ = getDOMMediaControllerPlayed
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "seekable"
   -- Type: TInterface "WebKit" "DOMTimeRanges"
   -- Flags: [PropertyReadable]

getDOMMediaControllerSeekable :: (MonadIO m, DOMMediaControllerK o) => o -> m DOMTimeRanges
getDOMMediaControllerSeekable obj = liftIO $ getObjectPropertyObject obj "seekable" DOMTimeRanges

data DOMMediaControllerSeekablePropertyInfo
instance AttrInfo DOMMediaControllerSeekablePropertyInfo where
    type AttrAllowedOps DOMMediaControllerSeekablePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerSeekablePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMMediaControllerSeekablePropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerSeekablePropertyInfo = DOMTimeRanges
    type AttrLabel DOMMediaControllerSeekablePropertyInfo = "DOMMediaController::seekable"
    attrGet _ = getDOMMediaControllerSeekable
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "volume"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]

getDOMMediaControllerVolume :: (MonadIO m, DOMMediaControllerK o) => o -> m Double
getDOMMediaControllerVolume obj = liftIO $ getObjectPropertyDouble obj "volume"

setDOMMediaControllerVolume :: (MonadIO m, DOMMediaControllerK o) => o -> Double -> m ()
setDOMMediaControllerVolume obj val = liftIO $ setObjectPropertyDouble obj "volume" val

constructDOMMediaControllerVolume :: Double -> IO ([Char], GValue)
constructDOMMediaControllerVolume val = constructObjectPropertyDouble "volume" val

data DOMMediaControllerVolumePropertyInfo
instance AttrInfo DOMMediaControllerVolumePropertyInfo where
    type AttrAllowedOps DOMMediaControllerVolumePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMMediaControllerVolumePropertyInfo = (~) Double
    type AttrBaseTypeConstraint DOMMediaControllerVolumePropertyInfo = DOMMediaControllerK
    type AttrGetType DOMMediaControllerVolumePropertyInfo = Double
    type AttrLabel DOMMediaControllerVolumePropertyInfo = "DOMMediaController::volume"
    attrGet _ = getDOMMediaControllerVolume
    attrSet _ = setDOMMediaControllerVolume
    attrConstruct _ = constructDOMMediaControllerVolume

type instance AttributeList DOMMediaController = DOMMediaControllerAttributeList
type DOMMediaControllerAttributeList = ('[ '("buffered", DOMMediaControllerBufferedPropertyInfo), '("core-object", DOMObjectCoreObjectPropertyInfo), '("current-time", DOMMediaControllerCurrentTimePropertyInfo), '("default-playback-rate", DOMMediaControllerDefaultPlaybackRatePropertyInfo), '("duration", DOMMediaControllerDurationPropertyInfo), '("muted", DOMMediaControllerMutedPropertyInfo), '("paused", DOMMediaControllerPausedPropertyInfo), '("playback-rate", DOMMediaControllerPlaybackRatePropertyInfo), '("playback-state", DOMMediaControllerPlaybackStatePropertyInfo), '("played", DOMMediaControllerPlayedPropertyInfo), '("seekable", DOMMediaControllerSeekablePropertyInfo), '("volume", DOMMediaControllerVolumePropertyInfo)] :: [(Symbol, *)])

type instance SignalList DOMMediaController = DOMMediaControllerSignalList
type DOMMediaControllerSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method DOMMediaController::get_buffered
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "DOMTimeRanges"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_buffered" webkit_dom_media_controller_get_buffered :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO (Ptr DOMTimeRanges)


dOMMediaControllerGetBuffered ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m DOMTimeRanges
dOMMediaControllerGetBuffered _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_buffered _obj'
    checkUnexpectedReturnNULL "webkit_dom_media_controller_get_buffered" result
    result' <- (wrapObject DOMTimeRanges) result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_current_time
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TDouble
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_current_time" webkit_dom_media_controller_get_current_time :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO CDouble


dOMMediaControllerGetCurrentTime ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m Double
dOMMediaControllerGetCurrentTime _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_current_time _obj'
    let result' = realToFrac result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_default_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TDouble
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_default_playback_rate" webkit_dom_media_controller_get_default_playback_rate :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO CDouble


dOMMediaControllerGetDefaultPlaybackRate ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m Double
dOMMediaControllerGetDefaultPlaybackRate _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_default_playback_rate _obj'
    let result' = realToFrac result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_duration
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TDouble
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_duration" webkit_dom_media_controller_get_duration :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO CDouble


dOMMediaControllerGetDuration ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m Double
dOMMediaControllerGetDuration _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_duration _obj'
    let result' = realToFrac result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_muted
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_muted" webkit_dom_media_controller_get_muted :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO CInt


dOMMediaControllerGetMuted ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m Bool
dOMMediaControllerGetMuted _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_muted _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_paused
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_paused" webkit_dom_media_controller_get_paused :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO CInt


dOMMediaControllerGetPaused ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m Bool
dOMMediaControllerGetPaused _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_paused _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TDouble
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_playback_rate" webkit_dom_media_controller_get_playback_rate :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO CDouble


dOMMediaControllerGetPlaybackRate ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m Double
dOMMediaControllerGetPlaybackRate _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_playback_rate _obj'
    let result' = realToFrac result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_playback_state
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_playback_state" webkit_dom_media_controller_get_playback_state :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO CString


dOMMediaControllerGetPlaybackState ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m T.Text
dOMMediaControllerGetPlaybackState _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_playback_state _obj'
    checkUnexpectedReturnNULL "webkit_dom_media_controller_get_playback_state" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_played
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "DOMTimeRanges"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_played" webkit_dom_media_controller_get_played :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO (Ptr DOMTimeRanges)


dOMMediaControllerGetPlayed ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m DOMTimeRanges
dOMMediaControllerGetPlayed _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_played _obj'
    checkUnexpectedReturnNULL "webkit_dom_media_controller_get_played" result
    result' <- (wrapObject DOMTimeRanges) result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_seekable
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "DOMTimeRanges"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_seekable" webkit_dom_media_controller_get_seekable :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO (Ptr DOMTimeRanges)


dOMMediaControllerGetSeekable ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m DOMTimeRanges
dOMMediaControllerGetSeekable _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_seekable _obj'
    checkUnexpectedReturnNULL "webkit_dom_media_controller_get_seekable" result
    result' <- (wrapObject DOMTimeRanges) result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::get_volume
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TDouble
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_volume" webkit_dom_media_controller_get_volume :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO CDouble


dOMMediaControllerGetVolume ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m Double
dOMMediaControllerGetVolume _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_dom_media_controller_get_volume _obj'
    let result' = realToFrac result
    touchManagedPtr _obj
    return result'

-- method DOMMediaController::pause
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_pause" webkit_dom_media_controller_pause :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO ()


dOMMediaControllerPause ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m ()
dOMMediaControllerPause _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_dom_media_controller_pause _obj'
    touchManagedPtr _obj
    return ()

-- method DOMMediaController::play
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_play" webkit_dom_media_controller_play :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO ()


dOMMediaControllerPlay ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m ()
dOMMediaControllerPlay _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_dom_media_controller_play _obj'
    touchManagedPtr _obj
    return ()

-- method DOMMediaController::set_current_time
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_set_current_time" webkit_dom_media_controller_set_current_time :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    CDouble ->                              -- value : TBasicType TDouble
    IO ()


dOMMediaControllerSetCurrentTime ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    Double ->                               -- value
    m ()
dOMMediaControllerSetCurrentTime _obj value = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let value' = realToFrac value
    webkit_dom_media_controller_set_current_time _obj' value'
    touchManagedPtr _obj
    return ()

-- method DOMMediaController::set_default_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_set_default_playback_rate" webkit_dom_media_controller_set_default_playback_rate :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    CDouble ->                              -- value : TBasicType TDouble
    IO ()


dOMMediaControllerSetDefaultPlaybackRate ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    Double ->                               -- value
    m ()
dOMMediaControllerSetDefaultPlaybackRate _obj value = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let value' = realToFrac value
    webkit_dom_media_controller_set_default_playback_rate _obj' value'
    touchManagedPtr _obj
    return ()

-- method DOMMediaController::set_muted
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_set_muted" webkit_dom_media_controller_set_muted :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()


dOMMediaControllerSetMuted ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- value
    m ()
dOMMediaControllerSetMuted _obj value = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_media_controller_set_muted _obj' value'
    touchManagedPtr _obj
    return ()

-- method DOMMediaController::set_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_set_playback_rate" webkit_dom_media_controller_set_playback_rate :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    CDouble ->                              -- value : TBasicType TDouble
    IO ()


dOMMediaControllerSetPlaybackRate ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    Double ->                               -- value
    m ()
dOMMediaControllerSetPlaybackRate _obj value = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let value' = realToFrac value
    webkit_dom_media_controller_set_playback_rate _obj' value'
    touchManagedPtr _obj
    return ()

-- method DOMMediaController::set_volume
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_set_volume" webkit_dom_media_controller_set_volume :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    CDouble ->                              -- value : TBasicType TDouble
    Ptr (Ptr GError) ->                     -- error
    IO ()


dOMMediaControllerSetVolume ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    Double ->                               -- value
    m ()
dOMMediaControllerSetVolume _obj value = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let value' = realToFrac value
    onException (do
        propagateGError $ webkit_dom_media_controller_set_volume _obj' value'
        touchManagedPtr _obj
        return ()
     ) (do
        return ()
     )

-- method DOMMediaController::unpause
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "DOMMediaController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_unpause" webkit_dom_media_controller_unpause :: 
    Ptr DOMMediaController ->               -- _obj : TInterface "WebKit" "DOMMediaController"
    IO ()


dOMMediaControllerUnpause ::
    (MonadIO m, DOMMediaControllerK a) =>
    a ->                                    -- _obj
    m ()
dOMMediaControllerUnpause _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_dom_media_controller_unpause _obj'
    touchManagedPtr _obj
    return ()