{-# 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.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 {-# SOURCE #-} qualified GI.GLib.Structs.MainContext as GLib.MainContext
newtype MainLoop = MainLoop (SP.ManagedPtr MainLoop)
deriving (MainLoop -> MainLoop -> Bool
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 = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr MainLoop)
gvalueSet_ Ptr GValue
gv (P.Just MainLoop
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MainLoop
obj (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 <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr MainLoop)
if Ptr MainLoop
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr MainLoop -> MainLoop
MainLoop Ptr MainLoop
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MainLoop
type instance O.AttributeList MainLoop = MainLoopAttributeList
type MainLoopAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MainContext
maybeContext <- case Maybe MainContext
context of
Maybe MainContext
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just MainContext
jContext -> do
Ptr MainContext
jContext' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainContext
jContext
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MainContext
jContext'
let isRunning' :: CInt
isRunning' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
isRunning
Ptr MainLoop
result <- Ptr MainContext -> CInt -> IO (Ptr MainLoop)
g_main_loop_new Ptr MainContext
maybeContext CInt
isRunning'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mainLoopNew" Ptr MainLoop
result
MainLoop
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr MainLoop -> MainLoop
MainLoop) Ptr MainLoop
result
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe MainContext
context forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- 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'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mainLoopGetContext" Ptr MainContext
result
MainContext
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MainContext -> MainContext
GLib.MainContext.MainContext) Ptr MainContext
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.MainLoop.mainLoopGetContext",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- 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' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.MainLoop.mainLoopIsRunning",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainLoop
loop
Ptr MainLoop -> IO ()
g_main_loop_quit Ptr MainLoop
loop'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.MainLoop.mainLoopQuit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- 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'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mainLoopRef" Ptr MainLoop
result
MainLoop
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr MainLoop -> MainLoop
MainLoop) Ptr MainLoop
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.MainLoop.mainLoopRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainLoop
loop
Ptr MainLoop -> IO ()
g_main_loop_run Ptr MainLoop
loop'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.MainLoop.mainLoopRun",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MainLoop
loop' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainLoop
loop
Ptr MainLoop -> IO ()
g_main_loop_unref Ptr MainLoop
loop'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MainLoop
loop
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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.MainLoop.mainLoopUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-MainLoop.html#v:mainLoopUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveMainLoopMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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