{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.Task
(
Task(..) ,
IsTask ,
toTask ,
#if defined(ENABLE_OVERLOADING)
ResolveTaskMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TaskGetCancellableMethodInfo ,
#endif
taskGetCancellable ,
#if defined(ENABLE_OVERLOADING)
TaskGetCheckCancellableMethodInfo ,
#endif
taskGetCheckCancellable ,
#if defined(ENABLE_OVERLOADING)
TaskGetCompletedMethodInfo ,
#endif
taskGetCompleted ,
#if defined(ENABLE_OVERLOADING)
TaskGetContextMethodInfo ,
#endif
taskGetContext ,
#if defined(ENABLE_OVERLOADING)
TaskGetNameMethodInfo ,
#endif
taskGetName ,
#if defined(ENABLE_OVERLOADING)
TaskGetPriorityMethodInfo ,
#endif
taskGetPriority ,
#if defined(ENABLE_OVERLOADING)
TaskGetReturnOnCancelMethodInfo ,
#endif
taskGetReturnOnCancel ,
#if defined(ENABLE_OVERLOADING)
TaskGetSourceObjectMethodInfo ,
#endif
taskGetSourceObject ,
#if defined(ENABLE_OVERLOADING)
TaskGetSourceTagMethodInfo ,
#endif
taskGetSourceTag ,
#if defined(ENABLE_OVERLOADING)
TaskGetTaskDataMethodInfo ,
#endif
taskGetTaskData ,
#if defined(ENABLE_OVERLOADING)
TaskHadErrorMethodInfo ,
#endif
taskHadError ,
taskIsValid ,
taskNew ,
#if defined(ENABLE_OVERLOADING)
TaskPropagateBooleanMethodInfo ,
#endif
taskPropagateBoolean ,
#if defined(ENABLE_OVERLOADING)
TaskPropagateIntMethodInfo ,
#endif
taskPropagateInt ,
#if defined(ENABLE_OVERLOADING)
TaskPropagatePointerMethodInfo ,
#endif
taskPropagatePointer ,
#if defined(ENABLE_OVERLOADING)
TaskPropagateValueMethodInfo ,
#endif
taskPropagateValue ,
taskReportError ,
#if defined(ENABLE_OVERLOADING)
TaskReturnBooleanMethodInfo ,
#endif
taskReturnBoolean ,
#if defined(ENABLE_OVERLOADING)
TaskReturnErrorMethodInfo ,
#endif
taskReturnError ,
#if defined(ENABLE_OVERLOADING)
TaskReturnErrorIfCancelledMethodInfo ,
#endif
taskReturnErrorIfCancelled ,
#if defined(ENABLE_OVERLOADING)
TaskReturnIntMethodInfo ,
#endif
taskReturnInt ,
#if defined(ENABLE_OVERLOADING)
TaskReturnPointerMethodInfo ,
#endif
taskReturnPointer ,
#if defined(ENABLE_OVERLOADING)
TaskReturnValueMethodInfo ,
#endif
taskReturnValue ,
#if defined(ENABLE_OVERLOADING)
TaskRunInThreadMethodInfo ,
#endif
taskRunInThread ,
#if defined(ENABLE_OVERLOADING)
TaskRunInThreadSyncMethodInfo ,
#endif
taskRunInThreadSync ,
#if defined(ENABLE_OVERLOADING)
TaskSetCheckCancellableMethodInfo ,
#endif
taskSetCheckCancellable ,
#if defined(ENABLE_OVERLOADING)
TaskSetNameMethodInfo ,
#endif
taskSetName ,
#if defined(ENABLE_OVERLOADING)
TaskSetPriorityMethodInfo ,
#endif
taskSetPriority ,
#if defined(ENABLE_OVERLOADING)
TaskSetReturnOnCancelMethodInfo ,
#endif
taskSetReturnOnCancel ,
#if defined(ENABLE_OVERLOADING)
TaskSetSourceTagMethodInfo ,
#endif
taskSetSourceTag ,
#if defined(ENABLE_OVERLOADING)
TaskSetStaticNameMethodInfo ,
#endif
taskSetStaticName ,
#if defined(ENABLE_OVERLOADING)
TaskSetTaskDataMethodInfo ,
#endif
taskSetTaskData ,
#if defined(ENABLE_OVERLOADING)
TaskCompletedPropertyInfo ,
#endif
getTaskCompleted ,
#if defined(ENABLE_OVERLOADING)
taskCompleted ,
#endif
) 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.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.MainContext as GLib.MainContext
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
newtype Task = Task (SP.ManagedPtr Task)
deriving (Task -> Task -> Bool
(Task -> Task -> Bool) -> (Task -> Task -> Bool) -> Eq Task
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Task -> Task -> Bool
== :: Task -> Task -> Bool
$c/= :: Task -> Task -> Bool
/= :: Task -> Task -> Bool
Eq)
instance SP.ManagedPtrNewtype Task where
toManagedPtr :: Task -> ManagedPtr Task
toManagedPtr (Task ManagedPtr Task
p) = ManagedPtr Task
p
foreign import ccall "g_task_get_type"
c_g_task_get_type :: IO B.Types.GType
instance B.Types.TypedObject Task where
glibType :: IO GType
glibType = IO GType
c_g_task_get_type
instance B.Types.GObject Task
class (SP.GObject o, O.IsDescendantOf Task o) => IsTask o
instance (SP.GObject o, O.IsDescendantOf Task o) => IsTask o
instance O.HasParentTypes Task
type instance O.ParentTypes Task = '[GObject.Object.Object, Gio.AsyncResult.AsyncResult]
toTask :: (MIO.MonadIO m, IsTask o) => o -> m Task
toTask :: forall (m :: * -> *) o. (MonadIO m, IsTask o) => o -> m Task
toTask = IO Task -> m Task
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Task -> m Task) -> (o -> IO Task) -> o -> m Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Task -> Task) -> o -> IO Task
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Task -> Task
Task
instance B.GValue.IsGValue (Maybe Task) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_task_get_type
gvalueSet_ :: Ptr GValue -> Maybe Task -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Task
P.Nothing = Ptr GValue -> Ptr Task -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Task
forall a. Ptr a
FP.nullPtr :: FP.Ptr Task)
gvalueSet_ Ptr GValue
gv (P.Just Task
obj) = Task -> (Ptr Task -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Task
obj (Ptr GValue -> Ptr Task -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Task)
gvalueGet_ Ptr GValue
gv = do
Ptr Task
ptr <- Ptr GValue -> IO (Ptr Task)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Task)
if Ptr Task
ptr Ptr Task -> Ptr Task -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Task
forall a. Ptr a
FP.nullPtr
then Task -> Maybe Task
forall a. a -> Maybe a
P.Just (Task -> Maybe Task) -> IO Task -> IO (Maybe Task)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Task -> Task) -> Ptr Task -> IO Task
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Task -> Task
Task Ptr Task
ptr
else Maybe Task -> IO (Maybe Task)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Task
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveTaskMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTaskMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveTaskMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveTaskMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveTaskMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveTaskMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveTaskMethod "hadError" o = TaskHadErrorMethodInfo
ResolveTaskMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveTaskMethod "isTagged" o = Gio.AsyncResult.AsyncResultIsTaggedMethodInfo
ResolveTaskMethod "legacyPropagateError" o = Gio.AsyncResult.AsyncResultLegacyPropagateErrorMethodInfo
ResolveTaskMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveTaskMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveTaskMethod "propagateBoolean" o = TaskPropagateBooleanMethodInfo
ResolveTaskMethod "propagateInt" o = TaskPropagateIntMethodInfo
ResolveTaskMethod "propagatePointer" o = TaskPropagatePointerMethodInfo
ResolveTaskMethod "propagateValue" o = TaskPropagateValueMethodInfo
ResolveTaskMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveTaskMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveTaskMethod "returnBoolean" o = TaskReturnBooleanMethodInfo
ResolveTaskMethod "returnError" o = TaskReturnErrorMethodInfo
ResolveTaskMethod "returnErrorIfCancelled" o = TaskReturnErrorIfCancelledMethodInfo
ResolveTaskMethod "returnInt" o = TaskReturnIntMethodInfo
ResolveTaskMethod "returnPointer" o = TaskReturnPointerMethodInfo
ResolveTaskMethod "returnValue" o = TaskReturnValueMethodInfo
ResolveTaskMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveTaskMethod "runInThread" o = TaskRunInThreadMethodInfo
ResolveTaskMethod "runInThreadSync" o = TaskRunInThreadSyncMethodInfo
ResolveTaskMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveTaskMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveTaskMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveTaskMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveTaskMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveTaskMethod "getCancellable" o = TaskGetCancellableMethodInfo
ResolveTaskMethod "getCheckCancellable" o = TaskGetCheckCancellableMethodInfo
ResolveTaskMethod "getCompleted" o = TaskGetCompletedMethodInfo
ResolveTaskMethod "getContext" o = TaskGetContextMethodInfo
ResolveTaskMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveTaskMethod "getName" o = TaskGetNameMethodInfo
ResolveTaskMethod "getPriority" o = TaskGetPriorityMethodInfo
ResolveTaskMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveTaskMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveTaskMethod "getReturnOnCancel" o = TaskGetReturnOnCancelMethodInfo
ResolveTaskMethod "getSourceObject" o = TaskGetSourceObjectMethodInfo
ResolveTaskMethod "getSourceTag" o = TaskGetSourceTagMethodInfo
ResolveTaskMethod "getTaskData" o = TaskGetTaskDataMethodInfo
ResolveTaskMethod "getUserData" o = Gio.AsyncResult.AsyncResultGetUserDataMethodInfo
ResolveTaskMethod "setCheckCancellable" o = TaskSetCheckCancellableMethodInfo
ResolveTaskMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveTaskMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveTaskMethod "setName" o = TaskSetNameMethodInfo
ResolveTaskMethod "setPriority" o = TaskSetPriorityMethodInfo
ResolveTaskMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveTaskMethod "setReturnOnCancel" o = TaskSetReturnOnCancelMethodInfo
ResolveTaskMethod "setSourceTag" o = TaskSetSourceTagMethodInfo
ResolveTaskMethod "setStaticName" o = TaskSetStaticNameMethodInfo
ResolveTaskMethod "setTaskData" o = TaskSetTaskDataMethodInfo
ResolveTaskMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTaskMethod t Task, O.OverloadedMethod info Task p) => OL.IsLabel t (Task -> 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 ~ ResolveTaskMethod t Task, O.OverloadedMethod info Task p, R.HasField t Task p) => R.HasField t Task p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTaskMethod t Task, O.OverloadedMethodInfo info Task) => OL.IsLabel t (O.MethodProxy info Task) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getTaskCompleted :: (MonadIO m, IsTask o) => o -> m Bool
getTaskCompleted :: forall (m :: * -> *) o. (MonadIO m, IsTask o) => o -> m Bool
getTaskCompleted o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"completed"
#if defined(ENABLE_OVERLOADING)
data TaskCompletedPropertyInfo
instance AttrInfo TaskCompletedPropertyInfo where
type AttrAllowedOps TaskCompletedPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint TaskCompletedPropertyInfo = IsTask
type AttrSetTypeConstraint TaskCompletedPropertyInfo = (~) ()
type AttrTransferTypeConstraint TaskCompletedPropertyInfo = (~) ()
type AttrTransferType TaskCompletedPropertyInfo = ()
type AttrGetType TaskCompletedPropertyInfo = Bool
type AttrLabel TaskCompletedPropertyInfo = "completed"
type AttrOrigin TaskCompletedPropertyInfo = Task
attrGet = getTaskCompleted
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.completed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#g:attr:completed"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Task
type instance O.AttributeList Task = TaskAttributeList
type TaskAttributeList = ('[ '("completed", TaskCompletedPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
taskCompleted :: AttrLabelProxy "completed"
taskCompleted = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Task = TaskSignalList
type TaskSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_task_new" g_task_new ::
Ptr GObject.Object.Object ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO (Ptr Task)
taskNew ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a, Gio.Cancellable.IsCancellable b) =>
Maybe (a)
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m Task
taskNew :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsCancellable b) =>
Maybe a -> Maybe b -> Maybe AsyncReadyCallback -> m Task
taskNew Maybe a
sourceObject Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO Task -> m Task
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Task -> m Task) -> IO Task -> m Task
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSourceObject <- case Maybe a
sourceObject of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSourceObject -> do
Ptr Object
jSourceObject' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSourceObject
Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSourceObject'
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let callbackData :: Ptr a
callbackData = Ptr a
forall a. Ptr a
nullPtr
Ptr Task
result <- Ptr Object
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO (Ptr Task)
g_task_new Ptr Object
maybeSourceObject Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
callbackData
Text -> Ptr Task -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"taskNew" Ptr Task
result
Task
result' <- ((ManagedPtr Task -> Task) -> Ptr Task -> IO Task
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Task -> Task
Task) Ptr Task
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
sourceObject a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Task -> IO Task
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Task
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_task_get_cancellable" g_task_get_cancellable ::
Ptr Task ->
IO (Ptr Gio.Cancellable.Cancellable)
taskGetCancellable ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m (Maybe Gio.Cancellable.Cancellable)
taskGetCancellable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m (Maybe Cancellable)
taskGetCancellable a
task = IO (Maybe Cancellable) -> m (Maybe Cancellable)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Cancellable) -> m (Maybe Cancellable))
-> IO (Maybe Cancellable) -> m (Maybe Cancellable)
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr Cancellable
result <- Ptr Task -> IO (Ptr Cancellable)
g_task_get_cancellable Ptr Task
task'
Maybe Cancellable
maybeResult <- Ptr Cancellable
-> (Ptr Cancellable -> IO Cancellable) -> IO (Maybe Cancellable)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Cancellable
result ((Ptr Cancellable -> IO Cancellable) -> IO (Maybe Cancellable))
-> (Ptr Cancellable -> IO Cancellable) -> IO (Maybe Cancellable)
forall a b. (a -> b) -> a -> b
$ \Ptr Cancellable
result' -> do
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'
Cancellable -> IO Cancellable
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Cancellable
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Maybe Cancellable -> IO (Maybe Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Cancellable
maybeResult
#if defined(ENABLE_OVERLOADING)
data TaskGetCancellableMethodInfo
instance (signature ~ (m (Maybe Gio.Cancellable.Cancellable)), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetCancellableMethodInfo a signature where
overloadedMethod = taskGetCancellable
instance O.OverloadedMethodInfo TaskGetCancellableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetCancellable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetCancellable"
})
#endif
foreign import ccall "g_task_get_check_cancellable" g_task_get_check_cancellable ::
Ptr Task ->
IO CInt
taskGetCheckCancellable ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskGetCheckCancellable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskGetCheckCancellable a
task = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CInt
result <- Ptr Task -> IO CInt
g_task_get_check_cancellable Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskGetCheckCancellableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetCheckCancellableMethodInfo a signature where
overloadedMethod = taskGetCheckCancellable
instance O.OverloadedMethodInfo TaskGetCheckCancellableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetCheckCancellable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetCheckCancellable"
})
#endif
foreign import ccall "g_task_get_completed" g_task_get_completed ::
Ptr Task ->
IO CInt
taskGetCompleted ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskGetCompleted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskGetCompleted a
task = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CInt
result <- Ptr Task -> IO CInt
g_task_get_completed Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskGetCompletedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetCompletedMethodInfo a signature where
overloadedMethod = taskGetCompleted
instance O.OverloadedMethodInfo TaskGetCompletedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetCompleted",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetCompleted"
})
#endif
foreign import ccall "g_task_get_context" g_task_get_context ::
Ptr Task ->
IO (Ptr GLib.MainContext.MainContext)
taskGetContext ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m GLib.MainContext.MainContext
taskGetContext :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m MainContext
taskGetContext a
task = IO MainContext -> m MainContext
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MainContext -> m MainContext)
-> IO MainContext -> m MainContext
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr MainContext
result <- Ptr Task -> IO (Ptr MainContext)
g_task_get_context Ptr Task
task'
Text -> Ptr MainContext -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"taskGetContext" Ptr MainContext
result
MainContext
result' <- ((ManagedPtr MainContext -> MainContext)
-> Ptr MainContext -> IO MainContext
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MainContext -> MainContext
GLib.MainContext.MainContext) Ptr MainContext
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
MainContext -> IO MainContext
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MainContext
result'
#if defined(ENABLE_OVERLOADING)
data TaskGetContextMethodInfo
instance (signature ~ (m GLib.MainContext.MainContext), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetContextMethodInfo a signature where
overloadedMethod = taskGetContext
instance O.OverloadedMethodInfo TaskGetContextMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetContext",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetContext"
})
#endif
foreign import ccall "g_task_get_name" g_task_get_name ::
Ptr Task ->
IO CString
taskGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m (Maybe T.Text)
taskGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m (Maybe Text)
taskGetName a
task = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CString
result <- Ptr Task -> IO CString
g_task_get_name Ptr Task
task'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data TaskGetNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetNameMethodInfo a signature where
overloadedMethod = taskGetName
instance O.OverloadedMethodInfo TaskGetNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetName"
})
#endif
foreign import ccall "g_task_get_priority" g_task_get_priority ::
Ptr Task ->
IO Int32
taskGetPriority ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Int32
taskGetPriority :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Int32
taskGetPriority a
task = IO Int32 -> m Int32
forall a. IO a -> m a
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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Int32
result <- Ptr Task -> IO Int32
g_task_get_priority Ptr Task
task'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TaskGetPriorityMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetPriorityMethodInfo a signature where
overloadedMethod = taskGetPriority
instance O.OverloadedMethodInfo TaskGetPriorityMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetPriority",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetPriority"
})
#endif
foreign import ccall "g_task_get_return_on_cancel" g_task_get_return_on_cancel ::
Ptr Task ->
IO CInt
taskGetReturnOnCancel ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskGetReturnOnCancel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskGetReturnOnCancel a
task = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CInt
result <- Ptr Task -> IO CInt
g_task_get_return_on_cancel Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskGetReturnOnCancelMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetReturnOnCancelMethodInfo a signature where
overloadedMethod = taskGetReturnOnCancel
instance O.OverloadedMethodInfo TaskGetReturnOnCancelMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetReturnOnCancel",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetReturnOnCancel"
})
#endif
foreign import ccall "g_task_get_source_object" g_task_get_source_object ::
Ptr Task ->
IO (Ptr GObject.Object.Object)
taskGetSourceObject ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m (Maybe GObject.Object.Object)
taskGetSourceObject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m (Maybe Object)
taskGetSourceObject a
task = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr Object
result <- Ptr Task -> IO (Ptr Object)
g_task_get_source_object Ptr Task
task'
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result'
Object -> IO Object
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
#if defined(ENABLE_OVERLOADING)
data TaskGetSourceObjectMethodInfo
instance (signature ~ (m (Maybe GObject.Object.Object)), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetSourceObjectMethodInfo a signature where
overloadedMethod = taskGetSourceObject
instance O.OverloadedMethodInfo TaskGetSourceObjectMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetSourceObject",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetSourceObject"
})
#endif
foreign import ccall "g_task_get_source_tag" g_task_get_source_tag ::
Ptr Task ->
IO (Ptr ())
taskGetSourceTag ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m (Ptr ())
taskGetSourceTag :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m (Ptr ())
taskGetSourceTag a
task = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr ()
result <- Ptr Task -> IO (Ptr ())
g_task_get_source_tag Ptr Task
task'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data TaskGetSourceTagMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetSourceTagMethodInfo a signature where
overloadedMethod = taskGetSourceTag
instance O.OverloadedMethodInfo TaskGetSourceTagMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetSourceTag",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetSourceTag"
})
#endif
foreign import ccall "g_task_get_task_data" g_task_get_task_data ::
Ptr Task ->
IO (Ptr ())
taskGetTaskData ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m (Ptr ())
taskGetTaskData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m (Ptr ())
taskGetTaskData a
task = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr ()
result <- Ptr Task -> IO (Ptr ())
g_task_get_task_data Ptr Task
task'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data TaskGetTaskDataMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsTask a) => O.OverloadedMethod TaskGetTaskDataMethodInfo a signature where
overloadedMethod = taskGetTaskData
instance O.OverloadedMethodInfo TaskGetTaskDataMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskGetTaskData",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskGetTaskData"
})
#endif
foreign import ccall "g_task_had_error" g_task_had_error ::
Ptr Task ->
IO CInt
taskHadError ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskHadError :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskHadError a
task = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CInt
result <- Ptr Task -> IO CInt
g_task_had_error Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskHadErrorMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.OverloadedMethod TaskHadErrorMethodInfo a signature where
overloadedMethod = taskHadError
instance O.OverloadedMethodInfo TaskHadErrorMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskHadError",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskHadError"
})
#endif
foreign import ccall "g_task_propagate_boolean" g_task_propagate_boolean ::
Ptr Task ->
Ptr (Ptr GError) ->
IO CInt
taskPropagateBoolean ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m ()
taskPropagateBoolean :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m ()
taskPropagateBoolean a
task = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Task -> Ptr (Ptr GError) -> IO CInt
g_task_propagate_boolean Ptr Task
task'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data TaskPropagateBooleanMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskPropagateBooleanMethodInfo a signature where
overloadedMethod = taskPropagateBoolean
instance O.OverloadedMethodInfo TaskPropagateBooleanMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskPropagateBoolean",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskPropagateBoolean"
})
#endif
foreign import ccall "g_task_propagate_int" g_task_propagate_int ::
Ptr Task ->
Ptr (Ptr GError) ->
IO Int64
taskPropagateInt ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Int64
taskPropagateInt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Int64
taskPropagateInt a
task = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
IO Int64 -> IO () -> IO Int64
forall a b. IO a -> IO b -> IO a
onException (do
Int64
result <- (Ptr (Ptr GError) -> IO Int64) -> IO Int64
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO Int64) -> IO Int64)
-> (Ptr (Ptr GError) -> IO Int64) -> IO Int64
forall a b. (a -> b) -> a -> b
$ Ptr Task -> Ptr (Ptr GError) -> IO Int64
g_task_propagate_int Ptr Task
task'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Int64 -> IO Int64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data TaskPropagateIntMethodInfo
instance (signature ~ (m Int64), MonadIO m, IsTask a) => O.OverloadedMethod TaskPropagateIntMethodInfo a signature where
overloadedMethod = taskPropagateInt
instance O.OverloadedMethodInfo TaskPropagateIntMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskPropagateInt",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskPropagateInt"
})
#endif
foreign import ccall "g_task_propagate_pointer" g_task_propagate_pointer ::
Ptr Task ->
Ptr (Ptr GError) ->
IO (Ptr ())
taskPropagatePointer ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m (Ptr ())
taskPropagatePointer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m (Ptr ())
taskPropagatePointer a
task = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
IO (Ptr ()) -> IO () -> IO (Ptr ())
forall a b. IO a -> IO b -> IO a
onException (do
Ptr ()
result <- (Ptr (Ptr GError) -> IO (Ptr ())) -> IO (Ptr ())
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr ())) -> IO (Ptr ()))
-> (Ptr (Ptr GError) -> IO (Ptr ())) -> IO (Ptr ())
forall a b. (a -> b) -> a -> b
$ Ptr Task -> Ptr (Ptr GError) -> IO (Ptr ())
g_task_propagate_pointer Ptr Task
task'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data TaskPropagatePointerMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsTask a) => O.OverloadedMethod TaskPropagatePointerMethodInfo a signature where
overloadedMethod = taskPropagatePointer
instance O.OverloadedMethodInfo TaskPropagatePointerMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskPropagatePointer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskPropagatePointer"
})
#endif
foreign import ccall "g_task_propagate_value" g_task_propagate_value ::
Ptr Task ->
Ptr GValue ->
Ptr (Ptr GError) ->
IO CInt
taskPropagateValue ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m (GValue)
taskPropagateValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m GValue
taskPropagateValue a
task = IO GValue -> m GValue
forall a. IO a -> m a
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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr GValue
value <- Int -> IO (Ptr GValue)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
IO GValue -> IO () -> IO GValue
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Task -> Ptr GValue -> Ptr (Ptr GError) -> IO CInt
g_task_propagate_value Ptr Task
task' Ptr GValue
value
GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
GValue -> IO GValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'
) (do
Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
value
)
#if defined(ENABLE_OVERLOADING)
data TaskPropagateValueMethodInfo
instance (signature ~ (m (GValue)), MonadIO m, IsTask a) => O.OverloadedMethod TaskPropagateValueMethodInfo a signature where
overloadedMethod = taskPropagateValue
instance O.OverloadedMethodInfo TaskPropagateValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskPropagateValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskPropagateValue"
})
#endif
foreign import ccall "g_task_return_boolean" g_task_return_boolean ::
Ptr Task ->
CInt ->
IO ()
taskReturnBoolean ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Bool
-> m ()
taskReturnBoolean :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Bool -> m ()
taskReturnBoolean a
task Bool
result_ = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
let result_' :: CInt
result_' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result_
Ptr Task -> CInt -> IO ()
g_task_return_boolean Ptr Task
task' CInt
result_'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskReturnBooleanMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskReturnBooleanMethodInfo a signature where
overloadedMethod = taskReturnBoolean
instance O.OverloadedMethodInfo TaskReturnBooleanMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskReturnBoolean",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskReturnBoolean"
})
#endif
foreign import ccall "g_task_return_error" g_task_return_error ::
Ptr Task ->
Ptr GError ->
IO ()
taskReturnError ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> GError
-> m ()
taskReturnError :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> GError -> m ()
taskReturnError a
task GError
error_ = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed GError
error_
Ptr Task -> Ptr GError -> IO ()
g_task_return_error Ptr Task
task' Ptr GError
error_'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskReturnErrorMethodInfo
instance (signature ~ (GError -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskReturnErrorMethodInfo a signature where
overloadedMethod = taskReturnError
instance O.OverloadedMethodInfo TaskReturnErrorMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskReturnError",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskReturnError"
})
#endif
foreign import ccall "g_task_return_error_if_cancelled" g_task_return_error_if_cancelled ::
Ptr Task ->
IO CInt
taskReturnErrorIfCancelled ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskReturnErrorIfCancelled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskReturnErrorIfCancelled a
task = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CInt
result <- Ptr Task -> IO CInt
g_task_return_error_if_cancelled Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskReturnErrorIfCancelledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.OverloadedMethod TaskReturnErrorIfCancelledMethodInfo a signature where
overloadedMethod = taskReturnErrorIfCancelled
instance O.OverloadedMethodInfo TaskReturnErrorIfCancelledMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskReturnErrorIfCancelled",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskReturnErrorIfCancelled"
})
#endif
foreign import ccall "g_task_return_int" g_task_return_int ::
Ptr Task ->
Int64 ->
IO ()
taskReturnInt ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Int64
-> m ()
taskReturnInt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Int64 -> m ()
taskReturnInt a
task Int64
result_ = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr Task -> Int64 -> IO ()
g_task_return_int Ptr Task
task' Int64
result_
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskReturnIntMethodInfo
instance (signature ~ (Int64 -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskReturnIntMethodInfo a signature where
overloadedMethod = taskReturnInt
instance O.OverloadedMethodInfo TaskReturnIntMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskReturnInt",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskReturnInt"
})
#endif
foreign import ccall "g_task_return_pointer" g_task_return_pointer ::
Ptr Task ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
taskReturnPointer ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Ptr ()
-> Maybe (GLib.Callbacks.DestroyNotify)
-> m ()
taskReturnPointer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Ptr () -> Maybe DestroyNotify -> m ()
taskReturnPointer a
task Ptr ()
result_ Maybe DestroyNotify
resultDestroy = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
FunPtr DestroyNotify
maybeResultDestroy <- case Maybe DestroyNotify
resultDestroy of
Maybe DestroyNotify
Nothing -> FunPtr DestroyNotify -> IO (FunPtr DestroyNotify)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr DestroyNotify
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just DestroyNotify
jResultDestroy -> do
Ptr (FunPtr DestroyNotify)
ptrresultDestroy <- IO (Ptr (FunPtr DestroyNotify))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
FunPtr DestroyNotify
jResultDestroy' <- 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)
ptrresultDestroy) DestroyNotify
jResultDestroy)
Ptr (FunPtr DestroyNotify) -> FunPtr DestroyNotify -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr DestroyNotify)
ptrresultDestroy FunPtr DestroyNotify
jResultDestroy'
FunPtr DestroyNotify -> IO (FunPtr DestroyNotify)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr DestroyNotify
jResultDestroy'
Ptr Task -> Ptr () -> FunPtr DestroyNotify -> IO ()
g_task_return_pointer Ptr Task
task' Ptr ()
result_ FunPtr DestroyNotify
maybeResultDestroy
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskReturnPointerMethodInfo
instance (signature ~ (Ptr () -> Maybe (GLib.Callbacks.DestroyNotify) -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskReturnPointerMethodInfo a signature where
overloadedMethod = taskReturnPointer
instance O.OverloadedMethodInfo TaskReturnPointerMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskReturnPointer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskReturnPointer"
})
#endif
foreign import ccall "g_task_return_value" g_task_return_value ::
Ptr Task ->
Ptr GValue ->
IO ()
taskReturnValue ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Maybe (GValue)
-> m ()
taskReturnValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Maybe GValue -> m ()
taskReturnValue a
task Maybe GValue
result_ = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr GValue
maybeResult_ <- case Maybe GValue
result_ of
Maybe GValue
Nothing -> Ptr GValue -> IO (Ptr GValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GValue
forall a. Ptr a
nullPtr
Just GValue
jResult_ -> do
Ptr GValue
jResult_' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
jResult_
Ptr GValue -> IO (Ptr GValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GValue
jResult_'
Ptr Task -> Ptr GValue -> IO ()
g_task_return_value Ptr Task
task' Ptr GValue
maybeResult_
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Maybe GValue -> (GValue -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GValue
result_ GValue -> 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 TaskReturnValueMethodInfo
instance (signature ~ (Maybe (GValue) -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskReturnValueMethodInfo a signature where
overloadedMethod = taskReturnValue
instance O.OverloadedMethodInfo TaskReturnValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskReturnValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskReturnValue"
})
#endif
foreign import ccall "g_task_run_in_thread" g_task_run_in_thread ::
Ptr Task ->
FunPtr Gio.Callbacks.C_TaskThreadFunc ->
IO ()
taskRunInThread ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Gio.Callbacks.TaskThreadFunc
-> m ()
taskRunInThread :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> TaskThreadFunc -> m ()
taskRunInThread a
task TaskThreadFunc
taskFunc = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr (FunPtr C_TaskThreadFunc)
ptrtaskFunc <- IO (Ptr (FunPtr C_TaskThreadFunc))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_TaskThreadFunc))
FunPtr C_TaskThreadFunc
taskFunc' <- C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)
Gio.Callbacks.mk_TaskThreadFunc (Maybe (Ptr (FunPtr C_TaskThreadFunc))
-> TaskThreadFunc -> C_TaskThreadFunc
Gio.Callbacks.wrap_TaskThreadFunc (Ptr (FunPtr C_TaskThreadFunc)
-> Maybe (Ptr (FunPtr C_TaskThreadFunc))
forall a. a -> Maybe a
Just Ptr (FunPtr C_TaskThreadFunc)
ptrtaskFunc) TaskThreadFunc
taskFunc)
Ptr (FunPtr C_TaskThreadFunc) -> FunPtr C_TaskThreadFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_TaskThreadFunc)
ptrtaskFunc FunPtr C_TaskThreadFunc
taskFunc'
Ptr Task -> FunPtr C_TaskThreadFunc -> IO ()
g_task_run_in_thread Ptr Task
task' FunPtr C_TaskThreadFunc
taskFunc'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskRunInThreadMethodInfo
instance (signature ~ (Gio.Callbacks.TaskThreadFunc -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskRunInThreadMethodInfo a signature where
overloadedMethod = taskRunInThread
instance O.OverloadedMethodInfo TaskRunInThreadMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskRunInThread",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskRunInThread"
})
#endif
foreign import ccall "g_task_run_in_thread_sync" g_task_run_in_thread_sync ::
Ptr Task ->
FunPtr Gio.Callbacks.C_TaskThreadFunc ->
IO ()
taskRunInThreadSync ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Gio.Callbacks.TaskThreadFunc
-> m ()
taskRunInThreadSync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> TaskThreadFunc -> m ()
taskRunInThreadSync a
task TaskThreadFunc
taskFunc = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr (FunPtr C_TaskThreadFunc)
ptrtaskFunc <- IO (Ptr (FunPtr C_TaskThreadFunc))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_TaskThreadFunc))
FunPtr C_TaskThreadFunc
taskFunc' <- C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)
Gio.Callbacks.mk_TaskThreadFunc (Maybe (Ptr (FunPtr C_TaskThreadFunc))
-> TaskThreadFunc -> C_TaskThreadFunc
Gio.Callbacks.wrap_TaskThreadFunc (Ptr (FunPtr C_TaskThreadFunc)
-> Maybe (Ptr (FunPtr C_TaskThreadFunc))
forall a. a -> Maybe a
Just Ptr (FunPtr C_TaskThreadFunc)
ptrtaskFunc) TaskThreadFunc
taskFunc)
Ptr (FunPtr C_TaskThreadFunc) -> FunPtr C_TaskThreadFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_TaskThreadFunc)
ptrtaskFunc FunPtr C_TaskThreadFunc
taskFunc'
Ptr Task -> FunPtr C_TaskThreadFunc -> IO ()
g_task_run_in_thread_sync Ptr Task
task' FunPtr C_TaskThreadFunc
taskFunc'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskRunInThreadSyncMethodInfo
instance (signature ~ (Gio.Callbacks.TaskThreadFunc -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskRunInThreadSyncMethodInfo a signature where
overloadedMethod = taskRunInThreadSync
instance O.OverloadedMethodInfo TaskRunInThreadSyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskRunInThreadSync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskRunInThreadSync"
})
#endif
foreign import ccall "g_task_set_check_cancellable" g_task_set_check_cancellable ::
Ptr Task ->
CInt ->
IO ()
taskSetCheckCancellable ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Bool
-> m ()
taskSetCheckCancellable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Bool -> m ()
taskSetCheckCancellable a
task Bool
checkCancellable = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
let checkCancellable' :: CInt
checkCancellable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
checkCancellable
Ptr Task -> CInt -> IO ()
g_task_set_check_cancellable Ptr Task
task' CInt
checkCancellable'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetCheckCancellableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskSetCheckCancellableMethodInfo a signature where
overloadedMethod = taskSetCheckCancellable
instance O.OverloadedMethodInfo TaskSetCheckCancellableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskSetCheckCancellable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskSetCheckCancellable"
})
#endif
foreign import ccall "g_task_set_name" g_task_set_name ::
Ptr Task ->
CString ->
IO ()
taskSetName ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Maybe (T.Text)
-> m ()
taskSetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Maybe Text -> m ()
taskSetName a
task Maybe Text
name = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CString
maybeName <- case Maybe Text
name 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
jName -> do
CString
jName' <- Text -> IO CString
textToCString Text
jName
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jName'
Ptr Task -> CString -> IO ()
g_task_set_name Ptr Task
task' CString
maybeName
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeName
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskSetNameMethodInfo a signature where
overloadedMethod = taskSetName
instance O.OverloadedMethodInfo TaskSetNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskSetName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskSetName"
})
#endif
foreign import ccall "g_task_set_priority" g_task_set_priority ::
Ptr Task ->
Int32 ->
IO ()
taskSetPriority ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Int32
-> m ()
taskSetPriority :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Int32 -> m ()
taskSetPriority a
task Int32
priority = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr Task -> Int32 -> IO ()
g_task_set_priority Ptr Task
task' Int32
priority
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetPriorityMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskSetPriorityMethodInfo a signature where
overloadedMethod = taskSetPriority
instance O.OverloadedMethodInfo TaskSetPriorityMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskSetPriority",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskSetPriority"
})
#endif
foreign import ccall "g_task_set_return_on_cancel" g_task_set_return_on_cancel ::
Ptr Task ->
CInt ->
IO CInt
taskSetReturnOnCancel ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Bool
-> m Bool
taskSetReturnOnCancel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Bool -> m Bool
taskSetReturnOnCancel a
task Bool
returnOnCancel = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
let returnOnCancel' :: CInt
returnOnCancel' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
returnOnCancel
CInt
result <- Ptr Task -> CInt -> IO CInt
g_task_set_return_on_cancel Ptr Task
task' CInt
returnOnCancel'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskSetReturnOnCancelMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m, IsTask a) => O.OverloadedMethod TaskSetReturnOnCancelMethodInfo a signature where
overloadedMethod = taskSetReturnOnCancel
instance O.OverloadedMethodInfo TaskSetReturnOnCancelMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskSetReturnOnCancel",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskSetReturnOnCancel"
})
#endif
foreign import ccall "g_task_set_source_tag" g_task_set_source_tag ::
Ptr Task ->
Ptr () ->
IO ()
taskSetSourceTag ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Ptr ()
-> m ()
taskSetSourceTag :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Ptr () -> m ()
taskSetSourceTag a
task Ptr ()
sourceTag = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr Task -> DestroyNotify
g_task_set_source_tag Ptr Task
task' Ptr ()
sourceTag
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetSourceTagMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskSetSourceTagMethodInfo a signature where
overloadedMethod = taskSetSourceTag
instance O.OverloadedMethodInfo TaskSetSourceTagMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskSetSourceTag",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskSetSourceTag"
})
#endif
foreign import ccall "g_task_set_static_name" g_task_set_static_name ::
Ptr Task ->
CString ->
IO ()
taskSetStaticName ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Maybe (T.Text)
-> m ()
taskSetStaticName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Maybe Text -> m ()
taskSetStaticName a
task Maybe Text
name = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CString
maybeName <- case Maybe Text
name 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
jName -> do
CString
jName' <- Text -> IO CString
textToCString Text
jName
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jName'
Ptr Task -> CString -> IO ()
g_task_set_static_name Ptr Task
task' CString
maybeName
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeName
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetStaticNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskSetStaticNameMethodInfo a signature where
overloadedMethod = taskSetStaticName
instance O.OverloadedMethodInfo TaskSetStaticNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskSetStaticName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskSetStaticName"
})
#endif
foreign import ccall "g_task_set_task_data" g_task_set_task_data ::
Ptr Task ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
taskSetTaskData ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Ptr ()
-> Maybe (GLib.Callbacks.DestroyNotify)
-> m ()
taskSetTaskData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> Ptr () -> Maybe DestroyNotify -> m ()
taskSetTaskData a
task Ptr ()
taskData Maybe DestroyNotify
taskDataDestroy = 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 Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
FunPtr DestroyNotify
maybeTaskDataDestroy <- case Maybe DestroyNotify
taskDataDestroy of
Maybe DestroyNotify
Nothing -> FunPtr DestroyNotify -> IO (FunPtr DestroyNotify)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr DestroyNotify
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just DestroyNotify
jTaskDataDestroy -> do
Ptr (FunPtr DestroyNotify)
ptrtaskDataDestroy <- IO (Ptr (FunPtr DestroyNotify))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
FunPtr DestroyNotify
jTaskDataDestroy' <- 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)
ptrtaskDataDestroy) DestroyNotify
jTaskDataDestroy)
Ptr (FunPtr DestroyNotify) -> FunPtr DestroyNotify -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr DestroyNotify)
ptrtaskDataDestroy FunPtr DestroyNotify
jTaskDataDestroy'
FunPtr DestroyNotify -> IO (FunPtr DestroyNotify)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr DestroyNotify
jTaskDataDestroy'
Ptr Task -> Ptr () -> FunPtr DestroyNotify -> IO ()
g_task_set_task_data Ptr Task
task' Ptr ()
taskData FunPtr DestroyNotify
maybeTaskDataDestroy
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetTaskDataMethodInfo
instance (signature ~ (Ptr () -> Maybe (GLib.Callbacks.DestroyNotify) -> m ()), MonadIO m, IsTask a) => O.OverloadedMethod TaskSetTaskDataMethodInfo a signature where
overloadedMethod = taskSetTaskData
instance O.OverloadedMethodInfo TaskSetTaskDataMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.Task.taskSetTaskData",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.32/docs/GI-Gio-Objects-Task.html#v:taskSetTaskData"
})
#endif
foreign import ccall "g_task_is_valid" g_task_is_valid ::
Ptr Gio.AsyncResult.AsyncResult ->
Ptr GObject.Object.Object ->
IO CInt
taskIsValid ::
(B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a, GObject.Object.IsObject b) =>
a
-> Maybe (b)
-> m Bool
taskIsValid :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAsyncResult a, IsObject b) =>
a -> Maybe b -> m Bool
taskIsValid a
result_ Maybe b
sourceObject = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncResult
result_' <- a -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
result_
Ptr Object
maybeSourceObject <- case Maybe b
sourceObject of
Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just b
jSourceObject -> do
Ptr Object
jSourceObject' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSourceObject
Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSourceObject'
CInt
result <- Ptr AsyncResult -> Ptr Object -> IO CInt
g_task_is_valid Ptr AsyncResult
result_' Ptr Object
maybeSourceObject
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
result_
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
sourceObject b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_task_report_error" g_task_report_error ::
Ptr GObject.Object.Object ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
Ptr () ->
Ptr GError ->
IO ()
taskReportError ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
Maybe (a)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> Ptr ()
-> GError
-> m ()
taskReportError :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
Maybe a -> Maybe AsyncReadyCallback -> Ptr () -> GError -> m ()
taskReportError Maybe a
sourceObject Maybe AsyncReadyCallback
callback Ptr ()
sourceTag GError
error_ = 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 Object
maybeSourceObject <- case Maybe a
sourceObject of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSourceObject -> do
Ptr Object
jSourceObject' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSourceObject
Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSourceObject'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed GError
error_
let callbackData :: Ptr a
callbackData = Ptr a
forall a. Ptr a
nullPtr
Ptr Object
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> Ptr ()
-> Ptr GError
-> IO ()
g_task_report_error Ptr Object
maybeSourceObject FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
callbackData Ptr ()
sourceTag Ptr GError
error_'
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
sourceObject a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif