{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.MainLoop
(
MainLoop(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveMainLoopMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MainLoopGetContextMethodInfo ,
#endif
mainLoopGetContext ,
#if defined(ENABLE_OVERLOADING)
MainLoopIsRunningMethodInfo ,
#endif
mainLoopIsRunning ,
mainLoopNew ,
#if defined(ENABLE_OVERLOADING)
MainLoopQuitMethodInfo ,
#endif
mainLoopQuit ,
#if defined(ENABLE_OVERLOADING)
MainLoopRefMethodInfo ,
#endif
mainLoopRef ,
#if defined(ENABLE_OVERLOADING)
MainLoopRunMethodInfo ,
#endif
mainLoopRun ,
#if defined(ENABLE_OVERLOADING)
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.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.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.GLib.Structs.MainContext as GLib.MainContext
newtype MainLoop = MainLoop (SP.ManagedPtr MainLoop)
deriving (MainLoop -> MainLoop -> Bool
(MainLoop -> MainLoop -> Bool)
-> (MainLoop -> MainLoop -> Bool) -> Eq MainLoop
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MainLoop -> MainLoop -> Bool
$c/= :: MainLoop -> MainLoop -> Bool
== :: MainLoop -> MainLoop -> Bool
$c== :: MainLoop -> MainLoop -> Bool
Eq)
instance SP.ManagedPtrNewtype MainLoop where
toManagedPtr :: MainLoop -> ManagedPtr MainLoop
toManagedPtr (MainLoop ManagedPtr MainLoop
p) = ManagedPtr MainLoop
p
foreign import ccall "g_main_loop_get_type" c_g_main_loop_get_type ::
IO GType
type instance O.ParentTypes MainLoop = '[]
instance O.HasParentTypes MainLoop
instance B.Types.TypedObject MainLoop where
glibType :: IO GType
glibType = IO GType
c_g_main_loop_get_type
instance B.Types.GBoxed MainLoop
instance B.GValue.IsGValue (Maybe MainLoop) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_main_loop_get_type
gvalueSet_ :: Ptr GValue -> Maybe MainLoop -> IO ()
gvalueSet_ Ptr GValue
gv Maybe MainLoop
P.Nothing = Ptr GValue -> Ptr MainLoop -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr MainLoop
forall a. Ptr a
FP.nullPtr :: FP.Ptr MainLoop)
gvalueSet_ Ptr GValue
gv (P.Just MainLoop
obj) = MainLoop -> (Ptr MainLoop -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MainLoop
obj (Ptr GValue -> Ptr MainLoop -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe MainLoop)
gvalueGet_ Ptr GValue
gv = do
Ptr MainLoop
ptr <- Ptr GValue -> IO (Ptr MainLoop)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr MainLoop)
if Ptr MainLoop
ptr Ptr MainLoop -> Ptr MainLoop -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr MainLoop
forall a. Ptr a
FP.nullPtr
then MainLoop -> Maybe MainLoop
forall a. a -> Maybe a
P.Just (MainLoop -> Maybe MainLoop) -> IO MainLoop -> IO (Maybe MainLoop)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr MainLoop -> MainLoop) -> Ptr MainLoop -> IO MainLoop
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr MainLoop -> MainLoop
MainLoop Ptr MainLoop
ptr
else Maybe MainLoop -> IO (Maybe MainLoop)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MainLoop
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe MainContext -> Bool -> m MainLoop
mainLoopNew Maybe MainContext
context Bool
isRunning = IO MainLoop -> m MainLoop
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MainLoop -> m MainLoop) -> IO MainLoop -> m MainLoop
forall a b. (a -> b) -> a -> b
$ do
Ptr MainContext
maybeContext <- case Maybe MainContext
context of
Maybe MainContext
Nothing -> Ptr MainContext -> IO (Ptr MainContext)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MainContext
forall a. Ptr a
nullPtr
Just MainContext
jContext -> do
Ptr MainContext
jContext' <- MainContext -> IO (Ptr MainContext)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainContext
jContext
Ptr MainContext -> IO (Ptr MainContext)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MainContext
jContext'
let isRunning' :: CInt
isRunning' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
isRunning
Ptr MainLoop
result <- Ptr MainContext -> CInt -> IO (Ptr MainLoop)
g_main_loop_new Ptr MainContext
maybeContext CInt
isRunning'
Text -> Ptr MainLoop -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mainLoopNew" Ptr MainLoop
result
MainLoop
result' <- ((ManagedPtr MainLoop -> MainLoop) -> Ptr MainLoop -> IO MainLoop
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr MainLoop -> MainLoop
MainLoop) Ptr MainLoop
result
Maybe MainContext -> (MainContext -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe MainContext
context MainContext -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
MainLoop -> IO MainLoop
forall (m :: * -> *) a. Monad m => a -> m a
return MainLoop
result'
#if defined(ENABLE_OVERLOADING)
#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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MainLoop -> m MainContext
mainLoopGetContext MainLoop
loop = IO MainContext -> m MainContext
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 MainLoop
loop' <- MainLoop -> IO (Ptr MainLoop)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainLoop
loop
Ptr MainContext
result <- Ptr MainLoop -> IO (Ptr MainContext)
g_main_loop_get_context Ptr MainLoop
loop'
Text -> Ptr MainContext -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mainLoopGetContext" 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
MainLoop -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
MainContext -> IO MainContext
forall (m :: * -> *) a. Monad m => a -> m a
return MainContext
result'
#if defined(ENABLE_OVERLOADING)
data MainLoopGetContextMethodInfo
instance (signature ~ (m GLib.MainContext.MainContext), MonadIO m) => O.OverloadedMethod MainLoopGetContextMethodInfo MainLoop signature where
overloadedMethod = mainLoopGetContext
instance O.OverloadedMethodInfo MainLoopGetContextMethodInfo MainLoop where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GLib.Structs.MainLoop.mainLoopGetContext",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-glib-2.0.25/docs/GI-GLib-Structs-MainLoop.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MainLoop -> m Bool
mainLoopIsRunning MainLoop
loop = 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 MainLoop
loop' <- MainLoop -> IO (Ptr MainLoop)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainLoop
loop
CInt
result <- Ptr MainLoop -> IO CInt
g_main_loop_is_running Ptr MainLoop
loop'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
MainLoop -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data MainLoopIsRunningMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod MainLoopIsRunningMethodInfo MainLoop signature where
overloadedMethod = mainLoopIsRunning
instance O.OverloadedMethodInfo MainLoopIsRunningMethodInfo MainLoop where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GLib.Structs.MainLoop.mainLoopIsRunning",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-glib-2.0.25/docs/GI-GLib-Structs-MainLoop.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => MainLoop -> m ()
mainLoopQuit MainLoop
loop = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- MainLoop -> IO (Ptr MainLoop)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainLoop
loop
Ptr MainLoop -> IO ()
g_main_loop_quit Ptr MainLoop
loop'
MainLoop -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MainLoopQuitMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MainLoopQuitMethodInfo MainLoop signature where
overloadedMethod = mainLoopQuit
instance O.OverloadedMethodInfo MainLoopQuitMethodInfo MainLoop where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GLib.Structs.MainLoop.mainLoopQuit",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-glib-2.0.25/docs/GI-GLib-Structs-MainLoop.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MainLoop -> m MainLoop
mainLoopRef MainLoop
loop = IO MainLoop -> m MainLoop
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MainLoop -> m MainLoop) -> IO MainLoop -> m MainLoop
forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- MainLoop -> IO (Ptr MainLoop)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainLoop
loop
Ptr MainLoop
result <- Ptr MainLoop -> IO (Ptr MainLoop)
g_main_loop_ref Ptr MainLoop
loop'
Text -> Ptr MainLoop -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mainLoopRef" Ptr MainLoop
result
MainLoop
result' <- ((ManagedPtr MainLoop -> MainLoop) -> Ptr MainLoop -> IO MainLoop
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr MainLoop -> MainLoop
MainLoop) Ptr MainLoop
result
MainLoop -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
MainLoop -> IO MainLoop
forall (m :: * -> *) a. Monad m => a -> m a
return MainLoop
result'
#if defined(ENABLE_OVERLOADING)
data MainLoopRefMethodInfo
instance (signature ~ (m MainLoop), MonadIO m) => O.OverloadedMethod MainLoopRefMethodInfo MainLoop signature where
overloadedMethod = mainLoopRef
instance O.OverloadedMethodInfo MainLoopRefMethodInfo MainLoop where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GLib.Structs.MainLoop.mainLoopRef",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-glib-2.0.25/docs/GI-GLib-Structs-MainLoop.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => MainLoop -> m ()
mainLoopRun MainLoop
loop = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- MainLoop -> IO (Ptr MainLoop)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainLoop
loop
Ptr MainLoop -> IO ()
g_main_loop_run Ptr MainLoop
loop'
MainLoop -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MainLoopRunMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MainLoopRunMethodInfo MainLoop signature where
overloadedMethod = mainLoopRun
instance O.OverloadedMethodInfo MainLoopRunMethodInfo MainLoop where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GLib.Structs.MainLoop.mainLoopRun",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-glib-2.0.25/docs/GI-GLib-Structs-MainLoop.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => MainLoop -> m ()
mainLoopUnref MainLoop
loop = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- MainLoop -> IO (Ptr MainLoop)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainLoop
loop
Ptr MainLoop -> IO ()
g_main_loop_unref Ptr MainLoop
loop'
MainLoop -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MainLoopUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MainLoopUnrefMethodInfo MainLoop signature where
overloadedMethod = mainLoopUnref
instance O.OverloadedMethodInfo MainLoopUnrefMethodInfo MainLoop where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GLib.Structs.MainLoop.mainLoopUnref",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-glib-2.0.25/docs/GI-GLib-Structs-MainLoop.html#v:mainLoopUnref"
}
#endif
#if defined(ENABLE_OVERLOADING)
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.OverloadedMethod info MainLoop p) => OL.IsLabel t (MainLoop -> 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 ~ ResolveMainLoopMethod t MainLoop, O.OverloadedMethod info MainLoop p, R.HasField t MainLoop p) => R.HasField t MainLoop p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMainLoopMethod t MainLoop, O.OverloadedMethodInfo info MainLoop) => OL.IsLabel t (O.MethodProxy info MainLoop) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif