{- |
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(..)                  ,
    IsDOMMediaController                    ,
    toDOMMediaController                    ,
    noDOMMediaController                    ,


 -- * Methods
-- ** getBuffered #method:getBuffered#
    DOMMediaControllerGetBufferedMethodInfo ,
    dOMMediaControllerGetBuffered           ,


-- ** getCurrentTime #method:getCurrentTime#
    DOMMediaControllerGetCurrentTimeMethodInfo,
    dOMMediaControllerGetCurrentTime        ,


-- ** getDefaultPlaybackRate #method:getDefaultPlaybackRate#
    DOMMediaControllerGetDefaultPlaybackRateMethodInfo,
    dOMMediaControllerGetDefaultPlaybackRate,


-- ** getDuration #method:getDuration#
    DOMMediaControllerGetDurationMethodInfo ,
    dOMMediaControllerGetDuration           ,


-- ** getMuted #method:getMuted#
    DOMMediaControllerGetMutedMethodInfo    ,
    dOMMediaControllerGetMuted              ,


-- ** getPaused #method:getPaused#
    DOMMediaControllerGetPausedMethodInfo   ,
    dOMMediaControllerGetPaused             ,


-- ** getPlaybackRate #method:getPlaybackRate#
    DOMMediaControllerGetPlaybackRateMethodInfo,
    dOMMediaControllerGetPlaybackRate       ,


-- ** getPlaybackState #method:getPlaybackState#
    DOMMediaControllerGetPlaybackStateMethodInfo,
    dOMMediaControllerGetPlaybackState      ,


-- ** getPlayed #method:getPlayed#
    DOMMediaControllerGetPlayedMethodInfo   ,
    dOMMediaControllerGetPlayed             ,


-- ** getSeekable #method:getSeekable#
    DOMMediaControllerGetSeekableMethodInfo ,
    dOMMediaControllerGetSeekable           ,


-- ** getVolume #method:getVolume#
    DOMMediaControllerGetVolumeMethodInfo   ,
    dOMMediaControllerGetVolume             ,


-- ** pause #method:pause#
    DOMMediaControllerPauseMethodInfo       ,
    dOMMediaControllerPause                 ,


-- ** play #method:play#
    DOMMediaControllerPlayMethodInfo        ,
    dOMMediaControllerPlay                  ,


-- ** setCurrentTime #method:setCurrentTime#
    DOMMediaControllerSetCurrentTimeMethodInfo,
    dOMMediaControllerSetCurrentTime        ,


-- ** setDefaultPlaybackRate #method:setDefaultPlaybackRate#
    DOMMediaControllerSetDefaultPlaybackRateMethodInfo,
    dOMMediaControllerSetDefaultPlaybackRate,


-- ** setMuted #method:setMuted#
    DOMMediaControllerSetMutedMethodInfo    ,
    dOMMediaControllerSetMuted              ,


-- ** setPlaybackRate #method:setPlaybackRate#
    DOMMediaControllerSetPlaybackRateMethodInfo,
    dOMMediaControllerSetPlaybackRate       ,


-- ** setVolume #method:setVolume#
    DOMMediaControllerSetVolumeMethodInfo   ,
    dOMMediaControllerSetVolume             ,


-- ** unpause #method:unpause#
    DOMMediaControllerUnpauseMethodInfo     ,
    dOMMediaControllerUnpause               ,




 -- * Properties
-- ** buffered #attr:buffered#
    DOMMediaControllerBufferedPropertyInfo  ,
    dOMMediaControllerBuffered              ,
    getDOMMediaControllerBuffered           ,


-- ** currentTime #attr:currentTime#
    DOMMediaControllerCurrentTimePropertyInfo,
    constructDOMMediaControllerCurrentTime  ,
    dOMMediaControllerCurrentTime           ,
    getDOMMediaControllerCurrentTime        ,
    setDOMMediaControllerCurrentTime        ,


-- ** defaultPlaybackRate #attr:defaultPlaybackRate#
    DOMMediaControllerDefaultPlaybackRatePropertyInfo,
    constructDOMMediaControllerDefaultPlaybackRate,
    dOMMediaControllerDefaultPlaybackRate   ,
    getDOMMediaControllerDefaultPlaybackRate,
    setDOMMediaControllerDefaultPlaybackRate,


-- ** duration #attr:duration#
    DOMMediaControllerDurationPropertyInfo  ,
    dOMMediaControllerDuration              ,
    getDOMMediaControllerDuration           ,


-- ** muted #attr:muted#
    DOMMediaControllerMutedPropertyInfo     ,
    constructDOMMediaControllerMuted        ,
    dOMMediaControllerMuted                 ,
    getDOMMediaControllerMuted              ,
    setDOMMediaControllerMuted              ,


-- ** paused #attr:paused#
    DOMMediaControllerPausedPropertyInfo    ,
    dOMMediaControllerPaused                ,
    getDOMMediaControllerPaused             ,


-- ** playbackRate #attr:playbackRate#
    DOMMediaControllerPlaybackRatePropertyInfo,
    constructDOMMediaControllerPlaybackRate ,
    dOMMediaControllerPlaybackRate          ,
    getDOMMediaControllerPlaybackRate       ,
    setDOMMediaControllerPlaybackRate       ,


-- ** playbackState #attr:playbackState#
    DOMMediaControllerPlaybackStatePropertyInfo,
    dOMMediaControllerPlaybackState         ,
    getDOMMediaControllerPlaybackState      ,


-- ** played #attr:played#
    DOMMediaControllerPlayedPropertyInfo    ,
    dOMMediaControllerPlayed                ,
    getDOMMediaControllerPlayed             ,


-- ** seekable #attr:seekable#
    DOMMediaControllerSeekablePropertyInfo  ,
    dOMMediaControllerSeekable              ,
    getDOMMediaControllerSeekable           ,


-- ** volume #attr:volume#
    DOMMediaControllerVolumePropertyInfo    ,
    constructDOMMediaControllerVolume       ,
    dOMMediaControllerVolume                ,
    getDOMMediaControllerVolume             ,
    setDOMMediaControllerVolume             ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit.Interfaces.DOMEventTarget as WebKit.DOMEventTarget
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMObject as WebKit.DOMObject
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMTimeRanges as WebKit.DOMTimeRanges

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

instance GObject DOMMediaController where
    gobjectType _ = c_webkit_dom_media_controller_get_type
    

class GObject o => IsDOMMediaController o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DOMMediaController a) =>
    IsDOMMediaController a
#endif
instance IsDOMMediaController DOMMediaController
instance WebKit.DOMObject.IsDOMObject DOMMediaController
instance GObject.Object.IsObject DOMMediaController
instance WebKit.DOMEventTarget.IsDOMEventTarget DOMMediaController

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

noDOMMediaController :: Maybe DOMMediaController
noDOMMediaController = Nothing

type family ResolveDOMMediaControllerMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMMediaControllerMethod "addEventListener" o = WebKit.DOMEventTarget.DOMEventTargetAddEventListenerMethodInfo
    ResolveDOMMediaControllerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMMediaControllerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMMediaControllerMethod "dispatchEvent" o = WebKit.DOMEventTarget.DOMEventTargetDispatchEventMethodInfo
    ResolveDOMMediaControllerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMMediaControllerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMMediaControllerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMMediaControllerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMMediaControllerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMMediaControllerMethod "pause" o = DOMMediaControllerPauseMethodInfo
    ResolveDOMMediaControllerMethod "play" o = DOMMediaControllerPlayMethodInfo
    ResolveDOMMediaControllerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMMediaControllerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMMediaControllerMethod "removeEventListener" o = WebKit.DOMEventTarget.DOMEventTargetRemoveEventListenerMethodInfo
    ResolveDOMMediaControllerMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDOMMediaControllerMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDOMMediaControllerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMMediaControllerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMMediaControllerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMMediaControllerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMMediaControllerMethod "unpause" o = DOMMediaControllerUnpauseMethodInfo
    ResolveDOMMediaControllerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMMediaControllerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMMediaControllerMethod "getBuffered" o = DOMMediaControllerGetBufferedMethodInfo
    ResolveDOMMediaControllerMethod "getCurrentTime" o = DOMMediaControllerGetCurrentTimeMethodInfo
    ResolveDOMMediaControllerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMMediaControllerMethod "getDefaultPlaybackRate" o = DOMMediaControllerGetDefaultPlaybackRateMethodInfo
    ResolveDOMMediaControllerMethod "getDuration" o = DOMMediaControllerGetDurationMethodInfo
    ResolveDOMMediaControllerMethod "getMuted" o = DOMMediaControllerGetMutedMethodInfo
    ResolveDOMMediaControllerMethod "getPaused" o = DOMMediaControllerGetPausedMethodInfo
    ResolveDOMMediaControllerMethod "getPlaybackRate" o = DOMMediaControllerGetPlaybackRateMethodInfo
    ResolveDOMMediaControllerMethod "getPlaybackState" o = DOMMediaControllerGetPlaybackStateMethodInfo
    ResolveDOMMediaControllerMethod "getPlayed" o = DOMMediaControllerGetPlayedMethodInfo
    ResolveDOMMediaControllerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMMediaControllerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMMediaControllerMethod "getSeekable" o = DOMMediaControllerGetSeekableMethodInfo
    ResolveDOMMediaControllerMethod "getVolume" o = DOMMediaControllerGetVolumeMethodInfo
    ResolveDOMMediaControllerMethod "setCurrentTime" o = DOMMediaControllerSetCurrentTimeMethodInfo
    ResolveDOMMediaControllerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMMediaControllerMethod "setDefaultPlaybackRate" o = DOMMediaControllerSetDefaultPlaybackRateMethodInfo
    ResolveDOMMediaControllerMethod "setMuted" o = DOMMediaControllerSetMutedMethodInfo
    ResolveDOMMediaControllerMethod "setPlaybackRate" o = DOMMediaControllerSetPlaybackRateMethodInfo
    ResolveDOMMediaControllerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMMediaControllerMethod "setVolume" o = DOMMediaControllerSetVolumeMethodInfo
    ResolveDOMMediaControllerMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDOMMediaControllerMethod t DOMMediaController, O.MethodInfo info DOMMediaController p) => O.IsLabelProxy t (DOMMediaController -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDOMMediaControllerMethod t DOMMediaController, O.MethodInfo info DOMMediaController p) => O.IsLabel t (DOMMediaController -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- VVV Prop "buffered"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMTimeRanges"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMMediaControllerBuffered :: (MonadIO m, IsDOMMediaController o) => o -> m (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
getDOMMediaControllerBuffered obj = liftIO $ getObjectPropertyObject obj "buffered" WebKit.DOMTimeRanges.DOMTimeRanges

data DOMMediaControllerBufferedPropertyInfo
instance AttrInfo DOMMediaControllerBufferedPropertyInfo where
    type AttrAllowedOps DOMMediaControllerBufferedPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMMediaControllerBufferedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMMediaControllerBufferedPropertyInfo = IsDOMMediaController
    type AttrGetType DOMMediaControllerBufferedPropertyInfo = (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
    type AttrLabel DOMMediaControllerBufferedPropertyInfo = "buffered"
    type AttrOrigin DOMMediaControllerBufferedPropertyInfo = DOMMediaController
    attrGet _ = getDOMMediaControllerBuffered
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "current-time"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

constructDOMMediaControllerCurrentTime :: (IsDOMMediaController o) => Double -> IO (GValueConstruct o)
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 = IsDOMMediaController
    type AttrGetType DOMMediaControllerCurrentTimePropertyInfo = Double
    type AttrLabel DOMMediaControllerCurrentTimePropertyInfo = "current-time"
    type AttrOrigin DOMMediaControllerCurrentTimePropertyInfo = DOMMediaController
    attrGet _ = getDOMMediaControllerCurrentTime
    attrSet _ = setDOMMediaControllerCurrentTime
    attrConstruct _ = constructDOMMediaControllerCurrentTime
    attrClear _ = undefined

-- VVV Prop "default-playback-rate"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

constructDOMMediaControllerDefaultPlaybackRate :: (IsDOMMediaController o) => Double -> IO (GValueConstruct o)
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 = IsDOMMediaController
    type AttrGetType DOMMediaControllerDefaultPlaybackRatePropertyInfo = Double
    type AttrLabel DOMMediaControllerDefaultPlaybackRatePropertyInfo = "default-playback-rate"
    type AttrOrigin DOMMediaControllerDefaultPlaybackRatePropertyInfo = DOMMediaController
    attrGet _ = getDOMMediaControllerDefaultPlaybackRate
    attrSet _ = setDOMMediaControllerDefaultPlaybackRate
    attrConstruct _ = constructDOMMediaControllerDefaultPlaybackRate
    attrClear _ = undefined

-- VVV Prop "duration"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMMediaControllerDuration :: (MonadIO m, IsDOMMediaController 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 = IsDOMMediaController
    type AttrGetType DOMMediaControllerDurationPropertyInfo = Double
    type AttrLabel DOMMediaControllerDurationPropertyInfo = "duration"
    type AttrOrigin DOMMediaControllerDurationPropertyInfo = DOMMediaController
    attrGet _ = getDOMMediaControllerDuration
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "muted"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

constructDOMMediaControllerMuted :: (IsDOMMediaController o) => Bool -> IO (GValueConstruct o)
constructDOMMediaControllerMuted val = constructObjectPropertyBool "muted" val

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

-- VVV Prop "paused"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMMediaControllerPaused :: (MonadIO m, IsDOMMediaController 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 = IsDOMMediaController
    type AttrGetType DOMMediaControllerPausedPropertyInfo = Bool
    type AttrLabel DOMMediaControllerPausedPropertyInfo = "paused"
    type AttrOrigin DOMMediaControllerPausedPropertyInfo = DOMMediaController
    attrGet _ = getDOMMediaControllerPaused
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "playback-rate"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

constructDOMMediaControllerPlaybackRate :: (IsDOMMediaController o) => Double -> IO (GValueConstruct o)
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 = IsDOMMediaController
    type AttrGetType DOMMediaControllerPlaybackRatePropertyInfo = Double
    type AttrLabel DOMMediaControllerPlaybackRatePropertyInfo = "playback-rate"
    type AttrOrigin DOMMediaControllerPlaybackRatePropertyInfo = DOMMediaController
    attrGet _ = getDOMMediaControllerPlaybackRate
    attrSet _ = setDOMMediaControllerPlaybackRate
    attrConstruct _ = constructDOMMediaControllerPlaybackRate
    attrClear _ = undefined

-- VVV Prop "playback-state"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

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

-- VVV Prop "played"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMTimeRanges"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMMediaControllerPlayed :: (MonadIO m, IsDOMMediaController o) => o -> m (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
getDOMMediaControllerPlayed obj = liftIO $ getObjectPropertyObject obj "played" WebKit.DOMTimeRanges.DOMTimeRanges

data DOMMediaControllerPlayedPropertyInfo
instance AttrInfo DOMMediaControllerPlayedPropertyInfo where
    type AttrAllowedOps DOMMediaControllerPlayedPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMMediaControllerPlayedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMMediaControllerPlayedPropertyInfo = IsDOMMediaController
    type AttrGetType DOMMediaControllerPlayedPropertyInfo = (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
    type AttrLabel DOMMediaControllerPlayedPropertyInfo = "played"
    type AttrOrigin DOMMediaControllerPlayedPropertyInfo = DOMMediaController
    attrGet _ = getDOMMediaControllerPlayed
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "seekable"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMTimeRanges"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMMediaControllerSeekable :: (MonadIO m, IsDOMMediaController o) => o -> m (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
getDOMMediaControllerSeekable obj = liftIO $ getObjectPropertyObject obj "seekable" WebKit.DOMTimeRanges.DOMTimeRanges

data DOMMediaControllerSeekablePropertyInfo
instance AttrInfo DOMMediaControllerSeekablePropertyInfo where
    type AttrAllowedOps DOMMediaControllerSeekablePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMMediaControllerSeekablePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMMediaControllerSeekablePropertyInfo = IsDOMMediaController
    type AttrGetType DOMMediaControllerSeekablePropertyInfo = (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
    type AttrLabel DOMMediaControllerSeekablePropertyInfo = "seekable"
    type AttrOrigin DOMMediaControllerSeekablePropertyInfo = DOMMediaController
    attrGet _ = getDOMMediaControllerSeekable
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "volume"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

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

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

constructDOMMediaControllerVolume :: (IsDOMMediaController o) => Double -> IO (GValueConstruct o)
constructDOMMediaControllerVolume val = constructObjectPropertyDouble "volume" val

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

instance O.HasAttributeList DOMMediaController
type instance O.AttributeList DOMMediaController = DOMMediaControllerAttributeList
type DOMMediaControllerAttributeList = ('[ '("buffered", DOMMediaControllerBufferedPropertyInfo), '("coreObject", WebKit.DOMObject.DOMObjectCoreObjectPropertyInfo), '("currentTime", DOMMediaControllerCurrentTimePropertyInfo), '("defaultPlaybackRate", DOMMediaControllerDefaultPlaybackRatePropertyInfo), '("duration", DOMMediaControllerDurationPropertyInfo), '("muted", DOMMediaControllerMutedPropertyInfo), '("paused", DOMMediaControllerPausedPropertyInfo), '("playbackRate", DOMMediaControllerPlaybackRatePropertyInfo), '("playbackState", DOMMediaControllerPlaybackStatePropertyInfo), '("played", DOMMediaControllerPlayedPropertyInfo), '("seekable", DOMMediaControllerSeekablePropertyInfo), '("volume", DOMMediaControllerVolumePropertyInfo)] :: [(Symbol, *)])

dOMMediaControllerBuffered :: AttrLabelProxy "buffered"
dOMMediaControllerBuffered = AttrLabelProxy

dOMMediaControllerCurrentTime :: AttrLabelProxy "currentTime"
dOMMediaControllerCurrentTime = AttrLabelProxy

dOMMediaControllerDefaultPlaybackRate :: AttrLabelProxy "defaultPlaybackRate"
dOMMediaControllerDefaultPlaybackRate = AttrLabelProxy

dOMMediaControllerDuration :: AttrLabelProxy "duration"
dOMMediaControllerDuration = AttrLabelProxy

dOMMediaControllerMuted :: AttrLabelProxy "muted"
dOMMediaControllerMuted = AttrLabelProxy

dOMMediaControllerPaused :: AttrLabelProxy "paused"
dOMMediaControllerPaused = AttrLabelProxy

dOMMediaControllerPlaybackRate :: AttrLabelProxy "playbackRate"
dOMMediaControllerPlaybackRate = AttrLabelProxy

dOMMediaControllerPlaybackState :: AttrLabelProxy "playbackState"
dOMMediaControllerPlaybackState = AttrLabelProxy

dOMMediaControllerPlayed :: AttrLabelProxy "played"
dOMMediaControllerPlayed = AttrLabelProxy

dOMMediaControllerSeekable :: AttrLabelProxy "seekable"
dOMMediaControllerSeekable = AttrLabelProxy

dOMMediaControllerVolume :: AttrLabelProxy "volume"
dOMMediaControllerVolume = AttrLabelProxy

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

-- method DOMMediaController::get_buffered
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMTimeRanges"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_buffered" webkit_dom_media_controller_get_buffered :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO (Ptr WebKit.DOMTimeRanges.DOMTimeRanges)

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetBuffered ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m WebKit.DOMTimeRanges.DOMTimeRanges
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMTimeRanges.DOMTimeRanges' -}
dOMMediaControllerGetBuffered self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_buffered self'
    checkUnexpectedReturnNULL "dOMMediaControllerGetBuffered" result
    result' <- (wrapObject WebKit.DOMTimeRanges.DOMTimeRanges) result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetBufferedMethodInfo
instance (signature ~ (m WebKit.DOMTimeRanges.DOMTimeRanges), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetBufferedMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetBuffered

-- method DOMMediaController::get_current_time
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (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 ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetCurrentTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMMediaControllerGetCurrentTime self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_current_time self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetCurrentTimeMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetCurrentTimeMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetCurrentTime

-- method DOMMediaController::get_default_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (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 ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetDefaultPlaybackRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMMediaControllerGetDefaultPlaybackRate self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_default_playback_rate self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetDefaultPlaybackRateMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetDefaultPlaybackRateMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetDefaultPlaybackRate

-- method DOMMediaController::get_duration
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_duration" webkit_dom_media_controller_get_duration :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMMediaControllerGetDuration self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_duration self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetDurationMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetDurationMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetDuration

-- method DOMMediaController::get_muted
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", 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 "webkit_dom_media_controller_get_muted" webkit_dom_media_controller_get_muted :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetMuted ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMMediaControllerGetMuted self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_muted self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetMutedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetMutedMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetMuted

-- method DOMMediaController::get_paused
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", 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 "webkit_dom_media_controller_get_paused" webkit_dom_media_controller_get_paused :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetPaused ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMMediaControllerGetPaused self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_paused self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetPausedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetPausedMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetPaused

-- method DOMMediaController::get_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (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 ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetPlaybackRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMMediaControllerGetPlaybackRate self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_playback_rate self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetPlaybackRateMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetPlaybackRateMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetPlaybackRate

-- method DOMMediaController::get_playback_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", 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 "webkit_dom_media_controller_get_playback_state" webkit_dom_media_controller_get_playback_state :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetPlaybackState ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMMediaControllerGetPlaybackState self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_playback_state self'
    checkUnexpectedReturnNULL "dOMMediaControllerGetPlaybackState" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetPlaybackStateMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetPlaybackStateMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetPlaybackState

-- method DOMMediaController::get_played
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMTimeRanges"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_played" webkit_dom_media_controller_get_played :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO (Ptr WebKit.DOMTimeRanges.DOMTimeRanges)

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetPlayed ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m WebKit.DOMTimeRanges.DOMTimeRanges
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMTimeRanges.DOMTimeRanges' -}
dOMMediaControllerGetPlayed self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_played self'
    checkUnexpectedReturnNULL "dOMMediaControllerGetPlayed" result
    result' <- (wrapObject WebKit.DOMTimeRanges.DOMTimeRanges) result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetPlayedMethodInfo
instance (signature ~ (m WebKit.DOMTimeRanges.DOMTimeRanges), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetPlayedMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetPlayed

-- method DOMMediaController::get_seekable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMTimeRanges"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_seekable" webkit_dom_media_controller_get_seekable :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO (Ptr WebKit.DOMTimeRanges.DOMTimeRanges)

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetSeekable ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m WebKit.DOMTimeRanges.DOMTimeRanges
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMTimeRanges.DOMTimeRanges' -}
dOMMediaControllerGetSeekable self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_seekable self'
    checkUnexpectedReturnNULL "dOMMediaControllerGetSeekable" result
    result' <- (wrapObject WebKit.DOMTimeRanges.DOMTimeRanges) result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetSeekableMethodInfo
instance (signature ~ (m WebKit.DOMTimeRanges.DOMTimeRanges), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetSeekableMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetSeekable

-- method DOMMediaController::get_volume
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_get_volume" webkit_dom_media_controller_get_volume :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMMediaControllerGetVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMMediaControllerGetVolume self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_media_controller_get_volume self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMMediaControllerGetVolumeMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerGetVolumeMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerGetVolume

-- method DOMMediaController::pause
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_pause" webkit_dom_media_controller_pause :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMMediaControllerPause ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m ()
dOMMediaControllerPause self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_media_controller_pause self'
    touchManagedPtr self
    return ()

data DOMMediaControllerPauseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerPauseMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerPause

-- method DOMMediaController::play
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_play" webkit_dom_media_controller_play :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMMediaControllerPlay ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m ()
dOMMediaControllerPlay self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_media_controller_play self'
    touchManagedPtr self
    return ()

data DOMMediaControllerPlayMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerPlayMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerPlay

-- method DOMMediaController::set_current_time
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gdouble", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_set_current_time" webkit_dom_media_controller_set_current_time :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    CDouble ->                              -- value : TBasicType TDouble
    IO ()

{- |
/No description available in the introspection data./
-}
dOMMediaControllerSetCurrentTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> Double
    {- ^ /@value@/: A @/gdouble/@ -}
    -> m ()
dOMMediaControllerSetCurrentTime self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = realToFrac value
    webkit_dom_media_controller_set_current_time self' value'
    touchManagedPtr self
    return ()

data DOMMediaControllerSetCurrentTimeMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerSetCurrentTimeMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerSetCurrentTime

-- method DOMMediaController::set_default_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gdouble", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- 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 ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    CDouble ->                              -- value : TBasicType TDouble
    IO ()

{- |
/No description available in the introspection data./
-}
dOMMediaControllerSetDefaultPlaybackRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> Double
    {- ^ /@value@/: A @/gdouble/@ -}
    -> m ()
dOMMediaControllerSetDefaultPlaybackRate self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = realToFrac value
    webkit_dom_media_controller_set_default_playback_rate self' value'
    touchManagedPtr self
    return ()

data DOMMediaControllerSetDefaultPlaybackRateMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerSetDefaultPlaybackRateMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerSetDefaultPlaybackRate

-- method DOMMediaController::set_muted
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_set_muted" webkit_dom_media_controller_set_muted :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

{- |
/No description available in the introspection data./
-}
dOMMediaControllerSetMuted ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMMediaControllerSetMuted self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_media_controller_set_muted self' value'
    touchManagedPtr self
    return ()

data DOMMediaControllerSetMutedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerSetMutedMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerSetMuted

-- method DOMMediaController::set_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gdouble", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_set_playback_rate" webkit_dom_media_controller_set_playback_rate :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    CDouble ->                              -- value : TBasicType TDouble
    IO ()

{- |
/No description available in the introspection data./
-}
dOMMediaControllerSetPlaybackRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> Double
    {- ^ /@value@/: A @/gdouble/@ -}
    -> m ()
dOMMediaControllerSetPlaybackRate self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = realToFrac value
    webkit_dom_media_controller_set_playback_rate self' value'
    touchManagedPtr self
    return ()

data DOMMediaControllerSetPlaybackRateMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerSetPlaybackRateMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerSetPlaybackRate

-- method DOMMediaController::set_volume
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gdouble", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_set_volume" webkit_dom_media_controller_set_volume :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    CDouble ->                              -- value : TBasicType TDouble
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
/No description available in the introspection data./
-}
dOMMediaControllerSetVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> Double
    {- ^ /@value@/: A @/gdouble/@ -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMMediaControllerSetVolume self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = realToFrac value
    onException (do
        propagateGError $ webkit_dom_media_controller_set_volume self' value'
        touchManagedPtr self
        return ()
     ) (do
        return ()
     )

data DOMMediaControllerSetVolumeMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerSetVolumeMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerSetVolume

-- method DOMMediaController::unpause
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMMediaController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMMediaController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_media_controller_unpause" webkit_dom_media_controller_unpause :: 
    Ptr DOMMediaController ->               -- self : TInterface (Name {namespace = "WebKit", name = "DOMMediaController"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMMediaControllerUnpause ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMMediaController a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMMediaController.DOMMediaController' -}
    -> m ()
dOMMediaControllerUnpause self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_media_controller_unpause self'
    touchManagedPtr self
    return ()

data DOMMediaControllerUnpauseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMMediaController a) => O.MethodInfo DOMMediaControllerUnpauseMethodInfo a signature where
    overloadedMethod _ = dOMMediaControllerUnpause