module GI.GLib.Structs.MainLoop
(
MainLoop(..) ,
noMainLoop ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
MainLoopGetContextMethodInfo ,
#endif
mainLoopGetContext ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
MainLoopIsRunningMethodInfo ,
#endif
mainLoopIsRunning ,
mainLoopNew ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
MainLoopQuitMethodInfo ,
#endif
mainLoopQuit ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
MainLoopRefMethodInfo ,
#endif
mainLoopRef ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
MainLoopRunMethodInfo ,
#endif
mainLoopRun ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
MainLoopUnrefMethodInfo ,
#endif
mainLoopUnref ,
) 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.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.Structs.MainContext as GLib.MainContext
newtype MainLoop = MainLoop (ManagedPtr MainLoop)
foreign import ccall "g_main_loop_get_type" c_g_main_loop_get_type ::
IO GType
instance BoxedObject MainLoop where
boxedType _ = c_g_main_loop_get_type
noMainLoop :: Maybe MainLoop
noMainLoop = Nothing
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList MainLoop
type instance O.AttributeList MainLoop = MainLoopAttributeList
type MainLoopAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "g_main_loop_new" g_main_loop_new ::
Ptr GLib.MainContext.MainContext ->
CInt ->
IO (Ptr MainLoop)
mainLoopNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (GLib.MainContext.MainContext)
-> Bool
-> m MainLoop
mainLoopNew context isRunning = liftIO $ do
maybeContext <- case context of
Nothing -> return nullPtr
Just jContext -> do
jContext' <- unsafeManagedPtrGetPtr jContext
return jContext'
let isRunning' = (fromIntegral . fromEnum) isRunning
result <- g_main_loop_new maybeContext isRunning'
checkUnexpectedReturnNULL "mainLoopNew" result
result' <- (wrapBoxed MainLoop) result
whenJust context touchManagedPtr
return result'
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif
foreign import ccall "g_main_loop_get_context" g_main_loop_get_context ::
Ptr MainLoop ->
IO (Ptr GLib.MainContext.MainContext)
mainLoopGetContext ::
(B.CallStack.HasCallStack, MonadIO m) =>
MainLoop
-> m GLib.MainContext.MainContext
mainLoopGetContext loop = liftIO $ do
loop' <- unsafeManagedPtrGetPtr loop
result <- g_main_loop_get_context loop'
checkUnexpectedReturnNULL "mainLoopGetContext" result
result' <- (newBoxed GLib.MainContext.MainContext) result
touchManagedPtr loop
return result'
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data MainLoopGetContextMethodInfo
instance (signature ~ (m GLib.MainContext.MainContext), MonadIO m) => O.MethodInfo MainLoopGetContextMethodInfo MainLoop signature where
overloadedMethod _ = mainLoopGetContext
#endif
foreign import ccall "g_main_loop_is_running" g_main_loop_is_running ::
Ptr MainLoop ->
IO CInt
mainLoopIsRunning ::
(B.CallStack.HasCallStack, MonadIO m) =>
MainLoop
-> m Bool
mainLoopIsRunning loop = liftIO $ do
loop' <- unsafeManagedPtrGetPtr loop
result <- g_main_loop_is_running loop'
let result' = (/= 0) result
touchManagedPtr loop
return result'
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data MainLoopIsRunningMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo MainLoopIsRunningMethodInfo MainLoop signature where
overloadedMethod _ = mainLoopIsRunning
#endif
foreign import ccall "g_main_loop_quit" g_main_loop_quit ::
Ptr MainLoop ->
IO ()
mainLoopQuit ::
(B.CallStack.HasCallStack, MonadIO m) =>
MainLoop
-> m ()
mainLoopQuit loop = liftIO $ do
loop' <- unsafeManagedPtrGetPtr loop
g_main_loop_quit loop'
touchManagedPtr loop
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data MainLoopQuitMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MainLoopQuitMethodInfo MainLoop signature where
overloadedMethod _ = mainLoopQuit
#endif
foreign import ccall "g_main_loop_ref" g_main_loop_ref ::
Ptr MainLoop ->
IO (Ptr MainLoop)
mainLoopRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
MainLoop
-> m MainLoop
mainLoopRef loop = liftIO $ do
loop' <- unsafeManagedPtrGetPtr loop
result <- g_main_loop_ref loop'
checkUnexpectedReturnNULL "mainLoopRef" result
result' <- (wrapBoxed MainLoop) result
touchManagedPtr loop
return result'
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data MainLoopRefMethodInfo
instance (signature ~ (m MainLoop), MonadIO m) => O.MethodInfo MainLoopRefMethodInfo MainLoop signature where
overloadedMethod _ = mainLoopRef
#endif
foreign import ccall "g_main_loop_run" g_main_loop_run ::
Ptr MainLoop ->
IO ()
mainLoopRun ::
(B.CallStack.HasCallStack, MonadIO m) =>
MainLoop
-> m ()
mainLoopRun loop = liftIO $ do
loop' <- unsafeManagedPtrGetPtr loop
g_main_loop_run loop'
touchManagedPtr loop
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data MainLoopRunMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MainLoopRunMethodInfo MainLoop signature where
overloadedMethod _ = mainLoopRun
#endif
foreign import ccall "g_main_loop_unref" g_main_loop_unref ::
Ptr MainLoop ->
IO ()
mainLoopUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
MainLoop
-> m ()
mainLoopUnref loop = liftIO $ do
loop' <- unsafeManagedPtrGetPtr loop
g_main_loop_unref loop'
touchManagedPtr loop
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data MainLoopUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MainLoopUnrefMethodInfo MainLoop signature where
overloadedMethod _ = mainLoopUnref
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveMainLoopMethod (t :: Symbol) (o :: *) :: * where
ResolveMainLoopMethod "isRunning" o = MainLoopIsRunningMethodInfo
ResolveMainLoopMethod "quit" o = MainLoopQuitMethodInfo
ResolveMainLoopMethod "ref" o = MainLoopRefMethodInfo
ResolveMainLoopMethod "run" o = MainLoopRunMethodInfo
ResolveMainLoopMethod "unref" o = MainLoopUnrefMethodInfo
ResolveMainLoopMethod "getContext" o = MainLoopGetContextMethodInfo
ResolveMainLoopMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMainLoopMethod t MainLoop, O.MethodInfo info MainLoop p) => O.IsLabelProxy t (MainLoop -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveMainLoopMethod t MainLoop, O.MethodInfo info MainLoop p) => O.IsLabel t (MainLoop -> 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