{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Atk.Interfaces.StreamableContent
(
StreamableContent(..) ,
IsStreamableContent ,
#if defined(ENABLE_OVERLOADING)
ResolveStreamableContentMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
StreamableContentGetMimeTypeMethodInfo ,
#endif
streamableContentGetMimeType ,
#if defined(ENABLE_OVERLOADING)
StreamableContentGetNMimeTypesMethodInfo,
#endif
streamableContentGetNMimeTypes ,
#if defined(ENABLE_OVERLOADING)
StreamableContentGetStreamMethodInfo ,
#endif
streamableContentGetStream ,
#if defined(ENABLE_OVERLOADING)
StreamableContentGetUriMethodInfo ,
#endif
streamableContentGetUri ,
) 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.Kind as DK
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.GLib.Structs.IOChannel as GLib.IOChannel
newtype StreamableContent = StreamableContent (SP.ManagedPtr StreamableContent)
deriving (StreamableContent -> StreamableContent -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StreamableContent -> StreamableContent -> Bool
$c/= :: StreamableContent -> StreamableContent -> Bool
== :: StreamableContent -> StreamableContent -> Bool
$c== :: StreamableContent -> StreamableContent -> Bool
Eq)
instance SP.ManagedPtrNewtype StreamableContent where
toManagedPtr :: StreamableContent -> ManagedPtr StreamableContent
toManagedPtr (StreamableContent ManagedPtr StreamableContent
p) = ManagedPtr StreamableContent
p
class (ManagedPtrNewtype o, O.IsDescendantOf StreamableContent o) => IsStreamableContent o
instance (ManagedPtrNewtype o, O.IsDescendantOf StreamableContent o) => IsStreamableContent o
instance BoxedPtr StreamableContent where
boxedPtrCopy :: StreamableContent -> IO StreamableContent
boxedPtrCopy = forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: StreamableContent -> IO ()
boxedPtrFree = \StreamableContent
_x -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
type family ResolveStreamableContentMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveStreamableContentMethod "getMimeType" o = StreamableContentGetMimeTypeMethodInfo
ResolveStreamableContentMethod "getNMimeTypes" o = StreamableContentGetNMimeTypesMethodInfo
ResolveStreamableContentMethod "getStream" o = StreamableContentGetStreamMethodInfo
ResolveStreamableContentMethod "getUri" o = StreamableContentGetUriMethodInfo
ResolveStreamableContentMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveStreamableContentMethod t StreamableContent, O.OverloadedMethod info StreamableContent p) => OL.IsLabel t (StreamableContent -> 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 ~ ResolveStreamableContentMethod t StreamableContent, O.OverloadedMethod info StreamableContent p, R.HasField t StreamableContent p) => R.HasField t StreamableContent p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveStreamableContentMethod t StreamableContent, O.OverloadedMethodInfo info StreamableContent) => OL.IsLabel t (O.MethodProxy info StreamableContent) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "atk_streamable_content_get_mime_type" atk_streamable_content_get_mime_type ::
Ptr StreamableContent ->
Int32 ->
IO CString
streamableContentGetMimeType ::
(B.CallStack.HasCallStack, MonadIO m, IsStreamableContent a) =>
a
-> Int32
-> m T.Text
streamableContentGetMimeType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStreamableContent a) =>
a -> Int32 -> m Text
streamableContentGetMimeType a
streamable Int32
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr StreamableContent
streamable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
streamable
CString
result <- Ptr StreamableContent -> Int32 -> IO CString
atk_streamable_content_get_mime_type Ptr StreamableContent
streamable' Int32
i
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"streamableContentGetMimeType" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
streamable
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data StreamableContentGetMimeTypeMethodInfo
instance (signature ~ (Int32 -> m T.Text), MonadIO m, IsStreamableContent a) => O.OverloadedMethod StreamableContentGetMimeTypeMethodInfo a signature where
overloadedMethod = streamableContentGetMimeType
instance O.OverloadedMethodInfo StreamableContentGetMimeTypeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.StreamableContent.streamableContentGetMimeType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-StreamableContent.html#v:streamableContentGetMimeType"
})
#endif
foreign import ccall "atk_streamable_content_get_n_mime_types" atk_streamable_content_get_n_mime_types ::
Ptr StreamableContent ->
IO Int32
streamableContentGetNMimeTypes ::
(B.CallStack.HasCallStack, MonadIO m, IsStreamableContent a) =>
a
-> m Int32
streamableContentGetNMimeTypes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStreamableContent a) =>
a -> m Int32
streamableContentGetNMimeTypes a
streamable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr StreamableContent
streamable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
streamable
Int32
result <- Ptr StreamableContent -> IO Int32
atk_streamable_content_get_n_mime_types Ptr StreamableContent
streamable'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
streamable
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data StreamableContentGetNMimeTypesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsStreamableContent a) => O.OverloadedMethod StreamableContentGetNMimeTypesMethodInfo a signature where
overloadedMethod = streamableContentGetNMimeTypes
instance O.OverloadedMethodInfo StreamableContentGetNMimeTypesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.StreamableContent.streamableContentGetNMimeTypes",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-StreamableContent.html#v:streamableContentGetNMimeTypes"
})
#endif
foreign import ccall "atk_streamable_content_get_stream" atk_streamable_content_get_stream ::
Ptr StreamableContent ->
CString ->
IO (Ptr GLib.IOChannel.IOChannel)
streamableContentGetStream ::
(B.CallStack.HasCallStack, MonadIO m, IsStreamableContent a) =>
a
-> T.Text
-> m GLib.IOChannel.IOChannel
streamableContentGetStream :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStreamableContent a) =>
a -> Text -> m IOChannel
streamableContentGetStream a
streamable Text
mimeType = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr StreamableContent
streamable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
streamable
CString
mimeType' <- Text -> IO CString
textToCString Text
mimeType
Ptr IOChannel
result <- Ptr StreamableContent -> CString -> IO (Ptr IOChannel)
atk_streamable_content_get_stream Ptr StreamableContent
streamable' CString
mimeType'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"streamableContentGetStream" Ptr IOChannel
result
IOChannel
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr IOChannel -> IOChannel
GLib.IOChannel.IOChannel) Ptr IOChannel
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
streamable
forall a. Ptr a -> IO ()
freeMem CString
mimeType'
forall (m :: * -> *) a. Monad m => a -> m a
return IOChannel
result'
#if defined(ENABLE_OVERLOADING)
data StreamableContentGetStreamMethodInfo
instance (signature ~ (T.Text -> m GLib.IOChannel.IOChannel), MonadIO m, IsStreamableContent a) => O.OverloadedMethod StreamableContentGetStreamMethodInfo a signature where
overloadedMethod = streamableContentGetStream
instance O.OverloadedMethodInfo StreamableContentGetStreamMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.StreamableContent.streamableContentGetStream",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-StreamableContent.html#v:streamableContentGetStream"
})
#endif
foreign import ccall "atk_streamable_content_get_uri" atk_streamable_content_get_uri ::
Ptr StreamableContent ->
CString ->
IO CString
streamableContentGetUri ::
(B.CallStack.HasCallStack, MonadIO m, IsStreamableContent a) =>
a
-> T.Text
-> m (Maybe T.Text)
streamableContentGetUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStreamableContent a) =>
a -> Text -> m (Maybe Text)
streamableContentGetUri a
streamable Text
mimeType = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr StreamableContent
streamable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
streamable
CString
mimeType' <- Text -> IO CString
textToCString Text
mimeType
CString
result <- Ptr StreamableContent -> CString -> IO CString
atk_streamable_content_get_uri Ptr StreamableContent
streamable' CString
mimeType'
Maybe Text
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
streamable
forall a. Ptr a -> IO ()
freeMem CString
mimeType'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data StreamableContentGetUriMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsStreamableContent a) => O.OverloadedMethod StreamableContentGetUriMethodInfo a signature where
overloadedMethod = streamableContentGetUri
instance O.OverloadedMethodInfo StreamableContentGetUriMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.StreamableContent.streamableContentGetUri",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-StreamableContent.html#v:streamableContentGetUri"
})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList StreamableContent = StreamableContentSignalList
type StreamableContentSignalList = ('[ ] :: [(Symbol, DK.Type)])
#endif