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 funcion, 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
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
198 : : * @add_platform_data: invoked (locally) to add 'platform data' to be sent to
199 : : * the primary instance when activating, opening or invoking actions
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 [ + + + - : 1149 : 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 [ + + + - : 71 : 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 : 47 : g_application_exported_actions_init (GApplicationExportedActions *actions)
360 : : {
361 : 47 : }
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 : 47 : g_application_exported_actions_new (GApplication *application)
377 : : {
378 : : GApplicationExportedActions *actions;
379 : :
380 : 47 : actions = g_object_new (g_application_exported_actions_get_type (), NULL);
381 : 47 : actions->application = application;
382 : :
383 : 47 : 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)
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 : 35 : g_application_parse_command_line (GApplication *application,
482 : : gchar ***arguments,
483 : : gboolean *print_version,
484 : : GError **error)
485 : : {
486 : 35 : gboolean become_service = FALSE;
487 : 35 : gchar *app_id = NULL;
488 : 35 : gboolean replace = FALSE;
489 : 35 : gboolean version = FALSE;
490 : 35 : 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 : 35 : g_return_val_if_fail (!application->priv->options_parsed, NULL);
501 : :
502 : 35 : context = g_option_context_new (application->priv->parameter_string);
503 : 35 : g_option_context_set_summary (context, application->priv->summary);
504 : 35 : g_option_context_set_description (context, application->priv->description);
505 : :
506 : 35 : gapplication_group = g_option_group_new ("gapplication",
507 : : _("GApplication Options:"), _("Show GApplication options"),
508 : : NULL, NULL);
509 : 35 : g_option_group_set_translation_domain (gapplication_group, GETTEXT_PACKAGE);
510 : 35 : 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 [ + + + + ]: 35 : 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 [ + + ]: 35 : 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 [ - + ]: 35 : 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 [ + - ]: 35 : if ((application->priv->flags & (G_APPLICATION_IS_SERVICE | G_APPLICATION_IS_LAUNCHER)) == 0)
549 : : {
550 : 35 : 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 : 35 : g_option_group_add_entries (gapplication_group, entries);
557 : : }
558 : :
559 : : /* Allow overriding the ID if the application allows it */
560 [ - + ]: 35 : 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 [ - + ]: 35 : 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 [ + + ]: 35 : 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 [ - + ]: 35 : if (!g_option_context_parse_strv (context, arguments, error))
596 : 0 : goto out;
597 : :
598 : 34 : *print_version = version;
599 : :
600 : : /* Check for --gapplication-service */
601 [ - + ]: 34 : if (become_service)
602 : 0 : application->priv->flags |= G_APPLICATION_IS_SERVICE;
603 : :
604 : : /* Check for --gapplication-app-id */
605 [ - + ]: 34 : if (app_id)
606 : 0 : g_application_set_application_id (application, app_id);
607 : :
608 : : /* Check for --gapplication-replace */
609 [ + + ]: 34 : if (replace)
610 : 2 : application->priv->flags |= G_APPLICATION_REPLACE;
611 : :
612 : 34 : dict = g_variant_dict_new (NULL);
613 [ + + ]: 34 : 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 : 31 : out:
621 : : /* Make sure we don't run again */
622 : 34 : application->priv->options_parsed = TRUE;
623 : :
624 : 34 : g_option_context_free (context);
625 : 34 : g_free (app_id);
626 : :
627 : 34 : 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 unrecognised options will be
713 : : * treated as errors. Unrecognised 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 unrecognised 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 : 16 : g_application_real_before_emit (GApplication *application,
943 : : GVariant *platform_data)
944 : : {
945 : 16 : }
946 : :
947 : : static void
948 : 24 : g_application_real_after_emit (GApplication *application,
949 : : GVariant *platform_data)
950 : : {
951 : 24 : }
952 : :
953 : : static void
954 : 35 : g_application_real_startup (GApplication *application)
955 : : {
956 : 35 : application->priv->did_startup = TRUE;
957 : 35 : }
958 : :
959 : : static void
960 : 30 : g_application_real_shutdown (GApplication *application)
961 : : {
962 : 30 : application->priv->did_shutdown = TRUE;
963 : 30 : }
964 : :
965 : : static void
966 : 28 : g_application_real_activate (GApplication *application)
967 : : {
968 [ - + ]: 28 : 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 : 6 : g_application_real_open (GApplication *application,
987 : : GFile **files,
988 : : gint n_files,
989 : : const gchar *hint)
990 : : {
991 [ - + ]: 6 : 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 : 31 : g_application_real_handle_local_options (GApplication *application,
1034 : : GVariantDict *options)
1035 : : {
1036 : 31 : return -1;
1037 : : }
1038 : :
1039 : : static GVariant *
1040 : 1 : get_platform_data (GApplication *application,
1041 : : GVariant *options)
1042 : : {
1043 : : GVariantBuilder *builder;
1044 : : GVariant *result;
1045 : :
1046 : 1 : builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
1047 : :
1048 : : {
1049 : 1 : gchar *cwd = g_get_current_dir ();
1050 : 1 : g_variant_builder_add (builder, "{sv}", "cwd",
1051 : : g_variant_new_bytestring (cwd));
1052 : 1 : g_free (cwd);
1053 : : }
1054 : :
1055 [ - + ]: 1 : 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 [ - + ]: 1 : if (options)
1068 : 0 : g_variant_builder_add (builder, "{sv}", "options", options);
1069 : :
1070 : 1 : G_APPLICATION_GET_CLASS (application)->
1071 : : add_platform_data (application, builder);
1072 : :
1073 : 1 : result = g_variant_builder_end (builder);
1074 : 1 : g_variant_builder_unref (builder);
1075 : :
1076 : 1 : return result;
1077 : : }
1078 : :
1079 : : static void
1080 : 5 : g_application_call_command_line (GApplication *application,
1081 : : const gchar * const *arguments,
1082 : : GVariant *options,
1083 : : gint *exit_status)
1084 : : {
1085 [ - + ]: 5 : 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 : :
1098 : 5 : v = g_variant_new_bytestring_array ((const gchar **) arguments, -1);
1099 : 5 : cmdline = g_object_new (G_TYPE_APPLICATION_COMMAND_LINE,
1100 : : "arguments", v,
1101 : : "options", options,
1102 : : NULL);
1103 : 5 : g_signal_emit (application, g_application_signals[SIGNAL_COMMAND_LINE], 0, cmdline, &handler_exit_status);
1104 : :
1105 : : /* For consistency with remote invocations */
1106 : 5 : g_application_command_line_set_exit_status (cmdline, handler_exit_status);
1107 : 5 : *exit_status = g_application_command_line_get_exit_status (cmdline);
1108 : :
1109 : 5 : g_object_unref (cmdline);
1110 : : }
1111 : 5 : }
1112 : :
1113 : : static gboolean
1114 : 35 : g_application_real_local_command_line (GApplication *application,
1115 : : gchar ***arguments,
1116 : : int *exit_status)
1117 : : {
1118 : 35 : GError *error = NULL;
1119 : : GVariantDict *options;
1120 : : gint n_args;
1121 : 35 : gboolean print_version = FALSE;
1122 : :
1123 : 35 : options = g_application_parse_command_line (application, arguments, &print_version, &error);
1124 [ - + ]: 34 : if (!options)
1125 : : {
1126 : 0 : g_printerr ("%s\n", error->message);
1127 : 0 : g_error_free (error);
1128 : 0 : *exit_status = 1;
1129 : 0 : return TRUE;
1130 : : }
1131 : :
1132 : : /* Exit quickly with --version? */
1133 [ - + ]: 34 : if (print_version)
1134 : : {
1135 : 0 : const char *prgname = g_get_prgname ();
1136 : :
1137 : 0 : g_assert (application->priv->version != NULL);
1138 : :
1139 [ # # ]: 0 : if (prgname != NULL)
1140 : 0 : g_print ("%s %s\n", prgname, application->priv->version);
1141 : : else
1142 : 0 : g_print ("%s\n", application->priv->version);
1143 : 0 : *exit_status = EXIT_SUCCESS;
1144 : 0 : return TRUE;
1145 : : }
1146 : :
1147 : 34 : g_signal_emit (application, g_application_signals[SIGNAL_HANDLE_LOCAL_OPTIONS], 0, options, exit_status);
1148 : :
1149 [ + + ]: 34 : if (*exit_status >= 0)
1150 : : {
1151 : 3 : g_variant_dict_unref (options);
1152 : 3 : return TRUE;
1153 : : }
1154 : :
1155 [ - + ]: 31 : if (!g_application_register (application, NULL, &error))
1156 : : {
1157 : 0 : g_printerr ("Failed to register: %s\n", error->message);
1158 : 0 : g_variant_dict_unref (options);
1159 : 0 : g_error_free (error);
1160 : 0 : *exit_status = 1;
1161 : 0 : return TRUE;
1162 : : }
1163 : :
1164 : 31 : n_args = g_strv_length (*arguments);
1165 : :
1166 [ - + ]: 31 : if (application->priv->flags & G_APPLICATION_IS_SERVICE)
1167 : : {
1168 [ # # ]: 0 : if ((*exit_status = n_args > 1))
1169 : : {
1170 : 0 : g_printerr ("GApplication service mode takes no arguments.\n");
1171 : 0 : application->priv->flags &= ~G_APPLICATION_IS_SERVICE;
1172 : 0 : *exit_status = 1;
1173 : : }
1174 : : else
1175 : 0 : *exit_status = 0;
1176 : : }
1177 [ + + ]: 31 : else if (application->priv->flags & G_APPLICATION_HANDLES_COMMAND_LINE)
1178 : : {
1179 : 5 : g_application_call_command_line (application,
1180 : : (const gchar **) *arguments,
1181 : : g_variant_dict_end (options),
1182 : : exit_status);
1183 : : }
1184 : : else
1185 : : {
1186 [ + - ]: 26 : if (n_args <= 1)
1187 : : {
1188 : 26 : g_application_activate (application);
1189 : 26 : *exit_status = 0;
1190 : : }
1191 : :
1192 : : else
1193 : : {
1194 [ # # ]: 0 : if (~application->priv->flags & G_APPLICATION_HANDLES_OPEN)
1195 : : {
1196 : 0 : g_critical ("This application can not open files.");
1197 : 0 : *exit_status = 1;
1198 : : }
1199 : : else
1200 : : {
1201 : : GFile **files;
1202 : : gint n_files;
1203 : : gint i;
1204 : :
1205 : 0 : n_files = n_args - 1;
1206 : 0 : files = g_new (GFile *, n_files);
1207 : :
1208 [ # # ]: 0 : for (i = 0; i < n_files; i++)
1209 : 0 : files[i] = g_file_new_for_commandline_arg ((*arguments)[i + 1]);
1210 : :
1211 : 0 : g_application_open (application, files, n_files, "");
1212 : :
1213 [ # # ]: 0 : for (i = 0; i < n_files; i++)
1214 : 0 : g_object_unref (files[i]);
1215 : 0 : g_free (files);
1216 : :
1217 : 0 : *exit_status = 0;
1218 : : }
1219 : : }
1220 : : }
1221 : :
1222 : 31 : g_variant_dict_unref (options);
1223 : :
1224 : 31 : return TRUE;
1225 : : }
1226 : :
1227 : : static void
1228 : 1 : g_application_real_add_platform_data (GApplication *application,
1229 : : GVariantBuilder *builder)
1230 : : {
1231 : 1 : }
1232 : :
1233 : : static gboolean
1234 : 30 : g_application_real_dbus_register (GApplication *application,
1235 : : GDBusConnection *connection,
1236 : : const gchar *object_path,
1237 : : GError **error)
1238 : : {
1239 : 30 : return TRUE;
1240 : : }
1241 : :
1242 : : static void
1243 : 30 : g_application_real_dbus_unregister (GApplication *application,
1244 : : GDBusConnection *connection,
1245 : : const gchar *object_path)
1246 : : {
1247 : 30 : }
1248 : :
1249 : : static gboolean
1250 : 0 : g_application_real_name_lost (GApplication *application)
1251 : : {
1252 : 0 : g_application_quit (application);
1253 : 0 : return TRUE;
1254 : : }
1255 : :
1256 : : /* GObject implementation stuff {{{1 */
1257 : : static void
1258 : 101 : g_application_set_property (GObject *object,
1259 : : guint prop_id,
1260 : : const GValue *value,
1261 : : GParamSpec *pspec)
1262 : : {
1263 : 101 : GApplication *application = G_APPLICATION (object);
1264 : :
1265 [ + + + + : 101 : switch (prop_id)
+ - - ]
1266 : : {
1267 : 49 : case PROP_APPLICATION_ID:
1268 : 49 : g_application_set_application_id (application,
1269 : : g_value_get_string (value));
1270 : 49 : break;
1271 : :
1272 : 4 : case PROP_VERSION:
1273 : 4 : g_application_set_version (application, g_value_get_string (value));
1274 : 4 : break;
1275 : :
1276 : 43 : case PROP_FLAGS:
1277 : 43 : g_application_set_flags (application, g_value_get_flags (value));
1278 : 43 : break;
1279 : :
1280 : 2 : case PROP_RESOURCE_BASE_PATH:
1281 : 2 : g_application_set_resource_base_path (application, g_value_get_string (value));
1282 : 2 : break;
1283 : :
1284 : 3 : case PROP_INACTIVITY_TIMEOUT:
1285 : 3 : g_application_set_inactivity_timeout (application,
1286 : : g_value_get_uint (value));
1287 : 3 : break;
1288 : :
1289 : 0 : case PROP_ACTION_GROUP:
1290 : 0 : g_clear_object (&application->priv->actions);
1291 : 0 : application->priv->actions = g_value_dup_object (value);
1292 : 0 : break;
1293 : :
1294 : 0 : default:
1295 : : g_assert_not_reached ();
1296 : : }
1297 : 101 : }
1298 : :
1299 : : /**
1300 : : * g_application_set_action_group:
1301 : : * @application: a #GApplication
1302 : : * @action_group: (nullable): a #GActionGroup, or %NULL
1303 : : *
1304 : : * This used to be how actions were associated with a #GApplication.
1305 : : * Now there is #GActionMap for that.
1306 : : *
1307 : : * Since: 2.28
1308 : : *
1309 : : * Deprecated:2.32:Use the #GActionMap interface instead. Never ever
1310 : : * mix use of this API with use of #GActionMap on the same @application
1311 : : * or things will go very badly wrong. This function is known to
1312 : : * introduce buggy behaviour (ie: signals not emitted on changes to the
1313 : : * action group), so you should really use #GActionMap instead.
1314 : : **/
1315 : : void
1316 : 0 : g_application_set_action_group (GApplication *application,
1317 : : GActionGroup *action_group)
1318 : : {
1319 : 0 : g_return_if_fail (G_IS_APPLICATION (application));
1320 : 0 : g_return_if_fail (!application->priv->is_registered);
1321 : :
1322 [ # # ]: 0 : if (application->priv->actions != NULL)
1323 : 0 : g_object_unref (application->priv->actions);
1324 : :
1325 : 0 : application->priv->actions = action_group;
1326 : :
1327 [ # # ]: 0 : if (application->priv->actions != NULL)
1328 : 0 : g_object_ref (application->priv->actions);
1329 : : }
1330 : :
1331 : : static void
1332 : 32 : g_application_get_property (GObject *object,
1333 : : guint prop_id,
1334 : : GValue *value,
1335 : : GParamSpec *pspec)
1336 : : {
1337 : 32 : GApplication *application = G_APPLICATION (object);
1338 : :
1339 [ + + + + : 32 : switch (prop_id)
+ + + +
- ]
1340 : : {
1341 : 9 : case PROP_APPLICATION_ID:
1342 : 9 : g_value_set_string (value,
1343 : : g_application_get_application_id (application));
1344 : 9 : break;
1345 : :
1346 : 5 : case PROP_VERSION:
1347 : 5 : g_value_set_string (value,
1348 : : g_application_get_version (application));
1349 : 5 : break;
1350 : :
1351 : 2 : case PROP_FLAGS:
1352 : 2 : g_value_set_flags (value,
1353 : 2 : g_application_get_flags (application));
1354 : 2 : break;
1355 : :
1356 : 1 : case PROP_RESOURCE_BASE_PATH:
1357 : 1 : g_value_set_string (value, g_application_get_resource_base_path (application));
1358 : 1 : break;
1359 : :
1360 : 3 : case PROP_IS_REGISTERED:
1361 : 3 : g_value_set_boolean (value,
1362 : : g_application_get_is_registered (application));
1363 : 3 : break;
1364 : :
1365 : 1 : case PROP_IS_REMOTE:
1366 : 1 : g_value_set_boolean (value,
1367 : : g_application_get_is_remote (application));
1368 : 1 : break;
1369 : :
1370 : 10 : case PROP_INACTIVITY_TIMEOUT:
1371 : 10 : g_value_set_uint (value,
1372 : : g_application_get_inactivity_timeout (application));
1373 : 10 : break;
1374 : :
1375 : 1 : case PROP_IS_BUSY:
1376 : 1 : g_value_set_boolean (value, g_application_get_is_busy (application));
1377 : 1 : break;
1378 : :
1379 : 0 : default:
1380 : : g_assert_not_reached ();
1381 : : }
1382 : 32 : }
1383 : :
1384 : : static void
1385 : 47 : g_application_constructed (GObject *object)
1386 : : {
1387 : 47 : GApplication *application = G_APPLICATION (object);
1388 : :
1389 [ + - ]: 47 : if (g_application_get_default () == NULL)
1390 : 47 : g_application_set_default (application);
1391 : :
1392 : : /* People should not set properties from _init... */
1393 : 47 : g_assert (application->priv->resource_path == NULL);
1394 : :
1395 [ + + ]: 47 : if (application->priv->id != NULL)
1396 : : {
1397 : : gint i;
1398 : :
1399 : 44 : application->priv->resource_path = g_strconcat ("/", application->priv->id, NULL);
1400 : :
1401 [ + + ]: 1211 : for (i = 1; application->priv->resource_path[i]; i++)
1402 [ + + ]: 1167 : if (application->priv->resource_path[i] == '.')
1403 : 114 : application->priv->resource_path[i] = '/';
1404 : : }
1405 : 47 : }
1406 : :
1407 : : static void
1408 : 46 : g_application_dispose (GObject *object)
1409 : : {
1410 : 46 : GApplication *application = G_APPLICATION (object);
1411 : :
1412 [ + + ]: 46 : if (application->priv->impl != NULL &&
1413 [ - + ]: 5 : G_APPLICATION_GET_CLASS (application)->dbus_unregister != g_application_real_dbus_unregister)
1414 : : {
1415 : : static gboolean warned;
1416 : :
1417 [ # # ]: 0 : if (!warned)
1418 : : {
1419 : 0 : g_warning ("Your application did not unregister from D-Bus before destruction. "
1420 : : "Consider using g_application_run().");
1421 : : }
1422 : :
1423 : 0 : warned = TRUE;
1424 : : }
1425 : :
1426 : 46 : G_OBJECT_CLASS (g_application_parent_class)->dispose (object);
1427 : 46 : }
1428 : :
1429 : : static void
1430 : 46 : g_application_finalize (GObject *object)
1431 : : {
1432 : 46 : GApplication *application = G_APPLICATION (object);
1433 : :
1434 [ - + ]: 46 : if (application->priv->inactivity_timeout_id)
1435 : 0 : g_source_remove (application->priv->inactivity_timeout_id);
1436 : :
1437 : 46 : g_slist_free_full (application->priv->option_groups, (GDestroyNotify) g_option_group_unref);
1438 [ - + ]: 46 : if (application->priv->main_options)
1439 : 0 : g_option_group_unref (application->priv->main_options);
1440 [ - + ]: 46 : if (application->priv->packed_options)
1441 : 0 : g_hash_table_unref (application->priv->packed_options);
1442 : :
1443 : 46 : g_free (application->priv->parameter_string);
1444 : 46 : g_free (application->priv->summary);
1445 : 46 : g_free (application->priv->description);
1446 : 46 : g_free (application->priv->version);
1447 : :
1448 : 46 : g_slist_free_full (application->priv->option_strings, g_free);
1449 : :
1450 [ + + ]: 46 : if (application->priv->impl)
1451 : 5 : g_application_impl_destroy (application->priv->impl);
1452 : 46 : g_free (application->priv->id);
1453 : :
1454 [ + - ]: 46 : if (g_application_get_default () == application)
1455 : 46 : g_application_set_default (NULL);
1456 : :
1457 [ + - ]: 46 : if (application->priv->actions)
1458 : 46 : g_object_unref (application->priv->actions);
1459 : :
1460 : 46 : g_clear_object (&application->priv->remote_actions);
1461 : :
1462 [ + + ]: 46 : if (application->priv->notifications)
1463 : 3 : g_object_unref (application->priv->notifications);
1464 : :
1465 : 46 : g_free (application->priv->resource_path);
1466 : :
1467 : 46 : G_OBJECT_CLASS (g_application_parent_class)
1468 : 46 : ->finalize (object);
1469 : 46 : }
1470 : :
1471 : : static void
1472 : 47 : g_application_init (GApplication *application)
1473 : : {
1474 : 47 : application->priv = g_application_get_instance_private (application);
1475 : :
1476 : 47 : application->priv->actions = g_application_exported_actions_new (application);
1477 : :
1478 : : /* application->priv->actions is the one and only ref on the group, so when
1479 : : * we dispose, the action group will die, disconnecting all signals.
1480 : : */
1481 : 47 : g_signal_connect_swapped (application->priv->actions, "action-added",
1482 : : G_CALLBACK (g_action_group_action_added), application);
1483 : 47 : g_signal_connect_swapped (application->priv->actions, "action-enabled-changed",
1484 : : G_CALLBACK (g_action_group_action_enabled_changed), application);
1485 : 47 : g_signal_connect_swapped (application->priv->actions, "action-state-changed",
1486 : : G_CALLBACK (g_action_group_action_state_changed), application);
1487 : 47 : g_signal_connect_swapped (application->priv->actions, "action-removed",
1488 : : G_CALLBACK (g_action_group_action_removed), application);
1489 : 47 : }
1490 : :
1491 : : static gboolean
1492 : 35 : g_application_handle_local_options_accumulator (GSignalInvocationHint *ihint,
1493 : : GValue *return_accu,
1494 : : const GValue *handler_return,
1495 : : gpointer dummy)
1496 : : {
1497 : : gint value;
1498 : :
1499 : 35 : value = g_value_get_int (handler_return);
1500 : 35 : g_value_set_int (return_accu, value);
1501 : :
1502 : 35 : return value < 0;
1503 : : }
1504 : :
1505 : : static void
1506 : 13 : g_application_class_init (GApplicationClass *class)
1507 : : {
1508 : 13 : GObjectClass *object_class = G_OBJECT_CLASS (class);
1509 : :
1510 : 13 : object_class->constructed = g_application_constructed;
1511 : 13 : object_class->dispose = g_application_dispose;
1512 : 13 : object_class->finalize = g_application_finalize;
1513 : 13 : object_class->get_property = g_application_get_property;
1514 : 13 : object_class->set_property = g_application_set_property;
1515 : :
1516 : 13 : class->before_emit = g_application_real_before_emit;
1517 : 13 : class->after_emit = g_application_real_after_emit;
1518 : 13 : class->startup = g_application_real_startup;
1519 : 13 : class->shutdown = g_application_real_shutdown;
1520 : 13 : class->activate = g_application_real_activate;
1521 : 13 : class->open = g_application_real_open;
1522 : 13 : class->command_line = g_application_real_command_line;
1523 : 13 : class->local_command_line = g_application_real_local_command_line;
1524 : 13 : class->handle_local_options = g_application_real_handle_local_options;
1525 : 13 : class->add_platform_data = g_application_real_add_platform_data;
1526 : 13 : class->dbus_register = g_application_real_dbus_register;
1527 : 13 : class->dbus_unregister = g_application_real_dbus_unregister;
1528 : 13 : class->name_lost = g_application_real_name_lost;
1529 : :
1530 : : /**
1531 : : * GApplication:application-id:
1532 : : *
1533 : : * The unique identifier for the application.
1534 : : *
1535 : : * Since: 2.28
1536 : : */
1537 : 13 : g_object_class_install_property (object_class, PROP_APPLICATION_ID,
1538 : : g_param_spec_string ("application-id", NULL, NULL,
1539 : : NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT |
1540 : : G_PARAM_STATIC_STRINGS));
1541 : :
1542 : : /**
1543 : : * GApplication:version:
1544 : : *
1545 : : * The human-readable version number of the application.
1546 : : *
1547 : : * Since: 2.80
1548 : : */
1549 : 13 : g_object_class_install_property (object_class, PROP_VERSION,
1550 : : g_param_spec_string ("version", NULL, NULL,
1551 : : NULL, G_PARAM_READWRITE |
1552 : : G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY));
1553 : :
1554 : : /**
1555 : : * GApplication:flags:
1556 : : *
1557 : : * Flags specifying the behaviour of the application.
1558 : : *
1559 : : * Since: 2.28
1560 : : */
1561 : 13 : g_object_class_install_property (object_class, PROP_FLAGS,
1562 : : g_param_spec_flags ("flags", NULL, NULL,
1563 : : G_TYPE_APPLICATION_FLAGS, G_APPLICATION_DEFAULT_FLAGS,
1564 : : G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1565 : :
1566 : : /**
1567 : : * GApplication:resource-base-path:
1568 : : *
1569 : : * The base resource path for the application.
1570 : : *
1571 : : * Since: 2.28
1572 : : */
1573 : 13 : g_object_class_install_property (object_class, PROP_RESOURCE_BASE_PATH,
1574 : : g_param_spec_string ("resource-base-path", NULL, NULL,
1575 : : NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1576 : :
1577 : : /**
1578 : : * GApplication:is-registered:
1579 : : *
1580 : : * Whether [method@Gio.Application.register] has been called.
1581 : : *
1582 : : * Since: 2.28
1583 : : */
1584 : 13 : g_object_class_install_property (object_class, PROP_IS_REGISTERED,
1585 : : g_param_spec_boolean ("is-registered", NULL, NULL,
1586 : : FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
1587 : :
1588 : : /**
1589 : : * GApplication:is-remote:
1590 : : *
1591 : : * Whether this application instance is remote.
1592 : : *
1593 : : * Since: 2.28
1594 : : */
1595 : 13 : g_object_class_install_property (object_class, PROP_IS_REMOTE,
1596 : : g_param_spec_boolean ("is-remote", NULL, NULL,
1597 : : FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
1598 : :
1599 : : /**
1600 : : * GApplication:inactivity-timeout:
1601 : : *
1602 : : * Time (in milliseconds) to stay alive after becoming idle.
1603 : : *
1604 : : * Since: 2.28
1605 : : */
1606 : 13 : g_object_class_install_property (object_class, PROP_INACTIVITY_TIMEOUT,
1607 : : g_param_spec_uint ("inactivity-timeout", NULL, NULL,
1608 : : 0, G_MAXUINT, 0,
1609 : : G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1610 : :
1611 : : /**
1612 : : * GApplication:action-group:
1613 : : *
1614 : : * The group of actions that the application exports.
1615 : : *
1616 : : * Since: 2.28
1617 : : */
1618 : 13 : g_object_class_install_property (object_class, PROP_ACTION_GROUP,
1619 : : g_param_spec_object ("action-group", NULL, NULL,
1620 : : G_TYPE_ACTION_GROUP,
1621 : : G_PARAM_DEPRECATED | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
1622 : :
1623 : : /**
1624 : : * GApplication:is-busy:
1625 : : *
1626 : : * Whether the application is currently marked as busy through
1627 : : * g_application_mark_busy() or g_application_bind_busy_property().
1628 : : *
1629 : : * Since: 2.44
1630 : : */
1631 : 13 : g_object_class_install_property (object_class, PROP_IS_BUSY,
1632 : : g_param_spec_boolean ("is-busy", NULL, NULL,
1633 : : FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
1634 : :
1635 : : /**
1636 : : * GApplication::startup:
1637 : : * @application: the application
1638 : : *
1639 : : * The ::startup signal is emitted on the primary instance immediately
1640 : : * after registration. See g_application_register().
1641 : : */
1642 : 13 : g_application_signals[SIGNAL_STARTUP] =
1643 : 13 : g_signal_new (I_("startup"), G_TYPE_APPLICATION, G_SIGNAL_RUN_FIRST,
1644 : : G_STRUCT_OFFSET (GApplicationClass, startup),
1645 : : NULL, NULL, NULL, G_TYPE_NONE, 0);
1646 : :
1647 : : /**
1648 : : * GApplication::shutdown:
1649 : : * @application: the application
1650 : : *
1651 : : * The ::shutdown signal is emitted only on the registered primary instance
1652 : : * immediately after the main loop terminates.
1653 : : */
1654 : 13 : g_application_signals[SIGNAL_SHUTDOWN] =
1655 : 13 : g_signal_new (I_("shutdown"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1656 : : G_STRUCT_OFFSET (GApplicationClass, shutdown),
1657 : : NULL, NULL, NULL, G_TYPE_NONE, 0);
1658 : :
1659 : : /**
1660 : : * GApplication::activate:
1661 : : * @application: the application
1662 : : *
1663 : : * The ::activate signal is emitted on the primary instance when an
1664 : : * activation occurs. See g_application_activate().
1665 : : */
1666 : 13 : g_application_signals[SIGNAL_ACTIVATE] =
1667 : 13 : g_signal_new (I_("activate"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1668 : : G_STRUCT_OFFSET (GApplicationClass, activate),
1669 : : NULL, NULL, NULL, G_TYPE_NONE, 0);
1670 : :
1671 : :
1672 : : /**
1673 : : * GApplication::open:
1674 : : * @application: the application
1675 : : * @files: (array length=n_files) (element-type GFile): an array of #GFiles
1676 : : * @n_files: the length of @files
1677 : : * @hint: a hint provided by the calling instance
1678 : : *
1679 : : * The ::open signal is emitted on the primary instance when there are
1680 : : * files to open. See g_application_open() for more information.
1681 : : */
1682 : 13 : g_application_signals[SIGNAL_OPEN] =
1683 : 13 : g_signal_new (I_("open"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1684 : : G_STRUCT_OFFSET (GApplicationClass, open),
1685 : : NULL, NULL,
1686 : : _g_cclosure_marshal_VOID__POINTER_INT_STRING,
1687 : : G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_STRING);
1688 : 13 : g_signal_set_va_marshaller (g_application_signals[SIGNAL_OPEN],
1689 : : G_TYPE_FROM_CLASS (class),
1690 : : _g_cclosure_marshal_VOID__POINTER_INT_STRINGv);
1691 : :
1692 : : /**
1693 : : * GApplication::command-line:
1694 : : * @application: the application
1695 : : * @command_line: a #GApplicationCommandLine representing the
1696 : : * passed commandline
1697 : : *
1698 : : * The ::command-line signal is emitted on the primary instance when
1699 : : * a commandline is not handled locally. See g_application_run() and
1700 : : * the #GApplicationCommandLine documentation for more information.
1701 : : *
1702 : : * Returns: An integer that is set as the exit status for the calling
1703 : : * process. See g_application_command_line_set_exit_status().
1704 : : */
1705 : 13 : g_application_signals[SIGNAL_COMMAND_LINE] =
1706 : 13 : g_signal_new (I_("command-line"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1707 : : G_STRUCT_OFFSET (GApplicationClass, command_line),
1708 : : g_signal_accumulator_first_wins, NULL,
1709 : : _g_cclosure_marshal_INT__OBJECT,
1710 : : G_TYPE_INT, 1, G_TYPE_APPLICATION_COMMAND_LINE);
1711 : 13 : g_signal_set_va_marshaller (g_application_signals[SIGNAL_COMMAND_LINE],
1712 : : G_TYPE_FROM_CLASS (class),
1713 : : _g_cclosure_marshal_INT__OBJECTv);
1714 : :
1715 : : /**
1716 : : * GApplication::handle-local-options:
1717 : : * @application: the application
1718 : : * @options: the options dictionary
1719 : : *
1720 : : * The ::handle-local-options signal is emitted on the local instance
1721 : : * after the parsing of the commandline options has occurred.
1722 : : *
1723 : : * You can add options to be recognised during commandline option
1724 : : * parsing using g_application_add_main_option_entries() and
1725 : : * g_application_add_option_group().
1726 : : *
1727 : : * Signal handlers can inspect @options (along with values pointed to
1728 : : * from the @arg_data of an installed #GOptionEntrys) in order to
1729 : : * decide to perform certain actions, including direct local handling
1730 : : * (which may be useful for options like --version).
1731 : : *
1732 : : * In the event that the application is marked
1733 : : * %G_APPLICATION_HANDLES_COMMAND_LINE the "normal processing" will
1734 : : * send the @options dictionary to the primary instance where it can be
1735 : : * read with g_application_command_line_get_options_dict(). The signal
1736 : : * handler can modify the dictionary before returning, and the
1737 : : * modified dictionary will be sent.
1738 : : *
1739 : : * In the event that %G_APPLICATION_HANDLES_COMMAND_LINE is not set,
1740 : : * "normal processing" will treat the remaining uncollected command
1741 : : * line arguments as filenames or URIs. If there are no arguments,
1742 : : * the application is activated by g_application_activate(). One or
1743 : : * more arguments results in a call to g_application_open().
1744 : : *
1745 : : * If you want to handle the local commandline arguments for yourself
1746 : : * by converting them to calls to g_application_open() or
1747 : : * g_action_group_activate_action() then you must be sure to register
1748 : : * the application first. You should probably not call
1749 : : * g_application_activate() for yourself, however: just return -1 and
1750 : : * allow the default handler to do it for you. This will ensure that
1751 : : * the `--gapplication-service` switch works properly (i.e. no activation
1752 : : * in that case).
1753 : : *
1754 : : * Note that this signal is emitted from the default implementation of
1755 : : * local_command_line(). If you override that function and don't
1756 : : * chain up then this signal will never be emitted.
1757 : : *
1758 : : * You can override local_command_line() if you need more powerful
1759 : : * capabilities than what is provided here, but this should not
1760 : : * normally be required.
1761 : : *
1762 : : * Returns: an exit code. If you have handled your options and want
1763 : : * to exit the process, return a non-negative option, 0 for success,
1764 : : * and a positive value for failure. To continue, return -1 to let
1765 : : * the default option processing continue.
1766 : : *
1767 : : * Since: 2.40
1768 : : **/
1769 : 13 : g_application_signals[SIGNAL_HANDLE_LOCAL_OPTIONS] =
1770 : 13 : g_signal_new (I_("handle-local-options"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1771 : : G_STRUCT_OFFSET (GApplicationClass, handle_local_options),
1772 : : g_application_handle_local_options_accumulator, NULL,
1773 : : _g_cclosure_marshal_INT__BOXED,
1774 : : G_TYPE_INT, 1, G_TYPE_VARIANT_DICT);
1775 : 13 : g_signal_set_va_marshaller (g_application_signals[SIGNAL_HANDLE_LOCAL_OPTIONS],
1776 : : G_TYPE_FROM_CLASS (class),
1777 : : _g_cclosure_marshal_INT__BOXEDv);
1778 : :
1779 : : /**
1780 : : * GApplication::name-lost:
1781 : : * @application: the application
1782 : : *
1783 : : * The ::name-lost signal is emitted only on the registered primary instance
1784 : : * when a new instance has taken over. This can only happen if the application
1785 : : * is using the %G_APPLICATION_ALLOW_REPLACEMENT flag.
1786 : : *
1787 : : * The default handler for this signal calls g_application_quit().
1788 : : *
1789 : : * Returns: %TRUE if the signal has been handled
1790 : : *
1791 : : * Since: 2.60
1792 : : */
1793 : 13 : g_application_signals[SIGNAL_NAME_LOST] =
1794 : 13 : g_signal_new (I_("name-lost"), G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST,
1795 : : G_STRUCT_OFFSET (GApplicationClass, name_lost),
1796 : : g_signal_accumulator_true_handled, NULL,
1797 : : _g_cclosure_marshal_BOOLEAN__VOID,
1798 : : G_TYPE_BOOLEAN, 0);
1799 : 13 : g_signal_set_va_marshaller (g_application_signals[SIGNAL_NAME_LOST],
1800 : : G_TYPE_FROM_CLASS (class),
1801 : : _g_cclosure_marshal_BOOLEAN__VOIDv);
1802 : 13 : }
1803 : :
1804 : : /* Application ID validity {{{1 */
1805 : :
1806 : : /**
1807 : : * g_application_id_is_valid:
1808 : : * @application_id: a potential application identifier
1809 : : *
1810 : : * Checks if @application_id is a valid application identifier.
1811 : : *
1812 : : * A valid ID is required for calls to g_application_new() and
1813 : : * g_application_set_application_id().
1814 : : *
1815 : : * Application identifiers follow the same format as
1816 : : * [D-Bus well-known bus names](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus).
1817 : : * For convenience, the restrictions on application identifiers are
1818 : : * reproduced here:
1819 : : *
1820 : : * - Application identifiers are composed of 1 or more elements separated by a
1821 : : * period (`.`) character. All elements must contain at least one character.
1822 : : *
1823 : : * - Each element must only contain the ASCII characters `[A-Z][a-z][0-9]_-`,
1824 : : * with `-` discouraged in new application identifiers. Each element must not
1825 : : * begin with a digit.
1826 : : *
1827 : : * - Application identifiers must contain at least one `.` (period) character
1828 : : * (and thus at least two elements).
1829 : : *
1830 : : * - Application identifiers must not begin with a `.` (period) character.
1831 : : *
1832 : : * - Application identifiers must not exceed 255 characters.
1833 : : *
1834 : : * Note that the hyphen (`-`) character is allowed in application identifiers,
1835 : : * but is problematic or not allowed in various specifications and APIs that
1836 : : * refer to D-Bus, such as
1837 : : * [Flatpak application IDs](http://docs.flatpak.org/en/latest/introduction.html#identifiers),
1838 : : * the
1839 : : * [`DBusActivatable` interface in the Desktop Entry Specification](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#dbus),
1840 : : * and the convention that an application's "main" interface and object path
1841 : : * resemble its application identifier and bus name. To avoid situations that
1842 : : * require special-case handling, it is recommended that new application
1843 : : * identifiers consistently replace hyphens with underscores.
1844 : : *
1845 : : * Like D-Bus interface names, application identifiers should start with the
1846 : : * reversed DNS domain name of the author of the interface (in lower-case), and
1847 : : * it is conventional for the rest of the application identifier to consist of
1848 : : * words run together, with initial capital letters.
1849 : : *
1850 : : * As with D-Bus interface names, if the author's DNS domain name contains
1851 : : * hyphen/minus characters they should be replaced by underscores, and if it
1852 : : * contains leading digits they should be escaped by prepending an underscore.
1853 : : * For example, if the owner of 7-zip.org used an application identifier for an
1854 : : * archiving application, it might be named `org._7_zip.Archiver`.
1855 : : *
1856 : : * Returns: %TRUE if @application_id is valid
1857 : : */
1858 : : gboolean
1859 : 113 : g_application_id_is_valid (const gchar *application_id)
1860 : : {
1861 [ + + + - ]: 211 : return g_dbus_is_name (application_id) &&
1862 : 98 : !g_dbus_is_unique_name (application_id);
1863 : : }
1864 : :
1865 : : /* Public Constructor {{{1 */
1866 : : /**
1867 : : * g_application_new:
1868 : : * @application_id: (nullable): the application id
1869 : : * @flags: the application flags
1870 : : *
1871 : : * Creates a new #GApplication instance.
1872 : : *
1873 : : * If non-%NULL, the application id must be valid. See
1874 : : * g_application_id_is_valid().
1875 : : *
1876 : : * If no application ID is given then some features of #GApplication
1877 : : * (most notably application uniqueness) will be disabled.
1878 : : *
1879 : : * Returns: a new #GApplication instance
1880 : : **/
1881 : : GApplication *
1882 : 41 : g_application_new (const gchar *application_id,
1883 : : GApplicationFlags flags)
1884 : : {
1885 : 41 : g_return_val_if_fail (application_id == NULL || g_application_id_is_valid (application_id), NULL);
1886 : :
1887 : 41 : return g_object_new (G_TYPE_APPLICATION,
1888 : : "application-id", application_id,
1889 : : "flags", flags,
1890 : : NULL);
1891 : : }
1892 : :
1893 : : /* Simple get/set: application id, flags, inactivity timeout {{{1 */
1894 : : /**
1895 : : * g_application_get_application_id:
1896 : : * @application: a #GApplication
1897 : : *
1898 : : * Gets the unique identifier for @application.
1899 : : *
1900 : : * Returns: (nullable): the identifier for @application, owned by @application
1901 : : *
1902 : : * Since: 2.28
1903 : : **/
1904 : : const gchar *
1905 : 25 : g_application_get_application_id (GApplication *application)
1906 : : {
1907 : 25 : g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
1908 : :
1909 : 25 : return application->priv->id;
1910 : : }
1911 : :
1912 : : /**
1913 : : * g_application_set_application_id:
1914 : : * @application: a #GApplication
1915 : : * @application_id: (nullable): the identifier for @application
1916 : : *
1917 : : * Sets the unique identifier for @application.
1918 : : *
1919 : : * The application id can only be modified if @application has not yet
1920 : : * been registered.
1921 : : *
1922 : : * If non-%NULL, the application id must be valid. See
1923 : : * g_application_id_is_valid().
1924 : : *
1925 : : * Since: 2.28
1926 : : **/
1927 : : void
1928 : 51 : g_application_set_application_id (GApplication *application,
1929 : : const gchar *application_id)
1930 : : {
1931 : 51 : g_return_if_fail (G_IS_APPLICATION (application));
1932 : :
1933 [ + + ]: 51 : if (g_strcmp0 (application->priv->id, application_id) != 0)
1934 : : {
1935 : 48 : g_return_if_fail (application_id == NULL || g_application_id_is_valid (application_id));
1936 : 48 : g_return_if_fail (!application->priv->is_registered);
1937 : :
1938 : 48 : g_free (application->priv->id);
1939 : 48 : application->priv->id = g_strdup (application_id);
1940 : :
1941 : 48 : g_object_notify (G_OBJECT (application), "application-id");
1942 : : }
1943 : : }
1944 : :
1945 : : /**
1946 : : * g_application_get_version:
1947 : : * @application: a #GApplication
1948 : : *
1949 : : * Gets the version of @application.
1950 : : *
1951 : : * Returns: (nullable): the version of @application
1952 : : *
1953 : : * Since: 2.80
1954 : : **/
1955 : : const gchar *
1956 : 5 : g_application_get_version (GApplication *application)
1957 : : {
1958 : 5 : g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
1959 : :
1960 : 5 : return application->priv->version;
1961 : : }
1962 : :
1963 : : /**
1964 : : * g_application_set_version
1965 : : * @application: a #GApplication
1966 : : * @version: the version of @application
1967 : : *
1968 : : * Sets the version number of @application. This will be used to implement
1969 : : * a `--version` command line argument
1970 : : *
1971 : : * The application version can only be modified if @application has not yet
1972 : : * been registered.
1973 : : *
1974 : : * Since: 2.80
1975 : : **/
1976 : : void
1977 : 4 : g_application_set_version (GApplication *application,
1978 : : const gchar *version)
1979 : : {
1980 : 4 : g_return_if_fail (G_IS_APPLICATION (application));
1981 : 4 : g_return_if_fail (version != NULL);
1982 : 4 : g_return_if_fail (!application->priv->is_registered);
1983 : :
1984 [ + + ]: 4 : if (g_set_str (&application->priv->version, version))
1985 : 3 : g_object_notify (G_OBJECT (application), "version");
1986 : : }
1987 : :
1988 : :
1989 : : /**
1990 : : * g_application_get_flags:
1991 : : * @application: a #GApplication
1992 : : *
1993 : : * Gets the flags for @application.
1994 : : *
1995 : : * See #GApplicationFlags.
1996 : : *
1997 : : * Returns: the flags for @application
1998 : : *
1999 : : * Since: 2.28
2000 : : **/
2001 : : GApplicationFlags
2002 : 44 : g_application_get_flags (GApplication *application)
2003 : : {
2004 : 44 : g_return_val_if_fail (G_IS_APPLICATION (application), 0);
2005 : :
2006 : 44 : return application->priv->flags;
2007 : : }
2008 : :
2009 : : /**
2010 : : * g_application_set_flags:
2011 : : * @application: a #GApplication
2012 : : * @flags: the flags for @application
2013 : : *
2014 : : * Sets the flags for @application.
2015 : : *
2016 : : * The flags can only be modified if @application has not yet been
2017 : : * registered.
2018 : : *
2019 : : * See #GApplicationFlags.
2020 : : *
2021 : : * Since: 2.28
2022 : : **/
2023 : : void
2024 : 43 : g_application_set_flags (GApplication *application,
2025 : : GApplicationFlags flags)
2026 : : {
2027 : 43 : g_return_if_fail (G_IS_APPLICATION (application));
2028 : :
2029 [ + + ]: 43 : if (application->priv->flags != flags)
2030 : : {
2031 : 17 : g_return_if_fail (!application->priv->is_registered);
2032 : :
2033 : 17 : application->priv->flags = flags;
2034 : :
2035 : 17 : g_object_notify (G_OBJECT (application), "flags");
2036 : : }
2037 : : }
2038 : :
2039 : : /**
2040 : : * g_application_get_resource_base_path:
2041 : : * @application: a #GApplication
2042 : : *
2043 : : * Gets the resource base path of @application.
2044 : : *
2045 : : * See g_application_set_resource_base_path() for more information.
2046 : : *
2047 : : * Returns: (nullable): the base resource path, if one is set
2048 : : *
2049 : : * Since: 2.42
2050 : : */
2051 : : const gchar *
2052 : 7 : g_application_get_resource_base_path (GApplication *application)
2053 : : {
2054 : 7 : g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
2055 : :
2056 : 7 : return application->priv->resource_path;
2057 : : }
2058 : :
2059 : : /**
2060 : : * g_application_set_resource_base_path:
2061 : : * @application: a #GApplication
2062 : : * @resource_path: (nullable): the resource path to use
2063 : : *
2064 : : * Sets (or unsets) the base resource path of @application.
2065 : : *
2066 : : * The path is used to automatically load various [application
2067 : : * resources][gresource] such as menu layouts and action descriptions.
2068 : : * The various types of resources will be found at fixed names relative
2069 : : * to the given base path.
2070 : : *
2071 : : * By default, the resource base path is determined from the application
2072 : : * ID by prefixing '/' and replacing each '.' with '/'. This is done at
2073 : : * the time that the #GApplication object is constructed. Changes to
2074 : : * the application ID after that point will not have an impact on the
2075 : : * resource base path.
2076 : : *
2077 : : * As an example, if the application has an ID of "org.example.app" then
2078 : : * the default resource base path will be "/org/example/app". If this
2079 : : * is a #GtkApplication (and you have not manually changed the path)
2080 : : * then Gtk will then search for the menus of the application at
2081 : : * "/org/example/app/gtk/menus.ui".
2082 : : *
2083 : : * See #GResource for more information about adding resources to your
2084 : : * application.
2085 : : *
2086 : : * You can disable automatic resource loading functionality by setting
2087 : : * the path to %NULL.
2088 : : *
2089 : : * Changing the resource base path once the application is running is
2090 : : * not recommended. The point at which the resource path is consulted
2091 : : * for forming paths for various purposes is unspecified. When writing
2092 : : * a sub-class of #GApplication you should either set the
2093 : : * #GApplication:resource-base-path property at construction time, or call
2094 : : * this function during the instance initialization. Alternatively, you
2095 : : * can call this function in the #GApplicationClass.startup virtual function,
2096 : : * before chaining up to the parent implementation.
2097 : : *
2098 : : * Since: 2.42
2099 : : */
2100 : : void
2101 : 4 : g_application_set_resource_base_path (GApplication *application,
2102 : : const gchar *resource_path)
2103 : : {
2104 : 4 : g_return_if_fail (G_IS_APPLICATION (application));
2105 : 4 : g_return_if_fail (resource_path == NULL || g_str_has_prefix (resource_path, "/"));
2106 : :
2107 [ + - ]: 4 : if (g_strcmp0 (application->priv->resource_path, resource_path) != 0)
2108 : : {
2109 : 4 : g_free (application->priv->resource_path);
2110 : :
2111 : 4 : application->priv->resource_path = g_strdup (resource_path);
2112 : :
2113 : 4 : g_object_notify (G_OBJECT (application), "resource-base-path");
2114 : : }
2115 : : }
2116 : :
2117 : : /**
2118 : : * g_application_get_inactivity_timeout:
2119 : : * @application: a #GApplication
2120 : : *
2121 : : * Gets the current inactivity timeout for the application.
2122 : : *
2123 : : * This is the amount of time (in milliseconds) after the last call to
2124 : : * g_application_release() before the application stops running.
2125 : : *
2126 : : * Returns: the timeout, in milliseconds
2127 : : *
2128 : : * Since: 2.28
2129 : : **/
2130 : : guint
2131 : 12 : g_application_get_inactivity_timeout (GApplication *application)
2132 : : {
2133 : 12 : g_return_val_if_fail (G_IS_APPLICATION (application), 0);
2134 : :
2135 : 12 : return application->priv->inactivity_timeout;
2136 : : }
2137 : :
2138 : : /**
2139 : : * g_application_set_inactivity_timeout:
2140 : : * @application: a #GApplication
2141 : : * @inactivity_timeout: the timeout, in milliseconds
2142 : : *
2143 : : * Sets the current inactivity timeout for the application.
2144 : : *
2145 : : * This is the amount of time (in milliseconds) after the last call to
2146 : : * g_application_release() before the application stops running.
2147 : : *
2148 : : * This call has no side effects of its own. The value set here is only
2149 : : * used for next time g_application_release() drops the use count to
2150 : : * zero. Any timeouts currently in progress are not impacted.
2151 : : *
2152 : : * Since: 2.28
2153 : : **/
2154 : : void
2155 : 7 : g_application_set_inactivity_timeout (GApplication *application,
2156 : : guint inactivity_timeout)
2157 : : {
2158 : 7 : g_return_if_fail (G_IS_APPLICATION (application));
2159 : :
2160 [ + + ]: 7 : if (application->priv->inactivity_timeout != inactivity_timeout)
2161 : : {
2162 : 6 : application->priv->inactivity_timeout = inactivity_timeout;
2163 : :
2164 : 6 : g_object_notify (G_OBJECT (application), "inactivity-timeout");
2165 : : }
2166 : : }
2167 : : /* Read-only property getters (is registered, is remote, dbus stuff) {{{1 */
2168 : : /**
2169 : : * g_application_get_is_registered:
2170 : : * @application: a #GApplication
2171 : : *
2172 : : * Checks if @application is registered.
2173 : : *
2174 : : * An application is registered if g_application_register() has been
2175 : : * successfully called.
2176 : : *
2177 : : * Returns: %TRUE if @application is registered
2178 : : *
2179 : : * Since: 2.28
2180 : : **/
2181 : : gboolean
2182 : 14 : g_application_get_is_registered (GApplication *application)
2183 : : {
2184 : 14 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2185 : :
2186 : 14 : return application->priv->is_registered;
2187 : : }
2188 : :
2189 : : /**
2190 : : * g_application_get_is_remote:
2191 : : * @application: a #GApplication
2192 : : *
2193 : : * Checks if @application is remote.
2194 : : *
2195 : : * If @application is remote then it means that another instance of
2196 : : * application already exists (the 'primary' instance). Calls to
2197 : : * perform actions on @application will result in the actions being
2198 : : * performed by the primary instance.
2199 : : *
2200 : : * The value of this property cannot be accessed before
2201 : : * g_application_register() has been called. See
2202 : : * g_application_get_is_registered().
2203 : : *
2204 : : * Returns: %TRUE if @application is remote
2205 : : *
2206 : : * Since: 2.28
2207 : : **/
2208 : : gboolean
2209 : 7 : g_application_get_is_remote (GApplication *application)
2210 : : {
2211 : 7 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2212 : 7 : g_return_val_if_fail (application->priv->is_registered, FALSE);
2213 : :
2214 : 7 : return application->priv->is_remote;
2215 : : }
2216 : :
2217 : : /**
2218 : : * g_application_get_dbus_connection:
2219 : : * @application: a #GApplication
2220 : : *
2221 : : * Gets the #GDBusConnection being used by the application, or %NULL.
2222 : : *
2223 : : * If #GApplication is using its D-Bus backend then this function will
2224 : : * return the #GDBusConnection being used for uniqueness and
2225 : : * communication with the desktop environment and other instances of the
2226 : : * application.
2227 : : *
2228 : : * If #GApplication is not using D-Bus then this function will return
2229 : : * %NULL. This includes the situation where the D-Bus backend would
2230 : : * normally be in use but we were unable to connect to the bus.
2231 : : *
2232 : : * This function must not be called before the application has been
2233 : : * registered. See g_application_get_is_registered().
2234 : : *
2235 : : * Returns: (nullable) (transfer none): a #GDBusConnection, or %NULL
2236 : : *
2237 : : * Since: 2.34
2238 : : **/
2239 : : GDBusConnection *
2240 : 8 : g_application_get_dbus_connection (GApplication *application)
2241 : : {
2242 : 8 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2243 : 8 : g_return_val_if_fail (application->priv->is_registered, FALSE);
2244 : :
2245 : 8 : return g_application_impl_get_dbus_connection (application->priv->impl);
2246 : : }
2247 : :
2248 : : /**
2249 : : * g_application_get_dbus_object_path:
2250 : : * @application: a #GApplication
2251 : : *
2252 : : * Gets the D-Bus object path being used by the application, or %NULL.
2253 : : *
2254 : : * If #GApplication is using its D-Bus backend then this function will
2255 : : * return the D-Bus object path that #GApplication is using. If the
2256 : : * application is the primary instance then there is an object published
2257 : : * at this path. If the application is not the primary instance then
2258 : : * the result of this function is undefined.
2259 : : *
2260 : : * If #GApplication is not using D-Bus then this function will return
2261 : : * %NULL. This includes the situation where the D-Bus backend would
2262 : : * normally be in use but we were unable to connect to the bus.
2263 : : *
2264 : : * This function must not be called before the application has been
2265 : : * registered. See g_application_get_is_registered().
2266 : : *
2267 : : * Returns: (nullable): the object path, or %NULL
2268 : : *
2269 : : * Since: 2.34
2270 : : **/
2271 : : const gchar *
2272 : 2 : g_application_get_dbus_object_path (GApplication *application)
2273 : : {
2274 : 2 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2275 : 2 : g_return_val_if_fail (application->priv->is_registered, FALSE);
2276 : :
2277 : 2 : return g_application_impl_get_dbus_object_path (application->priv->impl);
2278 : : }
2279 : :
2280 : :
2281 : : /* Register {{{1 */
2282 : : /**
2283 : : * g_application_register:
2284 : : * @application: a #GApplication
2285 : : * @cancellable: (nullable): a #GCancellable, or %NULL
2286 : : * @error: a pointer to a NULL #GError, or %NULL
2287 : : *
2288 : : * Attempts registration of the application.
2289 : : *
2290 : : * This is the point at which the application discovers if it is the
2291 : : * primary instance or merely acting as a remote for an already-existing
2292 : : * primary instance. This is implemented by attempting to acquire the
2293 : : * application identifier as a unique bus name on the session bus using
2294 : : * GDBus.
2295 : : *
2296 : : * If there is no application ID or if %G_APPLICATION_NON_UNIQUE was
2297 : : * given, then this process will always become the primary instance.
2298 : : *
2299 : : * Due to the internal architecture of GDBus, method calls can be
2300 : : * dispatched at any time (even if a main loop is not running). For
2301 : : * this reason, you must ensure that any object paths that you wish to
2302 : : * register are registered before calling this function.
2303 : : *
2304 : : * If the application has already been registered then %TRUE is
2305 : : * returned with no work performed.
2306 : : *
2307 : : * The #GApplication::startup signal is emitted if registration succeeds
2308 : : * and @application is the primary instance (including the non-unique
2309 : : * case).
2310 : : *
2311 : : * In the event of an error (such as @cancellable being cancelled, or a
2312 : : * failure to connect to the session bus), %FALSE is returned and @error
2313 : : * is set appropriately.
2314 : : *
2315 : : * Note: the return value of this function is not an indicator that this
2316 : : * instance is or is not the primary instance of the application. See
2317 : : * g_application_get_is_remote() for that.
2318 : : *
2319 : : * Returns: %TRUE if registration succeeded
2320 : : *
2321 : : * Since: 2.28
2322 : : **/
2323 : : gboolean
2324 : 37 : g_application_register (GApplication *application,
2325 : : GCancellable *cancellable,
2326 : : GError **error)
2327 : : {
2328 : 37 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
2329 : :
2330 [ + + ]: 37 : if (!application->priv->is_registered)
2331 : : {
2332 [ + + ]: 36 : if (application->priv->id == NULL)
2333 : 3 : application->priv->flags |= G_APPLICATION_NON_UNIQUE;
2334 : :
2335 : 72 : application->priv->impl =
2336 : 36 : g_application_impl_register (application, application->priv->id,
2337 : 36 : application->priv->flags,
2338 : 36 : application->priv->actions,
2339 : 36 : &application->priv->remote_actions,
2340 : : cancellable, error);
2341 : :
2342 [ - + ]: 36 : if (application->priv->impl == NULL)
2343 : 0 : return FALSE;
2344 : :
2345 : 36 : application->priv->is_remote = application->priv->remote_actions != NULL;
2346 : 36 : application->priv->is_registered = TRUE;
2347 : :
2348 : 36 : g_object_notify (G_OBJECT (application), "is-registered");
2349 : :
2350 [ + + ]: 36 : if (!application->priv->is_remote)
2351 : : {
2352 : 35 : g_signal_emit (application, g_application_signals[SIGNAL_STARTUP], 0);
2353 : :
2354 [ - + ]: 35 : if (!application->priv->did_startup)
2355 : 0 : g_critical ("GApplication subclass '%s' failed to chain up on"
2356 : : " ::startup (from start of override function)",
2357 : : G_OBJECT_TYPE_NAME (application));
2358 : : }
2359 : : }
2360 : :
2361 : 37 : return TRUE;
2362 : : }
2363 : :
2364 : : /* Hold/release {{{1 */
2365 : : /**
2366 : : * g_application_hold:
2367 : : * @application: a #GApplication
2368 : : *
2369 : : * Increases the use count of @application.
2370 : : *
2371 : : * Use this function to indicate that the application has a reason to
2372 : : * continue to run. For example, g_application_hold() is called by GTK
2373 : : * when a toplevel window is on the screen.
2374 : : *
2375 : : * To cancel the hold, call g_application_release().
2376 : : **/
2377 : : void
2378 : 28 : g_application_hold (GApplication *application)
2379 : : {
2380 : 28 : g_return_if_fail (G_IS_APPLICATION (application));
2381 : :
2382 [ - + ]: 28 : if (application->priv->inactivity_timeout_id)
2383 : : {
2384 : 0 : g_source_remove (application->priv->inactivity_timeout_id);
2385 : 0 : application->priv->inactivity_timeout_id = 0;
2386 : : }
2387 : :
2388 : 28 : application->priv->use_count++;
2389 : : }
2390 : :
2391 : : static gboolean
2392 : 1 : inactivity_timeout_expired (gpointer data)
2393 : : {
2394 : 1 : GApplication *application = G_APPLICATION (data);
2395 : :
2396 : 1 : application->priv->inactivity_timeout_id = 0;
2397 : :
2398 : 1 : return G_SOURCE_REMOVE;
2399 : : }
2400 : :
2401 : :
2402 : : /**
2403 : : * g_application_release:
2404 : : * @application: a #GApplication
2405 : : *
2406 : : * Decrease the use count of @application.
2407 : : *
2408 : : * When the use count reaches zero, the application will stop running.
2409 : : *
2410 : : * Never call this function except to cancel the effect of a previous
2411 : : * call to g_application_hold().
2412 : : **/
2413 : : void
2414 : 23 : g_application_release (GApplication *application)
2415 : : {
2416 : 23 : g_return_if_fail (G_IS_APPLICATION (application));
2417 : 23 : g_return_if_fail (application->priv->use_count > 0);
2418 : :
2419 : 23 : application->priv->use_count--;
2420 : :
2421 [ + - + + ]: 23 : if (application->priv->use_count == 0 && application->priv->inactivity_timeout)
2422 : 1 : application->priv->inactivity_timeout_id = g_timeout_add (application->priv->inactivity_timeout,
2423 : : inactivity_timeout_expired, application);
2424 : : }
2425 : :
2426 : : /* Activate, Open {{{1 */
2427 : : /**
2428 : : * g_application_activate:
2429 : : * @application: a #GApplication
2430 : : *
2431 : : * Activates the application.
2432 : : *
2433 : : * In essence, this results in the #GApplication::activate signal being
2434 : : * emitted in the primary instance.
2435 : : *
2436 : : * The application must be registered before calling this function.
2437 : : *
2438 : : * Since: 2.28
2439 : : **/
2440 : : void
2441 : 26 : g_application_activate (GApplication *application)
2442 : : {
2443 : 26 : g_return_if_fail (G_IS_APPLICATION (application));
2444 : 26 : g_return_if_fail (application->priv->is_registered);
2445 : :
2446 [ + + ]: 26 : if (application->priv->is_remote)
2447 : 1 : g_application_impl_activate (application->priv->impl,
2448 : : get_platform_data (application, NULL));
2449 : :
2450 : : else
2451 : 25 : g_signal_emit (application, g_application_signals[SIGNAL_ACTIVATE], 0);
2452 : : }
2453 : :
2454 : : /**
2455 : : * g_application_open:
2456 : : * @application: a #GApplication
2457 : : * @files: (array length=n_files): an array of #GFiles to open
2458 : : * @n_files: the length of the @files array
2459 : : * @hint: a hint (or ""), but never %NULL
2460 : : *
2461 : : * Opens the given files.
2462 : : *
2463 : : * In essence, this results in the #GApplication::open signal being emitted
2464 : : * in the primary instance.
2465 : : *
2466 : : * @n_files must be greater than zero.
2467 : : *
2468 : : * @hint is simply passed through to the ::open signal. It is
2469 : : * intended to be used by applications that have multiple modes for
2470 : : * opening files (eg: "view" vs "edit", etc). Unless you have a need
2471 : : * for this functionality, you should use "".
2472 : : *
2473 : : * The application must be registered before calling this function
2474 : : * and it must have the %G_APPLICATION_HANDLES_OPEN flag set.
2475 : : *
2476 : : * Since: 2.28
2477 : : **/
2478 : : void
2479 : 0 : g_application_open (GApplication *application,
2480 : : GFile **files,
2481 : : gint n_files,
2482 : : const gchar *hint)
2483 : : {
2484 : 0 : g_return_if_fail (G_IS_APPLICATION (application));
2485 : 0 : g_return_if_fail (application->priv->flags &
2486 : : G_APPLICATION_HANDLES_OPEN);
2487 : 0 : g_return_if_fail (application->priv->is_registered);
2488 : :
2489 [ # # ]: 0 : if (application->priv->is_remote)
2490 : 0 : g_application_impl_open (application->priv->impl,
2491 : : files, n_files, hint,
2492 : : get_platform_data (application, NULL));
2493 : :
2494 : : else
2495 : 0 : g_signal_emit (application, g_application_signals[SIGNAL_OPEN],
2496 : : 0, files, n_files, hint);
2497 : : }
2498 : :
2499 : : /* Run {{{1 */
2500 : : /**
2501 : : * g_application_run:
2502 : : * @application: a #GApplication
2503 : : * @argc: the argc from main() (or 0 if @argv is %NULL)
2504 : : * @argv: (array length=argc) (element-type filename) (nullable):
2505 : : * the argv from main(), or %NULL
2506 : : *
2507 : : * Runs the application.
2508 : : *
2509 : : * This function is intended to be run from main() and its return value
2510 : : * is intended to be returned by main(). Although you are expected to pass
2511 : : * the @argc, @argv parameters from main() to this function, it is possible
2512 : : * to pass %NULL if @argv is not available or commandline handling is not
2513 : : * required. Note that on Windows, @argc and @argv are ignored, and
2514 : : * g_win32_get_command_line() is called internally (for proper support
2515 : : * of Unicode commandline arguments).
2516 : : *
2517 : : * #GApplication will attempt to parse the commandline arguments. You
2518 : : * can add commandline flags to the list of recognised options by way of
2519 : : * g_application_add_main_option_entries(). After this, the
2520 : : * #GApplication::handle-local-options signal is emitted, from which the
2521 : : * application can inspect the values of its #GOptionEntrys.
2522 : : *
2523 : : * #GApplication::handle-local-options is a good place to handle options
2524 : : * such as `--version`, where an immediate reply from the local process is
2525 : : * desired (instead of communicating with an already-running instance).
2526 : : * A #GApplication::handle-local-options handler can stop further processing
2527 : : * by returning a non-negative value, which then becomes the exit status of
2528 : : * the process.
2529 : : *
2530 : : * What happens next depends on the flags: if
2531 : : * %G_APPLICATION_HANDLES_COMMAND_LINE was specified then the remaining
2532 : : * commandline arguments are sent to the primary instance, where a
2533 : : * #GApplication::command-line signal is emitted. Otherwise, the
2534 : : * remaining commandline arguments are assumed to be a list of files.
2535 : : * If there are no files listed, the application is activated via the
2536 : : * #GApplication::activate signal. If there are one or more files, and
2537 : : * %G_APPLICATION_HANDLES_OPEN was specified then the files are opened
2538 : : * via the #GApplication::open signal.
2539 : : *
2540 : : * If you are interested in doing more complicated local handling of the
2541 : : * commandline then you should implement your own #GApplication subclass
2542 : : * and override local_command_line(). In this case, you most likely want
2543 : : * to return %TRUE from your local_command_line() implementation to
2544 : : * suppress the default handling. See
2545 : : * [gapplication-example-cmdline2.c][https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline2.c]
2546 : : * for an example.
2547 : : *
2548 : : * If, after the above is done, the use count of the application is zero
2549 : : * then the exit status is returned immediately. If the use count is
2550 : : * non-zero then the default main context is iterated until the use count
2551 : : * falls to zero, at which point 0 is returned.
2552 : : *
2553 : : * If the %G_APPLICATION_IS_SERVICE flag is set, then the service will
2554 : : * run for as much as 10 seconds with a use count of zero while waiting
2555 : : * for the message that caused the activation to arrive. After that,
2556 : : * if the use count falls to zero the application will exit immediately,
2557 : : * except in the case that g_application_set_inactivity_timeout() is in
2558 : : * use.
2559 : : *
2560 : : * This function sets the prgname (g_set_prgname()), if not already set,
2561 : : * to the basename of argv[0].
2562 : : *
2563 : : * Much like g_main_loop_run(), this function will acquire the main context
2564 : : * for the duration that the application is running.
2565 : : *
2566 : : * Since 2.40, applications that are not explicitly flagged as services
2567 : : * or launchers (ie: neither %G_APPLICATION_IS_SERVICE or
2568 : : * %G_APPLICATION_IS_LAUNCHER are given as flags) will check (from the
2569 : : * default handler for local_command_line) if "--gapplication-service"
2570 : : * was given in the command line. If this flag is present then normal
2571 : : * commandline processing is interrupted and the
2572 : : * %G_APPLICATION_IS_SERVICE flag is set. This provides a "compromise"
2573 : : * solution whereby running an application directly from the commandline
2574 : : * will invoke it in the normal way (which can be useful for debugging)
2575 : : * while still allowing applications to be D-Bus activated in service
2576 : : * mode. The D-Bus service file should invoke the executable with
2577 : : * "--gapplication-service" as the sole commandline argument. This
2578 : : * approach is suitable for use by most graphical applications but
2579 : : * should not be used from applications like editors that need precise
2580 : : * control over when processes invoked via the commandline will exit and
2581 : : * what their exit status will be.
2582 : : *
2583 : : * Returns: the exit status
2584 : : *
2585 : : * Since: 2.28
2586 : : **/
2587 : : int
2588 : 36 : g_application_run (GApplication *application,
2589 : : int argc,
2590 : : char **argv)
2591 : : {
2592 : : gchar **arguments;
2593 : : int status;
2594 : : GMainContext *context;
2595 : : gboolean acquired_context;
2596 : :
2597 : 36 : g_return_val_if_fail (G_IS_APPLICATION (application), 1);
2598 : 36 : g_return_val_if_fail (argc == 0 || argv != NULL, 1);
2599 : 36 : g_return_val_if_fail (!application->priv->must_quit_now, 1);
2600 : :
2601 : : #ifdef G_OS_WIN32
2602 : : {
2603 : : gint new_argc = 0;
2604 : :
2605 : : arguments = g_win32_get_command_line ();
2606 : :
2607 : : /*
2608 : : * CommandLineToArgvW(), which is called by g_win32_get_command_line(),
2609 : : * pulls in the whole command line that is used to call the program. This is
2610 : : * fine in cases where the program is a .exe program, but in the cases where the
2611 : : * program is a called via a script, such as PyGObject's gtk-demo.py, which is normally
2612 : : * called using 'python gtk-demo.py' on Windows, the program name (argv[0])
2613 : : * returned by g_win32_get_command_line() will not be the argv[0] that ->local_command_line()
2614 : : * would expect, causing the program to fail with "This application can not open files."
2615 : : */
2616 : : new_argc = g_strv_length (arguments);
2617 : :
2618 : : if (new_argc > argc)
2619 : : {
2620 : : gint i;
2621 : :
2622 : : for (i = 0; i < new_argc - argc; i++)
2623 : : g_free (arguments[i]);
2624 : :
2625 : : memmove (&arguments[0],
2626 : : &arguments[new_argc - argc],
2627 : : sizeof (arguments[0]) * (argc + 1));
2628 : : }
2629 : : }
2630 : : #elif defined(__APPLE__)
2631 : : {
2632 : : gint i, j;
2633 : :
2634 : : /*
2635 : : * OSX adds an unexpected parameter on the format -psn_X_XXXXXX
2636 : : * when opening the application using Launch Services. In order
2637 : : * to avoid that GOption fails to parse this parameter we just
2638 : : * skip it if it was provided.
2639 : : * See: https://gitlab.gnome.org/GNOME/glib/issues/1784
2640 : : */
2641 : : arguments = g_new (gchar *, argc + 1);
2642 : : for (i = 0, j = 0; i < argc; i++)
2643 : : {
2644 : : if (!g_str_has_prefix (argv[i], "-psn_"))
2645 : : {
2646 : : arguments[j] = g_strdup (argv[i]);
2647 : : j++;
2648 : : }
2649 : : }
2650 : : arguments[j] = NULL;
2651 : : }
2652 : : #else
2653 : : {
2654 : : gint i;
2655 : :
2656 : 36 : arguments = g_new (gchar *, argc + 1);
2657 [ + + ]: 60 : for (i = 0; i < argc; i++)
2658 : 48 : arguments[i] = g_strdup (argv[i]);
2659 : 36 : arguments[i] = NULL;
2660 : : }
2661 : : #endif
2662 : :
2663 [ - + - - ]: 36 : if (g_get_prgname () == NULL && argc > 0)
2664 : : {
2665 : : gchar *prgname;
2666 : :
2667 : 0 : prgname = g_path_get_basename (argv[0]);
2668 : 0 : GLIB_PRIVATE_CALL (g_set_prgname_once) (prgname);
2669 : 0 : g_free (prgname);
2670 : : }
2671 : :
2672 : 36 : context = g_main_context_default ();
2673 : 36 : acquired_context = g_main_context_acquire (context);
2674 [ - + ]: 36 : if (!acquired_context)
2675 : : {
2676 : 0 : g_critical ("g_application_run() cannot acquire the default main context because it is already acquired by another thread!");
2677 : 0 : g_strfreev (arguments);
2678 : 0 : return 1;
2679 : : }
2680 : :
2681 [ - + ]: 35 : if (!G_APPLICATION_GET_CLASS (application)
2682 : 36 : ->local_command_line (application, &arguments, &status))
2683 : : {
2684 : 0 : GError *error = NULL;
2685 : :
2686 [ # # ]: 0 : if (!g_application_register (application, NULL, &error))
2687 : : {
2688 : 0 : g_printerr ("Failed to register: %s\n", error->message);
2689 : 0 : g_error_free (error);
2690 : 0 : return 1;
2691 : : }
2692 : :
2693 : 0 : g_application_call_command_line (application, (const gchar **) arguments, NULL, &status);
2694 : : }
2695 : :
2696 : 35 : g_strfreev (arguments);
2697 : :
2698 [ - + ]: 35 : if (application->priv->flags & G_APPLICATION_IS_SERVICE &&
2699 [ # # ]: 0 : application->priv->is_registered &&
2700 [ # # ]: 0 : !application->priv->use_count &&
2701 [ # # ]: 0 : !application->priv->inactivity_timeout_id)
2702 : : {
2703 : 0 : application->priv->inactivity_timeout_id =
2704 : 0 : g_timeout_add (10000, inactivity_timeout_expired, application);
2705 : : }
2706 : :
2707 [ + + + + ]: 136 : while (application->priv->use_count || application->priv->inactivity_timeout_id)
2708 : : {
2709 [ + + ]: 104 : if (application->priv->must_quit_now)
2710 : 3 : break;
2711 : :
2712 : 101 : g_main_context_iteration (context, TRUE);
2713 : 101 : status = 0;
2714 : : }
2715 : :
2716 [ + + + + ]: 35 : if (application->priv->is_registered && !application->priv->is_remote)
2717 : : {
2718 : 30 : g_signal_emit (application, g_application_signals[SIGNAL_SHUTDOWN], 0);
2719 : :
2720 [ - + ]: 30 : if (!application->priv->did_shutdown)
2721 : 0 : g_critical ("GApplication subclass '%s' failed to chain up on"
2722 : : " ::shutdown (from end of override function)",
2723 : : G_OBJECT_TYPE_NAME (application));
2724 : : }
2725 : :
2726 [ + + ]: 35 : if (application->priv->impl)
2727 : : {
2728 [ + - ]: 31 : if (application->priv->is_registered)
2729 : : {
2730 : 31 : application->priv->is_registered = FALSE;
2731 : :
2732 : 31 : g_object_notify (G_OBJECT (application), "is-registered");
2733 : : }
2734 : :
2735 : 31 : g_application_impl_flush (application->priv->impl);
2736 : 31 : g_application_impl_destroy (application->priv->impl);
2737 : 31 : application->priv->impl = NULL;
2738 : : }
2739 : :
2740 : 35 : g_settings_sync ();
2741 : :
2742 [ + + ]: 35 : if (!application->priv->must_quit_now)
2743 [ + + ]: 57 : while (g_main_context_iteration (context, FALSE))
2744 : : ;
2745 : :
2746 : 35 : g_main_context_release (context);
2747 : :
2748 : 35 : return status;
2749 : : }
2750 : :
2751 : : static gchar **
2752 : 3 : g_application_list_actions (GActionGroup *action_group)
2753 : : {
2754 : 3 : GApplication *application = G_APPLICATION (action_group);
2755 : :
2756 : 3 : g_return_val_if_fail (application->priv->is_registered, NULL);
2757 : :
2758 [ - + ]: 3 : if (application->priv->remote_actions != NULL)
2759 : 0 : return g_action_group_list_actions (G_ACTION_GROUP (application->priv->remote_actions));
2760 : :
2761 [ + - ]: 3 : else if (application->priv->actions != NULL)
2762 : 3 : return g_action_group_list_actions (application->priv->actions);
2763 : :
2764 : : else
2765 : : /* empty string array */
2766 : 0 : return g_new0 (gchar *, 1);
2767 : : }
2768 : :
2769 : : static gboolean
2770 : 8 : g_application_query_action (GActionGroup *group,
2771 : : const gchar *action_name,
2772 : : gboolean *enabled,
2773 : : const GVariantType **parameter_type,
2774 : : const GVariantType **state_type,
2775 : : GVariant **state_hint,
2776 : : GVariant **state)
2777 : : {
2778 : 8 : GApplication *application = G_APPLICATION (group);
2779 : :
2780 : 8 : g_return_val_if_fail (application->priv->is_registered, FALSE);
2781 : :
2782 [ - + ]: 8 : if (application->priv->remote_actions != NULL)
2783 : 0 : return g_action_group_query_action (G_ACTION_GROUP (application->priv->remote_actions),
2784 : : action_name,
2785 : : enabled,
2786 : : parameter_type,
2787 : : state_type,
2788 : : state_hint,
2789 : : state);
2790 : :
2791 [ + - ]: 8 : if (application->priv->actions != NULL)
2792 : 8 : return g_action_group_query_action (application->priv->actions,
2793 : : action_name,
2794 : : enabled,
2795 : : parameter_type,
2796 : : state_type,
2797 : : state_hint,
2798 : : state);
2799 : :
2800 : 0 : return FALSE;
2801 : : }
2802 : :
2803 : : static void
2804 : 1 : g_application_change_action_state (GActionGroup *action_group,
2805 : : const gchar *action_name,
2806 : : GVariant *value)
2807 : : {
2808 : 1 : GApplication *application = G_APPLICATION (action_group);
2809 : :
2810 : 1 : g_return_if_fail (application->priv->is_remote ||
2811 : : application->priv->actions != NULL);
2812 : 1 : g_return_if_fail (application->priv->is_registered);
2813 : :
2814 [ - + ]: 1 : if (application->priv->remote_actions)
2815 : 0 : g_remote_action_group_change_action_state_full (application->priv->remote_actions,
2816 : : action_name, value, get_platform_data (application, NULL));
2817 : :
2818 : : else
2819 : 1 : g_action_group_change_action_state (application->priv->actions, action_name, value);
2820 : : }
2821 : :
2822 : : static void
2823 : 3 : g_application_activate_action (GActionGroup *action_group,
2824 : : const gchar *action_name,
2825 : : GVariant *parameter)
2826 : : {
2827 : 3 : GApplication *application = G_APPLICATION (action_group);
2828 : :
2829 : 3 : g_return_if_fail (application->priv->is_remote ||
2830 : : application->priv->actions != NULL);
2831 : 3 : g_return_if_fail (application->priv->is_registered);
2832 : :
2833 [ - + ]: 3 : if (application->priv->remote_actions)
2834 : 0 : g_remote_action_group_activate_action_full (application->priv->remote_actions,
2835 : : action_name, parameter, get_platform_data (application, NULL));
2836 : :
2837 : : else
2838 : 3 : g_action_group_activate_action (application->priv->actions, action_name, parameter);
2839 : : }
2840 : :
2841 : : static GAction *
2842 : 1 : g_application_lookup_action (GActionMap *action_map,
2843 : : const gchar *action_name)
2844 : : {
2845 : 1 : GApplication *application = G_APPLICATION (action_map);
2846 : :
2847 : 1 : g_return_val_if_fail (G_IS_ACTION_MAP (application->priv->actions), NULL);
2848 : :
2849 : 1 : return g_action_map_lookup_action (G_ACTION_MAP (application->priv->actions), action_name);
2850 : : }
2851 : :
2852 : : static void
2853 : 20 : g_application_add_action (GActionMap *action_map,
2854 : : GAction *action)
2855 : : {
2856 : 20 : GApplication *application = G_APPLICATION (action_map);
2857 : :
2858 : 20 : g_return_if_fail (G_IS_ACTION_MAP (application->priv->actions));
2859 : :
2860 : 20 : g_action_map_add_action (G_ACTION_MAP (application->priv->actions), action);
2861 : : }
2862 : :
2863 : : static void
2864 : 1 : g_application_remove_action (GActionMap *action_map,
2865 : : const gchar *action_name)
2866 : : {
2867 : 1 : GApplication *application = G_APPLICATION (action_map);
2868 : :
2869 : 1 : g_return_if_fail (G_IS_ACTION_MAP (application->priv->actions));
2870 : :
2871 : 1 : g_action_map_remove_action (G_ACTION_MAP (application->priv->actions), action_name);
2872 : : }
2873 : :
2874 : : static void
2875 : 13 : g_application_action_group_iface_init (GActionGroupInterface *iface)
2876 : : {
2877 : 13 : iface->list_actions = g_application_list_actions;
2878 : 13 : iface->query_action = g_application_query_action;
2879 : 13 : iface->change_action_state = g_application_change_action_state;
2880 : 13 : iface->activate_action = g_application_activate_action;
2881 : 13 : }
2882 : :
2883 : : static void
2884 : 13 : g_application_action_map_iface_init (GActionMapInterface *iface)
2885 : : {
2886 : 13 : iface->lookup_action = g_application_lookup_action;
2887 : 13 : iface->add_action = g_application_add_action;
2888 : 13 : iface->remove_action = g_application_remove_action;
2889 : 13 : }
2890 : :
2891 : : /* Default Application {{{1 */
2892 : :
2893 : : static GApplication *default_app;
2894 : :
2895 : : /**
2896 : : * g_application_get_default:
2897 : : *
2898 : : * Returns the default #GApplication instance for this process.
2899 : : *
2900 : : * Normally there is only one #GApplication per process and it becomes
2901 : : * the default when it is created. You can exercise more control over
2902 : : * this by using g_application_set_default().
2903 : : *
2904 : : * If there is no default application then %NULL is returned.
2905 : : *
2906 : : * Returns: (nullable) (transfer none): the default application for this process, or %NULL
2907 : : *
2908 : : * Since: 2.32
2909 : : **/
2910 : : GApplication *
2911 : 93 : g_application_get_default (void)
2912 : : {
2913 : 93 : return default_app;
2914 : : }
2915 : :
2916 : : /**
2917 : : * g_application_set_default:
2918 : : * @application: (nullable): the application to set as default, or %NULL
2919 : : *
2920 : : * Sets or unsets the default application for the process, as returned
2921 : : * by g_application_get_default().
2922 : : *
2923 : : * This function does not take its own reference on @application. If
2924 : : * @application is destroyed then the default application will revert
2925 : : * back to %NULL.
2926 : : *
2927 : : * Since: 2.32
2928 : : **/
2929 : : void
2930 : 93 : g_application_set_default (GApplication *application)
2931 : : {
2932 : 93 : default_app = application;
2933 : 93 : }
2934 : :
2935 : : /**
2936 : : * g_application_quit:
2937 : : * @application: a #GApplication
2938 : : *
2939 : : * Immediately quits the application.
2940 : : *
2941 : : * Upon return to the mainloop, g_application_run() will return,
2942 : : * calling only the 'shutdown' function before doing so.
2943 : : *
2944 : : * The hold count is ignored.
2945 : : * Take care if your code has called g_application_hold() on the application and
2946 : : * is therefore still expecting it to exist.
2947 : : * (Note that you may have called g_application_hold() indirectly, for example
2948 : : * through gtk_application_add_window().)
2949 : : *
2950 : : * The result of calling g_application_run() again after it returns is
2951 : : * unspecified.
2952 : : *
2953 : : * Since: 2.32
2954 : : **/
2955 : : void
2956 : 6 : g_application_quit (GApplication *application)
2957 : : {
2958 : 6 : g_return_if_fail (G_IS_APPLICATION (application));
2959 : :
2960 : 6 : application->priv->must_quit_now = TRUE;
2961 : : }
2962 : :
2963 : : /**
2964 : : * g_application_mark_busy:
2965 : : * @application: a #GApplication
2966 : : *
2967 : : * Increases the busy count of @application.
2968 : : *
2969 : : * Use this function to indicate that the application is busy, for instance
2970 : : * while a long running operation is pending.
2971 : : *
2972 : : * The busy state will be exposed to other processes, so a session shell will
2973 : : * use that information to indicate the state to the user (e.g. with a
2974 : : * spinner).
2975 : : *
2976 : : * To cancel the busy indication, use g_application_unmark_busy().
2977 : : *
2978 : : * The application must be registered before calling this function.
2979 : : *
2980 : : * Since: 2.38
2981 : : **/
2982 : : void
2983 : 6 : g_application_mark_busy (GApplication *application)
2984 : : {
2985 : : gboolean was_busy;
2986 : :
2987 : 6 : g_return_if_fail (G_IS_APPLICATION (application));
2988 : 6 : g_return_if_fail (application->priv->is_registered);
2989 : :
2990 : 6 : was_busy = (application->priv->busy_count > 0);
2991 : 6 : application->priv->busy_count++;
2992 : :
2993 [ + + ]: 6 : if (!was_busy)
2994 : : {
2995 : 4 : g_application_impl_set_busy_state (application->priv->impl, TRUE);
2996 : 4 : g_object_notify (G_OBJECT (application), "is-busy");
2997 : : }
2998 : : }
2999 : :
3000 : : /**
3001 : : * g_application_unmark_busy:
3002 : : * @application: a #GApplication
3003 : : *
3004 : : * Decreases the busy count of @application.
3005 : : *
3006 : : * When the busy count reaches zero, the new state will be propagated
3007 : : * to other processes.
3008 : : *
3009 : : * This function must only be called to cancel the effect of a previous
3010 : : * call to g_application_mark_busy().
3011 : : *
3012 : : * Since: 2.38
3013 : : **/
3014 : : void
3015 : 6 : g_application_unmark_busy (GApplication *application)
3016 : : {
3017 : 6 : g_return_if_fail (G_IS_APPLICATION (application));
3018 : 6 : g_return_if_fail (application->priv->busy_count > 0);
3019 : :
3020 : 6 : application->priv->busy_count--;
3021 : :
3022 [ + + ]: 6 : if (application->priv->busy_count == 0)
3023 : : {
3024 : 4 : g_application_impl_set_busy_state (application->priv->impl, FALSE);
3025 : 4 : g_object_notify (G_OBJECT (application), "is-busy");
3026 : : }
3027 : : }
3028 : :
3029 : : /**
3030 : : * g_application_get_is_busy:
3031 : : * @application: a #GApplication
3032 : : *
3033 : : * Gets the application's current busy state, as set through
3034 : : * g_application_mark_busy() or g_application_bind_busy_property().
3035 : : *
3036 : : * Returns: %TRUE if @application is currently marked as busy
3037 : : *
3038 : : * Since: 2.44
3039 : : */
3040 : : gboolean
3041 : 14 : g_application_get_is_busy (GApplication *application)
3042 : : {
3043 : 14 : g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
3044 : :
3045 : 14 : return application->priv->busy_count > 0;
3046 : : }
3047 : :
3048 : : /* Notifications {{{1 */
3049 : :
3050 : : /**
3051 : : * g_application_send_notification:
3052 : : * @application: a #GApplication
3053 : : * @id: (nullable): id of the notification, or %NULL
3054 : : * @notification: the #GNotification to send
3055 : : *
3056 : : * Sends a notification on behalf of @application to the desktop shell.
3057 : : * There is no guarantee that the notification is displayed immediately,
3058 : : * or even at all.
3059 : : *
3060 : : * Notifications may persist after the application exits. It will be
3061 : : * D-Bus-activated when the notification or one of its actions is
3062 : : * activated.
3063 : : *
3064 : : * Modifying @notification after this call has no effect. However, the
3065 : : * object can be reused for a later call to this function.
3066 : : *
3067 : : * @id may be any string that uniquely identifies the event for the
3068 : : * application. It does not need to be in any special format. For
3069 : : * example, "new-message" might be appropriate for a notification about
3070 : : * new messages.
3071 : : *
3072 : : * If a previous notification was sent with the same @id, it will be
3073 : : * replaced with @notification and shown again as if it was a new
3074 : : * notification. This works even for notifications sent from a previous
3075 : : * execution of the application, as long as @id is the same string.
3076 : : *
3077 : : * @id may be %NULL, but it is impossible to replace or withdraw
3078 : : * notifications without an id.
3079 : : *
3080 : : * If @notification is no longer relevant, it can be withdrawn with
3081 : : * g_application_withdraw_notification().
3082 : : *
3083 : : * It is an error to call this function if @application has no
3084 : : * application ID.
3085 : : *
3086 : : * Since: 2.40
3087 : : */
3088 : : void
3089 : 5 : g_application_send_notification (GApplication *application,
3090 : : const gchar *id,
3091 : : GNotification *notification)
3092 : : {
3093 : 5 : gchar *generated_id = NULL;
3094 : :
3095 : 5 : g_return_if_fail (G_IS_APPLICATION (application));
3096 : 5 : g_return_if_fail (G_IS_NOTIFICATION (notification));
3097 : 5 : g_return_if_fail (g_application_get_is_registered (application));
3098 : 5 : g_return_if_fail (!g_application_get_is_remote (application));
3099 : 5 : g_return_if_fail (g_application_get_application_id (application) != NULL);
3100 : :
3101 [ + + ]: 5 : if (application->priv->notifications == NULL)
3102 : 1 : application->priv->notifications = g_notification_backend_new_default (application);
3103 : :
3104 [ + + ]: 5 : if (id == NULL)
3105 : : {
3106 : 1 : generated_id = g_dbus_generate_guid ();
3107 : 1 : id = generated_id;
3108 : : }
3109 : :
3110 : 5 : g_notification_backend_send_notification (application->priv->notifications, id, notification);
3111 : :
3112 : 5 : g_free (generated_id);
3113 : : }
3114 : :
3115 : : /**
3116 : : * g_application_withdraw_notification:
3117 : : * @application: a #GApplication
3118 : : * @id: id of a previously sent notification
3119 : : *
3120 : : * Withdraws a notification that was sent with
3121 : : * g_application_send_notification().
3122 : : *
3123 : : * This call does nothing if a notification with @id doesn't exist or
3124 : : * the notification was never sent.
3125 : : *
3126 : : * This function works even for notifications sent in previous
3127 : : * executions of this application, as long @id is the same as it was for
3128 : : * the sent notification.
3129 : : *
3130 : : * Note that notifications are dismissed when the user clicks on one
3131 : : * of the buttons in a notification or triggers its default action, so
3132 : : * there is no need to explicitly withdraw the notification in that case.
3133 : : *
3134 : : * Since: 2.40
3135 : : */
3136 : : void
3137 : 3 : g_application_withdraw_notification (GApplication *application,
3138 : : const gchar *id)
3139 : : {
3140 : 3 : g_return_if_fail (G_IS_APPLICATION (application));
3141 : 3 : g_return_if_fail (id != NULL);
3142 : :
3143 [ + + ]: 3 : if (application->priv->notifications == NULL)
3144 : 2 : application->priv->notifications = g_notification_backend_new_default (application);
3145 : :
3146 : 3 : g_notification_backend_withdraw_notification (application->priv->notifications, id);
3147 : : }
3148 : :
3149 : : /* Busy binding {{{1 */
3150 : :
3151 : : typedef struct
3152 : : {
3153 : : GApplication *app;
3154 : : gboolean is_busy;
3155 : : } GApplicationBusyBinding;
3156 : :
3157 : : static void
3158 : 2 : g_application_busy_binding_destroy (gpointer data,
3159 : : GClosure *closure)
3160 : : {
3161 : 2 : GApplicationBusyBinding *binding = data;
3162 : :
3163 [ + - ]: 2 : if (binding->is_busy)
3164 : 2 : g_application_unmark_busy (binding->app);
3165 : :
3166 : 2 : g_object_unref (binding->app);
3167 : 2 : g_slice_free (GApplicationBusyBinding, binding);
3168 : 2 : }
3169 : :
3170 : : static void
3171 : 4 : g_application_notify_busy_binding (GObject *object,
3172 : : GParamSpec *pspec,
3173 : : gpointer user_data)
3174 : : {
3175 : 4 : GApplicationBusyBinding *binding = user_data;
3176 : : gboolean is_busy;
3177 : :
3178 : 4 : g_object_get (object, pspec->name, &is_busy, NULL);
3179 : :
3180 [ + + + - ]: 4 : if (is_busy && !binding->is_busy)
3181 : 3 : g_application_mark_busy (binding->app);
3182 [ + - + - ]: 1 : else if (!is_busy && binding->is_busy)
3183 : 1 : g_application_unmark_busy (binding->app);
3184 : :
3185 : 4 : binding->is_busy = is_busy;
3186 : 4 : }
3187 : :
3188 : : /**
3189 : : * g_application_bind_busy_property:
3190 : : * @application: a #GApplication
3191 : : * @object: (type GObject.Object): a #GObject
3192 : : * @property: the name of a boolean property of @object
3193 : : *
3194 : : * Marks @application as busy (see g_application_mark_busy()) while
3195 : : * @property on @object is %TRUE.
3196 : : *
3197 : : * The binding holds a reference to @application while it is active, but
3198 : : * not to @object. Instead, the binding is destroyed when @object is
3199 : : * finalized.
3200 : : *
3201 : : * Since: 2.44
3202 : : */
3203 : : void
3204 : 2 : g_application_bind_busy_property (GApplication *application,
3205 : : gpointer object,
3206 : : const gchar *property)
3207 : : {
3208 : : guint notify_id;
3209 : : GQuark property_quark;
3210 : : GParamSpec *pspec;
3211 : : GApplicationBusyBinding *binding;
3212 : : GClosure *closure;
3213 : :
3214 : 2 : g_return_if_fail (G_IS_APPLICATION (application));
3215 : 2 : g_return_if_fail (G_IS_OBJECT (object));
3216 : 2 : g_return_if_fail (property != NULL);
3217 : :
3218 : 2 : notify_id = g_signal_lookup ("notify", G_TYPE_OBJECT);
3219 : 2 : property_quark = g_quark_from_string (property);
3220 : 2 : pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (object), property);
3221 : :
3222 : 2 : g_return_if_fail (pspec != NULL && pspec->value_type == G_TYPE_BOOLEAN);
3223 : :
3224 [ - + ]: 2 : if (g_signal_handler_find (object, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC,
3225 : : notify_id, property_quark, NULL, g_application_notify_busy_binding, NULL) > 0)
3226 : : {
3227 : 0 : g_critical ("%s: '%s' is already bound to the busy state of the application", G_STRFUNC, property);
3228 : 0 : return;
3229 : : }
3230 : :
3231 : 2 : binding = g_slice_new (GApplicationBusyBinding);
3232 : 2 : binding->app = g_object_ref (application);
3233 : 2 : binding->is_busy = FALSE;
3234 : :
3235 : 2 : closure = g_cclosure_new (G_CALLBACK (g_application_notify_busy_binding), binding,
3236 : : g_application_busy_binding_destroy);
3237 : 2 : g_signal_connect_closure_by_id (object, notify_id, property_quark, closure, FALSE);
3238 : :
3239 : : /* fetch the initial value */
3240 : 2 : g_application_notify_busy_binding (object, pspec, binding);
3241 : : }
3242 : :
3243 : : /**
3244 : : * g_application_unbind_busy_property:
3245 : : * @application: a #GApplication
3246 : : * @object: (type GObject.Object): a #GObject
3247 : : * @property: the name of a boolean property of @object
3248 : : *
3249 : : * Destroys a binding between @property and the busy state of
3250 : : * @application that was previously created with
3251 : : * g_application_bind_busy_property().
3252 : : *
3253 : : * Since: 2.44
3254 : : */
3255 : : void
3256 : 1 : g_application_unbind_busy_property (GApplication *application,
3257 : : gpointer object,
3258 : : const gchar *property)
3259 : : {
3260 : : guint notify_id;
3261 : : GQuark property_quark;
3262 : : gulong handler_id;
3263 : :
3264 : 1 : g_return_if_fail (G_IS_APPLICATION (application));
3265 : 1 : g_return_if_fail (G_IS_OBJECT (object));
3266 : 1 : g_return_if_fail (property != NULL);
3267 : :
3268 : 1 : notify_id = g_signal_lookup ("notify", G_TYPE_OBJECT);
3269 : 1 : property_quark = g_quark_from_string (property);
3270 : :
3271 : 1 : handler_id = g_signal_handler_find (object, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC,
3272 : : notify_id, property_quark, NULL, g_application_notify_busy_binding, NULL);
3273 [ - + ]: 1 : if (handler_id == 0)
3274 : : {
3275 : 0 : g_critical ("%s: '%s' is not bound to the busy state of the application", G_STRFUNC, property);
3276 : 0 : return;
3277 : : }
3278 : :
3279 : 1 : g_signal_handler_disconnect (object, handler_id);
3280 : : }
3281 : :
3282 : : /* Epilogue {{{1 */
3283 : : /* vim:set foldmethod=marker: */
|