/* GIO - GLib Input, Output and Streaming Library
*
* Copyright © 2010 Red Hat, Inc
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Authors: Colin Walters <walters@verbum.org>
* Emmanuele Bassi <ebassi@linux.intel.com>
*/
#include "config.h"
#include <string.h>
#include <stdlib.h>
#include <gobject/gvaluecollector.h>
#include "gapplication.h"
#include "gio-marshal.h"
#include "glibintl.h"
#include "gioerror.h"
#include "ginitable.h"
#include "gdbusconnection.h"
#include "gdbusintrospection.h"
#include "gdbusmethodinvocation.h"
/**
* SECTION: gapplication
* @title: GApplication
* @short_description: Core application class
*
* A #GApplication is the foundation of an application, unique for a
* given application identifier. The #GApplication wraps some
* low-level platform-specific services and is intended to act as the
* foundation for higher-level application classes such as
* #GtkApplication or #MxApplication. In general, you should not use
* this class outside of a higher level framework. By default,
* g_application_register_with_data() will invoke g_error() if it is
* run in a context where it cannot support its core features. Note
* that g_error() is by default fatal.
*
* One of the core features that #GApplication provides is process
* uniqueness, in the context of a "session". The session concept is
* platform-dependent, but corresponds roughly to a graphical desktop
* login. When your application is launched again, its arguments
* are passed through platform communication to the already running
* program.
*
* In addition, #GApplication provides support for 'actions', which
* can be presented to the user in a platform-specific way
* (e.g. Windows 7 jump lists). Note that these are just simple
* actions without parameters. For more flexible scriptability,
* implementing a a separate D-Bus interface is recommended, see e.g.
* <xref linkend="gdbus-convenience"/>.
*
* Finally, #GApplication acts as a basic lifecycle root; see the
* g_application_run() and g_application_quit_with_data() methods.
*
* Before using #GApplication, you must choose an "application identifier".
* The expected form of an application identifier is very close to that of
* of a <ulink url="http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-interface">DBus bus name</ulink>.
* Examples include: "com.example.MyApp" "org.example.internal-apps.Calculator"
* For convenience, the restrictions on application identifiers are reproduced
* here:
* <itemizedlist>
* <listitem>Application identifiers must contain only the ASCII characters "[A-Z][a-z][0-9]_-" and must not begin with a digit.</listitem>
* <listitem>Application identifiers must contain at least one '.' (period) character (and thus at least two elements).</listitem>
* <listitem>Application identifiers must not begin with a '.' (period) character.</listitem>
* <listitem>Application identifiers must not exceed 255 characters.</listitem>
* </itemizedlist>
*
* <refsect2><title>D-Bus implementation</title>
* <para>
* On UNIX systems using D-Bus, #GApplication is implemented by claiming the
* application identifier as a bus name on the session bus. The implementation
* exports an object at the object path that is created by replacing '.' with
* '/' in the application identifier (e.g. the object path for the
* application id 'org.gtk.TestApp' is '/org/gtk/TestApp'). The object
* implements the org.gtk.Application interface.
* </para>
* <classsynopsis class="interface">
* <ooclass><interfacename>org.gtk.Application</interfacename></ooclass>
* <methodsynopsis>
* <void/>
* <methodname>Activate</methodname>
* <methodparam><modifier>in</modifier><type>aay</type><parameter>arguments</parameter></methodparam>
* <methodparam><modifier>in</modifier><type>a{sv}</type><parameter>data</parameter></methodparam>
* </methodsynopsis>
* <methodsynopsis>
* <void/>
* <methodname>InvokeAction</methodname>
* <methodparam><modifier>in</modifier><type>s</type><parameter>action</parameter></methodparam>
* <methodparam><modifier>in</modifier><type>a{sv}</type><parameter>data</parameter></methodparam>
* </methodsynopsis>
* <methodsynopsis>
* <type>a{s(sb)}</type>
* <methodname>ListActions</methodname>
* <void/>
* </methodsynopsis>
* <methodsynopsis>
* <void/>
* <methodname>Quit</methodname>
* <methodparam><modifier>in</modifier><type>a{sv}</type><parameter>data</parameter></methodparam>
* </methodsynopsis>
* <methodsynopsis>
* <modifier>Signal</modifier>
* <void/>
* <methodname>ActionsChanged</methodname>
* <void/>
* </methodsynopsis>
* </classsynopsis>
* <para>
* The <methodname>Activate</methodname> function is called on the existing
* application instance when a second instance fails to take the bus name.
* @arguments contains the commandline arguments given to the second instance
* and @data contains platform-specific additional data.
*
* On all platforms, @data will have a key "cwd" of type signature
* "ay" which contains the working directory of the invoked
* executable; this data is defined to be in the default GLib
* filesystem encoding for the platform. See g_filename_to_utf8().
*
* </para>
* <para>
* The <methodname>InvokeAction</methodname> function can be called to
* invoke one of the actions exported by the application. On X11
* platforms, the platform_data argument should have a "timestamp"
* parameter of type "u" with the server time of the initiating event.
* </para>
* <para>
* The <methodname>ListActions</methodname> function returns a dictionary
* with the exported actions of the application. The keys of the dictionary
* are the action names, and the values are structs containing the description
* for the action and a boolean that represents if the action is enabled or not.
* </para>
* <para>
* The <methodname>Quit</methodname> function can be called to
* terminate the application. The @data parameter contains
* platform-specific data. On X11 platforms, the platform_data
* argument should have a "timestamp" parameter of type "u" with the
* server time of the initiating event.
* </para>
* <para>
* The <methodname>ActionsChanged</methodname> signal is emitted when the
* exported actions change (i.e. an action is added, removed, enabled,
* disabled, or otherwise changed).
* </para>
* <para>
* #GApplication is supported since Gio 2.26.
* </para>
* </refsect2>
*/
static void initable_iface_init (GInitableIface *initable_iface);
G_DEFINE_TYPE_WITH_CODE (GApplication, g_application, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init));
enum
{
PROP_0,
PROP_APPLICATION_ID,
PROP_REGISTER,
PROP_DEFAULT_QUIT,
PROP_IS_REMOTE,
PROP_ARGV,
PROP_PLATFORM_DATA
};
enum
{
QUIT_WITH_DATA,
ACTION_WITH_DATA,
PREPARE_ACTIVATION,
LAST_SIGNAL
};
static guint application_signals[LAST_SIGNAL] = { 0 };
typedef struct {
gchar *name;
gchar *description;
guint enabled : 1;
} GApplicationAction;
struct _GApplicationPrivate
{
gchar *appid;
GHashTable *actions; /* name -> GApplicationAction */
GMainLoop *mainloop;
GVariant *argv;
GVariant *platform_data;
guint do_register : 1;
guint default_quit : 1;
guint is_remote : 1;
guint actions_changed_id;
#ifdef G_OS_UNIX
gchar *dbus_path;
GDBusConnection *session_bus;
#endif
};
static GApplication *primary_application = NULL;
static GHashTable *instances_for_appid = NULL;
static gboolean initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error);
static gboolean _g_application_platform_init (GApplication *app,
GCancellable *cancellable,
GError **error);
static gboolean _g_application_platform_register (GApplication *app,
gboolean *unique,
GCancellable *cancellable,
GError **error);
static void _g_application_platform_remote_invoke_action (GApplication *app,
const gchar *action,
GVariant *platform_data);
static void _g_application_platform_remote_quit (GApplication *app,
GVariant *platform_data);
static void _g_application_platform_on_actions_changed (GApplication *app);
static void
initable_iface_init (GInitableIface *initable_iface)
{
initable_iface->init = initable_init;
}
#ifdef G_OS_UNIX
#include "gdbusapplication.c"
#else
#include "gnullapplication.c"
#endif
static gboolean
_g_application_validate_id (const char *id)
{
gboolean allow_dot;
if (strlen (id) > 255)
return FALSE;
if (!g_ascii_isalpha (*id))
return FALSE;
id++;
allow_dot = FALSE;
for (; *id; id++)
{
if (g_ascii_isalnum (*id) || (*id == '-') || (*id == '_'))
allow_dot = TRUE;
else if (allow_dot && *id == '.')
allow_dot = FALSE;
else
return FALSE;
}
return TRUE;
}
static gpointer
init_appid_statics (gpointer data)
{
instances_for_appid = g_hash_table_new (g_str_hash, g_str_equal);
return NULL;
}
static GApplication *
application_for_appid (const char *appid)
{
static GOnce appid_once = G_ONCE_INIT;
g_once (&appid_once, init_appid_statics, NULL);
return g_hash_table_lookup (instances_for_appid, appid);
}
static gboolean
g_application_default_quit_with_data (GApplication *application,
GVariant *platform_data)
{
g_return_val_if_fail (application->priv->mainloop != NULL, FALSE);
g_main_loop_quit (application->priv->mainloop);
return TRUE;
}
static void
g_application_default_run (GApplication *application)
{
if (application->priv->mainloop == NULL)
application->priv->mainloop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (application->priv->mainloop);
}
static GVariant *
append_cwd_to_platform_data (GVariant *platform_data)
{
GVariantBuilder builder;
gchar *cwd;
GVariant *result;
cwd = g_get_current_dir ();
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
if (cwd)
g_variant_builder_add (&builder, "{sv}",
"cwd",
g_variant_new_bytestring (cwd));
g_free (cwd);
if (platform_data)
{
GVariantIter iter;
GVariant *item;
g_variant_iter_init (&iter, platform_data);
while (g_variant_iter_next (&iter, "@{sv}", &item))
{
g_variant_builder_add_value (&builder, item);
g_variant_unref (item);
}
}
result = g_variant_builder_end (&builder);
return result;
}
static gboolean
timeout_handle_actions_changed (gpointer user_data)
{
GApplication *application = user_data;
application->priv->actions_changed_id = 0;
_g_application_platform_on_actions_changed (application);
return FALSE;
}
static inline void
queue_actions_change_notification (GApplication *application)
{
GApplicationPrivate *priv = application->priv;
if (priv->actions_changed_id == 0)
priv->actions_changed_id = g_timeout_add (0, timeout_handle_actions_changed, application);
}
static gboolean
initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
GApplication *app = G_APPLICATION (initable);
gboolean unique;
if (!_g_application_platform_init (app, cancellable, error))
return FALSE;
if (app->priv->do_register &&
!_g_application_platform_register (app, &unique, cancellable ,error))
return FALSE;
return TRUE;
}
static void
g_application_action_free (gpointer data)
{
if (G_LIKELY (data != NULL))
{
GApplicationAction *action = data;
g_free (action->name);
g_free (action->description);
g_slice_free (GApplicationAction, action);
}
}
/**
* g_application_new:
* @appid: System-dependent application identifier
* @argc: Number of arguments in @argv
* @argv: (allow-none) (array length=argc): Argument vector, usually from the <parameter>argv</parameter> parameter of main()
*
* Create a new #GApplication. This uses a platform-specific
* mechanism to ensure the current process is the unique owner of the
* application (as defined by the @appid). If successful, the
* #GApplication:is-remote property will be %FALSE, and it is safe to
* continue creating other resources such as graphics windows.
*
* If the given @appid is already running in another process, the the
* GApplication::activate_with_data signal will be emitted in the
* remote process, with the data from @argv and other
* platform-specific data available. Subsequently the
* #GApplication:default-quit property will be evaluated. If it's
* %TRUE, then the current process will terminate. If %FALSE, then
* the application remains in the #GApplication:is-remote state, and
* you can e.g. call g_application_invoke_action(). Note that proxy
* instances should not call g_application_add_action().
*
* This function may do synchronous I/O to obtain unique ownership
* of the application id, and will block the calling thread in this
* case.
*
* If the environment does not support the basic functionality of
* #GApplication, this function will invoke g_error(), which by
* default is a fatal operation. This may arise for example on
* UNIX systems using D-Bus when the session bus is not available.
*
* As a convenience, this function is defined to call g_type_init() as
* its very first action.
*
* Returns: (transfer full): An application instance
*
* Since: 2.26
*/
GApplication *
g_application_new (const gchar *appid,
int argc,
char **argv)
{
const gchar * const *args = (const gchar **) argv;
GObject *app;
GError *error = NULL;
GVariant *argv_variant;
g_type_init ();
g_return_val_if_fail (appid != NULL, NULL);
argv_variant = g_variant_new_bytestring_array (args, argc);
app = g_initable_new (G_TYPE_APPLICATION,
NULL,
&error,
"application-id", appid,
"argv", argv_variant,
NULL);
if (!app)
{
g_error ("%s", error->message);
g_clear_error (&error);
return NULL;
}
return G_APPLICATION (app);
}
/**
* g_application_try_new:
* @appid: System-dependent application identifier
* @argc: Number of arguments in @argv
* @argv: (allow-none) (array length=argc): Argument vector, usually from the <parameter>argv</parameter> parameter of main()
* @error: a #GError
*
* This function is similar to g_application_new(), but allows for
* more graceful fallback if the environment doesn't support the
* basic #GApplication functionality.
*
* Returns: (transfer full): An application instance
*
* Since: 2.26
*/
GApplication *
g_application_try_new (const gchar *appid,
int argc,
char **argv,
GError **error)
{
const gchar * const *args = (const gchar **) argv;
GVariant *argv_variant;
g_type_init ();
g_return_val_if_fail (appid != NULL, NULL);
argv_variant = g_variant_new_bytestring_array (args, argc);
return G_APPLICATION (g_initable_new (G_TYPE_APPLICATION,
NULL,
error,
"application-id", appid,
"argv", argv_variant,
NULL));
}
/**
* g_application_unregistered_try_new:
* @appid: System-dependent application identifier
* @argc: Number of arguments in @argv
* @argv: (allow-none) (array length=argc): Argument vector, usually from the <parameter>argv</parameter> parameter of main()
* @error: a #GError
*
* This function is similar to g_application_try_new(), but also
* sets the GApplication:register property to %FALSE. You can later
* call g_application_register() to complete initialization.
*
* Returns: (transfer full): An application instance
*
* Since: 2.26
*/
GApplication *
g_application_unregistered_try_new (const gchar *appid,
int argc,
char **argv,
GError **error)
{
const gchar * const *args = (const gchar **) argv;
GVariant *argv_variant;
g_type_init ();
g_return_val_if_fail (appid != NULL, NULL);
argv_variant = g_variant_new_bytestring_array (args, argc);
return G_APPLICATION (g_initable_new (G_TYPE_APPLICATION,
NULL,
error,
"application-id", appid,
"argv", argv_variant,
"register", FALSE,
NULL));
}
/**
* g_application_register:
* @application: a #GApplication
*
* By default, #GApplication ensures process uniqueness when
* initialized, but this behavior is controlled by the
* GApplication:register property. If it was given as %FALSE at
* construction time, this function allows you to later attempt
* to ensure uniqueness.
*
* Returns: %TRUE if registration was successful
*/
gboolean
g_application_register (GApplication *application)
{
gboolean unique;
g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
g_return_val_if_fail (application->priv->is_remote, FALSE);
if (!_g_application_platform_register (application, &unique, NULL, NULL))
return FALSE;
return unique;
}
/**
* g_application_add_action:
* @application: a #GApplication
* @name: the action name
* @description: the action description; can be a translatable
* string
*
* Adds an action @name to the list of exported actions of @application.
*
* It is an error to call this function if @application is a proxy for
* a remote application.
*
* You can invoke an action using g_application_invoke_action().
*
* The newly added action is enabled by default; you can call
* g_application_set_action_enabled() to disable it.
*
* Since: 2.26
*/
void
g_application_add_action (GApplication *application,
const gchar *name,
const gchar *description)
{
GApplicationPrivate *priv;
GApplicationAction *action;
g_return_if_fail (G_IS_APPLICATION (application));
g_return_if_fail (name != NULL && *name != '\0');
g_return_if_fail (!application->priv->is_remote);
priv = application->priv;
g_return_if_fail (g_hash_table_lookup (priv->actions, name) == NULL);
action = g_slice_new (GApplicationAction);
action->name = g_strdup (name);
action->description = g_strdup (description);
action->enabled = TRUE;
g_hash_table_insert (priv->actions, action->name, action);
queue_actions_change_notification (application);
}
/**
* g_application_remove_action:
* @application: a #GApplication
* @name: the name of the action to remove
*
* Removes the action @name from the list of exported actions of @application.
*
* It is an error to call this function if @application is a proxy for
* a remote application.
*
* Since: 2.26
*/
void
g_application_remove_action (GApplication *application,
const gchar *name)
{
GApplicationPrivate *priv;
g_return_if_fail (G_IS_APPLICATION (application));
g_return_if_fail (name != NULL && *name != '\0');
g_return_if_fail (!application->priv->is_remote);
priv = application->priv;
g_return_if_fail (g_hash_table_lookup (priv->actions, name) != NULL);
g_hash_table_remove (priv->actions, name);
queue_actions_change_notification (application);
}
/**
* g_application_invoke_action:
* @application: a #GApplication
* @name: the name of the action to invoke
* @platform_data: (allow-none): platform-specific event data
*
* Invokes the action @name of the passed #GApplication.
*
* This function has different behavior depending on whether @application
* is acting as a proxy for another process. In the normal case where
* the current process is hosting the application, and the specified
* action exists and is enabled, the #GApplication::action signal will
* be emitted.
*
* If @application is a proxy, then the specified action will be invoked
* in the remote process. It is not necessary to call
* g_application_add_action() in the current process in order to invoke
* one remotely.
*
* Since: 2.26
*/
void
g_application_invoke_action (GApplication *application,
const gchar *name,
GVariant *platform_data)
{
GApplicationPrivate *priv;
GApplicationAction *action;
g_return_if_fail (G_IS_APPLICATION (application));
g_return_if_fail (name != NULL);
g_return_if_fail (platform_data == NULL
|| g_variant_is_of_type (platform_data, G_VARIANT_TYPE ("a{sv}")));
if (platform_data == NULL)
platform_data = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
else
g_variant_ref (platform_data);
priv = application->priv;
if (priv->is_remote)
{
_g_application_platform_remote_invoke_action (application, name, platform_data);
goto out;
}
action = g_hash_table_lookup (priv->actions, name);
g_return_if_fail (action != NULL);
if (!action->enabled)
goto out;
g_signal_emit (application, application_signals[ACTION_WITH_DATA],
g_quark_from_string (name),
name,
platform_data);
out:
g_variant_unref (platform_data);
}
/**
* g_application_list_actions:
* @application: a #GApplication
*
* Retrieves the list of action names currently exported by @application.
*
* It is an error to call this function if @application is a proxy for
* a remote application.
*
* Return value: (transfer full): a newly allocation, %NULL-terminated array
* of strings containing action names; use g_strfreev() to free the
* resources used by the returned array
*
* Since: 2.26
*/
gchar **
g_application_list_actions (GApplication *application)
{
GApplicationPrivate *priv;
GHashTableIter iter;
gpointer key;
gchar **retval;
gint i;
g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
g_return_val_if_fail (!application->priv->is_remote, NULL);
priv = application->priv;
retval = g_new (gchar*, g_hash_table_size (priv->actions));
i = 0;
g_hash_table_iter_init (&iter, priv->actions);
while (g_hash_table_iter_next (&iter, &key, NULL))
retval[i++] = g_strdup (key);
retval[i] = NULL;
return retval;
}
/**
* g_application_set_action_enabled:
* @application: a #GApplication
* @name: the name of the application
* @enabled: whether to enable or disable the action @name
*
* Sets whether the action @name inside @application should be enabled
* or disabled.
*
* It is an error to call this function if @application is a proxy for
* a remote application.
*
* Invoking a disabled action will not result in the #GApplication::action
* signal being emitted.
*
* Since: 2.26
*/
void
g_application_set_action_enabled (GApplication *application,
const gchar *name,
gboolean enabled)
{
GApplicationAction *action;
g_return_if_fail (G_IS_APPLICATION (application));
g_return_if_fail (name != NULL);
g_return_if_fail (!application->priv->is_remote);
enabled = !!enabled;
action = g_hash_table_lookup (application->priv->actions, name);
g_return_if_fail (action != NULL);
if (action->enabled == enabled)
return;
action->enabled = enabled;
queue_actions_change_notification (application);
}
/**
* g_application_get_action_description:
* @application: a #GApplication
* @name: Action name
*
* Gets the description of the action @name.
*
* It is an error to call this function if @application is a proxy for
* a remote application.
*
* Returns: Description for the given action named @name
*
* Since: 2.26
*/
G_CONST_RETURN gchar *
g_application_get_action_description (GApplication *application,
const gchar *name)
{
GApplicationAction *action;
g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (!application->priv->is_remote, NULL);
action = g_hash_table_lookup (application->priv->actions, name);
g_return_val_if_fail (action != NULL, NULL);
return action->description;
}
/**
* g_application_get_action_enabled:
* @application: a #GApplication
* @name: the name of the action
*
* Retrieves whether the action @name is enabled or not.
*
* See g_application_set_action_enabled().
*
* It is an error to call this function if @application is a proxy for
* a remote application.
*
* Return value: %TRUE if the action was enabled, and %FALSE otherwise
*
* Since: 2.26
*/
gboolean
g_application_get_action_enabled (GApplication *application,
const gchar *name)
{
GApplicationAction *action;
g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (!application->priv->is_remote, FALSE);
action = g_hash_table_lookup (application->priv->actions, name);
g_return_val_if_fail (action != NULL, FALSE);
return action->enabled;
}
/**
* g_application_run:
* @application: a #GApplication
*
* Starts the application.
*
* The default implementation of this virtual function will simply run
* a main loop.
*
* It is an error to call this function if @application is a proxy for
* a remote application.
*
* Since: 2.26
*/
void
g_application_run (GApplication *application)
{
g_return_if_fail (G_IS_APPLICATION (application));
g_return_if_fail (!application->priv->is_remote);
G_APPLICATION_GET_CLASS (application)->run (application);
}
/**
* g_application_quit_with_data:
* @application: a #GApplication
* @platform_data: (allow-none): platform-specific data
*
* Request that the application quits.
*
* This function has different behavior depending on whether @application
* is acting as a proxy for another process. In the normal case where
* the current process is hosting the application, the default
* implementation will quit the main loop created by g_application_run().
*
* If @application is a proxy, then the remote process will be asked
* to quit.
*
* Returns: %TRUE if the application accepted the request, %FALSE otherwise
*
* Since: 2.26
*/
gboolean
g_application_quit_with_data (GApplication *application,
GVariant *platform_data)
{
gboolean retval = FALSE;
g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
g_return_val_if_fail (platform_data == NULL
|| g_variant_is_of_type (platform_data, G_VARIANT_TYPE ("a{sv}")), FALSE);
if (platform_data == NULL)
platform_data = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
else
g_variant_ref (platform_data);
if (application->priv->is_remote)
{
_g_application_platform_remote_quit (application, platform_data);
retval = TRUE;
}
else
g_signal_emit (application, application_signals[QUIT_WITH_DATA], 0, platform_data, &retval);
g_variant_unref (platform_data);
return retval;
}
/**
* g_application_get_instance:
*
* In the normal case where there is exactly one #GApplication instance
* in this process, return that instance. If there are multiple, the
* first one created will be returned. Otherwise, return %NULL.
*
* Returns: (transfer none): The primary instance of #GApplication,
* or %NULL if none is set
*
* Since: 2.26
*/
GApplication *
g_application_get_instance (void)
{
return primary_application;
}
/**
* g_application_get_id:
* @application: a #GApplication
*
* Retrieves the platform-specific identifier for the #GApplication.
*
* Return value: The platform-specific identifier. The returned string
* is owned by the #GApplication instance and it should never be
* modified or freed
*
* Since: 2.26
*/
G_CONST_RETURN gchar *
g_application_get_id (GApplication *application)
{
g_return_val_if_fail (G_IS_APPLICATION (application), NULL);
return application->priv->appid;
}
/**
* g_application_is_remote:
* @application: a #GApplication
*
* Returns whether the object represents a proxy for a remote application.
*
* Returns: %TRUE if this object represents a proxy for a remote application.
*/
gboolean
g_application_is_remote (GApplication *application)
{
g_return_val_if_fail (G_IS_APPLICATION (application), FALSE);
return application->priv->is_remote;
}
static void
g_application_init (GApplication *app)
{
app->priv = G_TYPE_INSTANCE_GET_PRIVATE (app,
G_TYPE_APPLICATION,
GApplicationPrivate);
app->priv->actions = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL,
g_application_action_free);
app->priv->default_quit = TRUE;
app->priv->do_register = TRUE;
app->priv->is_remote = TRUE;
app->priv->platform_data = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
}
static void
g_application_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GApplication *app = G_APPLICATION (object);
switch (prop_id)
{
case PROP_APPLICATION_ID:
g_value_set_string (value, g_application_get_id (app));
break;
case PROP_DEFAULT_QUIT:
g_value_set_boolean (value, app->priv->default_quit);
break;
case PROP_IS_REMOTE:
g_value_set_boolean (value, g_application_is_remote (app));
break;
case PROP_REGISTER:
g_value_set_boolean (value, app->priv->do_register);
break;
case PROP_ARGV:
g_value_set_variant (value, app->priv->argv);
break;
case PROP_PLATFORM_DATA:
g_value_set_variant (value, app->priv->platform_data);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
g_application_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GApplication *app = G_APPLICATION (object);
switch (prop_id)
{
case PROP_APPLICATION_ID:
g_return_if_fail (_g_application_validate_id (g_value_get_string (value)));
app->priv->appid = g_value_dup_string (value);
break;
case PROP_DEFAULT_QUIT:
app->priv->default_quit = g_value_get_boolean (value);
break;
case PROP_REGISTER:
app->priv->do_register = g_value_get_boolean (value);
break;
case PROP_ARGV:
app->priv->argv = g_value_dup_variant (value);
break;
case PROP_PLATFORM_DATA:
{
GVariant *platform_data = g_value_get_variant (value);
if (app->priv->platform_data)
g_variant_unref (app->priv->platform_data);
app->priv->platform_data = g_variant_ref_sink (append_cwd_to_platform_data (platform_data));
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static GObject*
g_application_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GApplication *app;
GObject *object;
const char *appid = NULL;
guint i;
for (i = 0; i < n_construct_properties; i++)
{
GObjectConstructParam *param = &construct_params[i];
if (strcmp (param->pspec->name, "application-id") == 0)
appid = g_value_get_string (param->value);
}
g_return_val_if_fail (appid != NULL, NULL);
app = application_for_appid (appid);
if (app != NULL)
return g_object_ref (app);
object = (* G_OBJECT_CLASS (g_application_parent_class)->constructor) (type,
n_construct_properties,
construct_params);
app = G_APPLICATION (object);
if (primary_application == NULL)
primary_application = app;
g_hash_table_insert (instances_for_appid, g_strdup (appid), app);
return object;
}
static void
g_application_finalize (GObject *object)
{
GApplication *app = G_APPLICATION (object);
g_free (app->priv->appid);
if (app->priv->actions)
g_hash_table_unref (app->priv->actions);
if (app->priv->actions_changed_id)
g_source_remove (app->priv->actions_changed_id);
if (app->priv->mainloop)
g_main_loop_unref (app->priv->mainloop);
#ifdef G_OS_UNIX
g_free (app->priv->dbus_path);
if (app->priv->session_bus)
g_object_unref (app->priv->session_bus);
#endif
G_OBJECT_CLASS (g_application_parent_class)->finalize (object);
}
static void
g_application_class_init (GApplicationClass *klass)
{
GObjectClass *gobject_class G_GNUC_UNUSED = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GApplicationPrivate));
gobject_class->constructor = g_application_constructor;
gobject_class->set_property = g_application_set_property;
gobject_class->get_property = g_application_get_property;
gobject_class->finalize = g_application_finalize;
klass->run = g_application_default_run;
klass->quit_with_data = g_application_default_quit_with_data;
/**
* GApplication::quit-with-data:
* @application: the object on which the signal is emitted
* @platform_data: Platform-specific data, or %NULL
*
* This signal is emitted when the Quit action is invoked on the
* application.
*
* The default handler for this signal exits the mainloop of the
* application.
*
* Returns: %TRUE if the signal has been handled, %FALSE to continue
* signal emission
*/
application_signals[QUIT_WITH_DATA] =
g_signal_new (g_intern_static_string ("quit-with-data"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GApplicationClass, quit_with_data),
g_signal_accumulator_true_handled, NULL,
_gio_marshal_BOOLEAN__VARIANT,
G_TYPE_BOOLEAN, 1,
G_TYPE_VARIANT);
/**
* GApplication::action-with-data:
* @application: the object on which the signal is emitted
* @name: The name of the activated action
* @platform_data: Platform-specific data, or %NULL
*
* This signal is emitted when an action is activated. The action name
* is passed as the first argument, but also as signal detail, so it
* is possible to connect to this signal for individual actions.
*
* The signal is never emitted for disabled actions.
*/
application_signals[ACTION_WITH_DATA] =
g_signal_new (g_intern_static_string ("action-with-data"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED,
G_STRUCT_OFFSET (GApplicationClass, action_with_data),
NULL, NULL,
_gio_marshal_VOID__STRING_VARIANT,
G_TYPE_NONE, 2,
G_TYPE_STRING,
G_TYPE_VARIANT);
/**
* GApplication::prepare-activation:
* @application: the object on which the signal is emitted
* @arguments: A #GVariant with the signature "aay"
* @platform_data: A #GVariant with the signature "a{sv}", or %NULL
*
* This signal is emitted when a non-primary process for a given
* application is invoked while your application is running; for
* example, when a file browser launches your program to open a
* file. The raw operating system arguments are passed in the
* @arguments variant. Additional platform-dependent data is
* stored in @platform_data.
*/
application_signals[PREPARE_ACTIVATION] =
g_signal_new (g_intern_static_string ("prepare-activation"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GApplicationClass, prepare_activation),
NULL, NULL,
_gio_marshal_VOID__VARIANT_VARIANT,
G_TYPE_NONE, 2,
G_TYPE_VARIANT,
G_TYPE_VARIANT);
/**
* GApplication:application-id:
*
* The unique identifier for this application. See the documentation for
* #GApplication for more information about this property.
*
*/
g_object_class_install_property (gobject_class,
PROP_APPLICATION_ID,
g_param_spec_string ("application-id",
P_("Application ID"),
P_("Identifier for this application"),
NULL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
/**
* GApplication:argv:
*
* The argument vector given to this application. It must be a #GVariant
* with a type signature "aay".
*
*/
g_object_class_install_property (gobject_class,
PROP_ARGV,
g_param_spec_variant ("argv",
P_("Argument vector"),
P_("System argument vector with type signature aay"),
G_VARIANT_TYPE ("aay"),
NULL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
/**
* GApplication:platform-data:
*
* Platform-specific data retrieved from the operating system
* environment. It must be a #GVariant with type signature "a{sv}".
*
*/
g_object_class_install_property (gobject_class,
PROP_PLATFORM_DATA,
g_param_spec_variant ("platform-data",
P_("Platform data"),
P_("Environmental data, must have type signature a{sv}"),
G_VARIANT_TYPE ("a{sv}"),
NULL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
/**
* GApplication:default-quit:
*
* By default, if a different process is running this application, the
* process will be exited. Set this property to %FALSE to allow custom
* interaction with the remote process.
*
*/
g_object_class_install_property (gobject_class,
PROP_DEFAULT_QUIT,
g_param_spec_boolean ("default-quit",
P_("Default Quit"),
P_("Exit the process by default"),
TRUE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
/**
* GApplication:is-remote:
*
* This property is %TRUE if this application instance represents a proxy
* to the instance of this application in another process.
*
*/
g_object_class_install_property (gobject_class,
PROP_IS_REMOTE,
g_param_spec_boolean ("is-remote",
P_("Is Remote"),
P_("Whether this application is a proxy for another process"),
TRUE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
/**
* GApplication:register:
*
* If this property is %FALSE, the application construction will not attempt
* to ensure process uniqueness, and the application is guaranteed to be in the
* remote state. See GApplication:is-remote.
*/
g_object_class_install_property (gobject_class,
PROP_REGISTER,
g_param_spec_boolean ("register",
P_("Register"),
P_("If false, do not "),
TRUE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
}