Branch data Line data Source code
1 : : /*
2 : : * Copyright © 2010 Codethink Limited
3 : : *
4 : : * SPDX-License-Identifier: LGPL-2.1-or-later
5 : : *
6 : : * This library is free software; you can redistribute it and/or
7 : : * modify it under the terms of the GNU Lesser General Public
8 : : * License as published by the Free Software Foundation; either
9 : : * version 2.1 of the License, or (at your option) any later version.
10 : : *
11 : : * This library is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 : : * Lesser General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU Lesser General
17 : : * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 : : *
19 : : * Authors: Ryan Lortie <desrt@desrt.ca>
20 : : */
21 : :
22 : : /* Prologue {{{1 */
23 : : #include "config.h"
24 : :
25 : : #include "gapplication.h"
26 : :
27 : : #include "gapplicationcommandline.h"
28 : : #include "gsimpleactiongroup.h"
29 : : #include "gremoteactiongroup.h"
30 : : #include "gapplicationimpl.h"
31 : : #include "gactiongroup.h"
32 : : #include "gactionmap.h"
33 : : #include "gsettings.h"
34 : : #include "gnotification-private.h"
35 : : #include "gnotificationbackend.h"
36 : : #include "gdbusutils.h"
37 : :
38 : : #include "gioenumtypes.h"
39 : : #include "gioenums.h"
40 : : #include "gfile.h"
41 : : #include "glib-private.h"
42 : :
43 : : #include "glibintl.h"
44 : : #include "gmarshal-internal.h"
45 : :
46 : : #include <string.h>
47 : :
48 : : /**
49 : : * GApplication:
50 : : *
51 : : * `GApplication` is the core class for application support.
52 : : *
53 : : * A `GApplication` is the foundation of an application. It wraps some
54 : : * low-level platform-specific services and is intended to act as the
55 : : * foundation for higher-level application classes such as
56 : : * `GtkApplication` or `MxApplication`. In general, you should not use
57 : : * this class outside of a higher level framework.
58 : : *
59 : : * `GApplication` provides convenient life-cycle management by maintaining
60 : : * a "use count" for the primary application instance. The use count can
61 : : * be changed using [method@Gio.Application.hold] and
62 : : * [method@Gio.Application.release]. If it drops to zero, the application
63 : : * exits. Higher-level classes such as `GtkApplication` employ the use count
64 : : * to ensure that the application stays alive as long as it has any opened
65 : : * windows.
66 : : *
67 : : * Another feature that `GApplication` (optionally) provides is process
68 : : * uniqueness. Applications can make use of this functionality by
69 : : * providing a unique application ID. If given, only one application
70 : : * with this ID can be running at a time per session. The session
71 : : * concept is platform-dependent, but corresponds roughly to a graphical
72 : : * desktop login. When your application is launched again, its
73 : : * arguments are passed through platform communication to the already
74 : : * running program. The already running instance of the program is
75 : : * called the "primary instance"; for non-unique applications this is
76 : : * always the current instance. On Linux, the D-Bus session bus
77 : : * is used for communication.
78 : : *
79 : : * The use of `GApplication` differs from some other commonly-used
80 : : * uniqueness libraries (such as libunique) in important ways. The
81 : : * application is not expected to manually register itself and check
82 : : * if it is the primary instance. Instead, the main() function of a
83 : : * `GApplication` should do very little more than instantiating the
84 : : * application instance, possibly connecting signal handlers, then
85 : : * calling [method@Gio.Application.run]. All checks for uniqueness are done
86 : : * internally. If the application is the primary instance then the
87 : : * startup signal is emitted and the mainloop runs. If the application
88 : : * is not the primary instance then a signal is sent to the primary
89 : : * instance and [method@Gio.Application.run] promptly returns. See the code
90 : : * examples below.
91 : : *
92 : : * If used, the expected form of an application identifier is the
93 : : * same as that of a
94 : : * [D-Bus well-known bus name](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus).
95 : : * Examples include: `com.example.MyApp`, `org.example.internal_apps.Calculator`,
96 : : * `org._7_zip.Archiver`.
97 : : * For details on valid application identifiers, see [func@Gio.Application.id_is_valid].
98 : : *
99 : : * On Linux, the application identifier is claimed as a well-known bus name
100 : : * on the user's session bus. This means that the uniqueness of your
101 : : * application is scoped to the current session. It also means that your
102 : : * application may provide additional services (through registration of other
103 : : * object paths) at that bus name. The registration of these object paths
104 : : * should be done with the shared GDBus session bus. Note that due to the
105 : : * internal architecture of GDBus, method calls can be dispatched at any time
106 : : * (even if a main loop is not running). For this reason, you must ensure that
107 : : * any object paths that you wish to register are registered before #GApplication
108 : : * attempts to acquire the bus name of your application (which happens in
109 : : * [method@Gio.Application.register]). Unfortunately, this means that you cannot
110 : : * use [property@Gio.Application:is-remote] to decide if you want to register
111 : : * object paths.
112 : : *
113 : : * `GApplication` also implements the [iface@Gio.ActionGroup] and [iface@Gio.ActionMap]
114 : : * interfaces and lets you easily export actions by adding them with
115 : : * [method@Gio.ActionMap.add_action]. When invoking an action by calling
116 : : * [method@Gio.ActionGroup.activate_action] on the application, it is always
117 : : * invoked in the primary instance. The actions are also exported on
118 : : * the session bus, and GIO provides the [class@Gio.DBusActionGroup] wrapper to
119 : : * conveniently access them remotely. GIO provides a [class@Gio.DBusMenuModel] wrapper
120 : : * for remote access to exported [class@Gio.MenuModel]s.
121 : : *
122 : : * Note: Due to the fact that actions are exported on the session bus,
123 : : * using `maybe` parameters is not supported, since D-Bus does not support
124 : : * `maybe` types.
125 : : *
126 : : * There is a number of different entry points into a `GApplication`:
127 : : *
128 : : * - via 'Activate' (i.e. just starting the application)
129 : : *
130 : : * - via 'Open' (i.e. opening some files)
131 : : *
132 : : * - by handling a command-line
133 : : *
134 : : * - via activating an action
135 : : *
136 : : * The [signal@Gio.Application::startup] signal lets you handle the application
137 : : * initialization for all of these in a single place.
138 : : *
139 : : * Regardless of which of these entry points is used to start the
140 : : * application, `GApplication` passes some ‘platform data’ from the
141 : : * launching instance to the primary instance, in the form of a
142 : : * [struct@GLib.Variant] dictionary mapping strings to variants. To use platform
143 : : * data, override the [vfunc@Gio.Application.before_emit] or
144 : : * [vfunc@Gio.Application.after_emit] virtual functions
145 : : * in your `GApplication` subclass. When dealing with
146 : : * [class@Gio.ApplicationCommandLine] objects, the platform data is
147 : : * directly available via [method@Gio.ApplicationCommandLine.get_cwd],
148 : : * [method@Gio.ApplicationCommandLine.get_environ] and
149 : : * [method@Gio.ApplicationCommandLine.get_platform_data].
150 : : *
151 : : * As the name indicates, the platform data may vary depending on the
152 : : * operating system, but it always includes the current directory (key
153 : : * `cwd`), and optionally the environment (ie the set of environment
154 : : * variables and their values) of the calling process (key `environ`).
155 : : * The environment is only added to the platform data if the
156 : : * `G_APPLICATION_SEND_ENVIRONMENT` flag is set. `GApplication` subclasses
157 : : * can add their own platform data by overriding the
158 : : * [vfunc@Gio.Application.add_platform_data] virtual function. For instance,
159 : : * `GtkApplication` adds startup notification data in this way.
160 : : *
161 : : * To parse commandline arguments you may handle the
162 : : * [signal@Gio.Application::command-line] signal or override the
163 : : * [vfunc@Gio.Application.local_command_line] virtual function, to parse them in
164 : : * either the primary instance or the local instance, respectively.
165 : : *
166 : : * For an example of opening files with a `GApplication`, see
167 : : * [gapplication-example-open.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-open.c).
168 : : *
169 : : * For an example of using actions with `GApplication`, see
170 : : * [gapplication-example-actions.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-actions.c).
171 : : *
172 : : * For an example of using extra D-Bus hooks with `GApplication`, see
173 : : * [gapplication-example-dbushooks.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-dbushooks.c).
174 : : *
175 : : * Since: 2.28
176 : : */
177 : :
178 : : /**
179 : : * GApplicationClass:
180 : : * @startup: invoked on the primary instance immediately after registration
181 : : * @shutdown: invoked only on the registered primary instance immediately
182 : : * after the main loop terminates
183 : : * @activate: invoked on the primary instance when an activation occurs
184 : : * @open: invoked on the primary instance when there are files to open
185 : : * @command_line: invoked on the primary instance when a command-line is
186 : : * not handled locally
187 : : * @local_command_line: invoked (locally). The virtual function has the chance
188 : : * to inspect (and possibly replace) command line arguments. See
189 : : * g_application_run() for more information. Also see the
190 : : * #GApplication::handle-local-options signal, which is a simpler
191 : : * alternative to handling some commandline options locally
192 : : * @before_emit: invoked on the primary instance before 'activate', 'open',
193 : : * 'command-line' or any action invocation, gets the 'platform data' from
194 : : * the calling instance. Must chain up
195 : : * @after_emit: invoked on the primary instance after 'activate', 'open',
196 : : * 'command-line' or any action invocation, gets the 'platform data' from
197 : : * the calling instance. Must chain up
198 : : * @add_platform_data: invoked (locally) to add 'platform data' to be sent to
199 : : * the primary instance when activating, opening or invoking actions. Must chain up
200 : : * @quit_mainloop: Used to be invoked on the primary instance when the use
201 : : * count of the application drops to zero (and after any inactivity
202 : : * timeout, if requested). Not used anymore since 2.32
203 : : * @run_mainloop: Used to be invoked on the primary instance from
204 : : * g_application_run() if the use-count is non-zero. Since 2.32,
205 : : * GApplication is iterating the main context directly and is not
206 : : * using @run_mainloop anymore
207 : : * @dbus_register: invoked locally during registration, if the application is
208 : : * using its D-Bus backend. You can use this to export extra objects on the
209 : : * bus, that need to exist before the application tries to own the bus name.
210 : : * The function is passed the #GDBusConnection to to session bus, and the
211 : : * object path that #GApplication will use to export its D-Bus API.
212 : : * If this function returns %TRUE, registration will proceed; otherwise
213 : : * registration will abort. Since: 2.34
214 : : * @dbus_unregister: invoked locally during unregistration, if the application
215 : : * is using its D-Bus backend. Use this to undo anything done by
216 : : * the @dbus_register vfunc. Since: 2.34
217 : : * @handle_local_options: invoked locally after the parsing of the commandline
218 : : * options has occurred. Since: 2.40
219 : : * @name_lost: invoked when another instance is taking over the name. Since: 2.60
220 : : *
221 : : * Virtual function table for #GApplication.
222 : : *
223 : : * Since: 2.28
224 : : */
225 : :
226 : : struct _GApplicationPrivate
227 : : {
228 : : GApplicationFlags flags;
229 : : gchar *id;
230 : : gchar *version;
231 : : gchar *resource_path;
232 : :
233 : : GActionGroup *actions;
234 : :
235 : : guint inactivity_timeout_id;
236 : : guint inactivity_timeout;
237 : : guint use_count;
238 : : guint busy_count;
239 : :
240 : : guint is_registered : 1;
241 : : guint is_remote : 1;
242 : : guint did_startup : 1;
243 : : guint did_shutdown : 1;
244 : : guint must_quit_now : 1;
245 : :
246 : : GRemoteActionGroup *remote_actions;
247 : : GApplicationImpl *impl;
248 : :
249 : : GNotificationBackend *notifications;
250 : :
251 : : /* GOptionContext support */
252 : : GOptionGroup *main_options;
253 : : GSList *option_groups;
254 : : GHashTable *packed_options;
255 : : gboolean options_parsed;
256 : : gchar *parameter_string;
257 : : gchar *summary;
258 : : gchar *description;
259 : :
260 : : /* Allocated option strings, from g_application_add_main_option() */
261 : : GSList *option_strings;
262 : : };
263 : :
264 : : enum
265 : : {
266 : : PROP_NONE,
267 : : PROP_APPLICATION_ID,
268 : : PROP_VERSION,
269 : : PROP_FLAGS,
270 : : PROP_RESOURCE_BASE_PATH,
271 : : PROP_IS_REGISTERED,
272 : : PROP_IS_REMOTE,
273 : : PROP_INACTIVITY_TIMEOUT,
274 : : PROP_ACTION_GROUP,
275 : : PROP_IS_BUSY
276 : : };
277 : :
278 : : enum
279 : : {
280 : : SIGNAL_STARTUP,
281 : : SIGNAL_SHUTDOWN,
282 : : SIGNAL_ACTIVATE,
283 : : SIGNAL_OPEN,
284 : : SIGNAL_ACTION,
285 : : SIGNAL_COMMAND_LINE,
286 : : SIGNAL_HANDLE_LOCAL_OPTIONS,
287 : : SIGNAL_NAME_LOST,
288 : : NR_SIGNALS
289 : : };
290 : :
291 : : static guint g_application_signals[NR_SIGNALS];
292 : :
293 : : static void g_application_action_group_iface_init (GActionGroupInterface *);
294 : : static void g_application_action_map_iface_init (GActionMapInterface *);
295 : 1332 : G_DEFINE_TYPE_WITH_CODE (GApplication, g_application, G_TYPE_OBJECT,
296 : : G_ADD_PRIVATE (GApplication)
297 : : G_IMPLEMENT_INTERFACE (G_TYPE_ACTION_GROUP, g_application_action_group_iface_init)
298 : : G_IMPLEMENT_INTERFACE (G_TYPE_ACTION_MAP, g_application_action_map_iface_init))
299 : :
300 : : /* GApplicationExportedActions {{{1 */
301 : :
302 : : /* We create a subclass of GSimpleActionGroup that implements
303 : : * GRemoteActionGroup and deals with the platform data using
304 : : * GApplication's before/after_emit vfuncs. This is the action group we
305 : : * will be exporting.
306 : : *
307 : : * We could implement GRemoteActionGroup on GApplication directly, but
308 : : * this would be potentially extremely confusing to have exposed as part
309 : : * of the public API of GApplication. We certainly don't want anyone in
310 : : * the same process to be calling these APIs...
311 : : */
312 : : typedef GSimpleActionGroupClass GApplicationExportedActionsClass;
313 : : typedef struct
314 : : {
315 : : GSimpleActionGroup parent_instance;
316 : : GApplication *application;
317 : : } GApplicationExportedActions;
318 : :
319 : : static GType g_application_exported_actions_get_type (void);
320 : : static void g_application_exported_actions_iface_init (GRemoteActionGroupInterface *iface);
321 : 80 : G_DEFINE_TYPE_WITH_CODE (GApplicationExportedActions, g_application_exported_actions, G_TYPE_SIMPLE_ACTION_GROUP,
322 : : G_IMPLEMENT_INTERFACE (G_TYPE_REMOTE_ACTION_GROUP, g_application_exported_actions_iface_init))
323 : :
324 : : static void
325 : 0 : g_application_exported_actions_activate_action_full (GRemoteActionGroup *remote,
326 : : const gchar *action_name,
327 : : GVariant *parameter,
328 : : GVariant *platform_data)
329 : : {
330 : 0 : GApplicationExportedActions *exported = (GApplicationExportedActions *) remote;
331 : :
332 : 0 : G_APPLICATION_GET_CLASS (exported->application)
333 : 0 : ->before_emit (exported->application, platform_data);
334 : :
335 : 0 : g_action_group_activate_action (G_ACTION_GROUP (exported), action_name, parameter);
336 : :
337 : 0 : G_APPLICATION_GET_CLASS (exported->application)
338 : 0 : ->after_emit (exported->application, platform_data);
339 : 0 : }
340 : :
341 : : static void
342 : 0 : g_application_exported_actions_change_action_state_full (GRemoteActionGroup *remote,
343 : : const gchar *action_name,
344 : : GVariant *value,
345 : : GVariant *platform_data)
346 : : {
347 : 0 : GApplicationExportedActions *exported = (GApplicationExportedActions *) remote;
348 : :
349 : 0 : G_APPLICATION_GET_CLASS (exported->application)
350 : 0 : ->before_emit (exported->application, platform_data);
351 : :
352 : 0 : g_action_group_change_action_state (G_ACTION_GROUP (exported), action_name, value);
353 : :
354 : 0 : G_APPLICATION_GET_CLASS (exported->application)
355 : 0 : ->after_emit (exported->application, platform_data);
356 : 0 : }
357 : :
358 : : static void
359 : 56 : g_application_exported_actions_init (GApplicationExportedActions *actions)
360 : : {
361 : 56 : }
362 : :
363 : : static void
364 : 12 : g_application_exported_actions_iface_init (GRemoteActionGroupInterface *iface)
365 : : {
366 : 12 : iface->activate_action_full = g_application_exported_actions_activate_action_full;
367 : 12 : iface->change_action_state_full = g_application_exported_actions_change_action_state_full;
368 : 12 : }
369 : :
370 : : static void
371 : 12 : g_application_exported_actions_class_init (GApplicationExportedActionsClass *class)
372 : : {
373 : 12 : }
374 : :
375 : : static GActionGroup *
376 : 56 : g_application_exported_actions_new (GApplication *application)
377 : : {
378 : : GApplicationExportedActions *actions;
379 : :
380 : 56 : actions = g_object_new (g_application_exported_actions_get_type (), NULL);
381 : 56 : actions->application = application;
382 : :
383 : 56 : return G_ACTION_GROUP (actions);
384 : : }
385 : :
386 : : /* Command line option handling {{{1 */
387 : :
388 : : static void
389 : 6 : free_option_entry (gpointer data)
390 : : {
391 : 6 : GOptionEntry *entry = data;
392 : :
393 : 6 : switch (entry->arg)
394 : : {
395 : 0 : case G_OPTION_ARG_STRING:
396 : : case G_OPTION_ARG_FILENAME:
397 : 0 : g_free (*(gchar **) entry->arg_data);
398 : 0 : break;
399 : :
400 : 0 : case G_OPTION_ARG_STRING_ARRAY:
401 : : case G_OPTION_ARG_FILENAME_ARRAY:
402 : 0 : g_strfreev (*(gchar ***) entry->arg_data);
403 : 0 : break;
404 : :
405 : 6 : default:
406 : : /* most things require no free... */
407 : 6 : break;
408 : : }
409 : :
410 : : /* ...except for the space that we allocated for it ourselves */
411 : 6 : g_free (entry->arg_data);
412 : :
413 : 6 : g_slice_free (GOptionEntry, entry);
414 : 6 : }
415 : :
416 : : static void
417 : 3 : g_application_pack_option_entries (GApplication *application,
418 : : GVariantDict *dict)
419 : : {
420 : : GHashTableIter iter;
421 : : gpointer item;
422 : :
423 : 3 : g_hash_table_iter_init (&iter, application->priv->packed_options);
424 : 12 : while (g_hash_table_iter_next (&iter, NULL, &item))
425 : : {
426 : 6 : GOptionEntry *entry = item;
427 : 6 : GVariant *value = NULL;
428 : :
429 : 6 : switch (entry->arg)
430 : : {
431 : 6 : case G_OPTION_ARG_NONE:
432 : 6 : if (*(gboolean *) entry->arg_data != 2)
433 : 2 : value = g_variant_new_boolean (*(gboolean *) entry->arg_data);
434 : 6 : break;
435 : :
436 : 0 : case G_OPTION_ARG_STRING:
437 : 0 : if (*(gchar **) entry->arg_data)
438 : 0 : value = g_variant_new_string (*(gchar **) entry->arg_data);
439 : 0 : break;
440 : :
441 : 0 : case G_OPTION_ARG_INT:
442 : 0 : if (*(gint32 *) entry->arg_data)
443 : 0 : value = g_variant_new_int32 (*(gint32 *) entry->arg_data);
444 : 0 : break;
445 : :
446 : 0 : case G_OPTION_ARG_FILENAME:
447 : 0 : if (*(gchar **) entry->arg_data)
448 : 0 : value = g_variant_new_bytestring (*(gchar **) entry->arg_data);
449 : 0 : break;
450 : :
451 : 0 : case G_OPTION_ARG_STRING_ARRAY:
452 : 0 : if (*(gchar ***) entry->arg_data)
453 : 0 : value = g_variant_new_strv (*(const gchar ***) entry->arg_data, -1);
454 : 0 : break;
455 : :
456 : 0 : case G_OPTION_ARG_FILENAME_ARRAY:
457 : 0 : if (*(gchar ***) entry->arg_data)
458 : 0 : value = g_variant_new_bytestring_array (*(const gchar ***) entry->arg_data, -1);
459 : 0 : break;
460 : :
461 : 0 : case G_OPTION_ARG_DOUBLE:
462 : 0 : if (*(gdouble *) entry->arg_data != 0.0)
463 : 0 : value = g_variant_new_double (*(gdouble *) entry->arg_data);
464 : 0 : break;
465 : :
466 : 0 : case G_OPTION_ARG_INT64:
467 : 0 : if (*(gint64 *) entry->arg_data)
468 : 0 : value = g_variant_new_int64 (*(gint64 *) entry->arg_data);
469 : 0 : break;
470 : :
471 : 0 : default:
472 : : g_assert_not_reached ();
473 : : }
474 : :
475 : 6 : if (value)
476 : 2 : g_variant_dict_insert_value (dict, entry->long_name, value);
477 : : }
478 : 3 : }
479 : :
480 : : static GVariantDict *
481 : 43 : g_application_parse_command_line (GApplication *application,
482 : : gchar ***arguments,
483 : : gboolean *print_version,
484 : : GError **error)
485 : : {
486 : 43 : gboolean become_service = FALSE;
487 : 43 : gchar *app_id = NULL;
488 : 43 : gboolean replace = FALSE;
489 : 43 : gboolean version = FALSE;
490 : 43 : GVariantDict *dict = NULL;
491 : : GOptionContext *context;
492 : : GOptionGroup *gapplication_group;
493 : :
494 : : /* Due to the memory management of GOptionGroup we can only parse
495 : : * options once. That's because once you add a group to the
496 : : * GOptionContext there is no way to get it back again. This is fine:
497 : : * local_command_line() should never get invoked more than once
498 : : * anyway. Add a sanity check just to be sure.
499 : : */
500 : 43 : g_return_val_if_fail (!application->priv->options_parsed, NULL);
501 : :
502 : 43 : context = g_option_context_new (application->priv->parameter_string);
503 : 43 : g_option_context_set_summary (context, application->priv->summary);
504 : 43 : g_option_context_set_description (context, application->priv->description);
505 : :
506 : 43 : gapplication_group = g_option_group_new ("gapplication",
507 : : _("GApplication Options:"), _("Show GApplication options"),
508 : : NULL, NULL);
509 : 43 : g_option_group_set_translation_domain (gapplication_group, GETTEXT_PACKAGE);
510 : 43 : g_option_context_add_group (context, gapplication_group);
511 : :
512 : : /* If the application has not registered local options and it has
513 : : * G_APPLICATION_HANDLES_COMMAND_LINE then we have to assume that
514 : : * their primary instance commandline handler may want to deal with
515 : : * the arguments. We must therefore ignore them.
516 : : *
517 : : * We must also ignore --help in this case since some applications
518 : : * will try to handle this from the remote side. See #737869.
519 : : */
520 : 43 : if (application->priv->main_options == NULL && (application->priv->flags & G_APPLICATION_HANDLES_COMMAND_LINE))
521 : : {
522 : 5 : g_option_context_set_ignore_unknown_options (context, TRUE);
523 : 5 : g_option_context_set_help_enabled (context, FALSE);
524 : : }
525 : :
526 : : /* Add the main option group, if it exists */
527 : 43 : if (application->priv->main_options)
528 : : {
529 : : /* This consumes the main_options */
530 : 4 : g_option_context_set_main_group (context, application->priv->main_options);
531 : 4 : application->priv->main_options = NULL;
532 : : }
533 : :
534 : : /* Add any other option groups if they exist. Adding them to the
535 : : * context will consume them, so we free the list as we go...
536 : : */
537 : 43 : while (application->priv->option_groups)
538 : : {
539 : 0 : g_option_context_add_group (context, application->priv->option_groups->data);
540 : 0 : application->priv->option_groups = g_slist_delete_link (application->priv->option_groups,
541 : 0 : application->priv->option_groups);
542 : : }
543 : :
544 : : /* In the case that we are not explicitly marked as a service or a
545 : : * launcher then we want to add the "--gapplication-service" option to
546 : : * allow the process to be made into a service.
547 : : */
548 : 43 : if ((application->priv->flags & (G_APPLICATION_IS_SERVICE | G_APPLICATION_IS_LAUNCHER)) == 0)
549 : : {
550 : 43 : GOptionEntry entries[] = {
551 : : { "gapplication-service", '\0', 0, G_OPTION_ARG_NONE, &become_service,
552 : : N_("Enter GApplication service mode (use from D-Bus service files)"), NULL },
553 : : G_OPTION_ENTRY_NULL
554 : : };
555 : :
556 : 43 : g_option_group_add_entries (gapplication_group, entries);
557 : : }
558 : :
559 : : /* Allow overriding the ID if the application allows it */
560 : 43 : if (application->priv->flags & G_APPLICATION_CAN_OVERRIDE_APP_ID)
561 : : {
562 : 0 : GOptionEntry entries[] = {
563 : : { "gapplication-app-id", '\0', 0, G_OPTION_ARG_STRING, &app_id,
564 : : N_("Override the application’s ID"), NULL },
565 : : G_OPTION_ENTRY_NULL
566 : : };
567 : :
568 : 0 : g_option_group_add_entries (gapplication_group, entries);
569 : : }
570 : :
571 : 43 : if (application->priv->version)
572 : : {
573 : 0 : GOptionEntry entries[] = {
574 : : { "version", '\0', 0, G_OPTION_ARG_NONE, &version,
575 : : N_("Print the application version"), NULL },
576 : : G_OPTION_ENTRY_NULL
577 : : };
578 : :
579 : 0 : g_option_group_add_entries (gapplication_group, entries);
580 : : }
581 : :
582 : : /* Allow replacing if the application allows it */
583 : 43 : if (application->priv->flags & G_APPLICATION_ALLOW_REPLACEMENT)
584 : : {
585 : 3 : GOptionEntry entries[] = {
586 : : { "gapplication-replace", '\0', 0, G_OPTION_ARG_NONE, &replace,
587 : : N_("Replace the running instance"), NULL },
588 : : G_OPTION_ENTRY_NULL
589 : : };
590 : :
591 : 3 : g_option_group_add_entries (gapplication_group, entries);
592 : : }
593 : :
594 : : /* Now we parse... */
595 : 43 : if (!g_option_context_parse_strv (context, arguments, error))
596 : 0 : goto out;
597 : :
598 : 42 : *print_version = version;
599 : :
600 : : /* Check for --gapplication-service */
601 : 42 : if (become_service)
602 : 0 : application->priv->flags |= G_APPLICATION_IS_SERVICE;
603 : :
604 : : /* Check for --gapplication-app-id */
605 : 42 : if (app_id)
606 : 0 : g_application_set_application_id (application, app_id);
607 : :
608 : : /* Check for --gapplication-replace */
609 : 42 : if (replace)
610 : 2 : application->priv->flags |= G_APPLICATION_REPLACE;
611 : :
612 : 42 : dict = g_variant_dict_new (NULL);
613 : 42 : if (application->priv->packed_options)
614 : : {
615 : 3 : g_application_pack_option_entries (application, dict);
616 : 3 : g_hash_table_unref (application->priv->packed_options);
617 : 3 : application->priv->packed_options = NULL;
618 : : }
619 : :
620 : 39 : out:
621 : : /* Make sure we don't run again */
622 : 42 : application->priv->options_parsed = TRUE;
623 : :
624 : 42 : g_option_context_free (context);
625 : 42 : g_free (app_id);
626 : :
627 : 42 : return dict;
628 : : }
629 : :
630 : : static void
631 : 7 : add_packed_option (GApplication *application,
632 : : GOptionEntry *entry)
633 : : {
634 : 7 : switch (entry->arg)
635 : : {
636 : 7 : case G_OPTION_ARG_NONE:
637 : 7 : entry->arg_data = g_new (gboolean, 1);
638 : 7 : *(gboolean *) entry->arg_data = 2;
639 : 7 : break;
640 : :
641 : 0 : case G_OPTION_ARG_INT:
642 : 0 : entry->arg_data = g_new0 (gint, 1);
643 : 0 : break;
644 : :
645 : 0 : case G_OPTION_ARG_STRING:
646 : : case G_OPTION_ARG_FILENAME:
647 : : case G_OPTION_ARG_STRING_ARRAY:
648 : : case G_OPTION_ARG_FILENAME_ARRAY:
649 : 0 : entry->arg_data = g_new0 (gpointer, 1);
650 : 0 : break;
651 : :
652 : 0 : case G_OPTION_ARG_INT64:
653 : 0 : entry->arg_data = g_new0 (gint64, 1);
654 : 0 : break;
655 : :
656 : 0 : case G_OPTION_ARG_DOUBLE:
657 : 0 : entry->arg_data = g_new0 (gdouble, 1);
658 : 0 : break;
659 : :
660 : 0 : default:
661 : : g_return_if_reached ();
662 : : }
663 : :
664 : 7 : if (!application->priv->packed_options)
665 : 4 : application->priv->packed_options = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, free_option_entry);
666 : :
667 : 7 : g_hash_table_insert (application->priv->packed_options,
668 : 14 : g_strdup (entry->long_name),
669 : : g_slice_dup (GOptionEntry, entry));
670 : : }
671 : :
672 : : /**
673 : : * g_application_add_main_option_entries:
674 : : * @application: a #GApplication
675 : : * @entries: (array zero-terminated=1) (element-type GOptionEntry): the
676 : : * main options for the application
677 : : *
678 : : * Adds main option entries to be handled by @application.
679 : : *
680 : : * This function is comparable to g_option_context_add_main_entries().
681 : : *
682 : : * After the commandline arguments are parsed, the
683 : : * #GApplication::handle-local-options signal will be emitted. At this
684 : : * point, the application can inspect the values pointed to by @arg_data
685 : : * in the given #GOptionEntrys.
686 : : *
687 : : * Unlike #GOptionContext, #GApplication supports giving a %NULL
688 : : * @arg_data for a non-callback #GOptionEntry. This results in the
689 : : * argument in question being packed into a #GVariantDict which is also
690 : : * passed to #GApplication::handle-local-options, where it can be
691 : : * inspected and modified. If %G_APPLICATION_HANDLES_COMMAND_LINE is
692 : : * set, then the resulting dictionary is sent to the primary instance,
693 : : * where g_application_command_line_get_options_dict() will return it.
694 : : * As it has been passed outside the process at this point, the types of all
695 : : * values in the options dict must be checked before being used.
696 : : * This "packing" is done according to the type of the argument --
697 : : * booleans for normal flags, strings for strings, bytestrings for
698 : : * filenames, etc. The packing only occurs if the flag is given (ie: we
699 : : * do not pack a "false" #GVariant in the case that a flag is missing).
700 : : *
701 : : * In general, it is recommended that all commandline arguments are
702 : : * parsed locally. The options dictionary should then be used to
703 : : * transmit the result of the parsing to the primary instance, where
704 : : * g_variant_dict_lookup() can be used. For local options, it is
705 : : * possible to either use @arg_data in the usual way, or to consult (and
706 : : * potentially remove) the option from the options dictionary.
707 : : *
708 : : * This function is new in GLib 2.40. Before then, the only real choice
709 : : * was to send all of the commandline arguments (options and all) to the
710 : : * primary instance for handling. #GApplication ignored them completely
711 : : * on the local side. Calling this function "opts in" to the new
712 : : * behaviour, and in particular, means that unrecognized options will be
713 : : * treated as errors. Unrecognized options have never been ignored when
714 : : * %G_APPLICATION_HANDLES_COMMAND_LINE is unset.
715 : : *
716 : : * If #GApplication::handle-local-options needs to see the list of
717 : : * filenames, then the use of %G_OPTION_REMAINING is recommended. If
718 : : * @arg_data is %NULL then %G_OPTION_REMAINING can be used as a key into
719 : : * the options dictionary. If you do use %G_OPTION_REMAINING then you
720 : : * need to handle these arguments for yourself because once they are
721 : : * consumed, they will no longer be visible to the default handling
722 : : * (which treats them as filenames to be opened).
723 : : *
724 : : * It is important to use the proper GVariant format when retrieving
725 : : * the options with g_variant_dict_lookup():
726 : : * - for %G_OPTION_ARG_NONE, use `b`
727 : : * - for %G_OPTION_ARG_STRING, use `&s`
728 : : * - for %G_OPTION_ARG_INT, use `i`
729 : : * - for %G_OPTION_ARG_INT64, use `x`
730 : : * - for %G_OPTION_ARG_DOUBLE, use `d`
731 : : * - for %G_OPTION_ARG_FILENAME, use `^&ay`
732 : : * - for %G_OPTION_ARG_STRING_ARRAY, use `^a&s`
733 : : * - for %G_OPTION_ARG_FILENAME_ARRAY, use `^a&ay`
734 : : *
735 : : * Since: 2.40
736 : : */
737 : : void
738 : 7 : g_application_add_main_option_entries (GApplication *application,
739 : : const GOptionEntry *entries)
740 : : {
741 : : gint i;
742 : :
743 : 7 : g_return_if_fail (G_IS_APPLICATION (application));
744 : 7 : g_return_if_fail (entries != NULL);
745 : :
746 : 7 : if (!application->priv->main_options)
747 : : {
748 : 4 : application->priv->main_options = g_option_group_new (NULL, NULL, NULL, NULL, NULL);
749 : 4 : g_option_group_set_translation_domain (application->priv->main_options, NULL);
750 : : }
751 : :
752 : 14 : for (i = 0; entries[i].long_name; i++)
753 : : {
754 : 7 : GOptionEntry my_entries[2] =
755 : : {
756 : : G_OPTION_ENTRY_NULL,
757 : : G_OPTION_ENTRY_NULL
758 : : };
759 : 7 : my_entries[0] = entries[i];
760 : :
761 : 7 : if (!my_entries[0].arg_data)
762 : 7 : add_packed_option (application, &my_entries[0]);
763 : :
764 : 7 : g_option_group_add_entries (application->priv->main_options, my_entries);
765 : : }
766 : : }
767 : :
768 : : /**
769 : : * g_application_add_main_option:
770 : : * @application: the #GApplication
771 : : * @long_name: the long name of an option used to specify it in a commandline
772 : : * @short_name: the short name of an option
773 : : * @flags: flags from #GOptionFlags
774 : : * @arg: the type of the option, as a #GOptionArg
775 : : * @description: the description for the option in `--help` output
776 : : * @arg_description: (nullable): the placeholder to use for the extra argument
777 : : * parsed by the option in `--help` output
778 : : *
779 : : * Add an option to be handled by @application.
780 : : *
781 : : * Calling this function is the equivalent of calling
782 : : * g_application_add_main_option_entries() with a single #GOptionEntry
783 : : * that has its arg_data member set to %NULL.
784 : : *
785 : : * The parsed arguments will be packed into a #GVariantDict which
786 : : * is passed to #GApplication::handle-local-options. If
787 : : * %G_APPLICATION_HANDLES_COMMAND_LINE is set, then it will also
788 : : * be sent to the primary instance. See
789 : : * g_application_add_main_option_entries() for more details.
790 : : *
791 : : * See #GOptionEntry for more documentation of the arguments.
792 : : *
793 : : * Since: 2.42
794 : : **/
795 : : void
796 : 7 : g_application_add_main_option (GApplication *application,
797 : : const char *long_name,
798 : : char short_name,
799 : : GOptionFlags flags,
800 : : GOptionArg arg,
801 : : const char *description,
802 : : const char *arg_description)
803 : : {
804 : : gchar *dup_string;
805 : 7 : GOptionEntry my_entry[2] = {
806 : : { NULL, short_name, flags, arg, NULL, NULL, NULL },
807 : : G_OPTION_ENTRY_NULL
808 : : };
809 : :
810 : 7 : g_return_if_fail (G_IS_APPLICATION (application));
811 : 7 : g_return_if_fail (long_name != NULL);
812 : 7 : g_return_if_fail (description != NULL);
813 : :
814 : 7 : my_entry[0].long_name = dup_string = g_strdup (long_name);
815 : 7 : application->priv->option_strings = g_slist_prepend (application->priv->option_strings, dup_string);
816 : :
817 : 7 : my_entry[0].description = dup_string = g_strdup (description);
818 : 7 : application->priv->option_strings = g_slist_prepend (application->priv->option_strings, dup_string);
819 : :
820 : 7 : my_entry[0].arg_description = dup_string = g_strdup (arg_description);
821 : 7 : application->priv->option_strings = g_slist_prepend (application->priv->option_strings, dup_string);
822 : :
823 : 7 : g_application_add_main_option_entries (application, my_entry);
824 : : }
825 : :
826 : : /**
827 : : * g_application_add_option_group:
828 : : * @application: the #GApplication
829 : : * @group: (transfer full): a #GOptionGroup
830 : : *
831 : : * Adds a #GOptionGroup to the commandline handling of @application.
832 : : *
833 : : * This function is comparable to g_option_context_add_group().
834 : : *
835 : : * Unlike g_application_add_main_option_entries(), this function does
836 : : * not deal with %NULL @arg_data and never transmits options to the
837 : : * primary instance.
838 : : *
839 : : * The reason for that is because, by the time the options arrive at the
840 : : * primary instance, it is typically too late to do anything with them.
841 : : * Taking the GTK option group as an example: GTK will already have been
842 : : * initialised by the time the #GApplication::command-line handler runs.
843 : : * In the case that this is not the first-running instance of the
844 : : * application, the existing instance may already have been running for
845 : : * a very long time.
846 : : *
847 : : * This means that the options from #GOptionGroup are only really usable
848 : : * in the case that the instance of the application being run is the
849 : : * first instance. Passing options like `--display=` or `--gdk-debug=`
850 : : * on future runs will have no effect on the existing primary instance.
851 : : *
852 : : * Calling this function will cause the options in the supplied option
853 : : * group to be parsed, but it does not cause you to be "opted in" to the
854 : : * new functionality whereby unrecognized options are rejected even if
855 : : * %G_APPLICATION_HANDLES_COMMAND_LINE was given.
856 : : *
857 : : * Since: 2.40
858 : : **/
859 : : void
860 : 0 : g_application_add_option_group (GApplication *application,
861 : : GOptionGroup *group)
862 : : {
863 : 0 : g_return_if_fail (G_IS_APPLICATION (application));
864 : 0 : g_return_if_fail (group != NULL);
865 : :
866 : 0 : application->priv->option_groups = g_slist_prepend (application->priv->option_groups, group);
867 : : }
868 : :
869 : : /**
870 : : * g_application_set_option_context_parameter_string:
871 : : * @application: the #GApplication
872 : : * @parameter_string: (nullable): a string which is displayed
873 : : * in the first line of `--help` output, after the usage summary `programname [OPTION...]`.
874 : : *
875 : : * Sets the parameter string to be used by the commandline handling of @application.
876 : : *
877 : : * This function registers the argument to be passed to g_option_context_new()
878 : : * when the internal #GOptionContext of @application is created.
879 : : *
880 : : * See g_option_context_new() for more information about @parameter_string.
881 : : *
882 : : * Since: 2.56
883 : : */
884 : : void
885 : 0 : g_application_set_option_context_parameter_string (GApplication *application,
886 : : const gchar *parameter_string)
887 : : {
888 : 0 : g_return_if_fail (G_IS_APPLICATION (application));
889 : :
890 : 0 : g_free (application->priv->parameter_string);
891 : 0 : application->priv->parameter_string = g_strdup (parameter_string);
892 : : }
893 : :
894 : : /**
895 : : * g_application_set_option_context_summary:
896 : : * @application: the #GApplication
897 : : * @summary: (nullable): a string to be shown in `--help` output
898 : : * before the list of options, or %NULL
899 : : *
900 : : * Adds a summary to the @application option context.
901 : : *
902 : : * See g_option_context_set_summary() for more information.
903 : : *
904 : : * Since: 2.56
905 : : */
906 : : void
907 : 0 : g_application_set_option_context_summary (GApplication *application,
908 : : const gchar *summary)
909 : : {
910 : 0 : g_return_if_fail (G_IS_APPLICATION (application));
911 : :
912 : 0 : g_free (application->priv->summary);
913 : 0 : application->priv->summary = g_strdup (summary);
914 : : }
915 : :
916 : : /**
917 : : * g_application_set_option_context_description:
918 : : * @application: the #GApplication
919 : : * @description: (nullable): a string to be shown in `--help` output
920 : : * after the list of options, or %NULL
921 : : *
922 : : * Adds a description to the @application option context.
923 : : *
924 : : * See g_option_context_set_description() for more information.
925 : : *
926 : : * Since: 2.56
927 : : */
928 : : void
929 : 0 : g_application_set_option_context_description (GApplication *application,
930 : : const gchar *description)
931 : : {
932 : 0 : g_return_if_fail (G_IS_APPLICATION (application));
933 : :
934 : 0 : g_free (application->priv->description);
935 : 0 : application->priv->description = g_strdup (description);
936 : :
937 : : }
938 : :
939 : :
940 : : /* vfunc defaults {{{1 */
941 : : static void
942 : 51 : g_application_real_before_emit (GApplication *application,
943 : : GVariant *platform_data)
944 : : {
945 : 51 : }
946 : :
947 : : static void
948 : 68 : g_application_real_after_emit (GApplication *application,
949 : : GVariant *platform_data)
950 : : {
951 : 68 : }
952 : :
953 : : static void
954 : 44 : g_application_real_startup (GApplication *application)
955 : : {
956 : 44 : application->priv->did_startup = TRUE;
957 : 44 : }
958 : :
959 : : static void
960 : 39 : g_application_real_shutdown (GApplication *application)
961 : : {
962 : 39 : application->priv->did_shutdown = TRUE;
963 : 39 : }
964 : :
965 : : static void
966 : 36 : g_application_real_activate (GApplication *application)
967 : : {
968 : 36 : if (!g_signal_has_handler_pending (application,
969 : : g_application_signals[SIGNAL_ACTIVATE],
970 : 0 : 0, TRUE) &&
971 : 0 : G_APPLICATION_GET_CLASS (application)->activate == g_application_real_activate)
972 : : {
973 : : static gboolean warned;
974 : :
975 : 0 : if (warned)
976 : 0 : return;
977 : :
978 : 0 : g_warning ("Your application does not implement "
979 : : "g_application_activate() and has no handlers connected "
980 : : "to the 'activate' signal. It should do one of these.");
981 : 0 : warned = TRUE;
982 : : }
983 : : }
984 : :
985 : : static void
986 : 8 : g_application_real_open (GApplication *application,
987 : : GFile **files,
988 : : gint n_files,
989 : : const gchar *hint)
990 : : {
991 : 8 : if (!g_signal_has_handler_pending (application,
992 : : g_application_signals[SIGNAL_OPEN],
993 : 0 : 0, TRUE) &&
994 : 0 : G_APPLICATION_GET_CLASS (application)->open == g_application_real_open)
995 : : {
996 : : static gboolean warned;
997 : :
998 : 0 : if (warned)
999 : 0 : return;
1000 : :
1001 : 0 : g_warning ("Your application claims to support opening files "
1002 : : "but does not implement g_application_open() and has no "
1003 : : "handlers connected to the 'open' signal.");
1004 : 0 : warned = TRUE;
1005 : : }
1006 : : }
1007 : :
1008 : : static int
1009 : 0 : g_application_real_command_line (GApplication *application,
1010 : : GApplicationCommandLine *cmdline)
1011 : : {
1012 : 0 : if (!g_signal_has_handler_pending (application,
1013 : : g_application_signals[SIGNAL_COMMAND_LINE],
1014 : 0 : 0, TRUE) &&
1015 : 0 : G_APPLICATION_GET_CLASS (application)->command_line == g_application_real_command_line)
1016 : : {
1017 : : static gboolean warned;
1018 : :
1019 : 0 : if (warned)
1020 : 0 : return 1;
1021 : :
1022 : 0 : g_warning ("Your application claims to support custom command line "
1023 : : "handling but does not implement g_application_command_line() "
1024 : : "and has no handlers connected to the 'command-line' signal.");
1025 : :
1026 : 0 : warned = TRUE;
1027 : : }
1028 : :
1029 : 0 : return 1;
1030 : : }
1031 : :
1032 : : static gint
1033 : 39 : g_application_real_handle_local_options (GApplication *application,
1034 : : GVariantDict *options)
1035 : : {
1036 : 39 : return -1;
1037 : : }
1038 : :
1039 : : static GVariant *
1040 : 40 : get_platform_data (GApplication *application,
1041 : : GVariant *options)
1042 : : {
1043 : : GVariantBuilder *builder;
1044 : : GVariant *result;
1045 : :
1046 : 40 : builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
1047 : :
1048 : : {
1049 : 40 : gchar *cwd = g_get_current_dir ();
1050 : 40 : g_variant_builder_add (builder, "{sv}", "cwd",
1051 : : g_variant_new_bytestring (cwd));
1052 : 40 : g_free (cwd);
1053 : : }
1054 : :
1055 : 40 : if (application->priv->flags & G_APPLICATION_SEND_ENVIRONMENT)
1056 : : {
1057 : : GVariant *array;
1058 : : gchar **envp;
1059 : :
1060 : 0 : envp = g_get_environ ();
1061 : 0 : array = g_variant_new_bytestring_array ((const gchar **) envp, -1);
1062 : 0 : g_strfreev (envp);
1063 : :
1064 : 0 : g_variant_builder_add (builder, "{sv}", "environ", array);
1065 : : }
1066 : :
1067 : 40 : if (options)
1068 : 5 : g_variant_builder_add (builder, "{sv}", "options", options);
1069 : :
1070 : 40 : G_APPLICATION_GET_CLASS (application)->
1071 : : add_platform_data (application, builder);
1072 : :
1073 : 40 : result = g_variant_builder_end (builder);
1074 : 40 : g_variant_builder_unref (builder);
1075 : :
1076 : 40 : return result;
1077 : : }
1078 : :
1079 : : static void
1080 : 6 : g_application_call_command_line (GApplication *application,
1081 : : const gchar * const *arguments,
1082 : : GVariant *options,
1083 : : gint *exit_status)
1084 : : {
1085 : 6 : if (application->priv->is_remote)
1086 : : {
1087 : : GVariant *platform_data;
1088 : :
1089 : 0 : platform_data = get_platform_data (application, options);
1090 : 0 : *exit_status = g_application_impl_command_line (application->priv->impl, arguments, platform_data);
1091 : : }
1092 : : else
1093 : : {
1094 : : GApplicationCommandLine *cmdline;
1095 : : GVariant *v;
1096 : : gint handler_exit_status;
1097 : : GVariant *platform_data;
1098 : :
1099 : 6 : if (options != NULL)
1100 : 5 : g_variant_ref_sink (options);
1101 : :
1102 : 6 : platform_data = g_variant_ref_sink (get_platform_data (application, options));
1103 : :
1104 : 6 : G_APPLICATION_GET_CLASS (application)->before_emit (application, platform_data);
1105 : :
1106 : 6 : v = g_variant_new_bytestring_array ((const gchar **) arguments, -1);
1107 : 6 : cmdline = g_object_new (G_TYPE_APPLICATION_COMMAND_LINE,
1108 : : "arguments", v,
1109 : : "options", options,
1110 : : NULL);
1111 : 6 : g_signal_emit (application, g_application_signals[SIGNAL_COMMAND_LINE], 0, cmdline, &handler_exit_status);
1112 : :
1113 : : /* For consistency with remote invocations */
1114 : 6 : g_application_command_line_set_exit_status (cmdline, handler_exit_status);
1115 : 6 : *exit_status = g_application_command_line_get_exit_status (cmdline);
1116 : :
1117 : 6 : g_object_unref (cmdline);
1118 : :
1119 : 6 : G_APPLICATION_GET_CLASS (application)->after_emit (application, platform_data);
1120 : 6 : g_variant_unref (platform_data);
1121 : 6 : if (options != NULL)
1122 : 5 : g_variant_unref (options);
1123 : : }
1124 : 6 : }
1125 : :
1126 : : static gboolean
1127 : 43 : g_application_real_local_command_line (GApplication *application,
1128 : : gchar ***arguments,
1129 : : int *exit_status)
1130 : : {
1131 : 43 : GError *error = NULL;
1132 : : GVariantDict *options;
1133 : : unsigned int n_args;
1134 : 43 : gboolean print_version = FALSE;
1135 : :
1136 : 43 : options = g_application_parse_command_line (application, arguments, &print_version, &error);
1137 : 42 : if (!options)
1138 : : {
1139 : 0 : g_printerr ("%s\n", error->message);
1140 : 0 : g_error_free (error);
1141 : 0 : *exit_status = 1;
1142 : 0 : return TRUE;
1143 : : }
1144 : :
1145 : : /* Exit quickly with --version? */
1146 : 42 : if (print_version)
1147 : : {
1148 : 0 : const char *prgname = g_get_prgname ();
1149 : :
1150 : 0 : g_assert (application->priv->version != NULL);
1151 : :
1152 : 0 : if (prgname != NULL)
1153 : 0 : g_print ("%s %s\n", prgname, application->priv->version);
1154 : : else
1155 : 0 : g_print ("%s\n", application->priv->version);
1156 : 0 : *exit_status = EXIT_SUCCESS;
1157 : 0 : return TRUE;
1158 : : }
1159 : :
1160 : 42 : g_signal_emit (application, g_application_signals[SIGNAL_HANDLE_LOCAL_OPTIONS], 0, options, exit_status);
1161 : :
1162 : 42 : if (*exit_status >= 0)
1163 : : {
1164 : 3 : g_variant_dict_unref (options);
1165 : 3 : return TRUE;
1166 : : }
1167 : :
1168 : 39 : if (!g_application_register (application, NULL, &error))
1169 : : {
1170 : 0 : g_printerr ("Failed to register: %s\n", error->message);
1171 : 0 : g_variant_dict_unref (options);
1172 : 0 : g_error_free (error);
1173 : 0 : *exit_status = 1;
1174 : 0 : return TRUE;
1175 : : }
1176 : :
1177 : 39 : n_args = g_strv_length (*arguments);
1178 : :
1179 : 39 : if (application->priv->flags & G_APPLICATION_IS_SERVICE)
1180 : : {
1181 : 0 : if ((*exit_status = n_args > 1))
1182 : : {
1183 : 0 : g_printerr ("GApplication service mode takes no arguments.\n");
1184 : 0 : application->priv->flags &= (unsigned int) ~G_APPLICATION_IS_SERVICE;
1185 : 0 : *exit_status = 1;
1186 : : }
1187 : : else
1188 : 0 : *exit_status = 0;
1189 : : }
1190 : 39 : else if (application->priv->flags & G_APPLICATION_HANDLES_COMMAND_LINE)
1191 : : {
1192 : 5 : g_application_call_command_line (application,
1193 : : (const gchar **) *arguments,
1194 : : g_variant_dict_end (options),
1195 : : exit_status);
1196 : : }
1197 : : else
1198 : : {
1199 : 34 : if (n_args <= 1)
1200 : : {
1201 : 34 : g_application_activate (application);
1202 : 34 : *exit_status = 0;
1203 : : }
1204 : :
1205 : : else
1206 : : {
1207 : 0 : if (~application->priv->flags & G_APPLICATION_HANDLES_OPEN)
1208 : : {
1209 : 0 : g_critical ("This application can not open files.");
1210 : 0 : *exit_status = 1;
1211 : : }
1212 : : else
1213 : : {
1214 : : GFile **files;
1215 : : unsigned int n_files;
1216 : :
1217 : 0 : n_files = n_args - 1;
1218 : 0 : g_assert (n_files <= INT_MAX);
1219 : 0 : files = g_new (GFile *, n_files);
1220 : :
1221 : 0 : for (unsigned int i = 0; i < n_files; i++)
1222 : 0 : files[i] = g_file_new_for_commandline_arg ((*arguments)[i + 1]);
1223 : :
1224 : 0 : g_application_open (application, files, (int) n_files, "");
1225 : :
1226 : 0 : for (unsigned int i = 0; i < n_files; i++)
1227 : 0 : g_object_unref (files[i]);
1228 : 0 : g_free (files);
1229 : :
1230 : 0 : *exit_status = 0;
1231 : : }
1232 : : }
1233 : : }
1234 : :
1235 : 39 : g_variant_dict_unref (options);
1236 : :
1237 : 39 : return TRUE;
1238 : : }
1239 : :
1240 : : static void
1241 : 40 : g_application_real_add_platform_data (GApplication *application,
1242 : : GVariantBuilder *builder)
1243 : : {
1244 : 40 : }
1245 : :
1246 : : static gboolean
1247 : 38 : g_application_real_dbus_register (GApplication *application,
1248 : : GDBusConnection *connection,
1249 : : const gchar *object_path,
1250 : : GError **error)
1251 : : {
1252 : 38 : return TRUE;
1253 : : }
1254 : :
1255 : : static void
1256 : 38 : g_application_real_dbus_unregister (GApplication *application,
1257 : : GDBusConnection *connection,
1258 : : const gchar *object_path)
1259 : : {
1260 : 38 : }
1261 : :
1262 : : static gboolean
1263 : 0 : g_application_real_name_lost (GApplication *application)
1264 : : {
1265 : 0 : g_application_quit (application);
1266 : 0 : return TRUE;
1267 : : }
1268 : :
1269 : : /* GObject implementation stuff {{{1 */
1270 : : static void
1271 : 119 : g_application_set_property (GObject *object,
1272 : : guint prop_id,
1273 : : const GValue *value,
1274 : : GParamSpec *pspec)
1275 : : {
1276 : 119 : GApplication *application = G_APPLICATION (object);
1277 : :
1278 : 119 : switch (prop_id)
1279 : : {
1280 : 58 : case PROP_APPLICATION_ID:
1281 : 58 : g_application_set_application_id (application,
1282 : : g_value_get_string (value));
1283 : 58 : break;
1284 : :
1285 : 4 : case PROP_VERSION:
1286 : 4 : g_application_set_version (application, g_value_get_string (value));
1287 : 4 : break;
1288 : :
1289 : 52 : case PROP_FLAGS:
1290 : 52 : g_application_set_flags (application, g_value_get_flags (value));
1291 : 52 : break;
1292 : :
1293 : 2 : case PROP_RESOURCE_BASE_PATH:
1294 : 2 : g_application_set_resource_base_path (application, g_value_get_string (value));
1295 : 2 : break;
1296 : :
1297 : 3 : case PROP_INACTIVITY_TIMEOUT:
1298 : 3 : g_application_set_inactivity_timeout (application,
1299 : : g_value_get_uint (value));
1300 : 3 : break;
1301 : :
1302 : 0 : case PROP_ACTION_GROUP:
1303 : 0 : g_clear_object (&application->priv->actions);
1304 : 0 : application->priv->actions = g_value_dup_object (value);
1305 : 0 : break;
1306 : :
1307 : 0 : default:
1308 : : g_assert_not_reached ();
1309 : : }
1310 : 119 : }
1311 : :
1312 : : /**
1313 : : * g_application_set_action_group:
1314 : : * @application: a #GApplication
1315 : : * @action_group: (nullable): a #GActionGroup, or %NULL
1316 : : *
1317 : : * This used to be how actions were associated with a #GApplication.
1318 : : * Now there is #GActionMap for that.
1319 : : *
1320 : : * Since: 2.28
1321 : : *
1322 : : * Deprecated:2.32:Use the #GActionMap interface instead. Never ever
1323 : : * mix use of this API with use of #GActionMap on the same @application
1324 : : * or things will go very badly wrong. This function is known to
1325 : : * introduce buggy behaviour (ie: signals not emitted on changes to the
1326 : : * action group), so you should really use #GActionMap instead.
1327 : : **/
1328 : : void
1329 : 0 : g_application_set_action_group (GApplication *application,
1330 : : GActionGroup *action_group)
1331 : : {
1332 : 0 : g_return_if_fail (G_IS_APPLICATION (application));
1333 : 0 : g_return_if_fail (!application->priv->is_registered);
1334 : :
1335 : 0 : if (application->priv->actions != NULL)
1336 : 0 : g_object_unref (application->priv->actions);
1337 : :
1338 : 0 : application->priv->actions = action_group;
1339 : :
1340 : 0 : if (application->priv->actions != NULL)
1341 : 0 : g_object_ref (application->priv->actions);
1342 : : }
1343 : :
1344 : : static void
1345 : 32 : g_application_get_property (GObject *object,
1346 : : guint prop_id,
1347 : : GValue *value,
1348 : : GParamSpec *pspec)
1349 : : {
1350 : 32 : GApplication *application = G_APPLICATION (object);
1351 : :
1352 : 32 : switch (prop_id)
1353 : : {
1354 : 9 : case PROP_APPLICATION_ID:
1355 : 9 : g_value_set_string (value,
1356 : : g_application_get_application_id (application));
1357 : 9 : break;
1358 : :
1359 : 5 : case PROP_VERSION:
1360 : 5 : g_value_set_string (value,
1361 : : g_application_get_version (application));
1362 : 5 : break;
1363 : :
1364 : 2 : case PROP_FLAGS:
1365 : 2 : g_value_set_flags (value,
1366 : 2 : g_application_get_flags (application));
1367 : 2 : break;
1368 : :
1369 : 1 : case PROP_RESOURCE_BASE_PATH:
1370 : 1 : g_value_set_string (value, g_application_get_resource_base_path (application));
1371 : 1 : break;
1372 : :
1373 : 3 : case PROP_IS_REGISTERED:
1374 : 3 : g_value_set_boolean (value,
1375 : : g_application_get_is_registered (application));
1376 : 3 : break;
1377 : :
1378 : 1 : case PROP_IS_REMOTE:
1379 : 1 : g_value_set_boolean (value,
1380 : : g_application_get_is_remote (application));
1381 : 1 : break;
1382 : :
1383 : 10 : case PROP_INACTIVITY_TIMEOUT:
1384 : 10 : g_value_set_uint (value,
1385 : : g_application_get_inactivity_timeout (application));
1386 : 10 : break;
1387 : :
1388 : 1 : case PROP_IS_BUSY:
1389 : 1 : g_value_set_boolean (value, g_application_get_is_busy (application));
1390 : 1 : break;
1391 : :
1392 : 0 : default:
1393 : : g_assert_not_reached ();
1394 : : }
1395 : 32 : }
1396 : :
1397 : : static void
1398 : 56 : g_application_constructed (GObject *object)
1399 : : {
1400 : 56 : GApplication *application = G_APPLICATION (object);
1401 : :
1402 : 56 : if (g_application_get_default () == NULL)
1403 : 56 : g_application_set_default (application);
1404 : :
1405 : : /* People should not set properties from _init... */
1406 : 56 : g_assert (application->priv->resource_path == NULL);
1407 : :
1408 : 56 : if (application->priv->id != NULL)
1409 : : {
1410 : : gint i;
1411 : :
1412 : 53 : application->priv->resource_path = g_strconcat ("/", application->priv->id, NULL);
1413 : :
1414 : 1529 : for (i = 1; application->priv->resource_path[i]; i++)
1415 : 1476 : if (application->priv->resource_path[i] == '.')
1416 : 142 : application->priv->resource_path[i] = '/';
1417 : : }
1418 : 56 : }
1419 : :
1420 : : static void
1421 : 55 : g_application_dispose (GObject *object)
1422 : : {
1423 : 55 : GApplication *application = G_APPLICATION (object);
1424 : :
1425 : 55 : if (application->priv->impl != NULL &&
1426 : 5 : G_APPLICATION_GET_CLASS (application)->dbus_unregister != g_application_real_dbus_unregister)
1427 : : {
1428 : : static gboolean warned;
1429 : :
1430 : 0 : if (!warned)
1431 : : {
1432 : 0 : g_warning ("Your application did not unregister from D-Bus before destruction. "
1433 : : "Consider using g_application_run().");
1434 : : }
1435 : :
1436 : 0 : warned = TRUE;
1437 : : }
1438 : :
1439 : 55 : G_OBJECT_CLASS (g_application_parent_class)->dispose (object);
1440 : 55 : }
1441 : :
1442 : : static void
1443 : 55 : g_application_finalize (GObject *object)
1444 : : {
1445 : 55 : GApplication *application = G_APPLICATION (object);
1446 : :
1447 : 55 : if (application->priv->inactivity_timeout_id)
1448 : 0 : g_source_remove (application->priv->inactivity_timeout_id);
1449 : :
1450 : 55 : g_slist_free_full (application->priv->option_groups, (GDestroyNotify) g_option_group_unref);
1451 : 55 : if (application->priv->main_options)
1452 : 0 : g_option_group_unref (application->priv->main_options);
1453 : 55 : if (application->priv->packed_options)
1454 : 0 : g_hash_table_unref (application->priv->packed_options);
1455 : :
1456 : 55 : g_free (application->priv->parameter_string);
1457 : 55 : g_free (application->priv->summary);
1458 : 55 : g_free (application->priv->description);
1459 : 55 : g_free (application->priv->version);
1460 : :
1461 : 55 : g_slist_free_full (application->priv->option_strings, g_free);
1462 : :
1463 : 55 : if (application->priv->impl)
1464 : 5 : g_application_impl_destroy (application->priv->impl);
1465 : 55 : g_free (application->priv->id);
1466 : :
1467 : 55 : if (g_application_get_default () == application)
1468 : 55 : g_application_set_default (NULL);
1469 : :
1470 : 55 : if (application->priv->actions)
1471 : 55 : g_object_unref (application->priv->actions);
1472 : :
1473 : 55 : g_clear_object (&application->priv->remote_actions);
1474 : :
1475 : 55 : if (application->priv->notifications)
1476 : 3 : g_object_unref (application->priv->notifications);
1477 : :
1478 : 55 : g_free (application->priv->resource_path);
1479 : :
1480 : 55 : G_OBJECT_CLASS (g_application_parent_class)
1481 : 55 : ->finalize (object);
1482 : 55 : }
1483 : :
1484 : : static void
1485 : 56 : g_application_init (GApplication *application)
1486 : : {
1487 : 56 : application->priv = g_application_get_instance_private (application);
1488 : :
1489 : 56 : application->priv->actions = g_application_exported_actions_new (application);
1490 : :
1491 : : /* application->priv->actions is the one and only ref on the group, so when
1492 : : * we dispose, the action group will die, disconnecting all signals.
1493 : : */
1494 : 56 : g_signal_connect_swapped (application->priv->actions, "action-added",
1495 : : G_CALLBACK (g_action_group_action_added), application);
1496 : 56 : g_signal_connect_swapped (application->priv->actions, "action-enabled-changed",
1497 : : G_CALLBACK (g_action_group_action_enabled_changed), application);
1498 : 56 : g_signal_connect_swapped (application->priv->actions, "action-state-changed",
1499 : : G_CALLBACK (g_action_group_action_state_changed), application);
1500 : 56 : g_signal_connect_swapped (application->priv->actions, "action-removed",
1501 : : G_CALLBACK (g_action_group_action_removed), application);
1502 : 56 : }
1503 : :
1504 : : static gboolean
1505 : 43 : g_application_handle_local_options_accumulator (GSignalInvocationHint *ihint,
1506 : : GValue *return_accu,
1507 : : const GValue *handler_return,
1508 : : gpointer dummy)
1509 : : {
1510 : : gint value;
1511 : :
1512 : 43 : value = g_value_get_int (handler_return);
1513 : 43 : g_value_set_int (return_accu, value);
1514 : :
1515 : 43 : return value < 0;
1516 : : }
1517 : :
1518 : : static void
1519 : 13 : g_application_class_init (GApplicationClass *class)
1520 : : {
1521 : 13 : GObjectClass *object_class = G_OBJECT_CLASS (class);
1522 : :
1523 : 13 : object_class->constructed = g_application_constructed;
1524 : 13 : object_class->dispose = g_application_dispose;
1525 : 13 : object_class->finalize = g_application_finalize;
1526 : 13 : object_class->get_property = g_application_get_property;
1527 : 13 : object_class->set_property = g_application_set_property;
1528 : :
1529 : 13 : class->before_emit = g_application_real_before_emit;
1530 : 13 : class->after_emit = g_application_real_after_emit;
1531 : 13 : class->startup = g_application_real_startup;
1532 : 13 : class->shutdown = g_application_real_shutdown;
1533 : 13 : class->activate = g_application_real_activate;
1534 : 13 : class->open = g_application_real_open;
1535 : 13 : class->command_line = g_application_real_command_line;
1536 : 13 : class->local_command_line = g_application_real_local_command_line;
1537 : 13 : class->handle_local_options = g_application_real_handle_local_options;
1538 : 13 : class->add_platform_data = g_application_real_add_platform_data;
1539 : 13 : class->dbus_register = g_application_real_dbus_register;
1540 : 13 : class->dbus_unregister = g_application_real_dbus_unregister;
1541 : 13 : class->name_lost = g_application_real_name_lost;
1542 : :
1543 : : /**
1544 : : * GApplication:application-id:
1545 : : *
1546 : : * The unique identifier for the application.
1547 : : *
1548 : : * Since: 2.28
1549 : : */
1550 : 13 : g_object_class_install_property (object_class, PROP_APPLICATION_ID,
1551 : : g_param_spec_string ("application-id", NULL, NULL,
1552 : : NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT |
1553 : : G_PARAM_STATIC_STRINGS));
1554 : :
1555 : : /**
1556 : : * GApplication:version:
1557 : : *
1558 : : * The human-readable version number of the application.
1559 : : *
1560 : : * Since: 2.80
1561 : : */
1562 : 13 : g_object_class_install_property (object_class, PROP_VERSION,
1563 : : g_param_spec_string ("version", NULL, NULL,
1564 : : NULL, G_PARAM_READWRITE |
1565 : : G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY));
1566 : :
1567 : : /**
1568 : : * GApplication:flags:
1569 : : *
1570 : : * Flags specifying the behaviour of the application.
1571 : : *
1572 : : * Since: 2.28
1573 : : */
1574 : 13 : g_object_class_install_property (object_class, PROP_FLAGS,
1575 : : g_param_spec_flags ("flags", NULL, NULL,
1576 : : G_TYPE_APPLICATION_FLAGS, G_APPLICATION_DEFAULT_FLAGS,
1577 : : G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1578 : :
1579 : : /**
1580 : : * GApplication:resource-base-path:
1581 : : *
1582 : : * The base resource path for the application.
1583 : : *
1584 : : * Since: 2.28
1585 : : */
1586 : 13 : g_object_class_install_property (object_class, PROP_RESOURCE_BASE_PATH,
1587 : : g_param_spec_string ("resource-base-path", NULL, NULL,
1588 : : NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1589 : :
1590 : : /**
1591 : : * GApplication:is-registered:
1592 : : *
1593 : : * Whether [method@Gio.Application.register] has been called.
1594 : : *
1595 : : * Since: 2.28
1596 : : */
1597 : 13 : g_object_class_install_property (object_class, PROP_IS_REGISTERED,
1598 : : g_param_spec_boolean ("is-registered", NULL, NULL,
1599 : : FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
1600 : :
1601 : : /**
1602 : : * GApplication:is-remote:
1603 : : *
1604 : : * Whether this application instance is remote.
1605 : : *
1606 : : * Since: 2.28
1607 : : */
1608 : 13 : g_object_class_install_property (object_class, PROP_IS_REMOTE,
1609 : : g_param_spec_boolean ("is-remote", NULL, NULL,
1610 : : FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
1611 : :
1612 : : /**
1613 : : * GApplication:inactivity-timeout:
1614 : : *
1615 : : * Time (in milliseconds) to stay alive after becoming idle.
1616 : : *
1617 : : * Since: 2.28
1618 : : */
1619 : 13 : g_object_class_install_property (object_class, PROP_INACTIVITY_TIMEOUT,
1620 : : g_param_spec_uint ("inactivity-timeout", NULL, NULL,
1621 : : 0, G_MAXUINT, 0,
1622 : : G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1623 : :
1624 : : /**
1625 : : * GApplication:action-group:
1626 : : *
1627 : : * The group of actions that the application exports.
1628 : : *
1629 : : * Since: 2.28
1630 : : * Deprecated: 2.32: Use the [iface@Gio.ActionMap] interface instead.
1631 : : * Never ever mix use of this API with use of `GActionMap` on the
1632 : : * same @application or things will go very badly wrong.
1633 : : */
1634 : 13 : g_object_class_install_property (object_class, PROP_ACTION_GROUP,
1635 : : g_param_spec_object ("action-group", NULL, NULL,
1636 : : G_TYPE_ACTION_GROUP,
1637 : : G_PARAM_DEPRECATED | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
1638 : :
1639 : : /**
1640 : : * GApplication:is-busy:
1641 : : *
1642 : : * Whether the application is currently marked as busy through
1643 : : * g_application_mark_busy() or g_application_bind_busy_property().
1644 : : *
1645 : : * Since: 2.44
1646 : : */
1647 : 13 : g_object_class_install_property (object_class, PROP_IS_BUSY,
1648 : : g_param_spec_boolean ("is-busy", NULL, NULL,
1649 : : FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
1650 : :
1651 : : /**
1652 : : * GApplication::startup:
1653 : : * @application: the application
1654 : : *
1655 : : * The ::startup signal is emitted on the primary instance immediately
1656 : : * after registration. See g_application_register().
1657 : : */
1658 : 13 : g_application_signals[SIGNAL_STARTUP] =
1659 : 13 : g_signal_new (I_("startup"), G_TYPE_APPLICATION, G_SIGNAL_RUN_FIRST,
1660 : : G_STRUCT_OFFSET (GApplicationClass, startup),
1661 : : NULL, NULL, NULL, G_TYPE_NONE, 0);
1662 : :
1663 : : /**
1664 : : * GApplication::shutdown:
1665 : : * @application: the application
1666 : : *
1667 : : * The ::shutdown signal is emitted only on the registered primary instance
1668 : : * immediately after the main loop terminates.
1669 : : */
1670 : 13 : g_application_signals[SIGNAL_SHUTDOWN] =
1671 : 13 : g_signal_new (I_("shutdown"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1672 : : G_STRUCT_OFFSET (GApplicationClass, shutdown),
1673 : : NULL, NULL, NULL, G_TYPE_NONE, 0);
1674 : :
1675 : : /**
1676 : : * GApplication::activate:
1677 : : * @application: the application
1678 : : *
1679 : : * The ::activate signal is emitted on the primary instance when an
1680 : : * activation occurs. See g_application_activate().
1681 : : */
1682 : 13 : g_application_signals[SIGNAL_ACTIVATE] =
1683 : 13 : g_signal_new (I_("activate"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1684 : : G_STRUCT_OFFSET (GApplicationClass, activate),
1685 : : NULL, NULL, NULL, G_TYPE_NONE, 0);
1686 : :
1687 : :
1688 : : /**
1689 : : * GApplication::open:
1690 : : * @application: the application
1691 : : * @files: (array length=n_files) (element-type GFile): an array of #GFiles
1692 : : * @n_files: the length of @files
1693 : : * @hint: a hint provided by the calling instance
1694 : : *
1695 : : * The ::open signal is emitted on the primary instance when there are
1696 : : * files to open. See g_application_open() for more information.
1697 : : */
1698 : 13 : g_application_signals[SIGNAL_OPEN] =
1699 : 13 : g_signal_new (I_("open"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1700 : : G_STRUCT_OFFSET (GApplicationClass, open),
1701 : : NULL, NULL,
1702 : : _g_cclosure_marshal_VOID__POINTER_INT_STRING,
1703 : : G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_STRING);
1704 : 13 : g_signal_set_va_marshaller (g_application_signals[SIGNAL_OPEN],
1705 : : G_TYPE_FROM_CLASS (class),
1706 : : _g_cclosure_marshal_VOID__POINTER_INT_STRINGv);
1707 : :
1708 : : /**
1709 : : * GApplication::command-line:
1710 : : * @application: the application
1711 : : * @command_line: a #GApplicationCommandLine representing the
1712 : : * passed commandline
1713 : : *
1714 : : * The ::command-line signal is emitted on the primary instance when
1715 : : * a commandline is not handled locally. See g_application_run() and
1716 : : * the #GApplicationCommandLine documentation for more information.
1717 : : *
1718 : : * Returns: An integer that is set as the exit status for the calling
1719 : : * process. See g_application_command_line_set_exit_status().
1720 : : */
1721 : 13 : g_application_signals[SIGNAL_COMMAND_LINE] =
1722 : 13 : g_signal_new (I_("command-line"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1723 : : G_STRUCT_OFFSET (GApplicationClass, command_line),
1724 : : g_signal_accumulator_first_wins, NULL,
1725 : : _g_cclosure_marshal_INT__OBJECT,
1726 : : G_TYPE_INT, 1, G_TYPE_APPLICATION_COMMAND_LINE);
1727 : 13 : g_signal_set_va_marshaller (g_application_signals[SIGNAL_COMMAND_LINE],
1728 : : G_TYPE_FROM_CLASS (class),
1729 : : _g_cclosure_marshal_INT__OBJECTv);
1730 : :
1731 : : /**
1732 : : * GApplication::handle-local-options:
1733 : : * @application: the application
1734 : : * @options: the options dictionary
1735 : : *
1736 : : * The ::handle-local-options signal is emitted on the local instance
1737 : : * after the parsing of the commandline options has occurred.
1738 : : *
1739 : : * You can add options to be recognised during commandline option
1740 : : * parsing using g_application_add_main_option_entries() and
1741 : : * g_application_add_option_group().
1742 : : *
1743 : : * Signal handlers can inspect @options (along with values pointed to
1744 : : * from the @arg_data of an installed #GOptionEntrys) in order to
1745 : : * decide to perform certain actions, including direct local handling
1746 : : * (which may be useful for options like --version).
1747 : : *
1748 : : * In the event that the application is marked
1749 : : * %G_APPLICATION_HANDLES_COMMAND_LINE the "normal processing" will
1750 : : * send the @options dictionary to the primary instance where it can be
1751 : : * read with g_application_command_line_get_options_dict(). The signal
1752 : : * handler can modify the dictionary before returning, and the
1753 : : * modified dictionary will be sent.
1754 : : *
1755 : : * In the event that %G_APPLICATION_HANDLES_COMMAND_LINE is not set,
1756 : : * "normal processing" will treat the remaining uncollected command
1757 : : * line arguments as filenames or URIs. If there are no arguments,
1758 : : * the application is activated by g_application_activate(). One or
1759 : : * more arguments results in a call to g_application_open().
1760 : : *
1761 : : * If you want to handle the local commandline arguments for yourself
1762 : : * by converting them to calls to g_application_open() or
1763 : : * g_action_group_activate_action() then you must be sure to register
1764 : : * the application first. You should probably not call
1765 : : * g_application_activate() for yourself, however: just return -1 and
1766 : : * allow the default handler to do it for you. This will ensure that
1767 : : * the `--gapplication-service` switch works properly (i.e. no activation
1768 : : * in that case).
1769 : : *
1770 : : * Note that this signal is emitted from the default implementation of
1771 : : * local_command_line(). If you override that function and don't
1772 : : * chain up then this signal will never be emitted.
1773 : : *
1774 : : * You can override local_command_line() if you need more powerful
1775 : : * capabilities than what is provided here, but this should not
1776 : : * normally be required.
1777 : : *
1778 : : * Returns: an exit code. If you have handled your options and want
1779 : : * to exit the process, return a non-negative option, 0 for success,
1780 : : * and a positive value for failure. To continue, return -1 to let
1781 : : * the default option processing continue.
1782 : : *
1783 : : * Since: 2.40
1784 : : **/
1785 : 13 : g_application_signals[SIGNAL_HANDLE_LOCAL_OPTIONS] =
1786 : 13 : g_signal_new (I_("handle-local-options"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1787 : : G_STRUCT_OFFSET (GApplicationClass, handle_local_options),
1788 : : g_application_handle_local_options_accumulator, NULL,
1789 : : _g_cclosure_marshal_INT__BOXED,
1790 : : G_TYPE_INT, 1, G_TYPE_VARIANT_DICT);
1791 : 13 : g_signal_set_va_marshaller (g_application_signals[SIGNAL_HANDLE_LOCAL_OPTIONS],
1792 : : G_TYPE_FROM_CLASS (class),
1793 : : _g_cclosure_marshal_INT__BOXEDv);
1794 : :
1795 : : /**
1796 : : * GApplication::name-lost:
1797 : : * @application: the application
1798 : : *
1799 : : * The ::name-lost signal is emitted only on the registered primary instance
1800 : : * when a new instance has taken over. This can only happen if the application
1801 : : * is using the %G_APPLICATION_ALLOW_REPLACEMENT flag.
1802 : : *
1803 : : * The default handler for this signal calls g_application_quit().
1804 : : *
1805 : : * Returns: %TRUE if the signal has been handled
1806 : : *
1807 : : * Since: 2.60
1808 : : */
1809 : 13 : g_application_signals[SIGNAL_NAME_LOST] =
1810 : 13 : g_signal_new (I_("name-lost"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1811 : : G_STRUCT_OFFSET (GApplicationClass, name_lost),
1812 : : g_signal_accumulator_true_handled, NULL,
1813 : : _g_cclosure_marshal_BOOLEAN__VOID,
1814 : : G_TYPE_BOOLEAN, 0);
1815 : 13 : g_signal_set_va_marshaller (g_application_signals[SIGNAL_NAME_LOST],
1816 : : G_TYPE_FROM_CLASS (class),
1817 : : _g_cclosure_marshal_BOOLEAN__VOIDv);
1818 : 13 : }
1819 : :
1820 : : /* Application ID validity {{{1 */
1821 : :
1822 : : /**
1823 : : * g_application_id_is_valid:
1824 : : * @application_id: a potential application identifier
1825 : : *
1826 : : * Checks if @application_id is a valid application identifier.
1827 : : *
1828 : : * A valid ID is required for calls to g_application_new() and
1829 : : * g_application_set_application_id().
1830 : : *
1831 : : * Application identifiers follow the same format as
1832 : : * [D-Bus well-known bus names](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus).
1833 : : * For convenience, the restrictions on application identifiers are
1834 : : * reproduced here:
1835 : : *
1836 : : * - Application identifiers are composed of 1 or more elements separated by a
1837 : : * period (`.`) character. All elements must contain at least one character.
1838 : : *
1839 : : * - Each element must only contain the ASCII characters `[A-Z][a-z][0-9]_-`,
1840 : : * with `-` discouraged in new application identifiers. Each element must not
1841 : : * begin with a digit.
1842 : : *
1843 : : * - Application identifiers must contain at least one `.` (period) character
1844 : : * (and thus at least two elements).
1845 : : *
1846 : : * - Application identifiers must not begin with a `.` (period) character.
1847 : : *
1848 : : * - Application identifiers must not exceed 255 characters.
1849 : : *
1850 : : * Note that the hyphen (`-`) character is allowed in application identifiers,
1851 : : * but is problematic or not allowed in various specifications and APIs that
1852 : : * refer to D-Bus, such as
1853 : : * [Flatpak application IDs](http://docs.flatpak.org/en/latest/introduction.html#identifiers),
1854 : : * the
1855 : : * [`DBusActivatable` interface in the Desktop Entry Specification](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#dbus),
1856 : : * and the convention that an application's "main" interface and object path
1857 : : * resemble its application identifier and bus name. To avoid situations that
1858 : : * require special-case handling, it is recommended that new application
1859 : : * identifiers consistently replace hyphens with underscores.
1860 : : *
1861 : : * Like D-Bus interface names, application identifiers should start with the
1862 : : * reversed DNS domain name of the author of the interface (in lower-case), and
1863 : : * it is conventional for the rest of the application identifier to consist of
1864 : : * words run together, with initial capital letters.
1865 : : *
1866 : : * As with D-Bus interface names, if the author's DNS domain name contains
1867 : : * hyphen/minus characters they should be replaced by underscores, and if it
1868 : : * contains leading digits they should be escaped by prepending an underscore.
1869 : : * For example, if the owner of 7-zip.org used an application identifier for an
1870 : : * archiving application, it might be named `org._7_zip.Archiver`.
1871 : : *
1872 : : * Returns: %TRUE if @application_id is valid
1873 : : */
1874 : : gboolean
1875 : 126 : g_application_id_is_valid (const gchar *application_id)
1876 : : {
1877 : 237 : return g_dbus_is_name (application_id) &&
1878 : 111 : !g_dbus_is_unique_name (application_id);
1879 : : }
1880 : :
1881 : : /* Public Constructor {{{1 */
1882 : : /**
1883 : : * g_application_new:
1884 : : * @application_id: (nullable): the application id
1885 : : * @flags: the application flags
1886 : : *
1887 : : * Creates a new #GApplication instance.
1888 : : *
1889 : : * If non-%NULL, the application id must be valid. See
1890 : : * g_application_id_is_valid().
1891 : : *
1892 : : * If no application ID is given then some features of #GApplication
1893 : : * (most notably application uniqueness) will be disabled.
1894 : : *
1895 : : * Returns: a new #GApplication instance
1896 : : **/
1897 : : GApplication *
1898 : 45 : g_application_new (const gchar *application_id,
1899 : : GApplicationFlags flags)
1900 : : {
1901 : 45 : g_return_val_if_fail (application_id == NULL || g_application_id_is_valid (application_id), NULL);
1902 : :
1903 : 45 : return g_object_new (G_TYPE_APPLICATION,
1904 : : "application-id", application_id,
1905 : : "flags", flags,
1906 : : NULL);
1907 : : }
1908 : :
1909 : : /* Simple get/set: application id, flags, inactivity timeout {{{1 */
1910 : : /**
1911 : : * g_application_get_application_id:
1912 : : * @application: a #GApplication
1913 : : *
1914 : : * Gets the unique identifier for @application.
1915 : : *
1916 : : * Returns: (nullable): the identifier for @application, owned by @application
1917 : : *
1918 : : * Since: 2.28
1919 : : **/
1920 : : const gchar *
1921 : 27 : g_application_get_application_id (GApplication *application)
1922 : : {
1923 : 27 : g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
1924 : :
1925 : 27 : return application->priv->id;
1926 : : }
1927 : :
1928 : : /**
1929 : : * g_application_set_application_id:
1930 : : * @application: a #GApplication
1931 : : * @application_id: (nullable): the identifier for @application
1932 : : *
1933 : : * Sets the unique identifier for @application.
1934 : : *
1935 : : * The application id can only be modified if @application has not yet
1936 : : * been registered.
1937 : : *
1938 : : * If non-%NULL, the application id must be valid. See
1939 : : * g_application_id_is_valid().
1940 : : *
1941 : : * Since: 2.28
1942 : : **/
1943 : : void
1944 : 60 : g_application_set_application_id (GApplication *application,
1945 : : const gchar *application_id)
1946 : : {
1947 : 60 : g_return_if_fail (G_IS_APPLICATION (application));
1948 : :
1949 : 60 : if (g_strcmp0 (application->priv->id, application_id) != 0)
1950 : : {
1951 : 57 : g_return_if_fail (application_id == NULL || g_application_id_is_valid (application_id));
1952 : 57 : g_return_if_fail (!application->priv->is_registered);
1953 : :
1954 : 57 : g_free (application->priv->id);
1955 : 57 : application->priv->id = g_strdup (application_id);
1956 : :
1957 : 57 : g_object_notify (G_OBJECT (application), "application-id");
1958 : : }
1959 : : }
1960 : :
1961 : : /**
1962 : : * g_application_get_version:
1963 : : * @application: a #GApplication
1964 : : *
1965 : : * Gets the version of @application.
1966 : : *
1967 : : * Returns: (nullable): the version of @application
1968 : : *
1969 : : * Since: 2.80
1970 : : **/
1971 : : const gchar *
1972 : 5 : g_application_get_version (GApplication *application)
1973 : : {
1974 : 5 : g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
1975 : :
1976 : 5 : return application->priv->version;
1977 : : }
1978 : :
1979 : : /**
1980 : : * g_application_set_version
1981 : : * @application: a #GApplication
1982 : : * @version: the version of @application
1983 : : *
1984 : : * Sets the version number of @application. This will be used to implement
1985 : : * a `--version` command line argument
1986 : : *
1987 : : * The application version can only be modified if @application has not yet
1988 : : * been registered.
1989 : : *
1990 : : * Since: 2.80
1991 : : **/
1992 : : void
1993 : 4 : g_application_set_version (GApplication *application,
1994 : : const gchar *version)
1995 : : {
1996 : 4 : g_return_if_fail (G_IS_APPLICATION (application));
1997 : 4 : g_return_if_fail (version != NULL);
1998 : 4 : g_return_if_fail (!application->priv->is_registered);
1999 : :
2000 : 4 : if (g_set_str (&application->priv->version, version))
2001 : 3 : g_object_notify (G_OBJECT (application), "version");
2002 : : }
2003 : :
2004 : :
2005 : : /**
2006 : : * g_application_get_flags:
2007 : : * @application: a #GApplication
2008 : : *
2009 : : * Gets the flags for @application.
2010 : : *
2011 : : * See #GApplicationFlags.
2012 : : *
2013 : : * Returns: the flags for @application
2014 : : *
2015 : : * Since: 2.28
2016 : : **/
2017 : : GApplicationFlags
2018 : 54 : g_application_get_flags (GApplication *application)
2019 : : {
2020 : 54 : g_return_val_if_fail (G_IS_APPLICATION (application), 0);
2021 : :
2022 : 54 : return application->priv->flags;
2023 : : }
2024 : :
2025 : : /**
2026 : : * g_application_set_flags:
2027 : : * @application: a #GApplication
2028 : : * @flags: the flags for @application
2029 : : *
2030 : : * Sets the flags for @application.
2031 : : *
2032 : : * The flags can only be modified if @application has not yet been
2033 : : * registered.
2034 : : *
2035 : : * See #GApplicationFlags.
2036 : : *
2037 : : * Since: 2.28
2038 : : **/
2039 : : void
2040 : 52 : g_application_set_flags (GApplication *application,
2041 : : GApplicationFlags flags)
2042 : : {
2043 : 52 : g_return_if_fail (G_IS_APPLICATION (application));
2044 : :
2045 : 52 : if (application->priv->flags != flags)
2046 : : {
2047 : 20 : g_return_if_fail (!application->priv->is_registered);
2048 : :
2049 : 20 : application->priv->flags = flags;
2050 : :
2051 : 20 : g_object_notify (G_OBJECT (application), "flags");
2052 : : }
2053 : : }
2054 : :
2055 : : /**
2056 : : * g_application_get_resource_base_path:
2057 : : * @application: a #GApplication
2058 : : *
2059 : : * Gets the resource base path of @application.
2060 : : *
2061 : : * See g_application_set_resource_base_path() for more information.
2062 : : *
2063 : : * Returns: (nullable): the base resource path, if one is set
2064 : : *
2065 : : * Since: 2.42
2066 : : */
2067 : : const gchar *
2068 : 7 : g_application_get_resource_base_path (GApplication *application)
2069 : : {
2070 : 7 : g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
2071 : :
2072 : 7 : return application->priv->resource_path;
2073 : : }
2074 : :
2075 : : /**
2076 : : * g_application_set_resource_base_path:
2077 : : * @application: a #GApplication
2078 : : * @resource_path: (nullable): the resource path to use
2079 : : *
2080 : : * Sets (or unsets) the base resource path of @application.
2081 : : *
2082 : : * The path is used to automatically load various
2083 : : * [application resources][struct@Gio.Resource] such as menu layouts and
2084 : : * action descriptions. The various types of resources will be found at
2085 : : * fixed names relative to the given base path.
2086 : : *
2087 : : * By default, the resource base path is determined from the application
2088 : : * ID by prefixing '/' and replacing each '.' with '/'. This is done at
2089 : : * the time that the #GApplication object is constructed. Changes to
2090 : : * the application ID after that point will not have an impact on the
2091 : : * resource base path.
2092 : : *
2093 : : * As an example, if the application has an ID of "org.example.app" then
2094 : : * the default resource base path will be "/org/example/app". If this
2095 : : * is a #GtkApplication (and you have not manually changed the path)
2096 : : * then Gtk will then search for the menus of the application at
2097 : : * "/org/example/app/gtk/menus.ui".
2098 : : *
2099 : : * See #GResource for more information about adding resources to your
2100 : : * application.
2101 : : *
2102 : : * You can disable automatic resource loading functionality by setting
2103 : : * the path to %NULL.
2104 : : *
2105 : : * Changing the resource base path once the application is running is
2106 : : * not recommended. The point at which the resource path is consulted
2107 : : * for forming paths for various purposes is unspecified. When writing
2108 : : * a sub-class of #GApplication you should either set the
2109 : : * #GApplication:resource-base-path property at construction time, or call
2110 : : * this function during the instance initialization. Alternatively, you
2111 : : * can call this function in the #GApplicationClass.startup virtual function,
2112 : : * before chaining up to the parent implementation.
2113 : : *
2114 : : * Since: 2.42
2115 : : */
2116 : : void
2117 : 4 : g_application_set_resource_base_path (GApplication *application,
2118 : : const gchar *resource_path)
2119 : : {
2120 : 4 : g_return_if_fail (G_IS_APPLICATION (application));
2121 : 4 : g_return_if_fail (resource_path == NULL || g_str_has_prefix (resource_path, "/"));
2122 : :
2123 : 4 : if (g_strcmp0 (application->priv->resource_path, resource_path) != 0)
2124 : : {
2125 : 4 : g_free (application->priv->resource_path);
2126 : :
2127 : 4 : application->priv->resource_path = g_strdup (resource_path);
2128 : :
2129 : 4 : g_object_notify (G_OBJECT (application), "resource-base-path");
2130 : : }
2131 : : }
2132 : :
2133 : : /**
2134 : : * g_application_get_inactivity_timeout:
2135 : : * @application: a #GApplication
2136 : : *
2137 : : * Gets the current inactivity timeout for the application.
2138 : : *
2139 : : * This is the amount of time (in milliseconds) after the last call to
2140 : : * g_application_release() before the application stops running.
2141 : : *
2142 : : * Returns: the timeout, in milliseconds
2143 : : *
2144 : : * Since: 2.28
2145 : : **/
2146 : : guint
2147 : 12 : g_application_get_inactivity_timeout (GApplication *application)
2148 : : {
2149 : 12 : g_return_val_if_fail (G_IS_APPLICATION (application), 0);
2150 : :
2151 : 12 : return application->priv->inactivity_timeout;
2152 : : }
2153 : :
2154 : : /**
2155 : : * g_application_set_inactivity_timeout:
2156 : : * @application: a #GApplication
2157 : : * @inactivity_timeout: the timeout, in milliseconds
2158 : : *
2159 : : * Sets the current inactivity timeout for the application.
2160 : : *
2161 : : * This is the amount of time (in milliseconds) after the last call to
2162 : : * g_application_release() before the application stops running.
2163 : : *
2164 : : * This call has no side effects of its own. The value set here is only
2165 : : * used for next time g_application_release() drops the use count to
2166 : : * zero. Any timeouts currently in progress are not impacted.
2167 : : *
2168 : : * Since: 2.28
2169 : : **/
2170 : : void
2171 : 7 : g_application_set_inactivity_timeout (GApplication *application,
2172 : : guint inactivity_timeout)
2173 : : {
2174 : 7 : g_return_if_fail (G_IS_APPLICATION (application));
2175 : :
2176 : 7 : if (application->priv->inactivity_timeout != inactivity_timeout)
2177 : : {
2178 : 6 : application->priv->inactivity_timeout = inactivity_timeout;
2179 : :
2180 : 6 : g_object_notify (G_OBJECT (application), "inactivity-timeout");
2181 : : }
2182 : : }
2183 : : /* Read-only property getters (is registered, is remote, dbus stuff) {{{1 */
2184 : : /**
2185 : : * g_application_get_is_registered:
2186 : : * @application: a #GApplication
2187 : : *
2188 : : * Checks if @application is registered.
2189 : : *
2190 : : * An application is registered if g_application_register() has been
2191 : : * successfully called.
2192 : : *
2193 : : * Returns: %TRUE if @application is registered
2194 : : *
2195 : : * Since: 2.28
2196 : : **/
2197 : : gboolean
2198 : 14 : g_application_get_is_registered (GApplication *application)
2199 : : {
2200 : 14 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2201 : :
2202 : 14 : return application->priv->is_registered;
2203 : : }
2204 : :
2205 : : /**
2206 : : * g_application_get_is_remote:
2207 : : * @application: a #GApplication
2208 : : *
2209 : : * Checks if @application is remote.
2210 : : *
2211 : : * If @application is remote then it means that another instance of
2212 : : * application already exists (the 'primary' instance). Calls to
2213 : : * perform actions on @application will result in the actions being
2214 : : * performed by the primary instance.
2215 : : *
2216 : : * The value of this property cannot be accessed before
2217 : : * g_application_register() has been called. See
2218 : : * g_application_get_is_registered().
2219 : : *
2220 : : * Returns: %TRUE if @application is remote
2221 : : *
2222 : : * Since: 2.28
2223 : : **/
2224 : : gboolean
2225 : 7 : g_application_get_is_remote (GApplication *application)
2226 : : {
2227 : 7 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2228 : 7 : g_return_val_if_fail (application->priv->is_registered, FALSE);
2229 : :
2230 : 7 : return application->priv->is_remote;
2231 : : }
2232 : :
2233 : : /**
2234 : : * g_application_get_dbus_connection:
2235 : : * @application: a #GApplication
2236 : : *
2237 : : * Gets the #GDBusConnection being used by the application, or %NULL.
2238 : : *
2239 : : * If #GApplication is using its D-Bus backend then this function will
2240 : : * return the #GDBusConnection being used for uniqueness and
2241 : : * communication with the desktop environment and other instances of the
2242 : : * application.
2243 : : *
2244 : : * If #GApplication is not using D-Bus then this function will return
2245 : : * %NULL. This includes the situation where the D-Bus backend would
2246 : : * normally be in use but we were unable to connect to the bus.
2247 : : *
2248 : : * This function must not be called before the application has been
2249 : : * registered. See g_application_get_is_registered().
2250 : : *
2251 : : * Returns: (nullable) (transfer none): a #GDBusConnection, or %NULL
2252 : : *
2253 : : * Since: 2.34
2254 : : **/
2255 : : GDBusConnection *
2256 : 8 : g_application_get_dbus_connection (GApplication *application)
2257 : : {
2258 : 8 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2259 : 8 : g_return_val_if_fail (application->priv->is_registered, FALSE);
2260 : :
2261 : 8 : return g_application_impl_get_dbus_connection (application->priv->impl);
2262 : : }
2263 : :
2264 : : /**
2265 : : * g_application_get_dbus_object_path:
2266 : : * @application: a #GApplication
2267 : : *
2268 : : * Gets the D-Bus object path being used by the application, or %NULL.
2269 : : *
2270 : : * If #GApplication is using its D-Bus backend then this function will
2271 : : * return the D-Bus object path that #GApplication is using. If the
2272 : : * application is the primary instance then there is an object published
2273 : : * at this path. If the application is not the primary instance then
2274 : : * the result of this function is undefined.
2275 : : *
2276 : : * If #GApplication is not using D-Bus then this function will return
2277 : : * %NULL. This includes the situation where the D-Bus backend would
2278 : : * normally be in use but we were unable to connect to the bus.
2279 : : *
2280 : : * This function must not be called before the application has been
2281 : : * registered. See g_application_get_is_registered().
2282 : : *
2283 : : * Returns: (nullable): the object path, or %NULL
2284 : : *
2285 : : * Since: 2.34
2286 : : **/
2287 : : const gchar *
2288 : 2 : g_application_get_dbus_object_path (GApplication *application)
2289 : : {
2290 : 2 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2291 : 2 : g_return_val_if_fail (application->priv->is_registered, FALSE);
2292 : :
2293 : 2 : return g_application_impl_get_dbus_object_path (application->priv->impl);
2294 : : }
2295 : :
2296 : :
2297 : : /* Register {{{1 */
2298 : : /**
2299 : : * g_application_register:
2300 : : * @application: a #GApplication
2301 : : * @cancellable: (nullable): a #GCancellable, or %NULL
2302 : : * @error: a pointer to a NULL #GError, or %NULL
2303 : : *
2304 : : * Attempts registration of the application.
2305 : : *
2306 : : * This is the point at which the application discovers if it is the
2307 : : * primary instance or merely acting as a remote for an already-existing
2308 : : * primary instance. This is implemented by attempting to acquire the
2309 : : * application identifier as a unique bus name on the session bus using
2310 : : * GDBus.
2311 : : *
2312 : : * If there is no application ID or if %G_APPLICATION_NON_UNIQUE was
2313 : : * given, then this process will always become the primary instance.
2314 : : *
2315 : : * Due to the internal architecture of GDBus, method calls can be
2316 : : * dispatched at any time (even if a main loop is not running). For
2317 : : * this reason, you must ensure that any object paths that you wish to
2318 : : * register are registered before calling this function.
2319 : : *
2320 : : * If the application has already been registered then %TRUE is
2321 : : * returned with no work performed.
2322 : : *
2323 : : * The #GApplication::startup signal is emitted if registration succeeds
2324 : : * and @application is the primary instance (including the non-unique
2325 : : * case).
2326 : : *
2327 : : * In the event of an error (such as @cancellable being cancelled, or a
2328 : : * failure to connect to the session bus), %FALSE is returned and @error
2329 : : * is set appropriately.
2330 : : *
2331 : : * Note: the return value of this function is not an indicator that this
2332 : : * instance is or is not the primary instance of the application. See
2333 : : * g_application_get_is_remote() for that.
2334 : : *
2335 : : * Returns: %TRUE if registration succeeded
2336 : : *
2337 : : * Since: 2.28
2338 : : **/
2339 : : gboolean
2340 : 46 : g_application_register (GApplication *application,
2341 : : GCancellable *cancellable,
2342 : : GError **error)
2343 : : {
2344 : 46 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2345 : :
2346 : 46 : if (!application->priv->is_registered)
2347 : : {
2348 : 45 : if (application->priv->id == NULL)
2349 : 3 : application->priv->flags |= G_APPLICATION_NON_UNIQUE;
2350 : :
2351 : 90 : application->priv->impl =
2352 : 45 : g_application_impl_register (application, application->priv->id,
2353 : 45 : application->priv->flags,
2354 : 45 : application->priv->actions,
2355 : 45 : &application->priv->remote_actions,
2356 : : cancellable, error);
2357 : :
2358 : 45 : if (application->priv->impl == NULL)
2359 : 0 : return FALSE;
2360 : :
2361 : 45 : application->priv->is_remote = application->priv->remote_actions != NULL;
2362 : 45 : application->priv->is_registered = TRUE;
2363 : :
2364 : 45 : g_object_notify (G_OBJECT (application), "is-registered");
2365 : :
2366 : 45 : if (!application->priv->is_remote)
2367 : : {
2368 : 44 : g_signal_emit (application, g_application_signals[SIGNAL_STARTUP], 0);
2369 : :
2370 : 44 : if (!application->priv->did_startup)
2371 : 0 : g_critical ("GApplication subclass '%s' failed to chain up on"
2372 : : " ::startup (from start of override function)",
2373 : : G_OBJECT_TYPE_NAME (application));
2374 : : }
2375 : : }
2376 : :
2377 : 46 : return TRUE;
2378 : : }
2379 : :
2380 : : /* Hold/release {{{1 */
2381 : : /**
2382 : : * g_application_hold:
2383 : : * @application: a #GApplication
2384 : : *
2385 : : * Increases the use count of @application.
2386 : : *
2387 : : * Use this function to indicate that the application has a reason to
2388 : : * continue to run. For example, g_application_hold() is called by GTK
2389 : : * when a toplevel window is on the screen.
2390 : : *
2391 : : * To cancel the hold, call g_application_release().
2392 : : **/
2393 : : void
2394 : 36 : g_application_hold (GApplication *application)
2395 : : {
2396 : 36 : g_return_if_fail (G_IS_APPLICATION (application));
2397 : :
2398 : 36 : if (application->priv->inactivity_timeout_id)
2399 : : {
2400 : 0 : g_source_remove (application->priv->inactivity_timeout_id);
2401 : 0 : application->priv->inactivity_timeout_id = 0;
2402 : : }
2403 : :
2404 : 36 : application->priv->use_count++;
2405 : : }
2406 : :
2407 : : static gboolean
2408 : 1 : inactivity_timeout_expired (gpointer data)
2409 : : {
2410 : 1 : GApplication *application = G_APPLICATION (data);
2411 : :
2412 : 1 : application->priv->inactivity_timeout_id = 0;
2413 : :
2414 : 1 : return G_SOURCE_REMOVE;
2415 : : }
2416 : :
2417 : :
2418 : : /**
2419 : : * g_application_release:
2420 : : * @application: a #GApplication
2421 : : *
2422 : : * Decrease the use count of @application.
2423 : : *
2424 : : * When the use count reaches zero, the application will stop running.
2425 : : *
2426 : : * Never call this function except to cancel the effect of a previous
2427 : : * call to g_application_hold().
2428 : : **/
2429 : : void
2430 : 31 : g_application_release (GApplication *application)
2431 : : {
2432 : 31 : g_return_if_fail (G_IS_APPLICATION (application));
2433 : 31 : g_return_if_fail (application->priv->use_count > 0);
2434 : :
2435 : 31 : application->priv->use_count--;
2436 : :
2437 : 31 : if (application->priv->use_count == 0 && application->priv->inactivity_timeout)
2438 : 1 : application->priv->inactivity_timeout_id = g_timeout_add (application->priv->inactivity_timeout,
2439 : : inactivity_timeout_expired, application);
2440 : : }
2441 : :
2442 : : /* Activate, Open {{{1 */
2443 : : /**
2444 : : * g_application_activate:
2445 : : * @application: a #GApplication
2446 : : *
2447 : : * Activates the application.
2448 : : *
2449 : : * In essence, this results in the #GApplication::activate signal being
2450 : : * emitted in the primary instance.
2451 : : *
2452 : : * The application must be registered before calling this function.
2453 : : *
2454 : : * Since: 2.28
2455 : : **/
2456 : : void
2457 : 34 : g_application_activate (GApplication *application)
2458 : : {
2459 : 34 : g_return_if_fail (G_IS_APPLICATION (application));
2460 : 34 : g_return_if_fail (application->priv->is_registered);
2461 : :
2462 : 34 : if (application->priv->is_remote)
2463 : 1 : g_application_impl_activate (application->priv->impl,
2464 : : get_platform_data (application, NULL));
2465 : :
2466 : : else
2467 : : {
2468 : 33 : GVariant *platform_data = g_variant_ref_sink (get_platform_data (application, NULL));
2469 : :
2470 : 33 : G_APPLICATION_GET_CLASS (application)->before_emit (application, platform_data);
2471 : 33 : g_signal_emit (application, g_application_signals[SIGNAL_ACTIVATE], 0);
2472 : 33 : G_APPLICATION_GET_CLASS (application)->after_emit (application, platform_data);
2473 : 33 : g_variant_unref (platform_data);
2474 : : }
2475 : : }
2476 : :
2477 : : /**
2478 : : * g_application_open:
2479 : : * @application: a #GApplication
2480 : : * @files: (array length=n_files): an array of #GFiles to open
2481 : : * @n_files: the length of the @files array
2482 : : * @hint: a hint (or ""), but never %NULL
2483 : : *
2484 : : * Opens the given files.
2485 : : *
2486 : : * In essence, this results in the #GApplication::open signal being emitted
2487 : : * in the primary instance.
2488 : : *
2489 : : * @n_files must be greater than zero.
2490 : : *
2491 : : * @hint is simply passed through to the ::open signal. It is
2492 : : * intended to be used by applications that have multiple modes for
2493 : : * opening files (eg: "view" vs "edit", etc). Unless you have a need
2494 : : * for this functionality, you should use "".
2495 : : *
2496 : : * The application must be registered before calling this function
2497 : : * and it must have the %G_APPLICATION_HANDLES_OPEN flag set.
2498 : : *
2499 : : * Since: 2.28
2500 : : **/
2501 : : void
2502 : 0 : g_application_open (GApplication *application,
2503 : : GFile **files,
2504 : : gint n_files,
2505 : : const gchar *hint)
2506 : : {
2507 : 0 : g_return_if_fail (G_IS_APPLICATION (application));
2508 : 0 : g_return_if_fail (application->priv->flags &
2509 : : G_APPLICATION_HANDLES_OPEN);
2510 : 0 : g_return_if_fail (application->priv->is_registered);
2511 : :
2512 : 0 : if (application->priv->is_remote)
2513 : 0 : g_application_impl_open (application->priv->impl,
2514 : : files, n_files, hint,
2515 : : get_platform_data (application, NULL));
2516 : :
2517 : : else
2518 : : {
2519 : 0 : GVariant *platform_data = g_variant_ref_sink (get_platform_data (application, NULL));
2520 : :
2521 : 0 : G_APPLICATION_GET_CLASS (application)->before_emit (application, platform_data);
2522 : 0 : g_signal_emit (application, g_application_signals[SIGNAL_OPEN], 0, files, n_files, hint);
2523 : 0 : G_APPLICATION_GET_CLASS (application)->after_emit (application, platform_data);
2524 : 0 : g_variant_unref (platform_data);
2525 : : }
2526 : : }
2527 : :
2528 : : /* Run {{{1 */
2529 : : /**
2530 : : * g_application_run:
2531 : : * @application: a #GApplication
2532 : : * @argc: the argc from main() (or 0 if @argv is %NULL)
2533 : : * @argv: (array length=argc) (element-type filename) (nullable):
2534 : : * the argv from main(), or %NULL
2535 : : *
2536 : : * Runs the application.
2537 : : *
2538 : : * This function is intended to be run from main() and its return value
2539 : : * is intended to be returned by main(). Although you are expected to pass
2540 : : * the @argc, @argv parameters from main() to this function, it is possible
2541 : : * to pass %NULL if @argv is not available or commandline handling is not
2542 : : * required. Note that on Windows, @argc and @argv are ignored, and
2543 : : * g_win32_get_command_line() is called internally (for proper support
2544 : : * of Unicode commandline arguments).
2545 : : *
2546 : : * #GApplication will attempt to parse the commandline arguments. You
2547 : : * can add commandline flags to the list of recognised options by way of
2548 : : * g_application_add_main_option_entries(). After this, the
2549 : : * #GApplication::handle-local-options signal is emitted, from which the
2550 : : * application can inspect the values of its #GOptionEntrys.
2551 : : *
2552 : : * #GApplication::handle-local-options is a good place to handle options
2553 : : * such as `--version`, where an immediate reply from the local process is
2554 : : * desired (instead of communicating with an already-running instance).
2555 : : * A #GApplication::handle-local-options handler can stop further processing
2556 : : * by returning a non-negative value, which then becomes the exit status of
2557 : : * the process.
2558 : : *
2559 : : * What happens next depends on the flags: if
2560 : : * %G_APPLICATION_HANDLES_COMMAND_LINE was specified then the remaining
2561 : : * commandline arguments are sent to the primary instance, where a
2562 : : * #GApplication::command-line signal is emitted. Otherwise, the
2563 : : * remaining commandline arguments are assumed to be a list of files.
2564 : : * If there are no files listed, the application is activated via the
2565 : : * #GApplication::activate signal. If there are one or more files, and
2566 : : * %G_APPLICATION_HANDLES_OPEN was specified then the files are opened
2567 : : * via the #GApplication::open signal.
2568 : : *
2569 : : * If you are interested in doing more complicated local handling of the
2570 : : * commandline then you should implement your own #GApplication subclass
2571 : : * and override local_command_line(). In this case, you most likely want
2572 : : * to return %TRUE from your local_command_line() implementation to
2573 : : * suppress the default handling. See
2574 : : * [gapplication-example-cmdline2.c][https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline2.c]
2575 : : * for an example.
2576 : : *
2577 : : * If, after the above is done, the use count of the application is zero
2578 : : * then the exit status is returned immediately. If the use count is
2579 : : * non-zero then the default main context is iterated until the use count
2580 : : * falls to zero, at which point 0 is returned.
2581 : : *
2582 : : * If the %G_APPLICATION_IS_SERVICE flag is set, then the service will
2583 : : * run for as much as 10 seconds with a use count of zero while waiting
2584 : : * for the message that caused the activation to arrive. After that,
2585 : : * if the use count falls to zero the application will exit immediately,
2586 : : * except in the case that g_application_set_inactivity_timeout() is in
2587 : : * use.
2588 : : *
2589 : : * This function sets the prgname (g_set_prgname()), if not already set,
2590 : : * to the basename of argv[0].
2591 : : *
2592 : : * Much like g_main_loop_run(), this function will acquire the main context
2593 : : * for the duration that the application is running.
2594 : : *
2595 : : * Since 2.40, applications that are not explicitly flagged as services
2596 : : * or launchers (ie: neither %G_APPLICATION_IS_SERVICE or
2597 : : * %G_APPLICATION_IS_LAUNCHER are given as flags) will check (from the
2598 : : * default handler for local_command_line) if "--gapplication-service"
2599 : : * was given in the command line. If this flag is present then normal
2600 : : * commandline processing is interrupted and the
2601 : : * %G_APPLICATION_IS_SERVICE flag is set. This provides a "compromise"
2602 : : * solution whereby running an application directly from the commandline
2603 : : * will invoke it in the normal way (which can be useful for debugging)
2604 : : * while still allowing applications to be D-Bus activated in service
2605 : : * mode. The D-Bus service file should invoke the executable with
2606 : : * "--gapplication-service" as the sole commandline argument. This
2607 : : * approach is suitable for use by most graphical applications but
2608 : : * should not be used from applications like editors that need precise
2609 : : * control over when processes invoked via the commandline will exit and
2610 : : * what their exit status will be.
2611 : : *
2612 : : * Returns: the exit status
2613 : : *
2614 : : * Since: 2.28
2615 : : **/
2616 : : int
2617 : 45 : g_application_run (GApplication *application,
2618 : : int argc,
2619 : : char **argv)
2620 : : {
2621 : : gchar **arguments;
2622 : : int status;
2623 : : GMainContext *context;
2624 : : gboolean acquired_context;
2625 : :
2626 : 45 : g_return_val_if_fail (G_IS_APPLICATION (application), 1);
2627 : 45 : g_return_val_if_fail (argc == 0 || argv != NULL, 1);
2628 : 45 : g_return_val_if_fail (argc >= 0, 1);
2629 : 45 : g_return_val_if_fail (!application->priv->must_quit_now, 1);
2630 : :
2631 : : #ifdef G_OS_WIN32
2632 : : {
2633 : : gint new_argc = 0;
2634 : :
2635 : : arguments = g_win32_get_command_line ();
2636 : :
2637 : : /*
2638 : : * CommandLineToArgvW(), which is called by g_win32_get_command_line(),
2639 : : * pulls in the whole command line that is used to call the program. This is
2640 : : * fine in cases where the program is a .exe program, but in the cases where the
2641 : : * program is a called via a script, such as PyGObject's gtk-demo.py, which is normally
2642 : : * called using 'python gtk-demo.py' on Windows, the program name (argv[0])
2643 : : * returned by g_win32_get_command_line() will not be the argv[0] that ->local_command_line()
2644 : : * would expect, causing the program to fail with "This application can not open files."
2645 : : */
2646 : : new_argc = g_strv_length (arguments);
2647 : :
2648 : : if (new_argc > argc)
2649 : : {
2650 : : gint i;
2651 : :
2652 : : for (i = 0; i < new_argc - argc; i++)
2653 : : g_free (arguments[i]);
2654 : :
2655 : : memmove (&arguments[0],
2656 : : &arguments[new_argc - argc],
2657 : : sizeof (arguments[0]) * (argc + 1));
2658 : : }
2659 : : }
2660 : : #elif defined(__APPLE__)
2661 : : {
2662 : : gint i, j;
2663 : :
2664 : : /*
2665 : : * OSX adds an unexpected parameter on the format -psn_X_XXXXXX
2666 : : * when opening the application using Launch Services. In order
2667 : : * to avoid that GOption fails to parse this parameter we just
2668 : : * skip it if it was provided.
2669 : : * See: https://gitlab.gnome.org/GNOME/glib/issues/1784
2670 : : */
2671 : : arguments = g_new (gchar *, argc + 1);
2672 : : for (i = 0, j = 0; i < argc; i++)
2673 : : {
2674 : : if (!g_str_has_prefix (argv[i], "-psn_"))
2675 : : {
2676 : : arguments[j] = g_strdup (argv[i]);
2677 : : j++;
2678 : : }
2679 : : }
2680 : : arguments[j] = NULL;
2681 : : }
2682 : : #else
2683 : : {
2684 : : gint i;
2685 : :
2686 : 45 : arguments = g_new (gchar *, (unsigned int) argc + 1);
2687 : 74 : for (i = 0; i < argc; i++)
2688 : 58 : arguments[i] = g_strdup (argv[i]);
2689 : 45 : arguments[i] = NULL;
2690 : : }
2691 : : #endif
2692 : :
2693 : 45 : if (g_get_prgname () == NULL && argc > 0)
2694 : : {
2695 : : gchar *prgname;
2696 : :
2697 : 0 : prgname = g_path_get_basename (argv[0]);
2698 : 0 : GLIB_PRIVATE_CALL (g_set_prgname_once) (prgname);
2699 : 0 : g_free (prgname);
2700 : : }
2701 : :
2702 : 45 : context = g_main_context_default ();
2703 : 45 : acquired_context = g_main_context_acquire (context);
2704 : 45 : if (!acquired_context)
2705 : : {
2706 : 0 : g_critical ("g_application_run() cannot acquire the default main context because it is already acquired by another thread!");
2707 : 0 : g_strfreev (arguments);
2708 : 0 : return 1;
2709 : : }
2710 : :
2711 : 44 : if (!G_APPLICATION_GET_CLASS (application)
2712 : 45 : ->local_command_line (application, &arguments, &status))
2713 : : {
2714 : 1 : GError *error = NULL;
2715 : :
2716 : 1 : if (!g_application_register (application, NULL, &error))
2717 : : {
2718 : 0 : g_printerr ("Failed to register: %s\n", error->message);
2719 : 0 : g_error_free (error);
2720 : 0 : return 1;
2721 : : }
2722 : :
2723 : 1 : g_application_call_command_line (application, (const gchar **) arguments, NULL, &status);
2724 : : }
2725 : :
2726 : 44 : g_strfreev (arguments);
2727 : :
2728 : 44 : if (application->priv->flags & G_APPLICATION_IS_SERVICE &&
2729 : 0 : application->priv->is_registered &&
2730 : 0 : !application->priv->use_count &&
2731 : 0 : !application->priv->inactivity_timeout_id)
2732 : : {
2733 : 0 : application->priv->inactivity_timeout_id =
2734 : 0 : g_timeout_add (10000, inactivity_timeout_expired, application);
2735 : : }
2736 : :
2737 : 178 : while (application->priv->use_count || application->priv->inactivity_timeout_id)
2738 : : {
2739 : 137 : if (application->priv->must_quit_now)
2740 : 3 : break;
2741 : :
2742 : 134 : g_main_context_iteration (context, TRUE);
2743 : 134 : status = 0;
2744 : : }
2745 : :
2746 : 44 : if (application->priv->is_registered && !application->priv->is_remote)
2747 : : {
2748 : 39 : g_signal_emit (application, g_application_signals[SIGNAL_SHUTDOWN], 0);
2749 : :
2750 : 39 : if (!application->priv->did_shutdown)
2751 : 0 : g_critical ("GApplication subclass '%s' failed to chain up on"
2752 : : " ::shutdown (from end of override function)",
2753 : : G_OBJECT_TYPE_NAME (application));
2754 : : }
2755 : :
2756 : 44 : if (application->priv->impl)
2757 : : {
2758 : 40 : if (application->priv->is_registered)
2759 : : {
2760 : 40 : application->priv->is_registered = FALSE;
2761 : :
2762 : 40 : g_object_notify (G_OBJECT (application), "is-registered");
2763 : : }
2764 : :
2765 : 40 : g_application_impl_flush (application->priv->impl);
2766 : 40 : g_application_impl_destroy (application->priv->impl);
2767 : 40 : application->priv->impl = NULL;
2768 : : }
2769 : :
2770 : 44 : g_settings_sync ();
2771 : :
2772 : 44 : if (!application->priv->must_quit_now)
2773 : 75 : while (g_main_context_iteration (context, FALSE))
2774 : : ;
2775 : :
2776 : 44 : g_main_context_release (context);
2777 : :
2778 : 44 : return status;
2779 : : }
2780 : :
2781 : : static gchar **
2782 : 3 : g_application_list_actions (GActionGroup *action_group)
2783 : : {
2784 : 3 : GApplication *application = G_APPLICATION (action_group);
2785 : :
2786 : 3 : g_return_val_if_fail (application->priv->is_registered, NULL);
2787 : :
2788 : 3 : if (application->priv->remote_actions != NULL)
2789 : 0 : return g_action_group_list_actions (G_ACTION_GROUP (application->priv->remote_actions));
2790 : :
2791 : 3 : else if (application->priv->actions != NULL)
2792 : 3 : return g_action_group_list_actions (application->priv->actions);
2793 : :
2794 : : else
2795 : : /* empty string array */
2796 : 0 : return g_new0 (gchar *, 1);
2797 : : }
2798 : :
2799 : : static gboolean
2800 : 8 : g_application_query_action (GActionGroup *group,
2801 : : const gchar *action_name,
2802 : : gboolean *enabled,
2803 : : const GVariantType **parameter_type,
2804 : : const GVariantType **state_type,
2805 : : GVariant **state_hint,
2806 : : GVariant **state)
2807 : : {
2808 : 8 : GApplication *application = G_APPLICATION (group);
2809 : :
2810 : 8 : g_return_val_if_fail (application->priv->is_registered, FALSE);
2811 : :
2812 : 8 : if (application->priv->remote_actions != NULL)
2813 : 0 : return g_action_group_query_action (G_ACTION_GROUP (application->priv->remote_actions),
2814 : : action_name,
2815 : : enabled,
2816 : : parameter_type,
2817 : : state_type,
2818 : : state_hint,
2819 : : state);
2820 : :
2821 : 8 : if (application->priv->actions != NULL)
2822 : 8 : return g_action_group_query_action (application->priv->actions,
2823 : : action_name,
2824 : : enabled,
2825 : : parameter_type,
2826 : : state_type,
2827 : : state_hint,
2828 : : state);
2829 : :
2830 : 0 : return FALSE;
2831 : : }
2832 : :
2833 : : static void
2834 : 1 : g_application_change_action_state (GActionGroup *action_group,
2835 : : const gchar *action_name,
2836 : : GVariant *value)
2837 : : {
2838 : 1 : GApplication *application = G_APPLICATION (action_group);
2839 : :
2840 : 1 : g_return_if_fail (application->priv->is_remote ||
2841 : : application->priv->actions != NULL);
2842 : 1 : g_return_if_fail (application->priv->is_registered);
2843 : :
2844 : 1 : if (application->priv->remote_actions)
2845 : 0 : g_remote_action_group_change_action_state_full (application->priv->remote_actions,
2846 : : action_name, value, get_platform_data (application, NULL));
2847 : :
2848 : : else
2849 : 1 : g_action_group_change_action_state (application->priv->actions, action_name, value);
2850 : : }
2851 : :
2852 : : static void
2853 : 3 : g_application_activate_action (GActionGroup *action_group,
2854 : : const gchar *action_name,
2855 : : GVariant *parameter)
2856 : : {
2857 : 3 : GApplication *application = G_APPLICATION (action_group);
2858 : :
2859 : 3 : g_return_if_fail (application->priv->is_remote ||
2860 : : application->priv->actions != NULL);
2861 : 3 : g_return_if_fail (application->priv->is_registered);
2862 : :
2863 : 3 : if (application->priv->remote_actions)
2864 : 0 : g_remote_action_group_activate_action_full (application->priv->remote_actions,
2865 : : action_name, parameter, get_platform_data (application, NULL));
2866 : :
2867 : : else
2868 : 3 : g_action_group_activate_action (application->priv->actions, action_name, parameter);
2869 : : }
2870 : :
2871 : : static GAction *
2872 : 1 : g_application_lookup_action (GActionMap *action_map,
2873 : : const gchar *action_name)
2874 : : {
2875 : 1 : GApplication *application = G_APPLICATION (action_map);
2876 : :
2877 : 1 : g_return_val_if_fail (G_IS_ACTION_MAP (application->priv->actions), NULL);
2878 : :
2879 : 1 : return g_action_map_lookup_action (G_ACTION_MAP (application->priv->actions), action_name);
2880 : : }
2881 : :
2882 : : static void
2883 : 56 : g_application_add_action (GActionMap *action_map,
2884 : : GAction *action)
2885 : : {
2886 : 56 : GApplication *application = G_APPLICATION (action_map);
2887 : :
2888 : 56 : g_return_if_fail (G_IS_ACTION_MAP (application->priv->actions));
2889 : :
2890 : 56 : g_action_map_add_action (G_ACTION_MAP (application->priv->actions), action);
2891 : : }
2892 : :
2893 : : static void
2894 : 1 : g_application_remove_action (GActionMap *action_map,
2895 : : const gchar *action_name)
2896 : : {
2897 : 1 : GApplication *application = G_APPLICATION (action_map);
2898 : :
2899 : 1 : g_return_if_fail (G_IS_ACTION_MAP (application->priv->actions));
2900 : :
2901 : 1 : g_action_map_remove_action (G_ACTION_MAP (application->priv->actions), action_name);
2902 : : }
2903 : :
2904 : : static void
2905 : 13 : g_application_action_group_iface_init (GActionGroupInterface *iface)
2906 : : {
2907 : 13 : iface->list_actions = g_application_list_actions;
2908 : 13 : iface->query_action = g_application_query_action;
2909 : 13 : iface->change_action_state = g_application_change_action_state;
2910 : 13 : iface->activate_action = g_application_activate_action;
2911 : 13 : }
2912 : :
2913 : : static void
2914 : 13 : g_application_action_map_iface_init (GActionMapInterface *iface)
2915 : : {
2916 : 13 : iface->lookup_action = g_application_lookup_action;
2917 : 13 : iface->add_action = g_application_add_action;
2918 : 13 : iface->remove_action = g_application_remove_action;
2919 : 13 : }
2920 : :
2921 : : /* Default Application {{{1 */
2922 : :
2923 : : static GApplication *default_app;
2924 : :
2925 : : /**
2926 : : * g_application_get_default:
2927 : : *
2928 : : * Returns the default #GApplication instance for this process.
2929 : : *
2930 : : * Normally there is only one #GApplication per process and it becomes
2931 : : * the default when it is created. You can exercise more control over
2932 : : * this by using g_application_set_default().
2933 : : *
2934 : : * If there is no default application then %NULL is returned.
2935 : : *
2936 : : * Returns: (nullable) (transfer none): the default application for this process, or %NULL
2937 : : *
2938 : : * Since: 2.32
2939 : : **/
2940 : : GApplication *
2941 : 111 : g_application_get_default (void)
2942 : : {
2943 : 111 : return default_app;
2944 : : }
2945 : :
2946 : : /**
2947 : : * g_application_set_default:
2948 : : * @application: (nullable): the application to set as default, or %NULL
2949 : : *
2950 : : * Sets or unsets the default application for the process, as returned
2951 : : * by g_application_get_default().
2952 : : *
2953 : : * This function does not take its own reference on @application. If
2954 : : * @application is destroyed then the default application will revert
2955 : : * back to %NULL.
2956 : : *
2957 : : * Since: 2.32
2958 : : **/
2959 : : void
2960 : 111 : g_application_set_default (GApplication *application)
2961 : : {
2962 : 111 : default_app = application;
2963 : 111 : }
2964 : :
2965 : : /**
2966 : : * g_application_quit:
2967 : : * @application: a #GApplication
2968 : : *
2969 : : * Immediately quits the application.
2970 : : *
2971 : : * Upon return to the mainloop, g_application_run() will return,
2972 : : * calling only the 'shutdown' function before doing so.
2973 : : *
2974 : : * The hold count is ignored.
2975 : : * Take care if your code has called g_application_hold() on the application and
2976 : : * is therefore still expecting it to exist.
2977 : : * (Note that you may have called g_application_hold() indirectly, for example
2978 : : * through gtk_application_add_window().)
2979 : : *
2980 : : * The result of calling g_application_run() again after it returns is
2981 : : * unspecified.
2982 : : *
2983 : : * Since: 2.32
2984 : : **/
2985 : : void
2986 : 6 : g_application_quit (GApplication *application)
2987 : : {
2988 : 6 : g_return_if_fail (G_IS_APPLICATION (application));
2989 : :
2990 : 6 : application->priv->must_quit_now = TRUE;
2991 : : }
2992 : :
2993 : : /**
2994 : : * g_application_mark_busy:
2995 : : * @application: a #GApplication
2996 : : *
2997 : : * Increases the busy count of @application.
2998 : : *
2999 : : * Use this function to indicate that the application is busy, for instance
3000 : : * while a long running operation is pending.
3001 : : *
3002 : : * The busy state will be exposed to other processes, so a session shell will
3003 : : * use that information to indicate the state to the user (e.g. with a
3004 : : * spinner).
3005 : : *
3006 : : * To cancel the busy indication, use g_application_unmark_busy().
3007 : : *
3008 : : * The application must be registered before calling this function.
3009 : : *
3010 : : * Since: 2.38
3011 : : **/
3012 : : void
3013 : 6 : g_application_mark_busy (GApplication *application)
3014 : : {
3015 : : gboolean was_busy;
3016 : :
3017 : 6 : g_return_if_fail (G_IS_APPLICATION (application));
3018 : 6 : g_return_if_fail (application->priv->is_registered);
3019 : :
3020 : 6 : was_busy = (application->priv->busy_count > 0);
3021 : 6 : application->priv->busy_count++;
3022 : :
3023 : 6 : if (!was_busy)
3024 : : {
3025 : 4 : g_application_impl_set_busy_state (application->priv->impl, TRUE);
3026 : 4 : g_object_notify (G_OBJECT (application), "is-busy");
3027 : : }
3028 : : }
3029 : :
3030 : : /**
3031 : : * g_application_unmark_busy:
3032 : : * @application: a #GApplication
3033 : : *
3034 : : * Decreases the busy count of @application.
3035 : : *
3036 : : * When the busy count reaches zero, the new state will be propagated
3037 : : * to other processes.
3038 : : *
3039 : : * This function must only be called to cancel the effect of a previous
3040 : : * call to g_application_mark_busy().
3041 : : *
3042 : : * Since: 2.38
3043 : : **/
3044 : : void
3045 : 6 : g_application_unmark_busy (GApplication *application)
3046 : : {
3047 : 6 : g_return_if_fail (G_IS_APPLICATION (application));
3048 : 6 : g_return_if_fail (application->priv->busy_count > 0);
3049 : :
3050 : 6 : application->priv->busy_count--;
3051 : :
3052 : 6 : if (application->priv->busy_count == 0)
3053 : : {
3054 : 4 : g_application_impl_set_busy_state (application->priv->impl, FALSE);
3055 : 4 : g_object_notify (G_OBJECT (application), "is-busy");
3056 : : }
3057 : : }
3058 : :
3059 : : /**
3060 : : * g_application_get_is_busy:
3061 : : * @application: a #GApplication
3062 : : *
3063 : : * Gets the application's current busy state, as set through
3064 : : * g_application_mark_busy() or g_application_bind_busy_property().
3065 : : *
3066 : : * Returns: %TRUE if @application is currently marked as busy
3067 : : *
3068 : : * Since: 2.44
3069 : : */
3070 : : gboolean
3071 : 14 : g_application_get_is_busy (GApplication *application)
3072 : : {
3073 : 14 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
3074 : :
3075 : 14 : return application->priv->busy_count > 0;
3076 : : }
3077 : :
3078 : : /* Notifications {{{1 */
3079 : :
3080 : : /**
3081 : : * g_application_send_notification:
3082 : : * @application: a #GApplication
3083 : : * @id: (nullable): id of the notification, or %NULL
3084 : : * @notification: the #GNotification to send
3085 : : *
3086 : : * Sends a notification on behalf of @application to the desktop shell.
3087 : : * There is no guarantee that the notification is displayed immediately,
3088 : : * or even at all.
3089 : : *
3090 : : * Notifications may persist after the application exits. It will be
3091 : : * D-Bus-activated when the notification or one of its actions is
3092 : : * activated.
3093 : : *
3094 : : * Modifying @notification after this call has no effect. However, the
3095 : : * object can be reused for a later call to this function.
3096 : : *
3097 : : * @id may be any string that uniquely identifies the event for the
3098 : : * application. It does not need to be in any special format. For
3099 : : * example, "new-message" might be appropriate for a notification about
3100 : : * new messages.
3101 : : *
3102 : : * If a previous notification was sent with the same @id, it will be
3103 : : * replaced with @notification and shown again as if it was a new
3104 : : * notification. This works even for notifications sent from a previous
3105 : : * execution of the application, as long as @id is the same string.
3106 : : *
3107 : : * @id may be `NULL`, but it is impossible to replace or withdraw
3108 : : * notifications without an id.
3109 : : *
3110 : : * If @notification is no longer relevant, it can be withdrawn with
3111 : : * [method@Gio.Application.withdraw_notification].
3112 : : *
3113 : : * It is an error to call this function if @application has no
3114 : : * application ID.
3115 : : *
3116 : : * Since: 2.40
3117 : : */
3118 : : void
3119 : 5 : g_application_send_notification (GApplication *application,
3120 : : const gchar *id,
3121 : : GNotification *notification)
3122 : : {
3123 : 5 : gchar *generated_id = NULL;
3124 : :
3125 : 5 : g_return_if_fail (G_IS_APPLICATION (application));
3126 : 5 : g_return_if_fail (G_IS_NOTIFICATION (notification));
3127 : 5 : g_return_if_fail (g_application_get_is_registered (application));
3128 : 5 : g_return_if_fail (!g_application_get_is_remote (application));
3129 : 5 : g_return_if_fail (g_application_get_application_id (application) != NULL);
3130 : :
3131 : 5 : if (application->priv->notifications == NULL)
3132 : 1 : application->priv->notifications = g_notification_backend_new_default (application);
3133 : :
3134 : 5 : if (id == NULL)
3135 : : {
3136 : 1 : generated_id = g_dbus_generate_guid ();
3137 : 1 : id = generated_id;
3138 : : }
3139 : :
3140 : 5 : g_notification_backend_send_notification (application->priv->notifications, id, notification);
3141 : :
3142 : 5 : g_free (generated_id);
3143 : : }
3144 : :
3145 : : /**
3146 : : * g_application_withdraw_notification:
3147 : : * @application: a #GApplication
3148 : : * @id: id of a previously sent notification
3149 : : *
3150 : : * Withdraws a notification that was sent with
3151 : : * g_application_send_notification().
3152 : : *
3153 : : * This call does nothing if a notification with @id doesn't exist or
3154 : : * the notification was never sent.
3155 : : *
3156 : : * This function works even for notifications sent in previous
3157 : : * executions of this application, as long @id is the same as it was for
3158 : : * the sent notification.
3159 : : *
3160 : : * Note that notifications are dismissed when the user clicks on one
3161 : : * of the buttons in a notification or triggers its default action, so
3162 : : * there is no need to explicitly withdraw the notification in that case.
3163 : : *
3164 : : * Since: 2.40
3165 : : */
3166 : : void
3167 : 3 : g_application_withdraw_notification (GApplication *application,
3168 : : const gchar *id)
3169 : : {
3170 : 3 : g_return_if_fail (G_IS_APPLICATION (application));
3171 : 3 : g_return_if_fail (id != NULL);
3172 : :
3173 : 3 : if (application->priv->notifications == NULL)
3174 : 2 : application->priv->notifications = g_notification_backend_new_default (application);
3175 : :
3176 : 3 : g_notification_backend_withdraw_notification (application->priv->notifications, id);
3177 : : }
3178 : :
3179 : : /* Busy binding {{{1 */
3180 : :
3181 : : typedef struct
3182 : : {
3183 : : GApplication *app;
3184 : : gboolean is_busy;
3185 : : } GApplicationBusyBinding;
3186 : :
3187 : : static void
3188 : 2 : g_application_busy_binding_destroy (gpointer data,
3189 : : GClosure *closure)
3190 : : {
3191 : 2 : GApplicationBusyBinding *binding = data;
3192 : :
3193 : 2 : if (binding->is_busy)
3194 : 2 : g_application_unmark_busy (binding->app);
3195 : :
3196 : 2 : g_object_unref (binding->app);
3197 : 2 : g_slice_free (GApplicationBusyBinding, binding);
3198 : 2 : }
3199 : :
3200 : : static void
3201 : 4 : g_application_notify_busy_binding (GObject *object,
3202 : : GParamSpec *pspec,
3203 : : gpointer user_data)
3204 : : {
3205 : 4 : GApplicationBusyBinding *binding = user_data;
3206 : : gboolean is_busy;
3207 : :
3208 : 4 : g_object_get (object, pspec->name, &is_busy, NULL);
3209 : :
3210 : 4 : if (is_busy && !binding->is_busy)
3211 : 3 : g_application_mark_busy (binding->app);
3212 : 1 : else if (!is_busy && binding->is_busy)
3213 : 1 : g_application_unmark_busy (binding->app);
3214 : :
3215 : 4 : binding->is_busy = is_busy;
3216 : 4 : }
3217 : :
3218 : : /**
3219 : : * g_application_bind_busy_property:
3220 : : * @application: a #GApplication
3221 : : * @object: (type GObject.Object): a #GObject
3222 : : * @property: the name of a boolean property of @object
3223 : : *
3224 : : * Marks @application as busy (see g_application_mark_busy()) while
3225 : : * @property on @object is %TRUE.
3226 : : *
3227 : : * The binding holds a reference to @application while it is active, but
3228 : : * not to @object. Instead, the binding is destroyed when @object is
3229 : : * finalized.
3230 : : *
3231 : : * Since: 2.44
3232 : : */
3233 : : void
3234 : 2 : g_application_bind_busy_property (GApplication *application,
3235 : : gpointer object,
3236 : : const gchar *property)
3237 : : {
3238 : : guint notify_id;
3239 : : GQuark property_quark;
3240 : : GParamSpec *pspec;
3241 : : GApplicationBusyBinding *binding;
3242 : : GClosure *closure;
3243 : :
3244 : 2 : g_return_if_fail (G_IS_APPLICATION (application));
3245 : 2 : g_return_if_fail (G_IS_OBJECT (object));
3246 : 2 : g_return_if_fail (property != NULL);
3247 : :
3248 : 2 : notify_id = g_signal_lookup ("notify", G_TYPE_OBJECT);
3249 : 2 : property_quark = g_quark_from_string (property);
3250 : 2 : pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (object), property);
3251 : :
3252 : 2 : g_return_if_fail (pspec != NULL && pspec->value_type == G_TYPE_BOOLEAN);
3253 : :
3254 : 2 : if (g_signal_handler_find (object, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC,
3255 : : notify_id, property_quark, NULL, g_application_notify_busy_binding, NULL) > 0)
3256 : : {
3257 : 0 : g_critical ("%s: '%s' is already bound to the busy state of the application", G_STRFUNC, property);
3258 : 0 : return;
3259 : : }
3260 : :
3261 : 2 : binding = g_slice_new (GApplicationBusyBinding);
3262 : 2 : binding->app = g_object_ref (application);
3263 : 2 : binding->is_busy = FALSE;
3264 : :
3265 : 2 : closure = g_cclosure_new (G_CALLBACK (g_application_notify_busy_binding), binding,
3266 : : g_application_busy_binding_destroy);
3267 : 2 : g_signal_connect_closure_by_id (object, notify_id, property_quark, closure, FALSE);
3268 : :
3269 : : /* fetch the initial value */
3270 : 2 : g_application_notify_busy_binding (object, pspec, binding);
3271 : : }
3272 : :
3273 : : /**
3274 : : * g_application_unbind_busy_property:
3275 : : * @application: a #GApplication
3276 : : * @object: (type GObject.Object): a #GObject
3277 : : * @property: the name of a boolean property of @object
3278 : : *
3279 : : * Destroys a binding between @property and the busy state of
3280 : : * @application that was previously created with
3281 : : * g_application_bind_busy_property().
3282 : : *
3283 : : * Since: 2.44
3284 : : */
3285 : : void
3286 : 1 : g_application_unbind_busy_property (GApplication *application,
3287 : : gpointer object,
3288 : : const gchar *property)
3289 : : {
3290 : : guint notify_id;
3291 : : GQuark property_quark;
3292 : : gulong handler_id;
3293 : :
3294 : 1 : g_return_if_fail (G_IS_APPLICATION (application));
3295 : 1 : g_return_if_fail (G_IS_OBJECT (object));
3296 : 1 : g_return_if_fail (property != NULL);
3297 : :
3298 : 1 : notify_id = g_signal_lookup ("notify", G_TYPE_OBJECT);
3299 : 1 : property_quark = g_quark_from_string (property);
3300 : :
3301 : 1 : handler_id = g_signal_handler_find (object, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC,
3302 : : notify_id, property_quark, NULL, g_application_notify_busy_binding, NULL);
3303 : 1 : if (handler_id == 0)
3304 : : {
3305 : 0 : g_critical ("%s: '%s' is not bound to the busy state of the application", G_STRFUNC, property);
3306 : 0 : return;
3307 : : }
3308 : :
3309 : 1 : g_signal_handler_disconnect (object, handler_id);
3310 : : }
3311 : :
3312 : : /* Epilogue {{{1 */
3313 : : /* vim:set foldmethod=marker: */
|
