source: appstream-generator/build/girepo/gio/AppLaunchContext.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 9.2 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module gio.AppLaunchContext;
22
23private import gi.gio;
24public  import gi.giotypes;
25private import gio.AppInfo;
26private import gio.AppInfoIF;
27private import gio.FileIF;
28private import glib.ConstructionException;
29private import glib.ListG;
30private import glib.Str;
31private import glib.Variant;
32private import gobject.ObjectG;
33private import gobject.Signals;
34private import std.algorithm;
35
36
37/**
38 * Integrating the launch with the launching application. This is used to
39 * handle for instance startup notification and launching the new application
40 * on the same screen as the launching window.
41 */
42public class AppLaunchContext : ObjectG
43{
44        /** the main Gtk struct */
45        protected GAppLaunchContext* gAppLaunchContext;
46
47        /** Get the main Gtk struct */
48        public GAppLaunchContext* getAppLaunchContextStruct()
49        {
50                return gAppLaunchContext;
51        }
52
53        /** the main Gtk struct as a void* */
54        protected override void* getStruct()
55        {
56                return cast(void*)gAppLaunchContext;
57        }
58
59        protected override void setStruct(GObject* obj)
60        {
61                gAppLaunchContext = cast(GAppLaunchContext*)obj;
62                super.setStruct(obj);
63        }
64
65        /**
66         * Sets our main struct and passes it to the parent class.
67         */
68        public this (GAppLaunchContext* gAppLaunchContext, bool ownedRef = false)
69        {
70                this.gAppLaunchContext = gAppLaunchContext;
71                super(cast(GObject*)gAppLaunchContext, ownedRef);
72        }
73
74
75        /** */
76        public static GType getType()
77        {
78                return g_app_launch_context_get_type();
79        }
80
81        /**
82         * Creates a new application launch context. This is not normally used,
83         * instead you instantiate a subclass of this, such as #GdkAppLaunchContext.
84         *
85         * Returns: a #GAppLaunchContext.
86         *
87         * Throws: ConstructionException GTK+ fails to create the object.
88         */
89        public this()
90        {
91                auto p = g_app_launch_context_new();
92               
93                if(p is null)
94                {
95                        throw new ConstructionException("null returned by new");
96                }
97               
98                this(cast(GAppLaunchContext*) p, true);
99        }
100
101        /**
102         * Gets the display string for the @context. This is used to ensure new
103         * applications are started on the same display as the launching
104         * application, by setting the `DISPLAY` environment variable.
105         *
106         * Params:
107         *     info = a #GAppInfo
108         *     files = a #GList of #GFile objects
109         *
110         * Returns: a display string for the display.
111         */
112        public string getDisplay(AppInfoIF info, ListG files)
113        {
114                auto retStr = g_app_launch_context_get_display(gAppLaunchContext, (info is null) ? null : info.getAppInfoStruct(), (files is null) ? null : files.getListGStruct());
115               
116                scope(exit) Str.freeString(retStr);
117                return Str.toString(retStr);
118        }
119
120        /**
121         * Gets the complete environment variable list to be passed to
122         * the child process when @context is used to launch an application.
123         * This is a %NULL-terminated array of strings, where each string has
124         * the form `KEY=VALUE`.
125         *
126         * Returns: the
127         *     child's environment
128         *
129         * Since: 2.32
130         */
131        public string[] getEnvironment()
132        {
133                auto retStr = g_app_launch_context_get_environment(gAppLaunchContext);
134               
135                scope(exit) Str.freeStringArray(retStr);
136                return Str.toStringArray(retStr);
137        }
138
139        /**
140         * Initiates startup notification for the application and returns the
141         * `DESKTOP_STARTUP_ID` for the launched operation, if supported.
142         *
143         * Startup notification IDs are defined in the
144         * [FreeDesktop.Org Startup Notifications standard](http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt").
145         *
146         * Params:
147         *     info = a #GAppInfo
148         *     files = a #GList of of #GFile objects
149         *
150         * Returns: a startup notification ID for the application, or %NULL if
151         *     not supported.
152         */
153        public string getStartupNotifyId(AppInfoIF info, ListG files)
154        {
155                auto retStr = g_app_launch_context_get_startup_notify_id(gAppLaunchContext, (info is null) ? null : info.getAppInfoStruct(), (files is null) ? null : files.getListGStruct());
156               
157                scope(exit) Str.freeString(retStr);
158                return Str.toString(retStr);
159        }
160
161        /**
162         * Called when an application has failed to launch, so that it can cancel
163         * the application startup notification started in g_app_launch_context_get_startup_notify_id().
164         *
165         * Params:
166         *     startupNotifyId = the startup notification id that was returned by g_app_launch_context_get_startup_notify_id().
167         */
168        public void launchFailed(string startupNotifyId)
169        {
170                g_app_launch_context_launch_failed(gAppLaunchContext, Str.toStringz(startupNotifyId));
171        }
172
173        /**
174         * Arranges for @variable to be set to @value in the child's
175         * environment when @context is used to launch an application.
176         *
177         * Params:
178         *     variable = the environment variable to set
179         *     value = the value for to set the variable to.
180         *
181         * Since: 2.32
182         */
183        public void setenv(string variable, string value)
184        {
185                g_app_launch_context_setenv(gAppLaunchContext, Str.toStringz(variable), Str.toStringz(value));
186        }
187
188        /**
189         * Arranges for @variable to be unset in the child's environment
190         * when @context is used to launch an application.
191         *
192         * Params:
193         *     variable = the environment variable to remove
194         *
195         * Since: 2.32
196         */
197        public void unsetenv(string variable)
198        {
199                g_app_launch_context_unsetenv(gAppLaunchContext, Str.toStringz(variable));
200        }
201
202        protected class OnLaunchFailedDelegateWrapper
203        {
204                static OnLaunchFailedDelegateWrapper[] listeners;
205                void delegate(string, AppLaunchContext) dlg;
206                gulong handlerId;
207               
208                this(void delegate(string, AppLaunchContext) dlg)
209                {
210                        this.dlg = dlg;
211                        this.listeners ~= this;
212                }
213               
214                void remove(OnLaunchFailedDelegateWrapper source)
215                {
216                        foreach(index, wrapper; listeners)
217                        {
218                                if (wrapper.handlerId == source.handlerId)
219                                {
220                                        listeners[index] = null;
221                                        listeners = std.algorithm.remove(listeners, index);
222                                        break;
223                                }
224                        }
225                }
226        }
227
228        /**
229         * The ::launch-failed signal is emitted when a #GAppInfo launch
230         * fails. The startup notification id is provided, so that the launcher
231         * can cancel the startup notification.
232         *
233         * Params:
234         *     startupNotifyId = the startup notification id for the failed launch
235         *
236         * Since: 2.36
237         */
238        gulong addOnLaunchFailed(void delegate(string, AppLaunchContext) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
239        {
240                auto wrapper = new OnLaunchFailedDelegateWrapper(dlg);
241                wrapper.handlerId = Signals.connectData(
242                        this,
243                        "launch-failed",
244                        cast(GCallback)&callBackLaunchFailed,
245                        cast(void*)wrapper,
246                        cast(GClosureNotify)&callBackLaunchFailedDestroy,
247                        connectFlags);
248                return wrapper.handlerId;
249        }
250       
251        extern(C) static void callBackLaunchFailed(GAppLaunchContext* applaunchcontextStruct, char* startupNotifyId, OnLaunchFailedDelegateWrapper wrapper)
252        {
253                wrapper.dlg(Str.toString(startupNotifyId), wrapper.outer);
254        }
255       
256        extern(C) static void callBackLaunchFailedDestroy(OnLaunchFailedDelegateWrapper wrapper, GClosure* closure)
257        {
258                wrapper.remove(wrapper);
259        }
260
261        protected class OnLaunchedDelegateWrapper
262        {
263                static OnLaunchedDelegateWrapper[] listeners;
264                void delegate(AppInfoIF, Variant, AppLaunchContext) dlg;
265                gulong handlerId;
266               
267                this(void delegate(AppInfoIF, Variant, AppLaunchContext) dlg)
268                {
269                        this.dlg = dlg;
270                        this.listeners ~= this;
271                }
272               
273                void remove(OnLaunchedDelegateWrapper source)
274                {
275                        foreach(index, wrapper; listeners)
276                        {
277                                if (wrapper.handlerId == source.handlerId)
278                                {
279                                        listeners[index] = null;
280                                        listeners = std.algorithm.remove(listeners, index);
281                                        break;
282                                }
283                        }
284                }
285        }
286
287        /**
288         * The ::launched signal is emitted when a #GAppInfo is successfully
289         * launched. The @platform_data is an GVariant dictionary mapping
290         * strings to variants (ie a{sv}), which contains additional,
291         * platform-specific data about this launch. On UNIX, at least the
292         * "pid" and "startup-notification-id" keys will be present.
293         *
294         * Params:
295         *     info = the #GAppInfo that was just launched
296         *     platformData = additional platform-specific data for this launch
297         *
298         * Since: 2.36
299         */
300        gulong addOnLaunched(void delegate(AppInfoIF, Variant, AppLaunchContext) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
301        {
302                auto wrapper = new OnLaunchedDelegateWrapper(dlg);
303                wrapper.handlerId = Signals.connectData(
304                        this,
305                        "launched",
306                        cast(GCallback)&callBackLaunched,
307                        cast(void*)wrapper,
308                        cast(GClosureNotify)&callBackLaunchedDestroy,
309                        connectFlags);
310                return wrapper.handlerId;
311        }
312       
313        extern(C) static void callBackLaunched(GAppLaunchContext* applaunchcontextStruct, GAppInfo* info, GVariant* platformData, OnLaunchedDelegateWrapper wrapper)
314        {
315                wrapper.dlg(ObjectG.getDObject!(AppInfo, AppInfoIF)(info), new Variant(platformData), wrapper.outer);
316        }
317       
318        extern(C) static void callBackLaunchedDestroy(OnLaunchedDelegateWrapper wrapper, GClosure* closure)
319        {
320                wrapper.remove(wrapper);
321        }
322}
Note: See TracBrowser for help on using the repository browser.