{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 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. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.AppLaunchContext ( -- * Exported types AppLaunchContext(..) , IsAppLaunchContext , toAppLaunchContext , noAppLaunchContext , -- * Methods -- ** getDisplay #method:getDisplay# #if ENABLE_OVERLOADING AppLaunchContextGetDisplayMethodInfo , #endif appLaunchContextGetDisplay , -- ** getEnvironment #method:getEnvironment# #if ENABLE_OVERLOADING AppLaunchContextGetEnvironmentMethodInfo, #endif appLaunchContextGetEnvironment , -- ** getStartupNotifyId #method:getStartupNotifyId# #if ENABLE_OVERLOADING AppLaunchContextGetStartupNotifyIdMethodInfo, #endif appLaunchContextGetStartupNotifyId , -- ** launchFailed #method:launchFailed# #if ENABLE_OVERLOADING AppLaunchContextLaunchFailedMethodInfo , #endif appLaunchContextLaunchFailed , -- ** new #method:new# appLaunchContextNew , -- ** setenv #method:setenv# #if ENABLE_OVERLOADING AppLaunchContextSetenvMethodInfo , #endif appLaunchContextSetenv , -- ** unsetenv #method:unsetenv# #if ENABLE_OVERLOADING AppLaunchContextUnsetenvMethodInfo , #endif appLaunchContextUnsetenv , -- * Signals -- ** launchFailed #signal:launchFailed# AppLaunchContextLaunchFailedCallback , #if ENABLE_OVERLOADING AppLaunchContextLaunchFailedSignalInfo , #endif C_AppLaunchContextLaunchFailedCallback , afterAppLaunchContextLaunchFailed , genClosure_AppLaunchContextLaunchFailed , mk_AppLaunchContextLaunchFailedCallback , noAppLaunchContextLaunchFailedCallback , onAppLaunchContextLaunchFailed , wrap_AppLaunchContextLaunchFailedCallback, -- ** launched #signal:launched# AppLaunchContextLaunchedCallback , #if 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.ManagedPtr as B.ManagedPtr 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.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 (ManagedPtr AppLaunchContext) foreign import ccall "g_app_launch_context_get_type" c_g_app_launch_context_get_type :: IO GType instance GObject AppLaunchContext where gobjectType = c_g_app_launch_context_get_type -- | Type class for types which can be safely cast to `AppLaunchContext`, for instance with `toAppLaunchContext`. class (GObject o, O.IsDescendantOf AppLaunchContext o) => IsAppLaunchContext o instance (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 = liftIO . unsafeCastTo AppLaunchContext -- | A convenience alias for `Nothing` :: `Maybe` `AppLaunchContext`. noAppLaunchContext :: Maybe AppLaunchContext noAppLaunchContext = Nothing #if 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 "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 (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal AppLaunchContext::launch-failed {- | The ::launch-failed signal is emitted when a '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 = 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 cb = liftIO $ do let cb' = wrap_AppLaunchContextLaunchFailedCallback cb mk_AppLaunchContextLaunchFailedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `AppLaunchContextLaunchFailedCallback` into a `C_AppLaunchContextLaunchFailedCallback`. wrap_AppLaunchContextLaunchFailedCallback :: AppLaunchContextLaunchFailedCallback -> C_AppLaunchContextLaunchFailedCallback wrap_AppLaunchContextLaunchFailedCallback _cb _ startupNotifyId _ = do startupNotifyId' <- cstringToText startupNotifyId _cb startupNotifyId' {- | Connect a signal handler for the “@launch-failed@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' appLaunchContext #launchFailed callback @ -} onAppLaunchContextLaunchFailed :: (IsAppLaunchContext a, MonadIO m) => a -> AppLaunchContextLaunchFailedCallback -> m SignalHandlerId onAppLaunchContextLaunchFailed obj cb = liftIO $ do let cb' = wrap_AppLaunchContextLaunchFailedCallback cb cb'' <- mk_AppLaunchContextLaunchFailedCallback cb' connectSignalFunPtr obj "launch-failed" cb'' SignalConnectBefore {- | Connect a signal handler for the “@launch-failed@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' appLaunchContext #launchFailed callback @ -} afterAppLaunchContextLaunchFailed :: (IsAppLaunchContext a, MonadIO m) => a -> AppLaunchContextLaunchFailedCallback -> m SignalHandlerId afterAppLaunchContextLaunchFailed obj cb = liftIO $ do let cb' = wrap_AppLaunchContextLaunchFailedCallback cb cb'' <- mk_AppLaunchContextLaunchFailedCallback cb' connectSignalFunPtr obj "launch-failed" cb'' SignalConnectAfter -- signal AppLaunchContext::launched {- | The ::launched signal is emitted when a '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 '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 = 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 cb = liftIO $ do let cb' = wrap_AppLaunchContextLaunchedCallback cb mk_AppLaunchContextLaunchedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `AppLaunchContextLaunchedCallback` into a `C_AppLaunchContextLaunchedCallback`. wrap_AppLaunchContextLaunchedCallback :: AppLaunchContextLaunchedCallback -> C_AppLaunchContextLaunchedCallback wrap_AppLaunchContextLaunchedCallback _cb _ info platformData _ = do info' <- (newObject Gio.AppInfo.AppInfo) info platformData' <- B.GVariant.newGVariantFromPtr platformData _cb info' platformData' {- | Connect a signal handler for the “@launched@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' appLaunchContext #launched callback @ -} onAppLaunchContextLaunched :: (IsAppLaunchContext a, MonadIO m) => a -> AppLaunchContextLaunchedCallback -> m SignalHandlerId onAppLaunchContextLaunched obj cb = liftIO $ do let cb' = wrap_AppLaunchContextLaunchedCallback cb cb'' <- mk_AppLaunchContextLaunchedCallback cb' connectSignalFunPtr obj "launched" cb'' SignalConnectBefore {- | Connect a signal handler for the “@launched@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' appLaunchContext #launched callback @ -} afterAppLaunchContextLaunched :: (IsAppLaunchContext a, MonadIO m) => a -> AppLaunchContextLaunchedCallback -> m SignalHandlerId afterAppLaunchContextLaunched obj cb = liftIO $ do let cb' = wrap_AppLaunchContextLaunchedCallback cb cb'' <- mk_AppLaunchContextLaunchedCallback cb' connectSignalFunPtr obj "launched" cb'' SignalConnectAfter #if ENABLE_OVERLOADING instance O.HasAttributeList AppLaunchContext type instance O.AttributeList AppLaunchContext = AppLaunchContextAttributeList type AppLaunchContextAttributeList = ('[ ] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING data AppLaunchContextLaunchFailedSignalInfo instance SignalInfo AppLaunchContextLaunchFailedSignalInfo where type HaskellCallbackType AppLaunchContextLaunchFailedSignalInfo = AppLaunchContextLaunchFailedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_AppLaunchContextLaunchFailedCallback cb cb'' <- mk_AppLaunchContextLaunchFailedCallback cb' connectSignalFunPtr obj "launch-failed" cb'' connectMode data AppLaunchContextLaunchedSignalInfo instance SignalInfo AppLaunchContextLaunchedSignalInfo where type HaskellCallbackType AppLaunchContextLaunchedSignalInfo = AppLaunchContextLaunchedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_AppLaunchContextLaunchedCallback cb cb'' <- mk_AppLaunchContextLaunchedCallback cb' connectSignalFunPtr obj "launched" cb'' connectMode 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 'GI.Gio.Objects.AppLaunchContext.AppLaunchContext'. -} appLaunchContextNew = liftIO $ do result <- g_app_launch_context_new checkUnexpectedReturnNULL "appLaunchContextNew" result result' <- (wrapObject AppLaunchContext) result return result' #if 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 'GI.Gio.Objects.AppLaunchContext.AppLaunchContext' -} -> b {- ^ /@info@/: a 'GI.Gio.Interfaces.AppInfo.AppInfo' -} -> [c] {- ^ /@files@/: a 'GI.GLib.Structs.List.List' of 'GI.Gio.Interfaces.File.File' objects -} -> m T.Text {- ^ __Returns:__ a display string for the display. -} appLaunchContextGetDisplay context info files = liftIO $ do context' <- unsafeManagedPtrCastPtr context info' <- unsafeManagedPtrCastPtr info files' <- mapM unsafeManagedPtrCastPtr files files'' <- packGList files' result <- g_app_launch_context_get_display context' info' files'' checkUnexpectedReturnNULL "appLaunchContextGetDisplay" result result' <- cstringToText result freeMem result touchManagedPtr context touchManagedPtr info mapM_ touchManagedPtr files g_list_free files'' return result' #if 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 '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 'GI.Gio.Objects.AppLaunchContext.AppLaunchContext' -} -> m [[Char]] {- ^ __Returns:__ the child\'s environment -} appLaunchContextGetEnvironment context = liftIO $ do context' <- unsafeManagedPtrCastPtr context result <- g_app_launch_context_get_environment context' checkUnexpectedReturnNULL "appLaunchContextGetEnvironment" result result' <- unpackZeroTerminatedFileNameArray result mapZeroTerminatedCArray freeMem result freeMem result touchManagedPtr context return result' #if 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 . -} appLaunchContextGetStartupNotifyId :: (B.CallStack.HasCallStack, MonadIO m, IsAppLaunchContext a, Gio.AppInfo.IsAppInfo b, Gio.File.IsFile c) => a {- ^ /@context@/: a 'GI.Gio.Objects.AppLaunchContext.AppLaunchContext' -} -> b {- ^ /@info@/: a 'GI.Gio.Interfaces.AppInfo.AppInfo' -} -> [c] {- ^ /@files@/: a 'GI.GLib.Structs.List.List' of of 'GI.Gio.Interfaces.File.File' objects -} -> m T.Text {- ^ __Returns:__ a startup notification ID for the application, or 'Nothing' if not supported. -} appLaunchContextGetStartupNotifyId context info files = liftIO $ do context' <- unsafeManagedPtrCastPtr context info' <- unsafeManagedPtrCastPtr info files' <- mapM unsafeManagedPtrCastPtr files files'' <- packGList files' result <- g_app_launch_context_get_startup_notify_id context' info' files'' checkUnexpectedReturnNULL "appLaunchContextGetStartupNotifyId" result result' <- cstringToText result freeMem result touchManagedPtr context touchManagedPtr info mapM_ touchManagedPtr files g_list_free files'' return result' #if 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 'GI.Gio.Objects.AppLaunchContext.AppLaunchContext'. -} -> T.Text {- ^ /@startupNotifyId@/: the startup notification id that was returned by 'GI.Gio.Objects.AppLaunchContext.appLaunchContextGetStartupNotifyId'. -} -> m () appLaunchContextLaunchFailed context startupNotifyId = liftIO $ do context' <- unsafeManagedPtrCastPtr context startupNotifyId' <- textToCString startupNotifyId g_app_launch_context_launch_failed context' startupNotifyId' touchManagedPtr context freeMem startupNotifyId' return () #if 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 'GI.Gio.Objects.AppLaunchContext.AppLaunchContext' -} -> [Char] {- ^ /@variable@/: the environment variable to set -} -> [Char] {- ^ /@value@/: the value for to set the variable to. -} -> m () appLaunchContextSetenv context variable value = liftIO $ do context' <- unsafeManagedPtrCastPtr context variable' <- stringToCString variable value' <- stringToCString value g_app_launch_context_setenv context' variable' value' touchManagedPtr context freeMem variable' freeMem value' return () #if 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 'GI.Gio.Objects.AppLaunchContext.AppLaunchContext' -} -> [Char] {- ^ /@variable@/: the environment variable to remove -} -> m () appLaunchContextUnsetenv context variable = liftIO $ do context' <- unsafeManagedPtrCastPtr context variable' <- stringToCString variable g_app_launch_context_unsetenv context' variable' touchManagedPtr context freeMem variable' return () #if ENABLE_OVERLOADING data AppLaunchContextUnsetenvMethodInfo instance (signature ~ ([Char] -> m ()), MonadIO m, IsAppLaunchContext a) => O.MethodInfo AppLaunchContextUnsetenvMethodInfo a signature where overloadedMethod _ = appLaunchContextUnsetenv #endif