{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GtkMediaFile@ implements @GtkMediaStream@ for files.
-- 
-- This provides a simple way to play back video files with GTK.
-- 
-- GTK provides a GIO extension point for @GtkMediaFile@ 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
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clear]("GI.Gtk.Objects.MediaFile#g:method:clear"), [computeConcreteSize]("GI.Gdk.Interfaces.Paintable#g:method:computeConcreteSize"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [gerror]("GI.Gtk.Objects.MediaStream#g:method:gerror"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasAudio]("GI.Gtk.Objects.MediaStream#g:method:hasAudio"), [hasVideo]("GI.Gtk.Objects.MediaStream#g:method:hasVideo"), [invalidateContents]("GI.Gdk.Interfaces.Paintable#g:method:invalidateContents"), [invalidateSize]("GI.Gdk.Interfaces.Paintable#g:method:invalidateSize"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isPrepared]("GI.Gtk.Objects.MediaStream#g:method:isPrepared"), [isSeekable]("GI.Gtk.Objects.MediaStream#g:method:isSeekable"), [isSeeking]("GI.Gtk.Objects.MediaStream#g:method:isSeeking"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [pause]("GI.Gtk.Objects.MediaStream#g:method:pause"), [play]("GI.Gtk.Objects.MediaStream#g:method:play"), [realize]("GI.Gtk.Objects.MediaStream#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [seek]("GI.Gtk.Objects.MediaStream#g:method:seek"), [seekFailed]("GI.Gtk.Objects.MediaStream#g:method:seekFailed"), [seekSuccess]("GI.Gtk.Objects.MediaStream#g:method:seekSuccess"), [snapshot]("GI.Gdk.Interfaces.Paintable#g:method:snapshot"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [streamEnded]("GI.Gtk.Objects.MediaStream#g:method:streamEnded"), [streamPrepared]("GI.Gtk.Objects.MediaStream#g:method:streamPrepared"), [streamUnprepared]("GI.Gtk.Objects.MediaStream#g:method:streamUnprepared"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unrealize]("GI.Gtk.Objects.MediaStream#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [update]("GI.Gtk.Objects.MediaStream#g:method:update"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getCurrentImage]("GI.Gdk.Interfaces.Paintable#g:method:getCurrentImage"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDuration]("GI.Gtk.Objects.MediaStream#g:method:getDuration"), [getEnded]("GI.Gtk.Objects.MediaStream#g:method:getEnded"), [getError]("GI.Gtk.Objects.MediaStream#g:method:getError"), [getFile]("GI.Gtk.Objects.MediaFile#g:method:getFile"), [getFlags]("GI.Gdk.Interfaces.Paintable#g:method:getFlags"), [getInputStream]("GI.Gtk.Objects.MediaFile#g:method:getInputStream"), [getIntrinsicAspectRatio]("GI.Gdk.Interfaces.Paintable#g:method:getIntrinsicAspectRatio"), [getIntrinsicHeight]("GI.Gdk.Interfaces.Paintable#g:method:getIntrinsicHeight"), [getIntrinsicWidth]("GI.Gdk.Interfaces.Paintable#g:method:getIntrinsicWidth"), [getLoop]("GI.Gtk.Objects.MediaStream#g:method:getLoop"), [getMuted]("GI.Gtk.Objects.MediaStream#g:method:getMuted"), [getPlaying]("GI.Gtk.Objects.MediaStream#g:method:getPlaying"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getTimestamp]("GI.Gtk.Objects.MediaStream#g:method:getTimestamp"), [getVolume]("GI.Gtk.Objects.MediaStream#g:method:getVolume").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFile]("GI.Gtk.Objects.MediaFile#g:method:setFile"), [setFilename]("GI.Gtk.Objects.MediaFile#g:method:setFilename"), [setInputStream]("GI.Gtk.Objects.MediaFile#g:method:setInputStream"), [setLoop]("GI.Gtk.Objects.MediaStream#g:method:setLoop"), [setMuted]("GI.Gtk.Objects.MediaStream#g:method:setMuted"), [setPlaying]("GI.Gtk.Objects.MediaStream#g:method:setPlaying"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setResource]("GI.Gtk.Objects.MediaFile#g:method:setResource"), [setVolume]("GI.Gtk.Objects.MediaStream#g:method:setVolume").

#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.
-- 
-- This is 'P.Nothing' 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.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.Coerce as Coerce
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 GHC.Records as R

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
$c== :: MediaFile -> MediaFile -> Bool
== :: MediaFile -> MediaFile -> Bool
$c/= :: MediaFile -> MediaFile -> Bool
/= :: 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

-- | 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 :: (MIO.MonadIO m, IsMediaFile o) => o -> m MediaFile
toMediaFile :: forall (m :: * -> *) o.
(MonadIO m, IsMediaFile o) =>
o -> m MediaFile
toMediaFile = IO MediaFile -> m MediaFile
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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'
B.ManagedPtr.unsafeCastTo ManagedPtr MediaFile -> MediaFile
MediaFile

-- | Convert 'MediaFile' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe MediaFile) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_media_file_get_type
    gvalueSet_ :: Ptr GValue -> Maybe MediaFile -> IO ()
gvalueSet_ Ptr GValue
gv Maybe MediaFile
P.Nothing = Ptr GValue -> Ptr MediaFile -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr MediaFile
forall a. Ptr a
FP.nullPtr :: FP.Ptr MediaFile)
    gvalueSet_ Ptr GValue
gv (P.Just MediaFile
obj) = MediaFile -> (Ptr MediaFile -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MediaFile
obj (Ptr GValue -> Ptr MediaFile -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe MediaFile)
gvalueGet_ Ptr GValue
gv = do
        Ptr MediaFile
ptr <- Ptr GValue -> IO (Ptr MediaFile)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr MediaFile)
        if Ptr MediaFile
ptr Ptr MediaFile -> Ptr MediaFile -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr MediaFile
forall a. Ptr a
FP.nullPtr
        then MediaFile -> Maybe MediaFile
forall a. a -> Maybe a
P.Just (MediaFile -> Maybe MediaFile)
-> IO MediaFile -> IO (Maybe MediaFile)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
        else Maybe MediaFile -> IO (Maybe MediaFile)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MediaFile
forall a. Maybe a
P.Nothing
        
    

#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 "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 "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 "streamEnded" o = Gtk.MediaStream.MediaStreamStreamEndedMethodInfo
    ResolveMediaFileMethod "streamPrepared" o = Gtk.MediaStream.MediaStreamStreamPreparedMethodInfo
    ResolveMediaFileMethod "streamUnprepared" o = Gtk.MediaStream.MediaStreamStreamUnpreparedMethodInfo
    ResolveMediaFileMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveMediaFileMethod t MediaFile, O.OverloadedMethod info MediaFile p, R.HasField t MediaFile p) => R.HasField t MediaFile p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveMediaFileMethod t MediaFile, O.OverloadedMethodInfo info MediaFile) => OL.IsLabel t (O.MethodProxy info MediaFile) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsMediaFile o) =>
o -> m (Maybe File)
getMediaFileFile o
obj = IO (Maybe File) -> m (Maybe File)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 :: forall (m :: * -> *) o a.
(MonadIO m, IsMediaFile o, IsFile a) =>
o -> a -> m ()
setMediaFileFile o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *) a.
(IsMediaFile o, MonadIO m, IsFile a) =>
a -> m (GValueConstruct o)
constructMediaFileFile a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (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 :: forall (m :: * -> *) o. (MonadIO m, IsMediaFile o) => o -> m ()
clearMediaFileFile o
obj = IO () -> m ()
forall a. IO a -> m a
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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.MediaFile.file"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-MediaFile.html#g:attr:file"
        })
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsMediaFile o) =>
o -> m (Maybe InputStream)
getMediaFileInputStream o
obj = IO (Maybe InputStream) -> m (Maybe InputStream)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 :: forall (m :: * -> *) o a.
(MonadIO m, IsMediaFile o, IsInputStream a) =>
o -> a -> m ()
setMediaFileInputStream o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *) a.
(IsMediaFile o, MonadIO m, IsInputStream a) =>
a -> m (GValueConstruct o)
constructMediaFileInputStream a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (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 :: forall (m :: * -> *) o. (MonadIO m, IsMediaFile o) => o -> m ()
clearMediaFileInputStream o
obj = IO () -> m ()
forall a. IO a -> m a
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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.MediaFile.inputStream"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-MediaFile.html#g:attr:inputStream"
        })
#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 @GtkMediaFile@
mediaFileNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MediaFile
mediaFileNew  = IO MediaFile -> m MediaFile
forall a. IO a -> m a
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 a. a -> IO a
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 @GtkMediaFile@ playing /@file@/
mediaFileNewForFile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFile a) =>
a -> m MediaFile
mediaFileNewForFile a
file = IO MediaFile -> m MediaFile
forall a. IO a -> m a
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 a. a -> IO a
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 TFileName
--           , 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 TFileName
    IO (Ptr MediaFile)

-- | Creates a new media file for the given filename.
-- 
-- This is a utility function that converts the given /@filename@/
-- to a @GFile@ and calls 'GI.Gtk.Objects.MediaFile.mediaFileNewForFile'.
mediaFileNewForFilename ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    [Char]
    -- ^ /@filename@/: filename to open
    -> m MediaFile
    -- ^ __Returns:__ a new @GtkMediaFile@ playing /@filename@/
mediaFileNewForFilename :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m MediaFile
mediaFileNewForFilename String
filename = IO MediaFile -> m MediaFile
forall a. IO a -> m a
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' <- String -> IO CString
stringToCString String
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 a. a -> IO a
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 @GSeekable@ interface.
mediaFileNewForInputStream ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a) =>
    a
    -- ^ /@stream@/: The stream to play
    -> m MediaFile
    -- ^ __Returns:__ a new @GtkMediaFile@
mediaFileNewForInputStream :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputStream a) =>
a -> m MediaFile
mediaFileNewForInputStream a
stream = IO MediaFile -> m MediaFile
forall a. IO a -> m a
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 a. a -> IO a
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)

-- | Creates a new new media file for the given resource.
-- 
-- This is a utility function that converts the given /@resource@/
-- to a @GFile@ 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 @GtkMediaFile@ playing /@resourcePath@/
mediaFileNewForResource :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m MediaFile
mediaFileNewForResource Text
resourcePath = IO MediaFile -> m MediaFile
forall a. IO a -> m a
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 a. a -> IO a
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 @GtkMediaFile@
    -> m ()
mediaFileClear :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMediaFile a) =>
a -> m ()
mediaFileClear a
self = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo MediaFileClearMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.MediaFile.mediaFileClear",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-MediaFile.html#v: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 @GtkMediaFile@
    -> m (Maybe Gio.File.File)
    -- ^ __Returns:__ The currently playing file
mediaFileGetFile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMediaFile a) =>
a -> m (Maybe File)
mediaFileGetFile a
self = IO (Maybe File) -> m (Maybe File)
forall a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod MediaFileGetFileMethodInfo a signature where
    overloadedMethod = mediaFileGetFile

instance O.OverloadedMethodInfo MediaFileGetFileMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.MediaFile.mediaFileGetFile",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-MediaFile.html#v: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 @GtkMediaFile@
    -> m (Maybe Gio.InputStream.InputStream)
    -- ^ __Returns:__ The currently playing stream
mediaFileGetInputStream :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMediaFile a) =>
a -> m (Maybe InputStream)
mediaFileGetInputStream a
self = IO (Maybe InputStream) -> m (Maybe InputStream)
forall a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod MediaFileGetInputStreamMethodInfo a signature where
    overloadedMethod = mediaFileGetInputStream

instance O.OverloadedMethodInfo MediaFileGetInputStreamMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.MediaFile.mediaFileGetInputStream",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-MediaFile.html#v: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 ()

-- | Sets the @GtkMediaFile@ to play the given file.
-- 
-- If any file is still playing, stop playing it.
mediaFileSetFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a, Gio.File.IsFile b) =>
    a
    -- ^ /@self@/: a @GtkMediaFile@
    -> Maybe (b)
    -- ^ /@file@/: the file to play
    -> m ()
mediaFileSetFile :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMediaFile a, IsFile b) =>
a -> Maybe b -> m ()
mediaFileSetFile a
self Maybe b
file = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod MediaFileSetFileMethodInfo a signature where
    overloadedMethod = mediaFileSetFile

instance O.OverloadedMethodInfo MediaFileSetFileMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.MediaFile.mediaFileSetFile",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-MediaFile.html#v: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 TFileName
--           , 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 TFileName
    IO ()

-- | Sets the @GtkMediaFile to play the given file.
-- 
-- This is a utility function that converts the given \@filename
-- to a @GFile\` and calls 'GI.Gtk.Objects.MediaFile.mediaFileSetFile'.
mediaFileSetFilename ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a) =>
    a
    -- ^ /@self@/: a @GtkMediaFile@
    -> Maybe ([Char])
    -- ^ /@filename@/: name of file to play
    -> m ()
mediaFileSetFilename :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMediaFile a) =>
a -> Maybe String -> m ()
mediaFileSetFilename a
self Maybe String
filename = IO () -> m ()
forall a. IO a -> m a
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 String
filename of
        Maybe String
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just String
jFilename -> do
            CString
jFilename' <- String -> IO CString
stringToCString String
jFilename
            CString -> IO CString
forall a. a -> IO a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MediaFileSetFilenameMethodInfo
instance (signature ~ (Maybe ([Char]) -> m ()), MonadIO m, IsMediaFile a) => O.OverloadedMethod MediaFileSetFilenameMethodInfo a signature where
    overloadedMethod = mediaFileSetFilename

instance O.OverloadedMethodInfo MediaFileSetFilenameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.MediaFile.mediaFileSetFilename",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-MediaFile.html#v: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 ()

-- | Sets the @GtkMediaFile@ to play the given stream.
-- 
-- If anything is still playing, stop playing it.
-- 
-- Full control about the /@stream@/ is assumed for the duration of
-- playback. The stream will not be closed.
mediaFileSetInputStream ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a, Gio.InputStream.IsInputStream b) =>
    a
    -- ^ /@self@/: a @GtkMediaFile@
    -> Maybe (b)
    -- ^ /@stream@/: the stream to play from
    -> m ()
mediaFileSetInputStream :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMediaFile a, IsInputStream b) =>
a -> Maybe b -> m ()
mediaFileSetInputStream a
self Maybe b
stream = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod MediaFileSetInputStreamMethodInfo a signature where
    overloadedMethod = mediaFileSetInputStream

instance O.OverloadedMethodInfo MediaFileSetInputStreamMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.MediaFile.mediaFileSetInputStream",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-MediaFile.html#v: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 ()

-- | Sets the @GtkMediaFile to play the given resource.
-- 
-- This is a utility function that converts the given \@resource_path
-- to a @GFile\` and calls 'GI.Gtk.Objects.MediaFile.mediaFileSetFile'.
mediaFileSetResource ::
    (B.CallStack.HasCallStack, MonadIO m, IsMediaFile a) =>
    a
    -- ^ /@self@/: a @GtkMediaFile@
    -> Maybe (T.Text)
    -- ^ /@resourcePath@/: path to resource to play
    -> m ()
mediaFileSetResource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMediaFile a) =>
a -> Maybe Text -> m ()
mediaFileSetResource a
self Maybe Text
resourcePath = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod MediaFileSetResourceMethodInfo a signature where
    overloadedMethod = mediaFileSetResource

instance O.OverloadedMethodInfo MediaFileSetResourceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.MediaFile.mediaFileSetResource",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-MediaFile.html#v:mediaFileSetResource"
        })


#endif