#define ENABLE_OVERLOADING \
(!defined(__HADDOCK_VERSION__))
module GI.Gio.Objects.Cancellable
(
Cancellable(..) ,
IsCancellable ,
toCancellable ,
noCancellable ,
#if ENABLE_OVERLOADING
CancellableCancelMethodInfo ,
#endif
cancellableCancel ,
#if ENABLE_OVERLOADING
CancellableConnectMethodInfo ,
#endif
cancellableConnect ,
#if ENABLE_OVERLOADING
CancellableDisconnectMethodInfo ,
#endif
cancellableDisconnect ,
cancellableGetCurrent ,
#if ENABLE_OVERLOADING
CancellableGetFdMethodInfo ,
#endif
cancellableGetFd ,
#if ENABLE_OVERLOADING
CancellableIsCancelledMethodInfo ,
#endif
cancellableIsCancelled ,
#if ENABLE_OVERLOADING
CancellableMakePollfdMethodInfo ,
#endif
cancellableMakePollfd ,
cancellableNew ,
#if ENABLE_OVERLOADING
CancellablePopCurrentMethodInfo ,
#endif
cancellablePopCurrent ,
#if ENABLE_OVERLOADING
CancellablePushCurrentMethodInfo ,
#endif
cancellablePushCurrent ,
#if ENABLE_OVERLOADING
CancellableReleaseFdMethodInfo ,
#endif
cancellableReleaseFd ,
#if ENABLE_OVERLOADING
CancellableResetMethodInfo ,
#endif
cancellableReset ,
#if ENABLE_OVERLOADING
CancellableSetErrorIfCancelledMethodInfo,
#endif
cancellableSetErrorIfCancelled ,
#if ENABLE_OVERLOADING
CancellableSourceNewMethodInfo ,
#endif
cancellableSourceNew ,
C_CancellableCancelledCallback ,
CancellableCancelledCallback ,
#if ENABLE_OVERLOADING
CancellableCancelledSignalInfo ,
#endif
afterCancellableCancelled ,
genClosure_CancellableCancelled ,
mk_CancellableCancelledCallback ,
noCancellableCancelledCallback ,
onCancellableCancelled ,
wrap_CancellableCancelledCallback ,
) 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.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.PollFD as GLib.PollFD
import qualified GI.GLib.Structs.Source as GLib.Source
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
newtype Cancellable = Cancellable (ManagedPtr Cancellable)
foreign import ccall "g_cancellable_get_type"
c_g_cancellable_get_type :: IO GType
instance GObject Cancellable where
gobjectType :: Cancellable -> IO GType
gobjectType _ = IO GType
c_g_cancellable_get_type
class GObject o => IsCancellable o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Cancellable a) =>
IsCancellable a
#endif
instance IsCancellable Cancellable
instance GObject.Object.IsObject Cancellable
toCancellable :: (MonadIO m, IsCancellable o) => o -> m Cancellable
toCancellable :: o -> m Cancellable
toCancellable = IO Cancellable -> m Cancellable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Cancellable -> m Cancellable)
-> (o -> IO Cancellable) -> o -> m Cancellable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Cancellable -> Cancellable) -> o -> IO Cancellable
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Cancellable -> Cancellable
Cancellable
noCancellable :: Maybe Cancellable
noCancellable :: Maybe Cancellable
noCancellable = Maybe Cancellable
forall a. Maybe a
Nothing
#if ENABLE_OVERLOADING
type family ResolveCancellableMethod (t :: Symbol) (o :: *) :: * where
ResolveCancellableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveCancellableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveCancellableMethod "cancel" o = CancellableCancelMethodInfo
ResolveCancellableMethod "connect" o = CancellableConnectMethodInfo
ResolveCancellableMethod "disconnect" o = CancellableDisconnectMethodInfo
ResolveCancellableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveCancellableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveCancellableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveCancellableMethod "isCancelled" o = CancellableIsCancelledMethodInfo
ResolveCancellableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveCancellableMethod "makePollfd" o = CancellableMakePollfdMethodInfo
ResolveCancellableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveCancellableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveCancellableMethod "popCurrent" o = CancellablePopCurrentMethodInfo
ResolveCancellableMethod "pushCurrent" o = CancellablePushCurrentMethodInfo
ResolveCancellableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveCancellableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveCancellableMethod "releaseFd" o = CancellableReleaseFdMethodInfo
ResolveCancellableMethod "reset" o = CancellableResetMethodInfo
ResolveCancellableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveCancellableMethod "sourceNew" o = CancellableSourceNewMethodInfo
ResolveCancellableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveCancellableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveCancellableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveCancellableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveCancellableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveCancellableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveCancellableMethod "getFd" o = CancellableGetFdMethodInfo
ResolveCancellableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveCancellableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveCancellableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveCancellableMethod "setErrorIfCancelled" o = CancellableSetErrorIfCancelledMethodInfo
ResolveCancellableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveCancellableMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveCancellableMethod t Cancellable, O.MethodInfo info Cancellable p) => O.IsLabelProxy t (Cancellable -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveCancellableMethod t Cancellable, O.MethodInfo info Cancellable p) => O.IsLabel t (Cancellable -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
#endif
type CancellableCancelledCallback =
IO ()
noCancellableCancelledCallback :: Maybe CancellableCancelledCallback
noCancellableCancelledCallback :: Maybe CancellableCancelledCallback
noCancellableCancelledCallback = Maybe CancellableCancelledCallback
forall a. Maybe a
Nothing
type C_CancellableCancelledCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_CancellableCancelledCallback :: C_CancellableCancelledCallback -> IO (FunPtr C_CancellableCancelledCallback)
genClosure_CancellableCancelled :: CancellableCancelledCallback -> IO Closure
genClosure_CancellableCancelled :: CancellableCancelledCallback -> IO Closure
genClosure_CancellableCancelled cb :: CancellableCancelledCallback
cb = do
let cb' :: C_CancellableCancelledCallback
cb' = CancellableCancelledCallback -> C_CancellableCancelledCallback
wrap_CancellableCancelledCallback CancellableCancelledCallback
cb
C_CancellableCancelledCallback
-> IO (FunPtr C_CancellableCancelledCallback)
mk_CancellableCancelledCallback C_CancellableCancelledCallback
cb' IO (FunPtr C_CancellableCancelledCallback)
-> (FunPtr C_CancellableCancelledCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CancellableCancelledCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_CancellableCancelledCallback ::
CancellableCancelledCallback ->
C_CancellableCancelledCallback
wrap_CancellableCancelledCallback :: CancellableCancelledCallback -> C_CancellableCancelledCallback
wrap_CancellableCancelledCallback _cb :: CancellableCancelledCallback
_cb _ _ = do
CancellableCancelledCallback
_cb
onCancellableCancelled :: (IsCancellable a, MonadIO m) => a -> CancellableCancelledCallback -> m SignalHandlerId
onCancellableCancelled :: a -> CancellableCancelledCallback -> m SignalHandlerId
onCancellableCancelled obj :: a
obj cb :: CancellableCancelledCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_CancellableCancelledCallback
cb' = CancellableCancelledCallback -> C_CancellableCancelledCallback
wrap_CancellableCancelledCallback CancellableCancelledCallback
cb
FunPtr C_CancellableCancelledCallback
cb'' <- C_CancellableCancelledCallback
-> IO (FunPtr C_CancellableCancelledCallback)
mk_CancellableCancelledCallback C_CancellableCancelledCallback
cb'
a
-> String
-> FunPtr C_CancellableCancelledCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "cancelled" FunPtr C_CancellableCancelledCallback
cb'' SignalConnectMode
SignalConnectBefore
afterCancellableCancelled :: (IsCancellable a, MonadIO m) => a -> CancellableCancelledCallback -> m SignalHandlerId
afterCancellableCancelled :: a -> CancellableCancelledCallback -> m SignalHandlerId
afterCancellableCancelled obj :: a
obj cb :: CancellableCancelledCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_CancellableCancelledCallback
cb' = CancellableCancelledCallback -> C_CancellableCancelledCallback
wrap_CancellableCancelledCallback CancellableCancelledCallback
cb
FunPtr C_CancellableCancelledCallback
cb'' <- C_CancellableCancelledCallback
-> IO (FunPtr C_CancellableCancelledCallback)
mk_CancellableCancelledCallback C_CancellableCancelledCallback
cb'
a
-> String
-> FunPtr C_CancellableCancelledCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "cancelled" FunPtr C_CancellableCancelledCallback
cb'' SignalConnectMode
SignalConnectAfter
#if ENABLE_OVERLOADING
instance O.HasAttributeList Cancellable
type instance O.AttributeList Cancellable = CancellableAttributeList
type CancellableAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
#endif
#if ENABLE_OVERLOADING
data CancellableCancelledSignalInfo
instance SignalInfo CancellableCancelledSignalInfo where
type HaskellCallbackType CancellableCancelledSignalInfo = CancellableCancelledCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_CancellableCancelledCallback cb
cb'' <- mk_CancellableCancelledCallback cb'
connectSignalFunPtr obj "cancelled" cb'' connectMode
type instance O.SignalList Cancellable = CancellableSignalList
type CancellableSignalList = ('[ '("cancelled", CancellableCancelledSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_cancellable_new" g_cancellable_new ::
IO (Ptr Cancellable)
cancellableNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Cancellable
cancellableNew :: m Cancellable
cancellableNew = 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 Cancellable
result <- IO (Ptr Cancellable)
g_cancellable_new
Text -> Ptr Cancellable -> CancellableCancelledCallback
forall a.
HasCallStack =>
Text -> Ptr a -> CancellableCancelledCallback
checkUnexpectedReturnNULL "cancellableNew" 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
wrapObject ManagedPtr Cancellable -> Cancellable
Cancellable) Ptr Cancellable
result
Cancellable -> IO Cancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Cancellable
result'
#if ENABLE_OVERLOADING
#endif
foreign import ccall "g_cancellable_cancel" g_cancellable_cancel ::
Ptr Cancellable ->
IO ()
cancellableCancel ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> m ()
cancellableCancel :: a -> m ()
cancellableCancel cancellable :: a
cancellable = CancellableCancelledCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (CancellableCancelledCallback -> m ())
-> CancellableCancelledCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
Ptr Cancellable -> CancellableCancelledCallback
g_cancellable_cancel Ptr Cancellable
cancellable'
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
() -> CancellableCancelledCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data CancellableCancelMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCancellable a) => O.MethodInfo CancellableCancelMethodInfo a signature where
overloadedMethod _ = cancellableCancel
#endif
foreign import ccall "g_cancellable_connect" g_cancellable_connect ::
Ptr Cancellable ->
FunPtr GObject.Callbacks.C_Callback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO CULong
cancellableConnect ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> GObject.Callbacks.Callback
-> m CULong
cancellableConnect :: a -> CancellableCancelledCallback -> m SignalHandlerId
cancellableConnect cancellable :: a
cancellable callback :: CancellableCancelledCallback
callback = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
FunPtr CancellableCancelledCallback
callback' <- CancellableCancelledCallback
-> IO (FunPtr CancellableCancelledCallback)
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr CancellableCancelledCallback))
-> CancellableCancelledCallback -> CancellableCancelledCallback
GObject.Callbacks.wrap_Callback Maybe (Ptr (FunPtr CancellableCancelledCallback))
forall a. Maybe a
Nothing CancellableCancelledCallback
callback)
let data_ :: Ptr ()
data_ = FunPtr CancellableCancelledCallback -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr CancellableCancelledCallback
callback'
let dataDestroyFunc :: FunPtr (Ptr a -> CancellableCancelledCallback)
dataDestroyFunc = FunPtr (Ptr a -> CancellableCancelledCallback)
forall a. FunPtr (Ptr a -> CancellableCancelledCallback)
safeFreeFunPtrPtr
SignalHandlerId
result <- Ptr Cancellable
-> FunPtr CancellableCancelledCallback
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO SignalHandlerId
g_cancellable_connect Ptr Cancellable
cancellable' FunPtr CancellableCancelledCallback
callback' Ptr ()
data_ FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> CancellableCancelledCallback)
dataDestroyFunc
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
SignalHandlerId -> IO SignalHandlerId
forall (m :: * -> *) a. Monad m => a -> m a
return SignalHandlerId
result
#if ENABLE_OVERLOADING
data CancellableConnectMethodInfo
instance (signature ~ (GObject.Callbacks.Callback -> m CULong), MonadIO m, IsCancellable a) => O.MethodInfo CancellableConnectMethodInfo a signature where
overloadedMethod _ = cancellableConnect
#endif
foreign import ccall "g_cancellable_disconnect" g_cancellable_disconnect ::
Ptr Cancellable ->
CULong ->
IO ()
cancellableDisconnect ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> CULong
-> m ()
cancellableDisconnect :: a -> SignalHandlerId -> m ()
cancellableDisconnect cancellable :: a
cancellable handlerId :: SignalHandlerId
handlerId = CancellableCancelledCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (CancellableCancelledCallback -> m ())
-> CancellableCancelledCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
Ptr Cancellable -> SignalHandlerId -> CancellableCancelledCallback
g_cancellable_disconnect Ptr Cancellable
cancellable' SignalHandlerId
handlerId
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
() -> CancellableCancelledCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data CancellableDisconnectMethodInfo
instance (signature ~ (CULong -> m ()), MonadIO m, IsCancellable a) => O.MethodInfo CancellableDisconnectMethodInfo a signature where
overloadedMethod _ = cancellableDisconnect
#endif
foreign import ccall "g_cancellable_get_fd" g_cancellable_get_fd ::
Ptr Cancellable ->
IO Int32
cancellableGetFd ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> m Int32
cancellableGetFd :: a -> m Int32
cancellableGetFd cancellable :: a
cancellable = 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 Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
Int32
result <- Ptr Cancellable -> IO Int32
g_cancellable_get_fd Ptr Cancellable
cancellable'
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if ENABLE_OVERLOADING
data CancellableGetFdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsCancellable a) => O.MethodInfo CancellableGetFdMethodInfo a signature where
overloadedMethod _ = cancellableGetFd
#endif
foreign import ccall "g_cancellable_is_cancelled" g_cancellable_is_cancelled ::
Ptr Cancellable ->
IO CInt
cancellableIsCancelled ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> m Bool
cancellableIsCancelled :: a -> m Bool
cancellableIsCancelled cancellable :: a
cancellable = IO Bool -> m Bool
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 Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
CInt
result <- Ptr Cancellable -> IO CInt
g_cancellable_is_cancelled Ptr Cancellable
cancellable'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if ENABLE_OVERLOADING
data CancellableIsCancelledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCancellable a) => O.MethodInfo CancellableIsCancelledMethodInfo a signature where
overloadedMethod _ = cancellableIsCancelled
#endif
foreign import ccall "g_cancellable_make_pollfd" g_cancellable_make_pollfd ::
Ptr Cancellable ->
Ptr GLib.PollFD.PollFD ->
IO CInt
cancellableMakePollfd ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> GLib.PollFD.PollFD
-> m Bool
cancellableMakePollfd :: a -> PollFD -> m Bool
cancellableMakePollfd cancellable :: a
cancellable pollfd :: PollFD
pollfd = IO Bool -> m Bool
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 Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
Ptr PollFD
pollfd' <- PollFD -> IO (Ptr PollFD)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PollFD
pollfd
CInt
result <- Ptr Cancellable -> Ptr PollFD -> IO CInt
g_cancellable_make_pollfd Ptr Cancellable
cancellable' Ptr PollFD
pollfd'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
PollFD -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr PollFD
pollfd
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if ENABLE_OVERLOADING
data CancellableMakePollfdMethodInfo
instance (signature ~ (GLib.PollFD.PollFD -> m Bool), MonadIO m, IsCancellable a) => O.MethodInfo CancellableMakePollfdMethodInfo a signature where
overloadedMethod _ = cancellableMakePollfd
#endif
foreign import ccall "g_cancellable_pop_current" g_cancellable_pop_current ::
Ptr Cancellable ->
IO ()
cancellablePopCurrent ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> m ()
cancellablePopCurrent :: a -> m ()
cancellablePopCurrent cancellable :: a
cancellable = CancellableCancelledCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (CancellableCancelledCallback -> m ())
-> CancellableCancelledCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
Ptr Cancellable -> CancellableCancelledCallback
g_cancellable_pop_current Ptr Cancellable
cancellable'
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
() -> CancellableCancelledCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data CancellablePopCurrentMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCancellable a) => O.MethodInfo CancellablePopCurrentMethodInfo a signature where
overloadedMethod _ = cancellablePopCurrent
#endif
foreign import ccall "g_cancellable_push_current" g_cancellable_push_current ::
Ptr Cancellable ->
IO ()
cancellablePushCurrent ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> m ()
cancellablePushCurrent :: a -> m ()
cancellablePushCurrent cancellable :: a
cancellable = CancellableCancelledCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (CancellableCancelledCallback -> m ())
-> CancellableCancelledCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
Ptr Cancellable -> CancellableCancelledCallback
g_cancellable_push_current Ptr Cancellable
cancellable'
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
() -> CancellableCancelledCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data CancellablePushCurrentMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCancellable a) => O.MethodInfo CancellablePushCurrentMethodInfo a signature where
overloadedMethod _ = cancellablePushCurrent
#endif
foreign import ccall "g_cancellable_release_fd" g_cancellable_release_fd ::
Ptr Cancellable ->
IO ()
cancellableReleaseFd ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> m ()
cancellableReleaseFd :: a -> m ()
cancellableReleaseFd cancellable :: a
cancellable = CancellableCancelledCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (CancellableCancelledCallback -> m ())
-> CancellableCancelledCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
Ptr Cancellable -> CancellableCancelledCallback
g_cancellable_release_fd Ptr Cancellable
cancellable'
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
() -> CancellableCancelledCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data CancellableReleaseFdMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCancellable a) => O.MethodInfo CancellableReleaseFdMethodInfo a signature where
overloadedMethod _ = cancellableReleaseFd
#endif
foreign import ccall "g_cancellable_reset" g_cancellable_reset ::
Ptr Cancellable ->
IO ()
cancellableReset ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> m ()
cancellableReset :: a -> m ()
cancellableReset cancellable :: a
cancellable = CancellableCancelledCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (CancellableCancelledCallback -> m ())
-> CancellableCancelledCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
Ptr Cancellable -> CancellableCancelledCallback
g_cancellable_reset Ptr Cancellable
cancellable'
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
() -> CancellableCancelledCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data CancellableResetMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCancellable a) => O.MethodInfo CancellableResetMethodInfo a signature where
overloadedMethod _ = cancellableReset
#endif
foreign import ccall "g_cancellable_set_error_if_cancelled" g_cancellable_set_error_if_cancelled ::
Ptr Cancellable ->
Ptr (Ptr GError) ->
IO CInt
cancellableSetErrorIfCancelled ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> m ()
cancellableSetErrorIfCancelled :: a -> m ()
cancellableSetErrorIfCancelled cancellable :: a
cancellable = CancellableCancelledCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (CancellableCancelledCallback -> m ())
-> CancellableCancelledCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
CancellableCancelledCallback
-> CancellableCancelledCallback -> CancellableCancelledCallback
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 Cancellable -> Ptr (Ptr GError) -> IO CInt
g_cancellable_set_error_if_cancelled Ptr Cancellable
cancellable'
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
() -> CancellableCancelledCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> CancellableCancelledCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if ENABLE_OVERLOADING
data CancellableSetErrorIfCancelledMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCancellable a) => O.MethodInfo CancellableSetErrorIfCancelledMethodInfo a signature where
overloadedMethod _ = cancellableSetErrorIfCancelled
#endif
foreign import ccall "g_cancellable_source_new" g_cancellable_source_new ::
Ptr Cancellable ->
IO (Ptr GLib.Source.Source)
cancellableSourceNew ::
(B.CallStack.HasCallStack, MonadIO m, IsCancellable a) =>
a
-> m GLib.Source.Source
cancellableSourceNew :: a -> m Source
cancellableSourceNew cancellable :: a
cancellable = IO Source -> m Source
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Source -> m Source) -> IO Source -> m Source
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
cancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cancellable
Ptr Source
result <- Ptr Cancellable -> IO (Ptr Source)
g_cancellable_source_new Ptr Cancellable
cancellable'
Text -> Ptr Source -> CancellableCancelledCallback
forall a.
HasCallStack =>
Text -> Ptr a -> CancellableCancelledCallback
checkUnexpectedReturnNULL "cancellableSourceNew" Ptr Source
result
Source
result' <- ((ManagedPtr Source -> Source) -> Ptr Source -> IO Source
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Source -> Source
GLib.Source.Source) Ptr Source
result
a -> CancellableCancelledCallback
forall a. ManagedPtrNewtype a => a -> CancellableCancelledCallback
touchManagedPtr a
cancellable
Source -> IO Source
forall (m :: * -> *) a. Monad m => a -> m a
return Source
result'
#if ENABLE_OVERLOADING
data CancellableSourceNewMethodInfo
instance (signature ~ (m GLib.Source.Source), MonadIO m, IsCancellable a) => O.MethodInfo CancellableSourceNewMethodInfo a signature where
overloadedMethod _ = cancellableSourceNew
#endif
foreign import ccall "g_cancellable_get_current" g_cancellable_get_current ::
IO (Ptr Cancellable)
cancellableGetCurrent ::
(B.CallStack.HasCallStack, MonadIO m) =>
m (Maybe Cancellable)
cancellableGetCurrent :: m (Maybe Cancellable)
cancellableGetCurrent = IO (Maybe Cancellable) -> m (Maybe Cancellable)
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 Cancellable
result <- IO (Ptr Cancellable)
g_cancellable_get_current
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
$ \result' :: 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
Cancellable) Ptr Cancellable
result'
Cancellable -> IO Cancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Cancellable
result''
Maybe Cancellable -> IO (Maybe Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Cancellable
maybeResult
#if ENABLE_OVERLOADING
#endif