{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

The @GMainLoop@ struct is an opaque data type
representing the main event loop of a GLib or GTK+ application.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.GLib.Structs.MainLoop
    ( 

-- * Exported types
    MainLoop(..)                            ,
    noMainLoop                              ,


 -- * Methods
-- ** getContext #method:getContext#

#if ENABLE_OVERLOADING
    MainLoopGetContextMethodInfo            ,
#endif
    mainLoopGetContext                      ,


-- ** isRunning #method:isRunning#

#if ENABLE_OVERLOADING
    MainLoopIsRunningMethodInfo             ,
#endif
    mainLoopIsRunning                       ,


-- ** new #method:new#

    mainLoopNew                             ,


-- ** quit #method:quit#

#if ENABLE_OVERLOADING
    MainLoopQuitMethodInfo                  ,
#endif
    mainLoopQuit                            ,


-- ** ref #method:ref#

#if ENABLE_OVERLOADING
    MainLoopRefMethodInfo                   ,
#endif
    mainLoopRef                             ,


-- ** run #method:run#

#if ENABLE_OVERLOADING
    MainLoopRunMethodInfo                   ,
#endif
    mainLoopRun                             ,


-- ** unref #method:unref#

#if 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.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 {-# SOURCE #-} qualified GI.GLib.Structs.MainContext as GLib.MainContext

-- | Memory-managed wrapper type.
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 :: MainLoop -> IO GType
boxedType _ = IO GType
c_g_main_loop_get_type

-- | A convenience alias for `Nothing` :: `Maybe` `MainLoop`.
noMainLoop :: Maybe MainLoop
noMainLoop :: Maybe MainLoop
noMainLoop = Maybe MainLoop
forall a. Maybe a
Nothing


#if ENABLE_OVERLOADING
instance O.HasAttributeList MainLoop
type instance O.AttributeList MainLoop = MainLoopAttributeList
type MainLoopAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method MainLoop::new
-- method type : Constructor
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "GLib", name = "MainContext"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GMainContext  (if %NULL, the default context will be used).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_running", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "set to %TRUE to indicate that the loop is running. This\nis not very important since calling g_main_loop_run() will set this to\n%TRUE anyway.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "MainLoop"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_main_loop_new" g_main_loop_new :: 
    Ptr GLib.MainContext.MainContext ->     -- context : TInterface (Name {namespace = "GLib", name = "MainContext"})
    CInt ->                                 -- is_running : TBasicType TBoolean
    IO (Ptr MainLoop)

{- |
Creates a new 'GI.GLib.Structs.MainLoop.MainLoop' structure.
-}
mainLoopNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (GLib.MainContext.MainContext)
    {- ^ /@context@/: a 'GI.GLib.Structs.MainContext.MainContext'  (if 'Nothing', the default context will be used). -}
    -> Bool
    {- ^ /@isRunning@/: set to 'True' to indicate that the loop is running. This
is not very important since calling 'GI.GLib.Structs.MainLoop.mainLoopRun' will set this to
'True' anyway. -}
    -> m MainLoop
    {- ^ __Returns:__ a new 'GI.GLib.Structs.MainLoop.MainLoop'. -}
mainLoopNew :: Maybe MainContext -> Bool -> m MainLoop
mainLoopNew context :: Maybe MainContext
context isRunning :: 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
        Nothing -> Ptr MainContext -> IO (Ptr MainContext)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MainContext
forall a. Ptr a
nullPtr
        Just jContext :: 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 "mainLoopNew" Ptr MainLoop
result
    MainLoop
result' <- ((ManagedPtr MainLoop -> MainLoop) -> Ptr MainLoop -> IO MainLoop
forall a.
(HasCallStack, BoxedObject 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 ENABLE_OVERLOADING
#endif

-- method MainLoop::get_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loop", argType = TInterface (Name {namespace = "GLib", name = "MainLoop"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMainLoop.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "MainContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_main_loop_get_context" g_main_loop_get_context :: 
    Ptr MainLoop ->                         -- loop : TInterface (Name {namespace = "GLib", name = "MainLoop"})
    IO (Ptr GLib.MainContext.MainContext)

{- |
Returns the 'GI.GLib.Structs.MainContext.MainContext' of /@loop@/.
-}
mainLoopGetContext ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MainLoop
    {- ^ /@loop@/: a 'GI.GLib.Structs.MainLoop.MainLoop'. -}
    -> m GLib.MainContext.MainContext
    {- ^ __Returns:__ the 'GI.GLib.Structs.MainContext.MainContext' of /@loop@/ -}
mainLoopGetContext :: MainLoop -> m MainContext
mainLoopGetContext loop :: 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 "mainLoopGetContext" Ptr MainContext
result
    MainContext
result' <- ((ManagedPtr MainContext -> MainContext)
-> Ptr MainContext -> IO MainContext
forall a.
(HasCallStack, BoxedObject 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 ENABLE_OVERLOADING
data MainLoopGetContextMethodInfo
instance (signature ~ (m GLib.MainContext.MainContext), MonadIO m) => O.MethodInfo MainLoopGetContextMethodInfo MainLoop signature where
    overloadedMethod _ = mainLoopGetContext

#endif

-- method MainLoop::is_running
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loop", argType = TInterface (Name {namespace = "GLib", name = "MainLoop"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMainLoop.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_main_loop_is_running" g_main_loop_is_running :: 
    Ptr MainLoop ->                         -- loop : TInterface (Name {namespace = "GLib", name = "MainLoop"})
    IO CInt

{- |
Checks to see if the main loop is currently being run via 'GI.GLib.Structs.MainLoop.mainLoopRun'.
-}
mainLoopIsRunning ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MainLoop
    {- ^ /@loop@/: a 'GI.GLib.Structs.MainLoop.MainLoop'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the mainloop is currently being run. -}
mainLoopIsRunning :: MainLoop -> m Bool
mainLoopIsRunning loop :: 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
/= 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 ENABLE_OVERLOADING
data MainLoopIsRunningMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo MainLoopIsRunningMethodInfo MainLoop signature where
    overloadedMethod _ = mainLoopIsRunning

#endif

-- method MainLoop::quit
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loop", argType = TInterface (Name {namespace = "GLib", name = "MainLoop"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMainLoop", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_main_loop_quit" g_main_loop_quit :: 
    Ptr MainLoop ->                         -- loop : TInterface (Name {namespace = "GLib", name = "MainLoop"})
    IO ()

{- |
Stops a 'GI.GLib.Structs.MainLoop.MainLoop' from running. Any calls to 'GI.GLib.Structs.MainLoop.mainLoopRun'
for the loop will return.

Note that sources that have already been dispatched when
'GI.GLib.Structs.MainLoop.mainLoopQuit' is called will still be executed.
-}
mainLoopQuit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MainLoop
    {- ^ /@loop@/: a 'GI.GLib.Structs.MainLoop.MainLoop' -}
    -> m ()
mainLoopQuit :: MainLoop -> m ()
mainLoopQuit loop :: 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 ENABLE_OVERLOADING
data MainLoopQuitMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MainLoopQuitMethodInfo MainLoop signature where
    overloadedMethod _ = mainLoopQuit

#endif

-- method MainLoop::ref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loop", argType = TInterface (Name {namespace = "GLib", name = "MainLoop"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMainLoop", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "MainLoop"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_main_loop_ref" g_main_loop_ref :: 
    Ptr MainLoop ->                         -- loop : TInterface (Name {namespace = "GLib", name = "MainLoop"})
    IO (Ptr MainLoop)

{- |
Increases the reference count on a 'GI.GLib.Structs.MainLoop.MainLoop' object by one.
-}
mainLoopRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MainLoop
    {- ^ /@loop@/: a 'GI.GLib.Structs.MainLoop.MainLoop' -}
    -> m MainLoop
    {- ^ __Returns:__ /@loop@/ -}
mainLoopRef :: MainLoop -> m MainLoop
mainLoopRef loop :: 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 "mainLoopRef" Ptr MainLoop
result
    MainLoop
result' <- ((ManagedPtr MainLoop -> MainLoop) -> Ptr MainLoop -> IO MainLoop
forall a.
(HasCallStack, BoxedObject 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 ENABLE_OVERLOADING
data MainLoopRefMethodInfo
instance (signature ~ (m MainLoop), MonadIO m) => O.MethodInfo MainLoopRefMethodInfo MainLoop signature where
    overloadedMethod _ = mainLoopRef

#endif

-- method MainLoop::run
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loop", argType = TInterface (Name {namespace = "GLib", name = "MainLoop"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMainLoop", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_main_loop_run" g_main_loop_run :: 
    Ptr MainLoop ->                         -- loop : TInterface (Name {namespace = "GLib", name = "MainLoop"})
    IO ()

{- |
Runs a main loop until 'GI.GLib.Structs.MainLoop.mainLoopQuit' is called on the loop.
If this is called for the thread of the loop\'s 'GI.GLib.Structs.MainContext.MainContext',
it will process events from the loop, otherwise it will
simply wait.
-}
mainLoopRun ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MainLoop
    {- ^ /@loop@/: a 'GI.GLib.Structs.MainLoop.MainLoop' -}
    -> m ()
mainLoopRun :: MainLoop -> m ()
mainLoopRun loop :: 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 ENABLE_OVERLOADING
data MainLoopRunMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MainLoopRunMethodInfo MainLoop signature where
    overloadedMethod _ = mainLoopRun

#endif

-- method MainLoop::unref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loop", argType = TInterface (Name {namespace = "GLib", name = "MainLoop"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMainLoop", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_main_loop_unref" g_main_loop_unref :: 
    Ptr MainLoop ->                         -- loop : TInterface (Name {namespace = "GLib", name = "MainLoop"})
    IO ()

{- |
Decreases the reference count on a 'GI.GLib.Structs.MainLoop.MainLoop' object by one. If
the result is zero, free the loop and free all associated memory.
-}
mainLoopUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MainLoop
    {- ^ /@loop@/: a 'GI.GLib.Structs.MainLoop.MainLoop' -}
    -> m ()
mainLoopUnref :: MainLoop -> m ()
mainLoopUnref loop :: 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 ENABLE_OVERLOADING
data MainLoopUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MainLoopUnrefMethodInfo MainLoop signature where
    overloadedMethod _ = mainLoopUnref

#endif

#if 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.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