{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gtk.Objects.MediaFile.MediaFile' is the implementation for media file usage with t'GI.Gtk.Objects.MediaStream.MediaStream'.
-- 
-- This provides a simple way to play back video files with GTK.
-- 
-- GTK+ provides a GIO extension point for t'GI.Gtk.Objects.MediaFile.MediaFile' implementations
-- to allow for external implementations using various media frameworks.
-- GTK+ itself includes implementations using GStreamer and ffmpeg.

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

module GI.Gtk.Objects.MediaFile
    ( 

-- * Exported types
    MediaFile(..)                           ,
    IsMediaFile                             ,
    toMediaFile                             ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveMediaFileMethod                  ,
#endif


-- ** clear #method:clear#

#if defined(ENABLE_OVERLOADING)
    MediaFileClearMethodInfo                ,
#endif
    mediaFileClear                          ,


-- ** getFile #method:getFile#

#if defined(ENABLE_OVERLOADING)
    MediaFileGetFileMethodInfo              ,
#endif
    mediaFileGetFile                        ,


-- ** getInputStream #method:getInputStream#

#if defined(ENABLE_OVERLOADING)
    MediaFileGetInputStreamMethodInfo       ,
#endif
    mediaFileGetInputStream                 ,


-- ** new #method:new#

    mediaFileNew                            ,


-- ** newForFile #method:newForFile#

    mediaFileNewForFile                     ,


-- ** newForFilename #method:newForFilename#

    mediaFileNewForFilename                 ,


-- ** newForInputStream #method:newForInputStream#

    mediaFileNewForInputStream              ,


-- ** newForResource #method:newForResource#

    mediaFileNewForResource                 ,


-- ** setFile #method:setFile#

#if defined(ENABLE_OVERLOADING)
    MediaFileSetFileMethodInfo              ,
#endif
    mediaFileSetFile                        ,


-- ** setFilename #method:setFilename#

#if defined(ENABLE_OVERLOADING)
    MediaFileSetFilenameMethodInfo          ,
#endif
    mediaFileSetFilename                    ,


-- ** setInputStream #method:setInputStream#

#if defined(ENABLE_OVERLOADING)
    MediaFileSetInputStreamMethodInfo       ,
#endif
    mediaFileSetInputStream                 ,


-- ** setResource #method:setResource#

#if defined(ENABLE_OVERLOADING)
    MediaFileSetResourceMethodInfo          ,
#endif
    mediaFileSetResource                    ,




 -- * Properties
-- ** file #attr:file#
-- | The file being played back or 'P.Nothing' if not playing a file.

#if defined(ENABLE_OVERLOADING)
    MediaFileFilePropertyInfo               ,
#endif
    clearMediaFileFile                      ,
    constructMediaFileFile                  ,
    getMediaFileFile                        ,
#if defined(ENABLE_OVERLOADING)
    mediaFileFile                           ,
#endif
    setMediaFileFile                        ,


-- ** inputStream #attr:inputStream#
-- | The stream being played back or 'P.Nothing' if not playing a stream, like when playing a file.

#if defined(ENABLE_OVERLOADING)
    MediaFileInputStreamPropertyInfo        ,
#endif
    clearMediaFileInputStream               ,
    constructMediaFileInputStream           ,
    getMediaFileInputStream                 ,
#if defined(ENABLE_OVERLOADING)
    mediaFileInputStream                    ,
#endif
    setMediaFileInputStream                 ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import {-# SOURCE #-} qualified GI.Gtk.Objects.MediaStream as Gtk.MediaStream

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

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

foreign import ccall "gtk_media_file_get_type"
    c_gtk_media_file_get_type :: IO B.Types.GType

instance B.Types.TypedObject MediaFile where
    glibType :: IO GType
glibType = IO GType
c_gtk_media_file_get_type

instance B.Types.GObject MediaFile

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

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

instance O.HasParentTypes MediaFile
type instance O.ParentTypes MediaFile = '[Gtk.MediaStream.MediaStream, GObject.Object.Object, Gdk.Paintable.Paintable]

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

#if defined(ENABLE_OVERLOADING)
type family ResolveMediaFileMethod (t :: Symbol) (o :: *) :: * where
    ResolveMediaFileMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveMediaFileMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveMediaFileMethod "clear" o = MediaFileClearMethodInfo
    ResolveMediaFileMethod "computeConcreteSize" o = Gdk.Paintable.PaintableComputeConcreteSizeMethodInfo
    ResolveMediaFileMethod "ended" o = Gtk.MediaStream.MediaStreamEndedMethodInfo
    ResolveMediaFileMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveMediaFileMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveMediaFileMethod "gerror" o = Gtk.MediaStream.MediaStreamGerrorMethodInfo
    ResolveMediaFileMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveMediaFileMethod "hasAudio" o = Gtk.MediaStream.MediaStreamHasAudioMethodInfo
    ResolveMediaFileMethod "hasVideo" o = Gtk.MediaStream.MediaStreamHasVideoMethodInfo
    ResolveMediaFileMethod "invalidateContents" o = Gdk.Paintable.PaintableInvalidateContentsMethodInfo
    ResolveMediaFileMethod "invalidateSize" o = Gdk.Paintable.PaintableInvalidateSizeMethodInfo
    ResolveMediaFileMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveMediaFileMethod "isPrepared" o = Gtk.MediaStream.MediaStreamIsPreparedMethodInfo
    ResolveMediaFileMethod "isSeekable" o = Gtk.MediaStream.MediaStreamIsSeekableMethodInfo
    ResolveMediaFileMethod "isSeeking" o = Gtk.MediaStream.MediaStreamIsSeekingMethodInfo
    ResolveMediaFileMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveMediaFileMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveMediaFileMethod "pause" o = Gtk.MediaStream.MediaStreamPauseMethodInfo
    ResolveMediaFileMethod "play" o = Gtk.MediaStream.MediaStreamPlayMethodInfo
    ResolveMediaFileMethod "prepared" o = Gtk.MediaStream.MediaStreamPreparedMethodInfo
    ResolveMediaFileMethod "realize" o = Gtk.MediaStream.MediaStreamRealizeMethodInfo
    ResolveMediaFileMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveMediaFileMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveMediaFileMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveMediaFileMethod "seek" o = Gtk.MediaStream.MediaStreamSeekMethodInfo
    ResolveMediaFileMethod "seekFailed" o = Gtk.MediaStream.MediaStreamSeekFailedMethodInfo
    ResolveMediaFileMethod "seekSuccess" o = Gtk.MediaStream.MediaStreamSeekSuccessMethodInfo
    ResolveMediaFileMethod "snapshot" o = Gdk.Paintable.PaintableSnapshotMethodInfo
    ResolveMediaFileMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveMediaFileMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveMediaFileMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveMediaFileMethod "unprepared" o = Gtk.MediaStream.MediaStreamUnpreparedMethodInfo
    ResolveMediaFileMethod "unrealize" o = Gtk.MediaStream.MediaStreamUnrealizeMethodInfo
    ResolveMediaFileMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveMediaFileMethod "update" o = Gtk.MediaStream.MediaStreamUpdateMethodInfo
    ResolveMediaFileMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveMediaFileMethod "getCurrentImage" o = Gdk.Paintable.PaintableGetCurrentImageMethodInfo
    ResolveMediaFileMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveMediaFileMethod "getDuration" o = Gtk.MediaStream.MediaStreamGetDurationMethodInfo
    ResolveMediaFileMethod "getEnded" o = Gtk.MediaStream.MediaStreamGetEndedMethodInfo
    ResolveMediaFileMethod "getError" o = Gtk.MediaStream.MediaStreamGetErrorMethodInfo
    ResolveMediaFileMethod "getFile" o = MediaFileGetFileMethodInfo
    ResolveMediaFileMethod "getFlags" o = Gdk.Paintable.PaintableGetFlagsMethodInfo
    ResolveMediaFileMethod "getInputStream" o = MediaFileGetInputStreamMethodInfo
    ResolveMediaFileMethod "getIntrinsicAspectRatio" o = Gdk.Paintable.PaintableGetIntrinsicAspectRatioMethodInfo
    ResolveMediaFileMethod "getIntrinsicHeight" o = Gdk.Paintable.PaintableGetIntrinsicHeightMethodInfo
    ResolveMediaFileMethod "getIntrinsicWidth" o = Gdk.Paintable.PaintableGetIntrinsicWidthMethodInfo
    ResolveMediaFileMethod "getLoop" o = Gtk.MediaStream.MediaStreamGetLoopMethodInfo
    ResolveMediaFileMethod "getMuted" o = Gtk.MediaStream.MediaStreamGetMutedMethodInfo
    ResolveMediaFileMethod "getPlaying" o = Gtk.MediaStream.MediaStreamGetPlayingMethodInfo
    ResolveMediaFileMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveMediaFileMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveMediaFileMethod "getTimestamp" o = Gtk.MediaStream.MediaStreamGetTimestampMethodInfo
    ResolveMediaFileMethod "getVolume" o = Gtk.MediaStream.MediaStreamGetVolumeMethodInfo
    ResolveMediaFileMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveMediaFileMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveMediaFileMethod "setFile" o = MediaFileSetFileMethodInfo
    ResolveMediaFileMethod "setFilename" o = MediaFileSetFilenameMethodInfo
    ResolveMediaFileMethod "setInputStream" o = MediaFileSetInputStreamMethodInfo
    ResolveMediaFileMethod "setLoop" o = Gtk.MediaStream.MediaStreamSetLoopMethodInfo
    ResolveMediaFileMethod "setMuted" o = Gtk.MediaStream.MediaStreamSetMutedMethodInfo
    ResolveMediaFileMethod "setPlaying" o = Gtk.MediaStream.MediaStreamSetPlayingMethodInfo
    ResolveMediaFileMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveMediaFileMethod "setResource" o = MediaFileSetResourceMethodInfo
    ResolveMediaFileMethod "setVolume" o = Gtk.MediaStream.MediaStreamSetVolumeMethodInfo
    ResolveMediaFileMethod l o = O.MethodResolutionFailed l o

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

#endif

-- VVV Prop "file"
   -- Type: TInterface (Name {namespace = "Gio", name = "File"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@file@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' mediaFile #file
-- @
getMediaFileFile :: (MonadIO m, IsMediaFile o) => o -> m (Maybe Gio.File.File)
getMediaFileFile :: o -> m (Maybe File)
getMediaFileFile o
obj = IO (Maybe File) -> m (Maybe File)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe File) -> m (Maybe File))
-> IO (Maybe File) -> m (Maybe File)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr File -> File) -> IO (Maybe File)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"file" ManagedPtr File -> File
Gio.File.File

-- | Set the value of the “@file@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' mediaFile [ #file 'Data.GI.Base.Attributes.:=' value ]
-- @
setMediaFileFile :: (MonadIO m, IsMediaFile o, Gio.File.IsFile a) => o -> a -> m ()
setMediaFileFile :: o -> a -> m ()
setMediaFileFile o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"file" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@file@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMediaFileFile :: (IsMediaFile o, MIO.MonadIO m, Gio.File.IsFile a) => a -> m (GValueConstruct o)
constructMediaFileFile :: a -> m (GValueConstruct o)
constructMediaFileFile a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"file" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@file@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #file
-- @
clearMediaFileFile :: (MonadIO m, IsMediaFile o) => o -> m ()
clearMediaFileFile :: o -> m ()
clearMediaFileFile o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe File -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"file" (Maybe File
forall a. Maybe a
Nothing :: Maybe Gio.File.File)

#if defined(ENABLE_OVERLOADING)
data MediaFileFilePropertyInfo
instance AttrInfo MediaFileFilePropertyInfo where
    type AttrAllowedOps MediaFileFilePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MediaFileFilePropertyInfo = IsMediaFile
    type AttrSetTypeConstraint MediaFileFilePropertyInfo = Gio.File.IsFile
    type AttrTransferTypeConstraint MediaFileFilePropertyInfo = Gio.File.IsFile
    type AttrTransferType MediaFileFilePropertyInfo = Gio.File.File
    type AttrGetType MediaFileFilePropertyInfo = (Maybe Gio.File.File)
    type AttrLabel MediaFileFilePropertyInfo = "file"
    type AttrOrigin MediaFileFilePropertyInfo = MediaFile
    attrGet = getMediaFileFile
    attrSet = setMediaFileFile
    attrTransfer _ v = do
        unsafeCastTo Gio.File.File v
    attrConstruct = constructMediaFileFile
    attrClear = clearMediaFileFile
#endif

-- VVV Prop "input-stream"
   -- Type: TInterface (Name {namespace = "Gio", name = "InputStream"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@input-stream@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' mediaFile #inputStream
-- @
getMediaFileInputStream :: (MonadIO m, IsMediaFile o) => o -> m (Maybe Gio.InputStream.InputStream)
getMediaFileInputStream :: o -> m (Maybe InputStream)
getMediaFileInputStream o
obj = IO (Maybe InputStream) -> m (Maybe InputStream)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStream) -> m (Maybe InputStream))
-> IO (Maybe InputStream) -> m (Maybe InputStream)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr InputStream -> InputStream)
-> IO (Maybe InputStream)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"input-stream" ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream

-- | Set the value of the “@input-stream@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' mediaFile [ #inputStream 'Data.GI.Base.Attributes.:=' value ]
-- @
setMediaFileInputStream :: (MonadIO m, IsMediaFile o, Gio.InputStream.IsInputStream a) => o -> a -> m ()
setMediaFileInputStream :: o -> a -> m ()
setMediaFileInputStream o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"input-stream" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@input-stream@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMediaFileInputStream :: (IsMediaFile o, MIO.MonadIO m, Gio.InputStream.IsInputStream a) => a -> m (GValueConstruct o)
constructMediaFileInputStream :: a -> m (GValueConstruct o)
constructMediaFileInputStream a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"input-stream" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@input-stream@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #inputStream
-- @
clearMediaFileInputStream :: (MonadIO m, IsMediaFile o) => o -> m ()
clearMediaFileInputStream :: o -> m ()
clearMediaFileInputStream o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe InputStream -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"input-stream" (Maybe InputStream
forall a. Maybe a
Nothing :: Maybe Gio.InputStream.InputStream)

#if defined(ENABLE_OVERLOADING)
data MediaFileInputStreamPropertyInfo
instance AttrInfo MediaFileInputStreamPropertyInfo where
    type AttrAllowedOps MediaFileInputStreamPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MediaFileInputStreamPropertyInfo = IsMediaFile
    type AttrSetTypeConstraint MediaFileInputStreamPropertyInfo = Gio.InputStream.IsInputStream
    type AttrTransferTypeConstraint MediaFileInputStreamPropertyInfo = Gio.InputStream.IsInputStream
    type AttrTransferType MediaFileInputStreamPropertyInfo = Gio.InputStream.InputStream
    type AttrGetType MediaFileInputStreamPropertyInfo = (Maybe Gio.InputStream.InputStream)
    type AttrLabel MediaFileInputStreamPropertyInfo = "input-stream"
    type AttrOrigin MediaFileInputStreamPropertyInfo = MediaFile
    attrGet = getMediaFileInputStream
    attrSet = setMediaFileInputStream
    attrTransfer _ v = do
        unsafeCastTo Gio.InputStream.InputStream v
    attrConstruct = constructMediaFileInputStream
    attrClear = clearMediaFileInputStream
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MediaFile
type instance O.AttributeList MediaFile = MediaFileAttributeList
type MediaFileAttributeList = ('[ '("duration", Gtk.MediaStream.MediaStreamDurationPropertyInfo), '("ended", Gtk.MediaStream.MediaStreamEndedPropertyInfo), '("error", Gtk.MediaStream.MediaStreamErrorPropertyInfo), '("file", MediaFileFilePropertyInfo), '("hasAudio", Gtk.MediaStream.MediaStreamHasAudioPropertyInfo), '("hasVideo", Gtk.MediaStream.MediaStreamHasVideoPropertyInfo), '("inputStream", MediaFileInputStreamPropertyInfo), '("loop", Gtk.MediaStream.MediaStreamLoopPropertyInfo), '("muted", Gtk.MediaStream.MediaStreamMutedPropertyInfo), '("playing", Gtk.MediaStream.MediaStreamPlayingPropertyInfo), '("prepared", Gtk.MediaStream.MediaStreamPreparedPropertyInfo), '("seekable", Gtk.MediaStream.MediaStreamSeekablePropertyInfo), '("seeking", Gtk.MediaStream.MediaStreamSeekingPropertyInfo), '("timestamp", Gtk.MediaStream.MediaStreamTimestampPropertyInfo), '("volume", Gtk.MediaStream.MediaStreamVolumePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
mediaFileFile :: AttrLabelProxy "file"
mediaFileFile = AttrLabelProxy

mediaFileInputStream :: AttrLabelProxy "inputStream"
mediaFileInputStream = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList MediaFile = MediaFileSignalList
type MediaFileSignalList = ('[ '("invalidateContents", Gdk.Paintable.PaintableInvalidateContentsSignalInfo), '("invalidateSize", Gdk.Paintable.PaintableInvalidateSizeSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method MediaFile::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "MediaFile" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_new" gtk_media_file_new :: 
    IO (Ptr MediaFile)

-- | Creates a new empty media file.
mediaFileNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m MediaFile
    -- ^ __Returns:__ a new t'GI.Gtk.Objects.MediaFile.MediaFile'
mediaFileNew :: m MediaFile
mediaFileNew  = IO MediaFile -> m MediaFile
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MediaFile -> m MediaFile) -> IO MediaFile -> m MediaFile
forall a b. (a -> b) -> a -> b
$ do
    Ptr MediaFile
result <- IO (Ptr MediaFile)
gtk_media_file_new
    Text -> Ptr MediaFile -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mediaFileNew" Ptr MediaFile
result
    MediaFile
result' <- ((ManagedPtr MediaFile -> MediaFile)
-> Ptr MediaFile -> IO MediaFile
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MediaFile -> MediaFile
MediaFile) Ptr MediaFile
result
    MediaFile -> IO MediaFile
forall (m :: * -> *) a. Monad m => a -> m a
return MediaFile
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method MediaFile::new_for_file
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "file"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The file to play" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "MediaFile" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_new_for_file" gtk_media_file_new_for_file :: 
    Ptr Gio.File.File ->                    -- file : TInterface (Name {namespace = "Gio", name = "File"})
    IO (Ptr MediaFile)

-- | Creates a new media file to play /@file@/.
mediaFileNewForFile ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) =>
    a
    -- ^ /@file@/: The file to play
    -> m MediaFile
    -- ^ __Returns:__ a new t'GI.Gtk.Objects.MediaFile.MediaFile' playing /@file@/
mediaFileNewForFile :: a -> m MediaFile
mediaFileNewForFile a
file = IO MediaFile -> m MediaFile
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MediaFile -> m MediaFile) -> IO MediaFile -> m MediaFile
forall a b. (a -> b) -> a -> b
$ do
    Ptr File
file' <- a -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
file
    Ptr MediaFile
result <- Ptr File -> IO (Ptr MediaFile)
gtk_media_file_new_for_file Ptr File
file'
    Text -> Ptr MediaFile -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mediaFileNewForFile" Ptr MediaFile
result
    MediaFile
result' <- ((ManagedPtr MediaFile -> MediaFile)
-> Ptr MediaFile -> IO MediaFile
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MediaFile -> MediaFile
MediaFile) Ptr MediaFile
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
file
    MediaFile -> IO MediaFile
forall (m :: * -> *) a. Monad m => a -> m a
return MediaFile
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method MediaFile::new_for_filename
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "filename"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "filename to open" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "MediaFile" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_new_for_filename" gtk_media_file_new_for_filename :: 
    CString ->                              -- filename : TBasicType TUTF8
    IO (Ptr MediaFile)

-- | This is a utility function that converts the given /@filename@/
-- to a t'GI.Gio.Interfaces.File.File' and calls 'GI.Gtk.Objects.MediaFile.mediaFileNewForFile'.
mediaFileNewForFilename ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@filename@/: filename to open
    -> m MediaFile
    -- ^ __Returns:__ a new t'GI.Gtk.Objects.MediaFile.MediaFile' playing /@filename@/
mediaFileNewForFilename :: Text -> m MediaFile
mediaFileNewForFilename Text
filename = IO MediaFile -> m MediaFile
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MediaFile -> m MediaFile) -> IO MediaFile -> m MediaFile
forall a b. (a -> b) -> a -> b
$ do
    CString
filename' <- Text -> IO CString
textToCString Text
filename
    Ptr MediaFile
result <- CString -> IO (Ptr MediaFile)
gtk_media_file_new_for_filename CString
filename'
    Text -> Ptr MediaFile -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mediaFileNewForFilename" Ptr MediaFile
result
    MediaFile
result' <- ((ManagedPtr MediaFile -> MediaFile)
-> Ptr MediaFile -> IO MediaFile
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MediaFile -> MediaFile
MediaFile) Ptr MediaFile
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
    MediaFile -> IO MediaFile
forall (m :: * -> *) a. Monad m => a -> m a
return MediaFile
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method MediaFile::new_for_input_stream
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The stream to play" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "MediaFile" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_new_for_input_stream" gtk_media_file_new_for_input_stream :: 
    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
    IO (Ptr MediaFile)

-- | Creates a new media file to play /@stream@/. If you want the
-- resulting media to be seekable, the stream should implement
-- the t'GI.Gio.Interfaces.Seekable.Seekable' interface.
mediaFileNewForInputStream ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a) =>
    a
    -- ^ /@stream@/: The stream to play
    -> m MediaFile
    -- ^ __Returns:__ a new t'GI.Gtk.Objects.MediaFile.MediaFile'
mediaFileNewForInputStream :: a -> m MediaFile
mediaFileNewForInputStream a
stream = IO MediaFile -> m MediaFile
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MediaFile -> m MediaFile) -> IO MediaFile -> m MediaFile
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputStream
stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    Ptr MediaFile
result <- Ptr InputStream -> IO (Ptr MediaFile)
gtk_media_file_new_for_input_stream Ptr InputStream
stream'
    Text -> Ptr MediaFile -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mediaFileNewForInputStream" Ptr MediaFile
result
    MediaFile
result' <- ((ManagedPtr MediaFile -> MediaFile)
-> Ptr MediaFile -> IO MediaFile
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MediaFile -> MediaFile
MediaFile) Ptr MediaFile
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
    MediaFile -> IO MediaFile
forall (m :: * -> *) a. Monad m => a -> m a
return MediaFile
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method MediaFile::new_for_resource
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "resource_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "resource path to open"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "MediaFile" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_new_for_resource" gtk_media_file_new_for_resource :: 
    CString ->                              -- resource_path : TBasicType TUTF8
    IO (Ptr MediaFile)

-- | This is a utility function that converts the given /@resource@/
-- to a t'GI.Gio.Interfaces.File.File' and calls 'GI.Gtk.Objects.MediaFile.mediaFileNewForFile'.
mediaFileNewForResource ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@resourcePath@/: resource path to open
    -> m MediaFile
    -- ^ __Returns:__ a new t'GI.Gtk.Objects.MediaFile.MediaFile' playing /@resourcePath@/
mediaFileNewForResource :: Text -> m MediaFile
mediaFileNewForResource Text
resourcePath = IO MediaFile -> m MediaFile
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MediaFile -> m MediaFile) -> IO MediaFile -> m MediaFile
forall a b. (a -> b) -> a -> b
$ do
    CString
resourcePath' <- Text -> IO CString
textToCString Text
resourcePath
    Ptr MediaFile
result <- CString -> IO (Ptr MediaFile)
gtk_media_file_new_for_resource CString
resourcePath'
    Text -> Ptr MediaFile -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mediaFileNewForResource" Ptr MediaFile
result
    MediaFile
result' <- ((ManagedPtr MediaFile -> MediaFile)
-> Ptr MediaFile -> IO MediaFile
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MediaFile -> MediaFile
MediaFile) Ptr MediaFile
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
resourcePath'
    MediaFile -> IO MediaFile
forall (m :: * -> *) a. Monad m => a -> m a
return MediaFile
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gtk_media_file_clear" gtk_media_file_clear :: 
    Ptr MediaFile ->                        -- self : TInterface (Name {namespace = "Gtk", name = "MediaFile"})
    IO ()

-- | Resets the media file to be empty.
mediaFileClear ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.MediaFile.MediaFile'
    -> m ()
mediaFileClear :: a -> m ()
mediaFileClear a
self = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MediaFile
self' <- a -> IO (Ptr MediaFile)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MediaFile -> IO ()
gtk_media_file_clear Ptr MediaFile
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MediaFileClearMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMediaFile a) => O.MethodInfo MediaFileClearMethodInfo a signature where
    overloadedMethod = mediaFileClear

#endif

-- method MediaFile::get_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "MediaFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkMediaFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "File" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_get_file" gtk_media_file_get_file :: 
    Ptr MediaFile ->                        -- self : TInterface (Name {namespace = "Gtk", name = "MediaFile"})
    IO (Ptr Gio.File.File)

-- | Returns the file that /@self@/ is currently playing from.
-- 
-- When /@self@/ is not playing or not playing from a file,
-- 'P.Nothing' is returned.
mediaFileGetFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.MediaFile.MediaFile'
    -> m (Maybe Gio.File.File)
    -- ^ __Returns:__ The currently playing file or 'P.Nothing' if not
    --     playing from a file.
mediaFileGetFile :: a -> m (Maybe File)
mediaFileGetFile a
self = IO (Maybe File) -> m (Maybe File)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe File) -> m (Maybe File))
-> IO (Maybe File) -> m (Maybe File)
forall a b. (a -> b) -> a -> b
$ do
    Ptr MediaFile
self' <- a -> IO (Ptr MediaFile)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
result <- Ptr MediaFile -> IO (Ptr File)
gtk_media_file_get_file Ptr MediaFile
self'
    Maybe File
maybeResult <- Ptr File -> (Ptr File -> IO File) -> IO (Maybe File)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr File
result ((Ptr File -> IO File) -> IO (Maybe File))
-> (Ptr File -> IO File) -> IO (Maybe File)
forall a b. (a -> b) -> a -> b
$ \Ptr File
result' -> do
        File
result'' <- ((ManagedPtr File -> File) -> Ptr File -> IO File
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr File -> File
Gio.File.File) Ptr File
result'
        File -> IO File
forall (m :: * -> *) a. Monad m => a -> m a
return File
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe File -> IO (Maybe File)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe File
maybeResult

#if defined(ENABLE_OVERLOADING)
data MediaFileGetFileMethodInfo
instance (signature ~ (m (Maybe Gio.File.File)), MonadIO m, IsMediaFile a) => O.MethodInfo MediaFileGetFileMethodInfo a signature where
    overloadedMethod = mediaFileGetFile

#endif

-- method MediaFile::get_input_stream
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "MediaFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkMediaFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "InputStream" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_get_input_stream" gtk_media_file_get_input_stream :: 
    Ptr MediaFile ->                        -- self : TInterface (Name {namespace = "Gtk", name = "MediaFile"})
    IO (Ptr Gio.InputStream.InputStream)

-- | Returns the stream that /@self@/ is currently playing from.
-- 
-- When /@self@/ is not playing or not playing from a stream,
-- 'P.Nothing' is returned.
mediaFileGetInputStream ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.MediaFile.MediaFile'
    -> m (Maybe Gio.InputStream.InputStream)
    -- ^ __Returns:__ The currently playing stream or 'P.Nothing' if not
    --     playing from a stream.
mediaFileGetInputStream :: a -> m (Maybe InputStream)
mediaFileGetInputStream a
self = IO (Maybe InputStream) -> m (Maybe InputStream)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStream) -> m (Maybe InputStream))
-> IO (Maybe InputStream) -> m (Maybe InputStream)
forall a b. (a -> b) -> a -> b
$ do
    Ptr MediaFile
self' <- a -> IO (Ptr MediaFile)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr InputStream
result <- Ptr MediaFile -> IO (Ptr InputStream)
gtk_media_file_get_input_stream Ptr MediaFile
self'
    Maybe InputStream
maybeResult <- Ptr InputStream
-> (Ptr InputStream -> IO InputStream) -> IO (Maybe InputStream)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr InputStream
result ((Ptr InputStream -> IO InputStream) -> IO (Maybe InputStream))
-> (Ptr InputStream -> IO InputStream) -> IO (Maybe InputStream)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStream
result' -> do
        InputStream
result'' <- ((ManagedPtr InputStream -> InputStream)
-> Ptr InputStream -> IO InputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
result'
        InputStream -> IO InputStream
forall (m :: * -> *) a. Monad m => a -> m a
return InputStream
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe InputStream -> IO (Maybe InputStream)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStream
maybeResult

#if defined(ENABLE_OVERLOADING)
data MediaFileGetInputStreamMethodInfo
instance (signature ~ (m (Maybe Gio.InputStream.InputStream)), MonadIO m, IsMediaFile a) => O.MethodInfo MediaFileGetInputStreamMethodInfo a signature where
    overloadedMethod = mediaFileGetInputStream

#endif

-- method MediaFile::set_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "MediaFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkMediaFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "file"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the file to play" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_set_file" gtk_media_file_set_file :: 
    Ptr MediaFile ->                        -- self : TInterface (Name {namespace = "Gtk", name = "MediaFile"})
    Ptr Gio.File.File ->                    -- file : TInterface (Name {namespace = "Gio", name = "File"})
    IO ()

-- | If any file is still playing, stop playing it.
-- 
-- Then start playing the given /@file@/.
mediaFileSetFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a, Gio.File.IsFile b) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.MediaFile.MediaFile'
    -> Maybe (b)
    -- ^ /@file@/: the file to play
    -> m ()
mediaFileSetFile :: a -> Maybe b -> m ()
mediaFileSetFile a
self Maybe b
file = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MediaFile
self' <- a -> IO (Ptr MediaFile)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
maybeFile <- case Maybe b
file of
        Maybe b
Nothing -> Ptr File -> IO (Ptr File)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr File
forall a. Ptr a
nullPtr
        Just b
jFile -> do
            Ptr File
jFile' <- b -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jFile
            Ptr File -> IO (Ptr File)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr File
jFile'
    Ptr MediaFile -> Ptr File -> IO ()
gtk_media_file_set_file Ptr MediaFile
self' Ptr File
maybeFile
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
file b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MediaFileSetFileMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsMediaFile a, Gio.File.IsFile b) => O.MethodInfo MediaFileSetFileMethodInfo a signature where
    overloadedMethod = mediaFileSetFile

#endif

-- method MediaFile::set_filename
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "MediaFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkMediaFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filename"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of file to play"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_set_filename" gtk_media_file_set_filename :: 
    Ptr MediaFile ->                        -- self : TInterface (Name {namespace = "Gtk", name = "MediaFile"})
    CString ->                              -- filename : TBasicType TUTF8
    IO ()

-- | This is a utility function that converts the given /@filename@/
-- to a t'GI.Gio.Interfaces.File.File' and calls 'GI.Gtk.Objects.MediaFile.mediaFileSetFile'.
mediaFileSetFilename ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.MediaFile.MediaFile'
    -> Maybe (T.Text)
    -- ^ /@filename@/: name of file to play
    -> m ()
mediaFileSetFilename :: a -> Maybe Text -> m ()
mediaFileSetFilename a
self Maybe Text
filename = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MediaFile
self' <- a -> IO (Ptr MediaFile)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeFilename <- case Maybe Text
filename of
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jFilename -> do
            CString
jFilename' <- Text -> IO CString
textToCString Text
jFilename
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFilename'
    Ptr MediaFile -> CString -> IO ()
gtk_media_file_set_filename Ptr MediaFile
self' CString
maybeFilename
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFilename
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MediaFileSetFilenameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsMediaFile a) => O.MethodInfo MediaFileSetFilenameMethodInfo a signature where
    overloadedMethod = mediaFileSetFilename

#endif

-- method MediaFile::set_input_stream
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "MediaFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkMediaFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the stream to play from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_set_input_stream" gtk_media_file_set_input_stream :: 
    Ptr MediaFile ->                        -- self : TInterface (Name {namespace = "Gtk", name = "MediaFile"})
    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
    IO ()

-- | If anything is still playing, stop playing it. Then start
-- playing the given /@stream@/.
-- 
-- Full control about the /@stream@/ is assumed for the duration of
-- playback. The stream will not bt be closed.
mediaFileSetInputStream ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a, Gio.InputStream.IsInputStream b) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.MediaFile.MediaFile'
    -> Maybe (b)
    -- ^ /@stream@/: the stream to play from
    -> m ()
mediaFileSetInputStream :: a -> Maybe b -> m ()
mediaFileSetInputStream a
self Maybe b
stream = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MediaFile
self' <- a -> IO (Ptr MediaFile)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr InputStream
maybeStream <- case Maybe b
stream of
        Maybe b
Nothing -> Ptr InputStream -> IO (Ptr InputStream)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputStream
forall a. Ptr a
nullPtr
        Just b
jStream -> do
            Ptr InputStream
jStream' <- b -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jStream
            Ptr InputStream -> IO (Ptr InputStream)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputStream
jStream'
    Ptr MediaFile -> Ptr InputStream -> IO ()
gtk_media_file_set_input_stream Ptr MediaFile
self' Ptr InputStream
maybeStream
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
stream b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MediaFileSetInputStreamMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsMediaFile a, Gio.InputStream.IsInputStream b) => O.MethodInfo MediaFileSetInputStreamMethodInfo a signature where
    overloadedMethod = mediaFileSetInputStream

#endif

-- method MediaFile::set_resource
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "MediaFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkMediaFile" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "resource_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "path to resource to play"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_media_file_set_resource" gtk_media_file_set_resource :: 
    Ptr MediaFile ->                        -- self : TInterface (Name {namespace = "Gtk", name = "MediaFile"})
    CString ->                              -- resource_path : TBasicType TUTF8
    IO ()

-- | This is a utility function that converts the given /@resourcePath@/
-- to a t'GI.Gio.Interfaces.File.File' and calls 'GI.Gtk.Objects.MediaFile.mediaFileSetFile'.
mediaFileSetResource ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.MediaFile.MediaFile'
    -> Maybe (T.Text)
    -- ^ /@resourcePath@/: path to resource to play
    -> m ()
mediaFileSetResource :: a -> Maybe Text -> m ()
mediaFileSetResource a
self Maybe Text
resourcePath = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MediaFile
self' <- a -> IO (Ptr MediaFile)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeResourcePath <- case Maybe Text
resourcePath of
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jResourcePath -> do
            CString
jResourcePath' <- Text -> IO CString
textToCString Text
jResourcePath
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jResourcePath'
    Ptr MediaFile -> CString -> IO ()
gtk_media_file_set_resource Ptr MediaFile
self' CString
maybeResourcePath
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeResourcePath
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MediaFileSetResourceMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsMediaFile a) => O.MethodInfo MediaFileSetResourceMethodInfo a signature where
    overloadedMethod = mediaFileSetResource

#endif