    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Integrating the launch with the launching application. This is used to
    -- handle for instance startup notification and launching the new application
    -- on the same screen as the launching window.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gio.Objects.AppLaunchContext
        (

    -- * Exported types
        AppLaunchContext(..)                    ,
        IsAppLaunchContext                      ,
        toAppLaunchContext                      ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveAppLaunchContextMethod           ,
    #endif

    -- ** getDisplay #method:getDisplay#

    #if defined(ENABLE_OVERLOADING)
        AppLaunchContextGetDisplayMethodInfo    ,
    #endif
        appLaunchContextGetDisplay              ,

    -- ** getEnvironment #method:getEnvironment#

    #if defined(ENABLE_OVERLOADING)
        AppLaunchContextGetEnvironmentMethodInfo,
    #endif
        appLaunchContextGetEnvironment          ,

    -- ** getStartupNotifyId #method:getStartupNotifyId#

    #if defined(ENABLE_OVERLOADING)
        AppLaunchContextGetStartupNotifyIdMethodInfo,
    #endif
        appLaunchContextGetStartupNotifyId      ,

    -- ** launchFailed #method:launchFailed#

    #if defined(ENABLE_OVERLOADING)
        AppLaunchContextLaunchFailedMethodInfo  ,
    #endif
        appLaunchContextLaunchFailed            ,

    -- ** new #method:new#

        appLaunchContextNew                     ,

    -- ** setenv #method:setenv#

    #if defined(ENABLE_OVERLOADING)
        AppLaunchContextSetenvMethodInfo        ,
    #endif
        appLaunchContextSetenv                  ,

    -- ** unsetenv #method:unsetenv#

    #if defined(ENABLE_OVERLOADING)
        AppLaunchContextUnsetenvMethodInfo      ,
    #endif
        appLaunchContextUnsetenv                ,

     -- * Signals
    -- ** launchFailed #signal:launchFailed#

        AppLaunchContextLaunchFailedCallback    ,
    #if defined(ENABLE_OVERLOADING)
        AppLaunchContextLaunchFailedSignalInfo  ,
    #endif
        C_AppLaunchContextLaunchFailedCallback  ,
        afterAppLaunchContextLaunchFailed       ,
        genClosure_AppLaunchContextLaunchFailed ,
        mk_AppLaunchContextLaunchFailedCallback ,
        noAppLaunchContextLaunchFailedCallback  ,
        onAppLaunchContextLaunchFailed          ,
        wrap_AppLaunchContextLaunchFailedCallback,

    -- ** launched #signal:launched#

        AppLaunchContextLaunchedCallback        ,
    #if defined(ENABLE_OVERLOADING)
        AppLaunchContextLaunchedSignalInfo      ,
    #endif
        C_AppLaunchContextLaunchedCallback      ,
        afterAppLaunchContextLaunched           ,
        genClosure_AppLaunchContextLaunched     ,
        mk_AppLaunchContextLaunchedCallback     ,
        noAppLaunchContextLaunchedCallback      ,
        onAppLaunchContextLaunched              ,
        wrap_AppLaunchContextLaunchedCallback   ,

        ) 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 GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AppInfo as Gio.AppInfo
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.File as Gio.File

    -- | Memory-managed wrapper type.
    newtype AppLaunchContext = AppLaunchContext (SP.ManagedPtr AppLaunchContext)
        deriving (AppLaunchContext -> AppLaunchContext -> Bool
    (AppLaunchContext -> AppLaunchContext -> Bool)
    -> (AppLaunchContext -> AppLaunchContext -> Bool)
    -> Eq AppLaunchContext
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AppLaunchContext -> AppLaunchContext -> Bool
    $c/= :: AppLaunchContext -> AppLaunchContext -> Bool
    == :: AppLaunchContext -> AppLaunchContext -> Bool
    $c== :: AppLaunchContext -> AppLaunchContext -> Bool
    Eq)

    instance SP.ManagedPtrNewtype AppLaunchContext where
        toManagedPtr :: AppLaunchContext -> ManagedPtr AppLaunchContext
    toManagedPtr (AppLaunchContext p :: ManagedPtr AppLaunchContext
    p) = ManagedPtr AppLaunchContext
    p

    foreign import ccall "g_app_launch_context_get_type"
        c_g_app_launch_context_get_type :: IO B.Types.GType

    instance B.Types.TypedObject AppLaunchContext where
        glibType :: IO GType
    glibType = IO GType
    c_g_app_launch_context_get_type

    instance B.Types.GObject AppLaunchContext

    -- | Convert 'AppLaunchContext' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue AppLaunchContext where
        toGValue :: AppLaunchContext -> IO GValue
    toGValue o :: AppLaunchContext
    o = do
            GType
    gtype <- IO GType
    c_g_app_launch_context_get_type
            AppLaunchContext
    -> (Ptr AppLaunchContext -> IO GValue) -> IO GValue
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr AppLaunchContext
    o (GType
    -> (GValue -> Ptr AppLaunchContext -> IO ())
    -> Ptr AppLaunchContext
    -> IO GValue
    forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
    B.GValue.buildGValue GType
    gtype GValue -> Ptr AppLaunchContext -> IO ()
    forall a. GObject a => GValue -> Ptr a -> IO ()
    B.GValue.set_object)

        fromGValue :: GValue -> IO AppLaunchContext
    fromGValue gv :: GValue
    gv = do
            Ptr AppLaunchContext
    ptr <- GValue -> IO (Ptr AppLaunchContext)
    forall b. GObject b => GValue -> IO (Ptr b)
    B.GValue.get_object GValue
    gv :: IO (Ptr AppLaunchContext)
            (ManagedPtr AppLaunchContext -> AppLaunchContext)
    -> Ptr AppLaunchContext -> IO AppLaunchContext
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr AppLaunchContext -> AppLaunchContext
    AppLaunchContext Ptr AppLaunchContext
    ptr

    -- | Type class for types which can be safely cast to `AppLaunchContext`, for instance with `toAppLaunchContext`.
    class (SP.GObject o, O.IsDescendantOf AppLaunchContext o) => IsAppLaunchContext o
    instance (SP.GObject o, O.IsDescendantOf AppLaunchContext o) => IsAppLaunchContext o

    instance O.HasParentTypes AppLaunchContext
    type instance O.ParentTypes AppLaunchContext = '[GObject.Object.Object]

    -- | Cast to `AppLaunchContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toAppLaunchContext :: (MonadIO m, IsAppLaunchContext o) => o -> m AppLaunchContext
    toAppLaunchContext :: o -> m AppLaunchContext
    toAppLaunchContext = IO AppLaunchContext -> m AppLaunchContext
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO AppLaunchContext -> m AppLaunchContext)
    -> (o -> IO AppLaunchContext) -> o -> m AppLaunchContext
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr AppLaunchContext -> AppLaunchContext)
    -> o -> IO AppLaunchContext
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    unsafeCastTo ManagedPtr AppLaunchContext -> AppLaunchContext
    AppLaunchContext

    #if defined(ENABLE_OVERLOADING)
    type family ResolveAppLaunchContextMethod (t :: Symbol) (o :: *) :: * where
        ResolveAppLaunchContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveAppLaunchContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveAppLaunchContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveAppLaunchContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveAppLaunchContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveAppLaunchContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveAppLaunchContextMethod "launchFailed" o = AppLaunchContextLaunchFailedMethodInfo
        ResolveAppLaunchContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveAppLaunchContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveAppLaunchContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveAppLaunchContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveAppLaunchContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveAppLaunchContextMethod "setenv" o = AppLaunchContextSetenvMethodInfo
        ResolveAppLaunchContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveAppLaunchContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveAppLaunchContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveAppLaunchContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveAppLaunchContextMethod "unsetenv" o = AppLaunchContextUnsetenvMethodInfo
        ResolveAppLaunchContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveAppLaunchContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveAppLaunchContextMethod "getDisplay" o = AppLaunchContextGetDisplayMethodInfo
        ResolveAppLaunchContextMethod "getEnvironment" o = AppLaunchContextGetEnvironmentMethodInfo
        ResolveAppLaunchContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveAppLaunchContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveAppLaunchContextMethod "getStartupNotifyId" o = AppLaunchContextGetStartupNotifyIdMethodInfo
        ResolveAppLaunchContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveAppLaunchContextMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveAppLaunchContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveAppLaunchContextMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveAppLaunchContextMethod t AppLaunchContext, O.MethodInfo info AppLaunchContext p) => OL.IsLabel t (AppLaunchContext -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #endif

    -- signal AppLaunchContext::launch-failed
    -- | The [launchFailed](#g:signal:launchFailed) signal is emitted when a t'GI.Gio.Interfaces.AppInfo.AppInfo' launch
    -- fails. The startup notification id is provided, so that the launcher
    -- can cancel the startup notification.
    --
    -- /Since: 2.36/
    type AppLaunchContextLaunchFailedCallback =
        T.Text
        -- ^ /@startupNotifyId@/: the startup notification id for the failed launch
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `AppLaunchContextLaunchFailedCallback`@.
    noAppLaunchContextLaunchFailedCallback :: Maybe AppLaunchContextLaunchFailedCallback
    noAppLaunchContextLaunchFailedCallback :: Maybe AppLaunchContextLaunchFailedCallback
    noAppLaunchContextLaunchFailedCallback = Maybe AppLaunchContextLaunchFailedCallback
    forall a. Maybe a
    Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_AppLaunchContextLaunchFailedCallback =
        Ptr () ->                               -- object
        CString ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_AppLaunchContextLaunchFailedCallback`.
    foreign import ccall "wrapper"
        mk_AppLaunchContextLaunchFailedCallback :: C_AppLaunchContextLaunchFailedCallback -> IO (FunPtr C_AppLaunchContextLaunchFailedCallback)

    -- | Wrap the callback into a `GClosure`.
    genClosure_AppLaunchContextLaunchFailed :: MonadIO m => AppLaunchContextLaunchFailedCallback -> m (GClosure C_AppLaunchContextLaunchFailedCallback)
    genClosure_AppLaunchContextLaunchFailed :: AppLaunchContextLaunchFailedCallback
    -> m (GClosure C_AppLaunchContextLaunchFailedCallback)
    genClosure_AppLaunchContextLaunchFailed cb :: AppLaunchContextLaunchFailedCallback
    cb = IO (GClosure C_AppLaunchContextLaunchFailedCallback)
    -> m (GClosure C_AppLaunchContextLaunchFailedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_AppLaunchContextLaunchFailedCallback)
     -> m (GClosure C_AppLaunchContextLaunchFailedCallback))
    -> IO (GClosure C_AppLaunchContextLaunchFailedCallback)
    -> m (GClosure C_AppLaunchContextLaunchFailedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_AppLaunchContextLaunchFailedCallback
    cb' = AppLaunchContextLaunchFailedCallback
    -> C_AppLaunchContextLaunchFailedCallback
    wrap_AppLaunchContextLaunchFailedCallback AppLaunchContextLaunchFailedCallback
    cb
        C_AppLaunchContextLaunchFailedCallback
    -> IO (FunPtr C_AppLaunchContextLaunchFailedCallback)
    mk_AppLaunchContextLaunchFailedCallback C_AppLaunchContextLaunchFailedCallback
    cb' IO (FunPtr C_AppLaunchContextLaunchFailedCallback)
    -> (FunPtr C_AppLaunchContextLaunchFailedCallback
        -> IO (GClosure C_AppLaunchContextLaunchFailedCallback))
    -> IO (GClosure C_AppLaunchContextLaunchFailedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_AppLaunchContextLaunchFailedCallback
    -> IO (GClosure C_AppLaunchContextLaunchFailedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `AppLaunchContextLaunchFailedCallback` into a `C_AppLaunchContextLaunchFailedCallback`.
    wrap_AppLaunchContextLaunchFailedCallback ::
        AppLaunchContextLaunchFailedCallback ->
        C_AppLaunchContextLaunchFailedCallback
    wrap_AppLaunchContextLaunchFailedCallback :: AppLaunchContextLaunchFailedCallback
    -> C_AppLaunchContextLaunchFailedCallback
    wrap_AppLaunchContextLaunchFailedCallback _cb :: AppLaunchContextLaunchFailedCallback
    _cb _ startupNotifyId :: CString
    startupNotifyId _ = do
        Text
    startupNotifyId' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    startupNotifyId
        AppLaunchContextLaunchFailedCallback
    _cb  Text
    startupNotifyId'

    -- | Connect a signal handler for the [launchFailed](#signal:launchFailed) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' appLaunchContext #launchFailed callback
    -- @
    --
    --
    onAppLaunchContextLaunchFailed :: (IsAppLaunchContext a, MonadIO m) => a -> AppLaunchContextLaunchFailedCallback -> m SignalHandlerId
    onAppLaunchContextLaunchFailed :: a -> AppLaunchContextLaunchFailedCallback -> m SignalHandlerId
    onAppLaunchContextLaunchFailed obj :: a
    obj cb :: AppLaunchContextLaunchFailedCallback
    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_AppLaunchContextLaunchFailedCallback
    cb' = AppLaunchContextLaunchFailedCallback
    -> C_AppLaunchContextLaunchFailedCallback
    wrap_AppLaunchContextLaunchFailedCallback AppLaunchContextLaunchFailedCallback
    cb
        FunPtr C_AppLaunchContextLaunchFailedCallback
    cb'' <- C_AppLaunchContextLaunchFailedCallback
    -> IO (FunPtr C_AppLaunchContextLaunchFailedCallback)
    mk_AppLaunchContextLaunchFailedCallback C_AppLaunchContextLaunchFailedCallback
    cb'
        a
    -> Text
    -> FunPtr C_AppLaunchContextLaunchFailedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "launch-failed" FunPtr C_AppLaunchContextLaunchFailedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [launchFailed](#signal:launchFailed) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' appLaunchContext #launchFailed callback
    -- @
    --
    --
    afterAppLaunchContextLaunchFailed :: (IsAppLaunchContext a, MonadIO m) => a -> AppLaunchContextLaunchFailedCallback -> m SignalHandlerId
    afterAppLaunchContextLaunchFailed :: a -> AppLaunchContextLaunchFailedCallback -> m SignalHandlerId
    afterAppLaunchContextLaunchFailed obj :: a
    obj cb :: AppLaunchContextLaunchFailedCallback
    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_AppLaunchContextLaunchFailedCallback
    cb' = AppLaunchContextLaunchFailedCallback
    -> C_AppLaunchContextLaunchFailedCallback
    wrap_AppLaunchContextLaunchFailedCallback AppLaunchContextLaunchFailedCallback
    cb
        FunPtr C_AppLaunchContextLaunchFailedCallback
    cb'' <- C_AppLaunchContextLaunchFailedCallback
    -> IO (FunPtr C_AppLaunchContextLaunchFailedCallback)
    mk_AppLaunchContextLaunchFailedCallback C_AppLaunchContextLaunchFailedCallback
    cb'
        a
    -> Text
    -> FunPtr C_AppLaunchContextLaunchFailedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "launch-failed" FunPtr C_AppLaunchContextLaunchFailedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data AppLaunchContextLaunchFailedSignalInfo
    instance SignalInfo AppLaunchContextLaunchFailedSignalInfo where
        type HaskellCallbackType AppLaunchContextLaunchFailedSignalInfo = AppLaunchContextLaunchFailedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_AppLaunchContextLaunchFailedCallback cb
            cb'' <- mk_AppLaunchContextLaunchFailedCallback cb'
            connectSignalFunPtr obj "launch-failed" cb'' connectMode detail

    #endif

    -- signal AppLaunchContext::launched
    -- | The [launched](#g:signal:launched) signal is emitted when a t'GI.Gio.Interfaces.AppInfo.AppInfo' is successfully
    -- launched. The /@platformData@/ is an GVariant dictionary mapping
    -- strings to variants (ie a{sv}), which contains additional,
    -- platform-specific data about this launch. On UNIX, at least the
    -- \"pid\" and \"startup-notification-id\" keys will be present.
    --
    -- /Since: 2.36/
    type AppLaunchContextLaunchedCallback =
        Gio.AppInfo.AppInfo
        -- ^ /@info@/: the t'GI.Gio.Interfaces.AppInfo.AppInfo' that was just launched
        -> GVariant
        -- ^ /@platformData@/: additional platform-specific data for this launch
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `AppLaunchContextLaunchedCallback`@.
    noAppLaunchContextLaunchedCallback :: Maybe AppLaunchContextLaunchedCallback
    noAppLaunchContextLaunchedCallback :: Maybe AppLaunchContextLaunchedCallback
    noAppLaunchContextLaunchedCallback = Maybe AppLaunchContextLaunchedCallback
    forall a. Maybe a
    Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_AppLaunchContextLaunchedCallback =
        Ptr () ->                               -- object
        Ptr Gio.AppInfo.AppInfo ->
        Ptr GVariant ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_AppLaunchContextLaunchedCallback`.
    foreign import ccall "wrapper"
        mk_AppLaunchContextLaunchedCallback :: C_AppLaunchContextLaunchedCallback -> IO (FunPtr C_AppLaunchContextLaunchedCallback)

    -- | Wrap the callback into a `GClosure`.
    genClosure_AppLaunchContextLaunched :: MonadIO m => AppLaunchContextLaunchedCallback -> m (GClosure C_AppLaunchContextLaunchedCallback)
    genClosure_AppLaunchContextLaunched :: AppLaunchContextLaunchedCallback
    -> m (GClosure C_AppLaunchContextLaunchedCallback)
    genClosure_AppLaunchContextLaunched cb :: AppLaunchContextLaunchedCallback
    cb = IO (GClosure C_AppLaunchContextLaunchedCallback)
    -> m (GClosure C_AppLaunchContextLaunchedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_AppLaunchContextLaunchedCallback)
     -> m (GClosure C_AppLaunchContextLaunchedCallback))
    -> IO (GClosure C_AppLaunchContextLaunchedCallback)
    -> m (GClosure C_AppLaunchContextLaunchedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_AppLaunchContextLaunchedCallback
    cb' = AppLaunchContextLaunchedCallback
    -> C_AppLaunchContextLaunchedCallback
    wrap_AppLaunchContextLaunchedCallback AppLaunchContextLaunchedCallback
    cb
        C_AppLaunchContextLaunchedCallback
    -> IO (FunPtr C_AppLaunchContextLaunchedCallback)
    mk_AppLaunchContextLaunchedCallback C_AppLaunchContextLaunchedCallback
    cb' IO (FunPtr C_AppLaunchContextLaunchedCallback)
    -> (FunPtr C_AppLaunchContextLaunchedCallback
        -> IO (GClosure C_AppLaunchContextLaunchedCallback))
    -> IO (GClosure C_AppLaunchContextLaunchedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_AppLaunchContextLaunchedCallback
    -> IO (GClosure C_AppLaunchContextLaunchedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `AppLaunchContextLaunchedCallback` into a `C_AppLaunchContextLaunchedCallback`.
    wrap_AppLaunchContextLaunchedCallback ::
        AppLaunchContextLaunchedCallback ->
        C_AppLaunchContextLaunchedCallback
    wrap_AppLaunchContextLaunchedCallback :: AppLaunchContextLaunchedCallback
    -> C_AppLaunchContextLaunchedCallback
    wrap_AppLaunchContextLaunchedCallback _cb :: AppLaunchContextLaunchedCallback
    _cb _ info :: Ptr AppInfo
    info platformData :: Ptr GVariant
    platformData _ = do
        AppInfo
    info' <- ((ManagedPtr AppInfo -> AppInfo) -> Ptr AppInfo -> IO AppInfo
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr AppInfo -> AppInfo
    Gio.AppInfo.AppInfo) Ptr AppInfo
    info
        GVariant
    platformData' <- Ptr GVariant -> IO GVariant
    B.GVariant.newGVariantFromPtr Ptr GVariant
    platformData
        AppLaunchContextLaunchedCallback
    _cb  AppInfo
    info' GVariant
    platformData'

    -- | Connect a signal handler for the [launched](#signal:launched) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' appLaunchContext #launched callback
    -- @
    --
    --
    onAppLaunchContextLaunched :: (IsAppLaunchContext a, MonadIO m) => a -> AppLaunchContextLaunchedCallback -> m SignalHandlerId
    onAppLaunchContextLaunched :: a -> AppLaunchContextLaunchedCallback -> m SignalHandlerId
    onAppLaunchContextLaunched obj :: a
    obj cb :: AppLaunchContextLaunchedCallback
    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_AppLaunchContextLaunchedCallback
    cb' = AppLaunchContextLaunchedCallback
    -> C_AppLaunchContextLaunchedCallback
    wrap_AppLaunchContextLaunchedCallback AppLaunchContextLaunchedCallback
    cb
        FunPtr C_AppLaunchContextLaunchedCallback
    cb'' <- C_AppLaunchContextLaunchedCallback
    -> IO (FunPtr C_AppLaunchContextLaunchedCallback)
    mk_AppLaunchContextLaunchedCallback C_AppLaunchContextLaunchedCallback
    cb'
        a
    -> Text
    -> FunPtr C_AppLaunchContextLaunchedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "launched" FunPtr C_AppLaunchContextLaunchedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [launched](#signal:launched) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' appLaunchContext #launched callback
    -- @
    --
    --
    afterAppLaunchContextLaunched :: (IsAppLaunchContext a, MonadIO m) => a -> AppLaunchContextLaunchedCallback -> m SignalHandlerId
    afterAppLaunchContextLaunched :: a -> AppLaunchContextLaunchedCallback -> m SignalHandlerId
    afterAppLaunchContextLaunched obj :: a
    obj cb :: AppLaunchContextLaunchedCallback
    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_AppLaunchContextLaunchedCallback
    cb' = AppLaunchContextLaunchedCallback
    -> C_AppLaunchContextLaunchedCallback
    wrap_AppLaunchContextLaunchedCallback AppLaunchContextLaunchedCallback
    cb
        FunPtr C_AppLaunchContextLaunchedCallback
    cb'' <- C_AppLaunchContextLaunchedCallback
    -> IO (FunPtr C_AppLaunchContextLaunchedCallback)
    mk_AppLaunchContextLaunchedCallback C_AppLaunchContextLaunchedCallback
    cb'
        a
    -> Text
    -> FunPtr C_AppLaunchContextLaunchedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "launched" FunPtr C_AppLaunchContextLaunchedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data AppLaunchContextLaunchedSignalInfo
    instance SignalInfo AppLaunchContextLaunchedSignalInfo where
        type HaskellCallbackType AppLaunchContextLaunchedSignalInfo = AppLaunchContextLaunchedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_AppLaunchContextLaunchedCallback cb
            cb'' <- mk_AppLaunchContextLaunchedCallback cb'
            connectSignalFunPtr obj "launched" cb'' connectMode detail

    #endif

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

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList AppLaunchContext = AppLaunchContextSignalList
    type AppLaunchContextSignalList = ('[ '("launchFailed", AppLaunchContextLaunchFailedSignalInfo), '("launched", AppLaunchContextLaunchedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method AppLaunchContext::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gio" , name = "AppLaunchContext" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_app_launch_context_new" g_app_launch_context_new ::
        IO (Ptr AppLaunchContext)

    -- | Creates a new application launch context. This is not normally used,
    -- instead you instantiate a subclass of this, such as @/GdkAppLaunchContext/@.
    appLaunchContextNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m AppLaunchContext
        -- ^ __Returns:__ a t'GI.Gio.Objects.AppLaunchContext.AppLaunchContext'.
    appLaunchContextNew :: m AppLaunchContext
    appLaunchContextNew  = IO AppLaunchContext -> m AppLaunchContext
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO AppLaunchContext -> m AppLaunchContext)
    -> IO AppLaunchContext -> m AppLaunchContext
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr AppLaunchContext
    result <- IO (Ptr AppLaunchContext)
    g_app_launch_context_new
        Text -> Ptr AppLaunchContext -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "appLaunchContextNew" Ptr AppLaunchContext
    result
        AppLaunchContext
    result' <- ((ManagedPtr AppLaunchContext -> AppLaunchContext)
    -> Ptr AppLaunchContext -> IO AppLaunchContext
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr AppLaunchContext -> AppLaunchContext
    AppLaunchContext) Ptr AppLaunchContext
    result
        AppLaunchContext -> IO AppLaunchContext
    forall (m :: * -> *) a. Monad m => a -> m a
    return AppLaunchContext
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method AppLaunchContext::get_display
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AppLaunchContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAppLaunchContext"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "info"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AppInfo" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAppInfo" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "files"
    --           , argType =
    --               TGList (TInterface Name { namespace = "Gio" , name = "File" })
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GList of #GFile objects"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_app_launch_context_get_display" g_app_launch_context_get_display ::
        Ptr AppLaunchContext ->                 -- context : TInterface (Name {namespace = "Gio", name = "AppLaunchContext"})
        Ptr Gio.AppInfo.AppInfo ->              -- info : TInterface (Name {namespace = "Gio", name = "AppInfo"})
        Ptr (GList (Ptr Gio.File.File)) ->      -- files : TGList (TInterface (Name {namespace = "Gio", name = "File"}))
        IO CString

    -- | Gets the display string for the /@context@/. This is used to ensure new
    -- applications are started on the same display as the launching
    -- application, by setting the @DISPLAY@ environment variable.
    appLaunchContextGetDisplay ::
        (B.CallStack.HasCallStack, MonadIO m, IsAppLaunchContext a, Gio.AppInfo.IsAppInfo b, Gio.File.IsFile c) =>
        a
        -- ^ /@context@/: a t'GI.Gio.Objects.AppLaunchContext.AppLaunchContext'
        -> b
        -- ^ /@info@/: a t'GI.Gio.Interfaces.AppInfo.AppInfo'
        -> [c]
        -- ^ /@files@/: a t'GI.GLib.Structs.List.List' of t'GI.Gio.Interfaces.File.File' objects
        -> m T.Text
        -- ^ __Returns:__ a display string for the display.
    appLaunchContextGetDisplay :: a -> b -> [c] -> m Text
    appLaunchContextGetDisplay context :: a
    context info :: b
    info files :: [c]
    files = IO Text -> m Text
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr AppLaunchContext
    context' <- a -> IO (Ptr AppLaunchContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr AppInfo
    info' <- b -> IO (Ptr AppInfo)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    info
        [Ptr File]
    files' <- (c -> IO (Ptr File)) -> [c] -> IO [Ptr File]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM c -> IO (Ptr File)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr [c]
    files
        Ptr (GList (Ptr File))
    files'' <- [Ptr File] -> IO (Ptr (GList (Ptr File)))
    forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
    packGList [Ptr File]
    files'
        CString
    result <- Ptr AppLaunchContext
    -> Ptr AppInfo -> Ptr (GList (Ptr File)) -> IO CString
    g_app_launch_context_get_display Ptr AppLaunchContext
    context' Ptr AppInfo
    info' Ptr (GList (Ptr File))
    files''
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "appLaunchContextGetDisplay" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    info
        (c -> IO ()) -> [c] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ c -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr [c]
    files
        Ptr (GList (Ptr File)) -> IO ()
    forall a. Ptr (GList a) -> IO ()
    g_list_free Ptr (GList (Ptr File))
    files''
        Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

    #if defined(ENABLE_OVERLOADING)
    data AppLaunchContextGetDisplayMethodInfo
    instance (signature ~ (b -> [c] -> m T.Text), MonadIO m, IsAppLaunchContext a, Gio.AppInfo.IsAppInfo b, Gio.File.IsFile c) => O.MethodInfo AppLaunchContextGetDisplayMethodInfo a signature where
        overloadedMethod = appLaunchContextGetDisplay

    #endif

    -- method AppLaunchContext::get_environment
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AppLaunchContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAppLaunchContext"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TCArray True (-1) (-1) (TBasicType TFileName))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_app_launch_context_get_environment" g_app_launch_context_get_environment ::
        Ptr AppLaunchContext ->                 -- context : TInterface (Name {namespace = "Gio", name = "AppLaunchContext"})
        IO (Ptr CString)

    -- | Gets the complete environment variable list to be passed to
    -- the child process when /@context@/ is used to launch an application.
    -- This is a 'P.Nothing'-terminated array of strings, where each string has
    -- the form @KEY=VALUE@.
    --
    -- /Since: 2.32/
    appLaunchContextGetEnvironment ::
        (B.CallStack.HasCallStack, MonadIO m, IsAppLaunchContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gio.Objects.AppLaunchContext.AppLaunchContext'
        -> m [[Char]]
        -- ^ __Returns:__
        --     the child\'s environment
    appLaunchContextGetEnvironment :: a -> m [[Char]]
    appLaunchContextGetEnvironment context :: a
    context = IO [[Char]] -> m [[Char]]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [[Char]] -> m [[Char]]) -> IO [[Char]] -> m [[Char]]
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr AppLaunchContext
    context' <- a -> IO (Ptr AppLaunchContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr CString
    result <- Ptr AppLaunchContext -> IO (Ptr CString)
    g_app_launch_context_get_environment Ptr AppLaunchContext
    context'
        Text -> Ptr CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "appLaunchContextGetEnvironment" Ptr CString
    result
        [[Char]]
    result' <- HasCallStack => Ptr CString -> IO [[Char]]
    Ptr CString -> IO [[Char]]
    unpackZeroTerminatedFileNameArray Ptr CString
    result
        (CString -> IO ()) -> Ptr CString -> IO ()
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
    mapZeroTerminatedCArray CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        Ptr CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        [[Char]] -> IO [[Char]]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [[Char]]
    result'

    #if defined(ENABLE_OVERLOADING)
    data AppLaunchContextGetEnvironmentMethodInfo
    instance (signature ~ (m [[Char]]), MonadIO m, IsAppLaunchContext a) => O.MethodInfo AppLaunchContextGetEnvironmentMethodInfo a signature where
        overloadedMethod = appLaunchContextGetEnvironment

    #endif

    -- method AppLaunchContext::get_startup_notify_id
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AppLaunchContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAppLaunchContext"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "info"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AppInfo" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAppInfo" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "files"
    --           , argType =
    --               TGList (TInterface Name { namespace = "Gio" , name = "File" })
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GList of of #GFile objects"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_app_launch_context_get_startup_notify_id" g_app_launch_context_get_startup_notify_id ::
        Ptr AppLaunchContext ->                 -- context : TInterface (Name {namespace = "Gio", name = "AppLaunchContext"})
        Ptr Gio.AppInfo.AppInfo ->              -- info : TInterface (Name {namespace = "Gio", name = "AppInfo"})
        Ptr (GList (Ptr Gio.File.File)) ->      -- files : TGList (TInterface (Name {namespace = "Gio", name = "File"}))
        IO CString

    -- | Initiates startup notification for the application and returns the
    -- @DESKTOP_STARTUP_ID@ for the launched operation, if supported.
    --
    -- Startup notification IDs are defined in the
    -- <http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt FreeDesktop.Org Startup Notifications standard>.
    appLaunchContextGetStartupNotifyId ::
        (B.CallStack.HasCallStack, MonadIO m, IsAppLaunchContext a, Gio.AppInfo.IsAppInfo b, Gio.File.IsFile c) =>
        a
        -- ^ /@context@/: a t'GI.Gio.Objects.AppLaunchContext.AppLaunchContext'
        -> b
        -- ^ /@info@/: a t'GI.Gio.Interfaces.AppInfo.AppInfo'
        -> [c]
        -- ^ /@files@/: a t'GI.GLib.Structs.List.List' of of t'GI.Gio.Interfaces.File.File' objects
        -> m T.Text
        -- ^ __Returns:__ a startup notification ID for the application, or 'P.Nothing' if
        --     not supported.
    appLaunchContextGetStartupNotifyId :: a -> b -> [c] -> m Text
    appLaunchContextGetStartupNotifyId context :: a
    context info :: b
    info files :: [c]
    files = IO Text -> m Text
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr AppLaunchContext
    context' <- a -> IO (Ptr AppLaunchContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr AppInfo
    info' <- b -> IO (Ptr AppInfo)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    info
        [Ptr File]
    files' <- (c -> IO (Ptr File)) -> [c] -> IO [Ptr File]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM c -> IO (Ptr File)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr [c]
    files
        Ptr (GList (Ptr File))
    files'' <- [Ptr File] -> IO (Ptr (GList (Ptr File)))
    forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
    packGList [Ptr File]
    files'
        CString
    result <- Ptr AppLaunchContext
    -> Ptr AppInfo -> Ptr (GList (Ptr File)) -> IO CString
    g_app_launch_context_get_startup_notify_id Ptr AppLaunchContext
    context' Ptr AppInfo
    info' Ptr (GList (Ptr File))
    files''
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "appLaunchContextGetStartupNotifyId" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    info
        (c -> IO ()) -> [c] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ c -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr [c]
    files
        Ptr (GList (Ptr File)) -> IO ()
    forall a. Ptr (GList a) -> IO ()
    g_list_free Ptr (GList (Ptr File))
    files''
        Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

    #if defined(ENABLE_OVERLOADING)
    data AppLaunchContextGetStartupNotifyIdMethodInfo
    instance (signature ~ (b -> [c] -> m T.Text), MonadIO m, IsAppLaunchContext a, Gio.AppInfo.IsAppInfo b, Gio.File.IsFile c) => O.MethodInfo AppLaunchContextGetStartupNotifyIdMethodInfo a signature where
        overloadedMethod = appLaunchContextGetStartupNotifyId

    #endif

    -- method AppLaunchContext::launch_failed
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AppLaunchContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAppLaunchContext."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "startup_notify_id"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the startup notification id that was returned by g_app_launch_context_get_startup_notify_id()."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_app_launch_context_launch_failed" g_app_launch_context_launch_failed ::
        Ptr AppLaunchContext ->                 -- context : TInterface (Name {namespace = "Gio", name = "AppLaunchContext"})
        CString ->                              -- startup_notify_id : TBasicType TUTF8
        IO ()

    -- | Called when an application has failed to launch, so that it can cancel
    -- the application startup notification started in 'GI.Gio.Objects.AppLaunchContext.appLaunchContextGetStartupNotifyId'.
    appLaunchContextLaunchFailed ::
        (B.CallStack.HasCallStack, MonadIO m, IsAppLaunchContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gio.Objects.AppLaunchContext.AppLaunchContext'.
        -> T.Text
        -- ^ /@startupNotifyId@/: the startup notification id that was returned by 'GI.Gio.Objects.AppLaunchContext.appLaunchContextGetStartupNotifyId'.
        -> m ()
    appLaunchContextLaunchFailed :: a -> Text -> m ()
    appLaunchContextLaunchFailed context :: a
    context startupNotifyId :: Text
    startupNotifyId = 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 AppLaunchContext
    context' <- a -> IO (Ptr AppLaunchContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CString
    startupNotifyId' <- Text -> IO CString
    textToCString Text
    startupNotifyId
        Ptr AppLaunchContext -> CString -> IO ()
    g_app_launch_context_launch_failed Ptr AppLaunchContext
    context' CString
    startupNotifyId'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    startupNotifyId'
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data AppLaunchContextLaunchFailedMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsAppLaunchContext a) => O.MethodInfo AppLaunchContextLaunchFailedMethodInfo a signature where
        overloadedMethod = appLaunchContextLaunchFailed

    #endif

    -- method AppLaunchContext::setenv
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AppLaunchContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAppLaunchContext"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "variable"
    --           , argType = TBasicType TFileName
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the environment variable to set"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TFileName
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value for to set the variable to."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_app_launch_context_setenv" g_app_launch_context_setenv ::
        Ptr AppLaunchContext ->                 -- context : TInterface (Name {namespace = "Gio", name = "AppLaunchContext"})
        CString ->                              -- variable : TBasicType TFileName
        CString ->                              -- value : TBasicType TFileName
        IO ()

    -- | Arranges for /@variable@/ to be set to /@value@/ in the child\'s
    -- environment when /@context@/ is used to launch an application.
    --
    -- /Since: 2.32/
    appLaunchContextSetenv ::
        (B.CallStack.HasCallStack, MonadIO m, IsAppLaunchContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gio.Objects.AppLaunchContext.AppLaunchContext'
        -> [Char]
        -- ^ /@variable@/: the environment variable to set
        -> [Char]
        -- ^ /@value@/: the value for to set the variable to.
        -> m ()
    appLaunchContextSetenv :: a -> [Char] -> [Char] -> m ()
    appLaunchContextSetenv context :: a
    context variable :: [Char]
    variable value :: [Char]
    value = 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 AppLaunchContext
    context' <- a -> IO (Ptr AppLaunchContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CString
    variable' <- [Char] -> IO CString
    stringToCString [Char]
    variable
        CString
    value' <- [Char] -> IO CString
    stringToCString [Char]
    value
        Ptr AppLaunchContext -> CString -> CString -> IO ()
    g_app_launch_context_setenv Ptr AppLaunchContext
    context' CString
    variable' CString
    value'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    variable'
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    value'
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data AppLaunchContextSetenvMethodInfo
    instance (signature ~ ([Char] -> [Char] -> m ()), MonadIO m, IsAppLaunchContext a) => O.MethodInfo AppLaunchContextSetenvMethodInfo a signature where
        overloadedMethod = appLaunchContextSetenv

    #endif

    -- method AppLaunchContext::unsetenv
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AppLaunchContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAppLaunchContext"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "variable"
    --           , argType = TBasicType TFileName
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the environment variable to remove"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_app_launch_context_unsetenv" g_app_launch_context_unsetenv ::
        Ptr AppLaunchContext ->                 -- context : TInterface (Name {namespace = "Gio", name = "AppLaunchContext"})
        CString ->                              -- variable : TBasicType TFileName
        IO ()

    -- | Arranges for /@variable@/ to be unset in the child\'s environment
    -- when /@context@/ is used to launch an application.
    --
    -- /Since: 2.32/
    appLaunchContextUnsetenv ::
        (B.CallStack.HasCallStack, MonadIO m, IsAppLaunchContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gio.Objects.AppLaunchContext.AppLaunchContext'
        -> [Char]
        -- ^ /@variable@/: the environment variable to remove
        -> m ()
    appLaunchContextUnsetenv :: a -> [Char] -> m ()
    appLaunchContextUnsetenv context :: a
    context variable :: [Char]
    variable = 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 AppLaunchContext
    context' <- a -> IO (Ptr AppLaunchContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CString
    variable' <- [Char] -> IO CString
    stringToCString [Char]
    variable
        Ptr AppLaunchContext -> CString -> IO ()
    g_app_launch_context_unsetenv Ptr AppLaunchContext
    context' CString
    variable'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    variable'
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data AppLaunchContextUnsetenvMethodInfo
    instance (signature ~ ([Char] -> m ()), MonadIO m, IsAppLaunchContext a) => O.MethodInfo AppLaunchContextUnsetenvMethodInfo a signature where
        overloadedMethod = appLaunchContextUnsetenv

    #endif