{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Objects.ContentSerializer
(
ContentSerializer(..) ,
IsContentSerializer ,
toContentSerializer ,
noContentSerializer ,
#if defined(ENABLE_OVERLOADING)
ResolveContentSerializerMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetCancellableMethodInfo,
#endif
contentSerializerGetCancellable ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetGtypeMethodInfo ,
#endif
contentSerializerGetGtype ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetMimeTypeMethodInfo ,
#endif
contentSerializerGetMimeType ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetOutputStreamMethodInfo,
#endif
contentSerializerGetOutputStream ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetPriorityMethodInfo ,
#endif
contentSerializerGetPriority ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetTaskDataMethodInfo ,
#endif
contentSerializerGetTaskData ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetUserDataMethodInfo ,
#endif
contentSerializerGetUserData ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetValueMethodInfo ,
#endif
contentSerializerGetValue ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerReturnErrorMethodInfo ,
#endif
contentSerializerReturnError ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerReturnSuccessMethodInfo,
#endif
contentSerializerReturnSuccess ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerSetTaskDataMethodInfo ,
#endif
contentSerializerSetTaskData ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.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 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.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
newtype ContentSerializer = ContentSerializer (ManagedPtr ContentSerializer)
deriving (ContentSerializer -> ContentSerializer -> Bool
(ContentSerializer -> ContentSerializer -> Bool)
-> (ContentSerializer -> ContentSerializer -> Bool)
-> Eq ContentSerializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ContentSerializer -> ContentSerializer -> Bool
$c/= :: ContentSerializer -> ContentSerializer -> Bool
== :: ContentSerializer -> ContentSerializer -> Bool
$c== :: ContentSerializer -> ContentSerializer -> Bool
Eq)
foreign import ccall "gdk_content_serializer_get_type"
c_gdk_content_serializer_get_type :: IO GType
instance GObject ContentSerializer where
gobjectType :: IO GType
gobjectType = IO GType
c_gdk_content_serializer_get_type
instance B.GValue.IsGValue ContentSerializer where
toGValue :: ContentSerializer -> IO GValue
toGValue o :: ContentSerializer
o = do
GType
gtype <- IO GType
c_gdk_content_serializer_get_type
ContentSerializer
-> (Ptr ContentSerializer -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ContentSerializer
o (GType
-> (GValue -> Ptr ContentSerializer -> IO ())
-> Ptr ContentSerializer
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr ContentSerializer -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO ContentSerializer
fromGValue gv :: GValue
gv = do
Ptr ContentSerializer
ptr <- GValue -> IO (Ptr ContentSerializer)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr ContentSerializer)
(ManagedPtr ContentSerializer -> ContentSerializer)
-> Ptr ContentSerializer -> IO ContentSerializer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ContentSerializer -> ContentSerializer
ContentSerializer Ptr ContentSerializer
ptr
class (GObject o, O.IsDescendantOf ContentSerializer o) => IsContentSerializer o
instance (GObject o, O.IsDescendantOf ContentSerializer o) => IsContentSerializer o
instance O.HasParentTypes ContentSerializer
type instance O.ParentTypes ContentSerializer = '[GObject.Object.Object, Gio.AsyncResult.AsyncResult]
toContentSerializer :: (MonadIO m, IsContentSerializer o) => o -> m ContentSerializer
toContentSerializer :: o -> m ContentSerializer
toContentSerializer = IO ContentSerializer -> m ContentSerializer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ContentSerializer -> m ContentSerializer)
-> (o -> IO ContentSerializer) -> o -> m ContentSerializer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ContentSerializer -> ContentSerializer)
-> o -> IO ContentSerializer
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr ContentSerializer -> ContentSerializer
ContentSerializer
noContentSerializer :: Maybe ContentSerializer
noContentSerializer :: Maybe ContentSerializer
noContentSerializer = Maybe ContentSerializer
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveContentSerializerMethod (t :: Symbol) (o :: *) :: * where
ResolveContentSerializerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveContentSerializerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveContentSerializerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveContentSerializerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveContentSerializerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveContentSerializerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveContentSerializerMethod "isTagged" o = Gio.AsyncResult.AsyncResultIsTaggedMethodInfo
ResolveContentSerializerMethod "legacyPropagateError" o = Gio.AsyncResult.AsyncResultLegacyPropagateErrorMethodInfo
ResolveContentSerializerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveContentSerializerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveContentSerializerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveContentSerializerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveContentSerializerMethod "returnError" o = ContentSerializerReturnErrorMethodInfo
ResolveContentSerializerMethod "returnSuccess" o = ContentSerializerReturnSuccessMethodInfo
ResolveContentSerializerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveContentSerializerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveContentSerializerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveContentSerializerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveContentSerializerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveContentSerializerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveContentSerializerMethod "getCancellable" o = ContentSerializerGetCancellableMethodInfo
ResolveContentSerializerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveContentSerializerMethod "getGtype" o = ContentSerializerGetGtypeMethodInfo
ResolveContentSerializerMethod "getMimeType" o = ContentSerializerGetMimeTypeMethodInfo
ResolveContentSerializerMethod "getOutputStream" o = ContentSerializerGetOutputStreamMethodInfo
ResolveContentSerializerMethod "getPriority" o = ContentSerializerGetPriorityMethodInfo
ResolveContentSerializerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveContentSerializerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveContentSerializerMethod "getSourceObject" o = Gio.AsyncResult.AsyncResultGetSourceObjectMethodInfo
ResolveContentSerializerMethod "getTaskData" o = ContentSerializerGetTaskDataMethodInfo
ResolveContentSerializerMethod "getUserData" o = ContentSerializerGetUserDataMethodInfo
ResolveContentSerializerMethod "getValue" o = ContentSerializerGetValueMethodInfo
ResolveContentSerializerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveContentSerializerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveContentSerializerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveContentSerializerMethod "setTaskData" o = ContentSerializerSetTaskDataMethodInfo
ResolveContentSerializerMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveContentSerializerMethod t ContentSerializer, O.MethodInfo info ContentSerializer p) => OL.IsLabel t (ContentSerializer -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ContentSerializer
type instance O.AttributeList ContentSerializer = ContentSerializerAttributeList
type ContentSerializerAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ContentSerializer = ContentSerializerSignalList
type ContentSerializerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gdk_content_serializer_get_cancellable" gdk_content_serializer_get_cancellable ::
Ptr ContentSerializer ->
IO (Ptr Gio.Cancellable.Cancellable)
contentSerializerGetCancellable ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m Gio.Cancellable.Cancellable
contentSerializerGetCancellable :: a -> m Cancellable
contentSerializerGetCancellable serializer :: a
serializer = IO Cancellable -> m Cancellable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Cancellable -> m Cancellable)
-> IO Cancellable -> m Cancellable
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr Cancellable
result <- Ptr ContentSerializer -> IO (Ptr Cancellable)
gdk_content_serializer_get_cancellable Ptr ContentSerializer
serializer'
Text -> Ptr Cancellable -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "contentSerializerGetCancellable" Ptr Cancellable
result
Cancellable
result' <- ((ManagedPtr Cancellable -> Cancellable)
-> Ptr Cancellable -> IO Cancellable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Cancellable -> Cancellable
Gio.Cancellable.Cancellable) Ptr Cancellable
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Cancellable -> IO Cancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Cancellable
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetCancellableMethodInfo
instance (signature ~ (m Gio.Cancellable.Cancellable), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerGetCancellableMethodInfo a signature where
overloadedMethod = contentSerializerGetCancellable
#endif
foreign import ccall "gdk_content_serializer_get_gtype" gdk_content_serializer_get_gtype ::
Ptr ContentSerializer ->
IO CGType
contentSerializerGetGtype ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m GType
contentSerializerGetGtype :: a -> m GType
contentSerializerGetGtype serializer :: a
serializer = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
CGType
result <- Ptr ContentSerializer -> IO CGType
gdk_content_serializer_get_gtype Ptr ContentSerializer
serializer'
let result' :: GType
result' = CGType -> GType
GType CGType
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetGtypeMethodInfo
instance (signature ~ (m GType), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerGetGtypeMethodInfo a signature where
overloadedMethod = contentSerializerGetGtype
#endif
foreign import ccall "gdk_content_serializer_get_mime_type" gdk_content_serializer_get_mime_type ::
Ptr ContentSerializer ->
IO CString
contentSerializerGetMimeType ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m T.Text
contentSerializerGetMimeType :: a -> m Text
contentSerializerGetMimeType serializer :: a
serializer = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
CString
result <- Ptr ContentSerializer -> IO CString
gdk_content_serializer_get_mime_type Ptr ContentSerializer
serializer'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "contentSerializerGetMimeType" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetMimeTypeMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerGetMimeTypeMethodInfo a signature where
overloadedMethod = contentSerializerGetMimeType
#endif
foreign import ccall "gdk_content_serializer_get_output_stream" gdk_content_serializer_get_output_stream ::
Ptr ContentSerializer ->
IO (Ptr Gio.OutputStream.OutputStream)
contentSerializerGetOutputStream ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m Gio.OutputStream.OutputStream
contentSerializerGetOutputStream :: a -> m OutputStream
contentSerializerGetOutputStream serializer :: a
serializer = IO OutputStream -> m OutputStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO OutputStream -> m OutputStream)
-> IO OutputStream -> m OutputStream
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr OutputStream
result <- Ptr ContentSerializer -> IO (Ptr OutputStream)
gdk_content_serializer_get_output_stream Ptr ContentSerializer
serializer'
Text -> Ptr OutputStream -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "contentSerializerGetOutputStream" Ptr OutputStream
result
OutputStream
result' <- ((ManagedPtr OutputStream -> OutputStream)
-> Ptr OutputStream -> IO OutputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr OutputStream -> OutputStream
Gio.OutputStream.OutputStream) Ptr OutputStream
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
OutputStream -> IO OutputStream
forall (m :: * -> *) a. Monad m => a -> m a
return OutputStream
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetOutputStreamMethodInfo
instance (signature ~ (m Gio.OutputStream.OutputStream), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerGetOutputStreamMethodInfo a signature where
overloadedMethod = contentSerializerGetOutputStream
#endif
foreign import ccall "gdk_content_serializer_get_priority" gdk_content_serializer_get_priority ::
Ptr ContentSerializer ->
IO Int32
contentSerializerGetPriority ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m Int32
contentSerializerGetPriority :: a -> m Int32
contentSerializerGetPriority serializer :: a
serializer = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Int32
result <- Ptr ContentSerializer -> IO Int32
gdk_content_serializer_get_priority Ptr ContentSerializer
serializer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetPriorityMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerGetPriorityMethodInfo a signature where
overloadedMethod = contentSerializerGetPriority
#endif
foreign import ccall "gdk_content_serializer_get_task_data" gdk_content_serializer_get_task_data ::
Ptr ContentSerializer ->
IO (Ptr ())
contentSerializerGetTaskData ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m (Ptr ())
contentSerializerGetTaskData :: a -> m (Ptr ())
contentSerializerGetTaskData serializer :: a
serializer = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr ()
result <- Ptr ContentSerializer -> IO (Ptr ())
gdk_content_serializer_get_task_data Ptr ContentSerializer
serializer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetTaskDataMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerGetTaskDataMethodInfo a signature where
overloadedMethod = contentSerializerGetTaskData
#endif
foreign import ccall "gdk_content_serializer_get_user_data" gdk_content_serializer_get_user_data ::
Ptr ContentSerializer ->
IO (Ptr ())
contentSerializerGetUserData ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m (Ptr ())
contentSerializerGetUserData :: a -> m (Ptr ())
contentSerializerGetUserData serializer :: a
serializer = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr ()
result <- Ptr ContentSerializer -> IO (Ptr ())
gdk_content_serializer_get_user_data Ptr ContentSerializer
serializer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetUserDataMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerGetUserDataMethodInfo a signature where
overloadedMethod = contentSerializerGetUserData
#endif
foreign import ccall "gdk_content_serializer_get_value" gdk_content_serializer_get_value ::
Ptr ContentSerializer ->
IO (Ptr GValue)
contentSerializerGetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m GValue
contentSerializerGetValue :: a -> m GValue
contentSerializerGetValue serializer :: a
serializer = IO GValue -> m GValue
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr GValue
result <- Ptr ContentSerializer -> IO (Ptr GValue)
gdk_content_serializer_get_value Ptr ContentSerializer
serializer'
Text -> Ptr GValue -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "contentSerializerGetValue" Ptr GValue
result
GValue
result' <- ((ManagedPtr GValue -> GValue) -> Ptr GValue -> IO GValue
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr GValue -> GValue
GValue) Ptr GValue
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
GValue -> IO GValue
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetValueMethodInfo
instance (signature ~ (m GValue), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerGetValueMethodInfo a signature where
overloadedMethod = contentSerializerGetValue
#endif
foreign import ccall "gdk_content_serializer_return_error" gdk_content_serializer_return_error ::
Ptr ContentSerializer ->
Ptr GError ->
IO ()
contentSerializerReturnError ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> GError
-> m ()
contentSerializerReturnError :: a -> GError -> m ()
contentSerializerReturnError serializer :: a
serializer error_ :: GError
error_ = 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 ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GError
error_
Ptr ContentSerializer -> Ptr GError -> IO ()
gdk_content_serializer_return_error Ptr ContentSerializer
serializer' Ptr GError
error_'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ContentSerializerReturnErrorMethodInfo
instance (signature ~ (GError -> m ()), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerReturnErrorMethodInfo a signature where
overloadedMethod = contentSerializerReturnError
#endif
foreign import ccall "gdk_content_serializer_return_success" gdk_content_serializer_return_success ::
Ptr ContentSerializer ->
IO ()
contentSerializerReturnSuccess ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m ()
contentSerializerReturnSuccess :: a -> m ()
contentSerializerReturnSuccess serializer :: a
serializer = 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 ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr ContentSerializer -> IO ()
gdk_content_serializer_return_success Ptr ContentSerializer
serializer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ContentSerializerReturnSuccessMethodInfo
instance (signature ~ (m ()), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerReturnSuccessMethodInfo a signature where
overloadedMethod = contentSerializerReturnSuccess
#endif
foreign import ccall "gdk_content_serializer_set_task_data" gdk_content_serializer_set_task_data ::
Ptr ContentSerializer ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
contentSerializerSetTaskData ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> Ptr ()
-> GLib.Callbacks.DestroyNotify
-> m ()
contentSerializerSetTaskData :: a -> Ptr () -> DestroyNotify -> m ()
contentSerializerSetTaskData serializer :: a
serializer data_ :: Ptr ()
data_ notify :: DestroyNotify
notify = 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 ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr (FunPtr DestroyNotify)
ptrnotify <- IO (Ptr (FunPtr DestroyNotify))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
FunPtr DestroyNotify
notify' <- DestroyNotify -> IO (FunPtr DestroyNotify)
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr DestroyNotify))
-> DestroyNotify -> DestroyNotify
GLib.Callbacks.wrap_DestroyNotify (Ptr (FunPtr DestroyNotify) -> Maybe (Ptr (FunPtr DestroyNotify))
forall a. a -> Maybe a
Just Ptr (FunPtr DestroyNotify)
ptrnotify) DestroyNotify
notify)
Ptr (FunPtr DestroyNotify) -> FunPtr DestroyNotify -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr DestroyNotify)
ptrnotify FunPtr DestroyNotify
notify'
Ptr ContentSerializer -> Ptr () -> FunPtr DestroyNotify -> IO ()
gdk_content_serializer_set_task_data Ptr ContentSerializer
serializer' Ptr ()
data_ FunPtr DestroyNotify
notify'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ContentSerializerSetTaskDataMethodInfo
instance (signature ~ (Ptr () -> GLib.Callbacks.DestroyNotify -> m ()), MonadIO m, IsContentSerializer a) => O.MethodInfo ContentSerializerSetTaskDataMethodInfo a signature where
overloadedMethod = contentSerializerSetTaskData
#endif