LCOV - code coverage report
Current view: top level - glib/gio - gapplication.c (source / functions) Hit Total Coverage
Test: unnamed Lines: 600 813 73.8 %
Date: 2024-03-26 05:16:46 Functions: 81 91 89.0 %
Branches: 165 290 56.9 %

           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: */

Generated by: LCOV version 1.14