gio/gapplication.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright © 2010 Red Hat, Inc
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Authors: Colin Walters <walters@verbum.org>
  21  *          Emmanuele Bassi <ebassi@linux.intel.com>
  22  */
  23
  24 #include "config.h"
  25
  26 #include <string.h>
  27 #include <stdlib.h>
  28
  29 #include <gobject/gvaluecollector.h>
  30
  31 #include "gapplication.h"
  32 #include "gio-marshal.h"
  33 #include "glibintl.h"
  34
  35 #include "gioerror.h"
  36
  37 #include "gdbusconnection.h"
  38 #include "gdbusintrospection.h"
  39 #include "gdbusmethodinvocation.h"
  40
  41 #include "gioalias.h"
  42
  43 /**
  44  * SECTION: gapplication
  45  * @title: GApplication
  46  * @short_description: Core application class
  47  *
  48  * A #GApplication is the foundation of an application, unique for
  49  * a given application identifier.  The #GApplication wraps some
  50  * low-level platform-specific services; it's expected that most
  51  * software will use a higher-level application class such as
  52  * #GtkApplication or #MxApplication.
  53  *
  54  * In addition to single-instance-ness, #GApplication provides support
  55  * for 'actions', which can be presented to the user in a platform-specific
  56  * way (e.g. Windows 7 jump lists). Note that these are just simple actions
  57  * without parameters. For more flexible scriptability, implementing a
  58  * a separate D-Bus interface is recommended, see e.g.
  59  * <xref linkend="gdbus-convenience"/>.
  60  *
  61  * Before using #GApplication, you must choose an "application identifier".
  62  * The expected form of an application identifier is very close to that of
  63  * of a <ulink url="http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-interface">DBus bus name</ulink>.
  64  * Examples include: "com.example.MyApp" "org.example.internal-apps.Calculator"
  65  * For convenience, the restrictions on application identifiers are reproduced
  66  * here:
  67  * <itemizedlist>
  68  *   <listitem>Application identifiers must contain only the ASCII characters "[A-Z][a-z][0-9]_-" and must not begin with a digit.</listitem>
  69  *   <listitem>Application identifiers must contain at least one '.' (period) character (and thus at least two elements).</listitem>
  70  *   <listitem>Application identifiers must not begin with a '.' (period) character.</listitem>
  71  *   <listitem>Application identifiers must not exceed 255 characters.</listitem>
  72  * </itemizedlist>
  73  *
  74  * <refsect2><title>D-Bus implementation</title>
  75  * <para>
  76  * On UNIX systems using D-Bus, #GApplication is implemented by claiming the
  77  * application identifier as a bus name on the session bus. The implementation
  78  * exports an object at the object path that is created by replacing '.' with
  79  * '/' in the application identifier (e.g. the object path for the
  80  * application id 'org.gtk.TestApp' is '/org/gtk/TestApp'). The object
  81  * implements the org.gtk.Application interface.
  82  * </para>
  83  * <classsynopsis class="interface">
  84  *   <ooclass><interfacename>org.gtk.Application</interfacename></ooclass>
  85  *   <methodsynopsis>
  86  *     <void/>
  87  *     <methodname>Activate</methodname>
  88  *     <methodparam><modifier>in</modifier><type>aay</type><parameter>arguments</parameter></methodparam>
  89  *     <methodparam><modifier>in</modifier><type>a{sv}</type><parameter>data</parameter></methodparam>
  90  *   </methodsynopsis>
  91  *   <methodsynopsis>
  92  *     <void/>
  93  *     <methodname>InvokeAction</methodname>
  94  *     <methodparam><modifier>in</modifier><type>s</type><parameter>action</parameter></methodparam>
  95  *     <methodparam><modifier>in</modifier><type>u</type><parameter>timestamp</parameter></methodparam>
  96  *   </methodsynopsis>
  97  *   <methodsynopsis>
  98  *     <type>a{s(sb)}</type>
  99  *     <methodname>ListActions</methodname>
 100  *     <void/>
 101  *   </methodsynopsis>
 102  *   <methodsynopsis>
 103  *     <void/>
 104  *     <methodname>Quit</methodname>
 105  *     <methodparam><modifier>in</modifier><type>u</type><parameter>timestamp</parameter></methodparam>
 106  *   </methodsynopsis>
 107  *   <methodsynopsis>
 108  *     <modifier>Signal</modifier>
 109  *     <void/>
 110  *     <methodname>ActionsChanged</methodname>
 111  *     <void/>
 112  *   </methodsynopsis>
 113  * </classsynopsis>
 114  * <para>
 115  * The <methodname>Activate</methodname> function is called on the existing
 116  * application instance when a second instance fails to take the bus name.
 117  * @arguments contains the commandline arguments given to the second instance
 118  * and @data contains platform-specific additional data, see
 119  * g_application_format_activation_data().
 120  * </para>
 121  * <para>
 122  * The <methodname>InvokeAction</methodname> function can be called to invoke
 123  * one of the actions exported by the application. The @timestamp parameter
 124  * should be taken from the user event that triggered the method call (e.g.
 125  * a button press event).
 126  * </para>
 127  * <para>
 128  * The <methodname>ListActions</methodname> function returns a dictionary
 129  * with the exported actions of the application. The keys of the dictionary
 130  * are the action names, and the values are structs containing the description
 131  * for the action and a boolean that represents if the action is enabled or not.
 132  * </para>
 133  * <para>
 134  * The <methodname>Quit</methodname> function can be called to terminate
 135  * the application. The @timestamp parameter should be taken from the user
 136  * event that triggered the method call (e.g. a button press event).
 137  * </para>
 138  * <para>
 139  * The <methodname>ActionsChanged</methodname> signal is emitted when the
 140  * exported actions change (i.e. an action is added, removed, enabled,
 141  * disabled, or otherwise changed).
 142  * </para>
 143  * <para>
 144  * #GApplication is supported since Gio 2.26.
 145  * </para>
 146  * </refsect2>
 147  */
 148
 149 G_DEFINE_TYPE (GApplication, g_application, G_TYPE_OBJECT);
 150
 151 enum
 152 {
 153   PROP_0,
 154
 155   PROP_APPLICATION_ID,
 156   PROP_DEFAULT_QUIT,
 157   PROP_IS_REMOTE
 158 };
 159
 160 enum
 161 {
 162   QUIT,
 163   ACTION,
 164   PREPARE_ACTIVATION,
 165
 166   LAST_SIGNAL
 167 };
 168
 169 static guint application_signals[LAST_SIGNAL] = { 0 };
 170
 171 typedef struct {
 172   gchar *name;
 173   gchar *description;
 174   guint enabled : 1;
 175 } GApplicationAction;
 176
 177 struct _GApplicationPrivate
 178 {
 179   gchar *appid;
 180   GHashTable *actions; /* name -> GApplicationAction */
 181   GMainLoop *mainloop;
 182
 183   guint default_quit : 1;
 184   guint is_remote    : 1;
 185
 186   guint actions_changed_id;
 187
 188 #ifdef G_OS_UNIX
 189   gchar *dbus_path;
 190   GDBusConnection *session_bus;
 191 #endif
 192 };
 193
 194 static GApplication *primary_application = NULL;
 195 static GHashTable *instances_for_appid = NULL;
 196
 197 static void     _g_application_platform_init                    (GApplication  *app);
 198 static gboolean _g_application_platform_acquire_single_instance (GApplication  *app,
 199                                                                  GError       **error);
 200 static void     _g_application_platform_remote_invoke_action    (GApplication  *app,
 201                                                                  const gchar   *action,
 202                                                                  guint          timestamp);
 203 static void     _g_application_platform_remote_quit             (GApplication  *app,
 204                                                                  guint          timestamp);
 205 static void     _g_application_platform_activate                (GApplication  *app,
 206                                                                  GVariant      *data) G_GNUC_NORETURN;
 207 static void     _g_application_platform_on_actions_changed      (GApplication  *app);
 208
 209 #ifdef G_OS_UNIX
 210 #include "gdbusapplication.c"
 211 #else
 212 #include "gnullapplication.c"
 213 #endif
 214
 215 static gboolean
 216 _g_application_validate_id (const char *id)
 217 {
 218   gboolean allow_dot;
 219
 220   if (strlen (id) > 255)
 221     return FALSE;
 222
 223   if (!g_ascii_isalpha (*id))
 224     return FALSE;
 225
 226   id++;
 227   allow_dot = FALSE;
 228   for (; *id; id++)
 229     {
 230       if (g_ascii_isalnum (*id) || (*id == '-') || (*id == '_'))
 231         allow_dot = TRUE;
 232       else if (allow_dot && *id == '.')
 233         allow_dot = FALSE;
 234       else
 235         return FALSE;
 236     }
 237   return TRUE;
 238 }
 239
 240 static gpointer
 241 init_appid_statics (gpointer data)
 242 {
 243   instances_for_appid = g_hash_table_new (g_str_hash, g_str_equal);
 244   return NULL;
 245 }
 246
 247 static GApplication *
 248 application_for_appid (const char *appid)
 249 {
 250   static GOnce appid_once = G_ONCE_INIT;
 251
 252   g_once (&appid_once, init_appid_statics, NULL);
 253
 254   return g_hash_table_lookup (instances_for_appid, appid);
 255 }
 256
 257 static gboolean
 258 g_application_default_quit (GApplication *application,
 259                             guint         timestamp)
 260 {
 261   g_return_val_if_fail (application->priv->mainloop != NULL, FALSE);
 262   g_main_loop_quit (application->priv->mainloop);
 263
 264   return TRUE;
 265 }
 266
 267 static void
 268 g_application_default_run (GApplication *application)
 269 {
 270   if (application->priv->mainloop == NULL)
 271     application->priv->mainloop = g_main_loop_new (NULL, TRUE);
 272
 273   g_main_loop_run (application->priv->mainloop);
 274 }
 275
 276 static void
 277 _g_application_handle_activation (GApplication  *app,
 278                                   int            argc,
 279                                   char         **argv,
 280                                   GVariant      *platform_data)
 281 {
 282   GVariantBuilder builder;
 283   GVariant *message;
 284   int i;
 285
 286   g_variant_builder_init (&builder, G_VARIANT_TYPE ("(aaya{sv})"));
 287   g_variant_builder_open (&builder, G_VARIANT_TYPE ("aay"));
 288
 289   for (i = 1; i < argc; i++)
 290     {
 291       int j;
 292       guint8 *argv_bytes;
 293
 294       g_variant_builder_open (&builder, G_VARIANT_TYPE ("ay"));
 295
 296       argv_bytes = (guint8*) argv[i];
 297       for (j = 0; argv_bytes[j]; j++)
 298         g_variant_builder_add_value (&builder,
 299                                      g_variant_new_byte (argv_bytes[j]));
 300       g_variant_builder_close (&builder);
 301     }
 302   g_variant_builder_close (&builder);
 303
 304   if (platform_data)
 305     g_variant_builder_add (&builder, "@a{sv}", platform_data);
 306   else
 307     {
 308       g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}"));
 309       g_variant_builder_close (&builder);
 310     }
 311
 312   message = g_variant_builder_end (&builder);
 313   _g_application_platform_activate (app, message);
 314   g_variant_unref (message);
 315 }
 316
 317 static gboolean
 318 timeout_handle_actions_changed (gpointer user_data)
 319 {
 320   GApplication *application = user_data;
 321
 322   application->priv->actions_changed_id = 0;
 323
 324   _g_application_platform_on_actions_changed (application);
 325
 326   return FALSE;
 327 }
 328
 329 static inline void
 330 queue_actions_change_notification (GApplication *application)
 331 {
 332   GApplicationPrivate *priv = application->priv;
 333
 334   if (priv->actions_changed_id == 0)
 335     priv->actions_changed_id = g_timeout_add (0, timeout_handle_actions_changed, application);
 336 }
 337
 338 static void
 339 g_application_action_free (gpointer data)
 340 {
 341   if (G_LIKELY (data != NULL))
 342     {
 343       GApplicationAction *action = data;
 344
 345       g_free (action->name);
 346       g_free (action->description);
 347
 348       g_slice_free (GApplicationAction, action);
 349     }
 350 }
 351
 352
 353 /**
 354  * g_application_new:
 355  * @appid: System-dependent application identifier
 356  *
 357  * Create a new #GApplication.  The application is initially in
 358  * "remote" mode.  Almost certainly, you want to call
 359  * g_application_register() immediately after this function, which
 360  * will finish initialization.
 361  *
 362  * As a convenience, this function is defined to call g_type_init() as
 363  * its very first action.
 364  *
 365  * Returns: (transfer full): An application instance
 366  *
 367  * Since: 2.26
 368  */
 369 GApplication *
 370 g_application_new (const gchar *appid)
 371 {
 372   g_type_init ();
 373
 374   return G_APPLICATION (g_object_new (G_TYPE_APPLICATION, "application-id", appid, NULL));
 375 }
 376
 377 /**
 378  * g_application_register_with_data:
 379  * @application: A #GApplication
 380  * @argc: System argument count
 381  * @argv: (array length=argc): System argument vector
 382  * @platform_data: (allow-none): Arbitrary platform-specific data, must have signature "a{sv}"
 383  *
 384  * Ensure the current process is the unique owner of the application.
 385  * If successful, the #GApplication:is-remote property will be changed
 386  * to %FALSE, and it is safe to continue creating other resources
 387  * such as graphics windows.
 388  *
 389  * If the given @appid is already running in another process, the
 390  * #GApplication:default-exit property will be evaluated.  If it's
 391  * %TRUE, then a platform-specific action such as bringing any
 392  * graphics windows associated with the application to the foreground
 393  * may be initiated.  After that, the current process will terminate.
 394  * If %FALSE, then the application remains in the #GApplication:is-remote
 395  * state, and you can e.g. call g_application_invoke_action().
 396  *
 397  * This function may do synchronous I/O to obtain unique ownership
 398  * of the application id, and will block the calling thread in this
 399  * case.
 400  */
 401 void
 402 g_application_register_with_data (GApplication  *application,
 403                                   gint           argc,
 404                                   gchar        **argv,
 405                                   GVariant      *platform_data)
 406 {
 407   g_return_if_fail (application->priv->appid != NULL);
 408   g_return_if_fail (application->priv->is_remote);
 409   g_return_if_fail (platform_data == NULL
 410                     || g_variant_is_of_type (platform_data, G_VARIANT_TYPE ("a{sv}")) == 0);
 411
 412   if (!_g_application_platform_acquire_single_instance (application, NULL))
 413     {
 414       if (application->priv->default_quit)
 415         _g_application_handle_activation (application, argc, argv, platform_data);
 416       else
 417         return;
 418     }
 419
 420   application->priv->is_remote = FALSE;
 421
 422   _g_application_platform_init (application);
 423 }
 424
 425 /**
 426  * g_application_new_and_register:
 427  * @appid: An application identifier
 428  * @argc: System argument count
 429  * @argv: (array length=argc): System argument vector
 430  *
 431  * This is a convenience function which combines g_application_new()
 432  * with g_application_register_with_data(). Therefore, it may block
 433  * the calling thread just like g_application_register_with_data().
 434  */
 435 GApplication *
 436 g_application_new_and_register (const gchar  *appid,
 437                                 gint          argc,
 438                                 gchar       **argv)
 439 {
 440   GApplication *app = g_application_new (appid);
 441   g_application_register_with_data (app, argc, argv, NULL);
 442   return app;
 443 }
 444
 445 /**
 446  * g_application_add_action:
 447  * @application: a #GApplication
 448  * @name: the action name
 449  * @description: the action description; can be a translatable
 450  *   string
 451  *
 452  * Adds an action @name to the list of exported actions of @application.
 453  *
 454  * It is an error to call this function if @application is a proxy for
 455  * a remote application.
 456  *
 457  * You can invoke an action using g_application_invoke_action().
 458  *
 459  * The newly added action is enabled by default; you can call
 460  * g_application_set_action_enabled() to disable it.
 461  *
 462  * Since: 2.26
 463  */
 464 void
 465 g_application_add_action (GApplication *application,
 466                           const gchar  *name,
 467                           const gchar  *description)
 468 {
 469   GApplicationPrivate *priv;
 470   GApplicationAction *action;
 471
 472   g_return_if_fail (G_IS_APPLICATION (application));
 473   g_return_if_fail (name != NULL && *name != '\0');
 474   g_return_if_fail (!application->priv->is_remote);
 475
 476   priv = application->priv;
 477
 478   g_return_if_fail (g_hash_table_lookup (priv->actions, name) == NULL);
 479
 480   action = g_slice_new (GApplicationAction);
 481   action->name = g_strdup (name);
 482   action->description = g_strdup (description);
 483   action->enabled = TRUE;
 484
 485   g_hash_table_insert (priv->actions, action->name, action);
 486   queue_actions_change_notification (application);
 487 }
 488
 489 /**
 490  * g_application_remove_action:
 491  * @application: a #GApplication
 492  * @name: the name of the action to remove
 493  *
 494  * Removes the action @name from the list of exported actions of @application.
 495  *
 496  * It is an error to call this function if @application is a proxy for
 497  * a remote application.
 498  *
 499  * Since: 2.26
 500  */
 501 void
 502 g_application_remove_action (GApplication *application,
 503                              const gchar  *name)
 504 {
 505   GApplicationPrivate *priv;
 506
 507   g_return_if_fail (G_IS_APPLICATION (application));
 508   g_return_if_fail (name != NULL && *name != '\0');
 509   g_return_if_fail (!application->priv->is_remote);
 510
 511   priv = application->priv;
 512
 513   g_return_if_fail (g_hash_table_lookup (priv->actions, name) != NULL);
 514
 515   g_hash_table_remove (priv->actions, name);
 516   queue_actions_change_notification (application);
 517 }
 518
 519 /**
 520  * g_application_invoke_action:
 521  * @application: a #GApplication
 522  * @name: the name of the action to invoke
 523  * @timestamp: the timestamp that is going to be passed to
 524  *   the #GApplication::action signal
 525  *
 526  * Invokes the action @name of the passed #GApplication.
 527  *
 528  * This function has different behavior depending on whether @application
 529  * is acting as a proxy for another process.  In the normal case where
 530  * the current process is hosting the application, and the specified
 531  * action exists and is enabled, the #GApplication::action signal will
 532  * be emitted.
 533  *
 534  * If @application is a proxy, then the specified action will be invoked
 535  * in the remote process. It is not necessary to call
 536  * g_application_add_action() in the current process in order to invoke
 537  * one remotely.
 538  *
 539  * Since: 2.26
 540  */
 541 void
 542 g_application_invoke_action (GApplication *application,
 543                              const gchar  *name,
 544                              guint         timestamp)
 545 {
 546   GApplicationPrivate *priv;
 547   GApplicationAction *action;
 548
 549   g_return_if_fail (G_IS_APPLICATION (application));
 550   g_return_if_fail (name != NULL);
 551
 552   priv = application->priv;
 553
 554   if (priv->is_remote)
 555     {
 556       _g_application_platform_remote_invoke_action (application, name, timestamp);
 557       return;
 558     }
 559
 560   action = g_hash_table_lookup (priv->actions, name);
 561   g_return_if_fail (action != NULL);
 562   if (!action->enabled)
 563     return;
 564
 565   g_signal_emit (application, application_signals[ACTION],
 566                  g_quark_from_string (name),
 567                  name,
 568                  timestamp);
 569 }
 570
 571 /**
 572  * g_application_list_actions:
 573  * @application: a #GApplication
 574  *
 575  * Retrieves the list of action names currently exported by @application.
 576  *
 577  * It is an error to call this function if @application is a proxy for
 578  * a remote application.
 579  *
 580  * Return value: (transfer full): a newly allocation, %NULL-terminated array
 581  *   of strings containing action names; use g_strfreev() to free the
 582  *   resources used by the returned array
 583  *
 584  * Since: 2.26
 585  */
 586 gchar **
 587 g_application_list_actions (GApplication *application)
 588 {
 589   GApplicationPrivate *priv;
 590   GHashTableIter iter;
 591   gpointer key;
 592   gchar **retval;
 593   gint i;
 594
 595   g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
 596   g_return_val_if_fail (!application->priv->is_remote, NULL);
 597
 598   priv = application->priv;
 599
 600   retval = g_new (gchar*, g_hash_table_size (priv->actions));
 601
 602   i = 0;
 603   g_hash_table_iter_init (&iter, priv->actions);
 604   while (g_hash_table_iter_next (&iter, &key, NULL))
 605     retval[i++] = g_strdup (key);
 606
 607   retval[i] = NULL;
 608
 609   return retval;
 610 }
 611
 612 /**
 613  * g_application_set_action_enabled:
 614  * @application: a #GApplication
 615  * @name: the name of the application
 616  * @enabled: whether to enable or disable the action @name
 617  *
 618  * Sets whether the action @name inside @application should be enabled
 619  * or disabled.
 620  *
 621  * It is an error to call this function if @application is a proxy for
 622  * a remote application.
 623  *
 624  * Invoking a disabled action will not result in the #GApplication::action
 625  * signal being emitted.
 626  *
 627  * Since: 2.26
 628  */
 629 void
 630 g_application_set_action_enabled (GApplication *application,
 631                                   const gchar  *name,
 632                                   gboolean      enabled)
 633 {
 634   GApplicationAction *action;
 635
 636   g_return_if_fail (G_IS_APPLICATION (application));
 637   g_return_if_fail (name != NULL);
 638   g_return_if_fail (!application->priv->is_remote);
 639
 640   enabled = !!enabled;
 641
 642   action = g_hash_table_lookup (application->priv->actions, name);
 643   g_return_if_fail (action != NULL);
 644   if (action->enabled == enabled)
 645     return;
 646
 647   action->enabled = enabled;
 648
 649   queue_actions_change_notification (application);
 650 }
 651
 652
 653 /**
 654  * g_application_get_action_description:
 655  * @application: a #GApplication
 656  * @name: Action name
 657  *
 658  * Gets the description of the action @name.
 659  *
 660  * It is an error to call this function if @application is a proxy for
 661  * a remote application.
 662  *
 663  * Returns: Description for the given action named @name
 664  *
 665  * Since: 2.26
 666  */
 667 G_CONST_RETURN gchar *
 668 g_application_get_action_description (GApplication *application,
 669                                       const gchar  *name)
 670 {
 671   GApplicationAction *action;
 672
 673   g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
 674   g_return_val_if_fail (name != NULL, NULL);
 675   g_return_val_if_fail (!application->priv->is_remote, NULL);
 676
 677   action = g_hash_table_lookup (application->priv->actions, name);
 678   g_return_val_if_fail (action != NULL, NULL);
 679
 680   return action->description;
 681 }
 682
 683
 684 /**
 685  * g_application_get_action_enabled:
 686  * @application: a #GApplication
 687  * @name: the name of the action
 688  *
 689  * Retrieves whether the action @name is enabled or not.
 690  *
 691  * See g_application_set_action_enabled().
 692  *
 693  * It is an error to call this function if @application is a proxy for
 694  * a remote application.
 695  *
 696  * Return value: %TRUE if the action was enabled, and %FALSE otherwise
 697  *
 698  * Since: 2.26
 699  */
 700 gboolean
 701 g_application_get_action_enabled (GApplication *application,
 702                                   const gchar  *name)
 703 {
 704   GApplicationAction *action;
 705
 706   g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
 707   g_return_val_if_fail (name != NULL, FALSE);
 708   g_return_val_if_fail (!application->priv->is_remote, FALSE);
 709
 710   action = g_hash_table_lookup (application->priv->actions, name);
 711   g_return_val_if_fail (action != NULL, FALSE);
 712
 713   return action->enabled;
 714 }
 715
 716 /**
 717  * g_application_run:
 718  * @application: a #GApplication
 719  *
 720  * Starts the application.
 721  *
 722  * The default implementation of this virtual function will simply run
 723  * a main loop.
 724  *
 725  * It is an error to call this function if @application is a proxy for
 726  * a remote application.
 727  *
 728  * Since: 2.26
 729  */
 730 void
 731 g_application_run (GApplication *application)
 732 {
 733   g_return_if_fail (G_IS_APPLICATION (application));
 734   g_return_if_fail (!application->priv->is_remote);
 735
 736   G_APPLICATION_GET_CLASS (application)->run (application);
 737 }
 738
 739 /**
 740  * g_application_quit:
 741  * @application: a #GApplication
 742  * @timestamp: Platform-specific event timestamp, may be 0 for default
 743  *
 744  * Request that the application quits.
 745  *
 746  * This function has different behavior depending on whether @application
 747  * is acting as a proxy for another process.  In the normal case where
 748  * the current process is hosting the application, the default
 749  * implementation will quit the main loop created by g_application_run().
 750  *
 751  * If @application is a proxy, then the remote process will be asked
 752  * to quit.
 753  *
 754  * Returns: %TRUE if the application accepted the request, %FALSE otherwise
 755  *
 756  * Since: 2.26
 757  */
 758 gboolean
 759 g_application_quit (GApplication *application,
 760                     guint         timestamp)
 761 {
 762   gboolean retval = FALSE;
 763
 764   g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
 765
 766   if (application->priv->is_remote)
 767     {
 768        _g_application_platform_remote_quit (application, timestamp);
 769        retval = TRUE;
 770     }
 771   else
 772     g_signal_emit (application, application_signals[QUIT], 0, timestamp, &retval);
 773
 774   return retval;
 775 }
 776
 777 /**
 778  * g_application_get_instance:
 779  *
 780  * In the normal case where there is exactly one #GApplication instance
 781  * in this process, return that instance.  If there are multiple, the
 782  * first one created will be returned.  Otherwise, return %NULL.
 783  *
 784  * Returns: (transfer none): The primary instance of #GApplication,
 785  *   or %NULL if none is set
 786  *
 787  * Since: 2.26
 788  */
 789 GApplication *
 790 g_application_get_instance (void)
 791 {
 792   return primary_application;
 793 }
 794
 795 /**
 796  * g_application_get_id:
 797  * @application: a #GApplication
 798  *
 799  * Retrieves the platform-specific identifier for the #GApplication.
 800  *
 801  * Return value: The platform-specific identifier. The returned string
 802  *   is owned by the #GApplication instance and it should never be
 803  *   modified or freed
 804  *
 805  * Since: 2.26
 806  */
 807 G_CONST_RETURN gchar *
 808 g_application_get_id (GApplication *application)
 809 {
 810   g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
 811
 812   return application->priv->appid;
 813 }
 814
 815 /**
 816  * g_application_is_remote:
 817  * @application: a #GApplication
 818  *
 819  * Returns: %TRUE if this object represents a proxy for a remote application.
 820  */
 821 gboolean
 822 g_application_is_remote (GApplication *application)
 823 {
 824   g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
 825
 826   return application->priv->is_remote;
 827 }
 828
 829 static void
 830 g_application_init (GApplication *app)
 831 {
 832   app->priv = G_TYPE_INSTANCE_GET_PRIVATE (app,
 833                                            G_TYPE_APPLICATION,
 834                                            GApplicationPrivate);
 835
 836   app->priv->actions = g_hash_table_new_full (g_str_hash, g_str_equal,
 837                                               NULL,
 838                                               g_application_action_free);
 839   app->priv->default_quit = TRUE;
 840   app->priv->is_remote = TRUE;
 841 }
 842
 843 static void
 844 g_application_get_property (GObject    *object,
 845                             guint       prop_id,
 846                             GValue     *value,
 847                             GParamSpec *pspec)
 848 {
 849   GApplication *app = G_APPLICATION (object);
 850
 851   switch (prop_id)
 852     {
 853     case PROP_APPLICATION_ID:
 854       g_value_set_string (value, g_application_get_id (app));
 855       break;
 856
 857     case PROP_DEFAULT_QUIT:
 858       g_value_set_boolean (value, app->priv->default_quit);
 859       break;
 860
 861     case PROP_IS_REMOTE:
 862       g_value_set_boolean (value, g_application_is_remote (app));
 863       break;
 864
 865     default:
 866       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 867     }
 868 }
 869
 870 static void
 871 g_application_set_property (GObject      *object,
 872                             guint         prop_id,
 873                             const GValue *value,
 874                             GParamSpec   *pspec)
 875 {
 876   GApplication *app = G_APPLICATION (object);
 877
 878   switch (prop_id)
 879     {
 880     case PROP_APPLICATION_ID:
 881       g_return_if_fail (_g_application_validate_id (g_value_get_string (value)));
 882       app->priv->appid = g_value_dup_string (value);
 883       break;
 884
 885     case PROP_DEFAULT_QUIT:
 886       app->priv->default_quit = g_value_get_boolean (value);
 887       break;
 888
 889     default:
 890       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 891     }
 892 }
 893
 894 static GObject*
 895 g_application_constructor (GType                  type,
 896                            guint                  n_construct_properties,
 897                            GObjectConstructParam *construct_params)
 898 {
 899   GApplication *app;
 900   GObject *object;
 901   const char *appid = NULL;
 902   guint i;
 903
 904   for (i = 0; i < n_construct_properties; i++)
 905     {
 906       GObjectConstructParam *param = &construct_params[i];
 907       if (strcmp (param->pspec->name, "application-id") == 0)
 908         appid = g_value_get_string (param->value);
 909     }
 910
 911   g_return_val_if_fail (appid != NULL, NULL);
 912
 913   app = application_for_appid (appid);
 914   if (app != NULL)
 915     return g_object_ref (app);
 916
 917   object = (* G_OBJECT_CLASS (g_application_parent_class)->constructor) (type,
 918                                                                          n_construct_properties,
 919                                                                          construct_params);
 920   app = G_APPLICATION (object);
 921
 922   if (primary_application == NULL)
 923     primary_application = app;
 924   g_hash_table_insert (instances_for_appid, g_strdup (appid), app);
 925
 926   return object;
 927 }
 928
 929 static void
 930 g_application_finalize (GObject *object)
 931 {
 932   GApplication *app = G_APPLICATION (object);
 933
 934   g_free (app->priv->appid);
 935   if (app->priv->actions)
 936     g_hash_table_unref (app->priv->actions);
 937   if (app->priv->actions_changed_id)
 938     g_source_remove (app->priv->actions_changed_id);
 939   if (app->priv->mainloop)
 940     g_main_loop_unref (app->priv->mainloop);
 941
 942 #ifdef G_OS_UNIX
 943   g_free (app->priv->dbus_path);
 944   if (app->priv->session_bus)
 945     g_object_unref (app->priv->session_bus);
 946 #endif
 947
 948   G_OBJECT_CLASS (g_application_parent_class)->finalize (object);
 949 }
 950
 951 static void
 952 g_application_class_init (GApplicationClass *klass)
 953 {
 954   GObjectClass *gobject_class G_GNUC_UNUSED = G_OBJECT_CLASS (klass);
 955
 956   g_type_class_add_private (klass, sizeof (GApplicationPrivate));
 957
 958   gobject_class->constructor = g_application_constructor;
 959   gobject_class->set_property = g_application_set_property;
 960   gobject_class->get_property = g_application_get_property;
 961
 962   gobject_class->finalize = g_application_finalize;
 963
 964   klass->run = g_application_default_run;
 965   klass->quit = g_application_default_quit;
 966
 967   /**
 968    * GApplication::quit:
 969    * @application: the object on which the signal is emitted
 970    * @timestamp: Platform-specific event timestamp, may be 0 for default
 971    *
 972    * This signal is emitted when the Quit action is invoked on the
 973    * application.
 974    *
 975    * The default handler for this signal exits the mainloop of the
 976    * application.
 977    *
 978    * Returns: %TRUE if the signal has been handled, %FALSE to continue
 979    *   signal emission
 980    */
 981   application_signals[QUIT] =
 982     g_signal_new (g_intern_static_string ("quit"),
 983                   G_OBJECT_CLASS_TYPE (klass),
 984                   G_SIGNAL_RUN_LAST,
 985                   G_STRUCT_OFFSET (GApplicationClass, quit),
 986                   g_signal_accumulator_true_handled, NULL,
 987                   _gio_marshal_BOOLEAN__UINT,
 988                   G_TYPE_BOOLEAN, 1,
 989                   G_TYPE_UINT);
 990
 991   /**
 992    * GApplication::action:
 993    * @application: the object on which the signal is emitted
 994    * @name: The name of the activated action
 995    * @timestamp: Platform-specific event timestamp, may be 0 for default
 996    *
 997    * This signal is emitted when an action is activated. The action name
 998    * is passed as the first argument, but also as signal detail, so it
 999    * is possible to connect to this signal for individual actions.
1000    *
1001    * The signal is never emitted for disabled actions.
1002    */
1003   application_signals[ACTION] =
1004     g_signal_new (g_intern_static_string ("action"),
1005                   G_OBJECT_CLASS_TYPE (klass),
1006                   G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED,
1007                   G_STRUCT_OFFSET (GApplicationClass, action),
1008                   NULL, NULL,
1009                   _gio_marshal_VOID__STRING_UINT,
1010                   G_TYPE_NONE, 2,
1011                   G_TYPE_STRING,
1012                   G_TYPE_UINT);
1013
1014    /**
1015    * GApplication::prepare-activation:
1016    * @application: the object on which the signal is emitted
1017    * @arguments: A #GVariant with the signature "aay"
1018    * @platform_data: A #GVariant with the signature "a{sv}"
1019    *
1020    * This signal is emitted when a non-primary process for a given
1021    * application is invoked while your application is running; for
1022    * example, when a file browser launches your program to open a
1023    * file.  The raw operating system arguments are passed in the
1024    * @arguments variant.  Additional platform-dependent data is
1025    * stored in @platform_data.
1026    */
1027   application_signals[PREPARE_ACTIVATION] =
1028     g_signal_new (g_intern_static_string ("prepare-activation"),
1029                   G_OBJECT_CLASS_TYPE (klass),
1030                   G_SIGNAL_RUN_LAST,
1031                   G_STRUCT_OFFSET (GApplicationClass, prepare_activation),
1032                   NULL, NULL,
1033                   _gio_marshal_VOID__BOXED_BOXED,
1034                   G_TYPE_NONE, 2,
1035                   G_TYPE_VARIANT,
1036                   G_TYPE_VARIANT);
1037
1038    /**
1039    * GApplication:application-id:
1040    *
1041    * The unique identifier for this application.  See the documentation for
1042    * #GApplication for more information about this property.
1043    *
1044    */
1045   g_object_class_install_property (gobject_class,
1046                                    PROP_APPLICATION_ID,
1047                                    g_param_spec_string ("application-id",
1048                                                         P_("Application ID"),
1049                                                         P_("Identifier for this application"),
1050                                                         NULL,
1051                                                         G_PARAM_READWRITE |
1052                                                         G_PARAM_CONSTRUCT_ONLY |
1053                                                         G_PARAM_STATIC_STRINGS));
1054
1055   /**
1056    * GApplication:default-quit:
1057    *
1058    * By default, if a different process is running this application, the
1059    * process will be exited.  Set this property to %FALSE to allow custom
1060    * interaction with the remote process.
1061    *
1062    */
1063   g_object_class_install_property (gobject_class,
1064                                    PROP_DEFAULT_QUIT,
1065                                    g_param_spec_boolean ("default-quit",
1066                                                          P_("Default Quit"),
1067                                                          P_("Exit the process by default"),
1068                                                          TRUE,
1069                                                          G_PARAM_READWRITE |
1070                                                          G_PARAM_CONSTRUCT_ONLY |
1071                                                          G_PARAM_STATIC_STRINGS));
1072
1073
1074   /**
1075    * GApplication:is-remote:
1076    *
1077    * This property is %TRUE if this application instance represents a proxy
1078    * to the instance of this application in another process.
1079    *
1080    */
1081   g_object_class_install_property (gobject_class,
1082                                    PROP_IS_REMOTE,
1083                                    g_param_spec_boolean ("is-remote",
1084                                                          P_("Is Remote"),
1085                                                          P_("Whether this application is a proxy for another process"),
1086                                                          TRUE,
1087                                                          G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
1088 }
1089
1090 #define __G_APPLICATION_C__
1091 #include "gioaliasdef.c"