X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gio%2Fgapplication.c;h=d3132e1b4825415597c875d53775640f04e6b2e3;hb=639bd3626b683a0be273462d47e6bc30351a77d1;hp=0abdcfc9d364eb39e9d5f80bd104a6df0d767766;hpb=ae0bd032cac1931fba13bd7a20040760edcd349c;p=platform%2Fupstream%2Fglib.git diff --git a/gio/gapplication.c b/gio/gapplication.c index 0abdcfc..d3132e1 100644 --- a/gio/gapplication.c +++ b/gio/gapplication.c @@ -25,10 +25,16 @@ #include "gapplication.h" #include "gapplicationcommandline.h" +#include "gsimpleactiongroup.h" +#include "gremoteactiongroup.h" #include "gapplicationimpl.h" #include "gactiongroup.h" +#include "gactionmap.h" #include "gmenumodel.h" #include "gsettings.h" +#include "gnotification-private.h" +#include "gnotificationbackend.h" +#include "gdbusutils.h" #include "gioenumtypes.h" #include "gioenums.h" @@ -43,59 +49,74 @@ * @title: GApplication * @short_description: Core application class * - * A #GApplication is the foundation of an application, unique for a - * given application identifier. The GApplication class wraps some + * A #GApplication is the foundation of an application. It 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. * - * 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. The already running instance of the program is called the - * primary instance. - * - * Before using GApplication, you must choose an "application identifier". - * The expected form of an application identifier is very close to that of - * of a DBus bus name. - * Examples include: "com.example.MyApp", "org.example.internal-apps.Calculator". - * For details on valid application identifiers, see - * g_application_id_is_valid(). - * - * The application identifier is claimed by the application as a - * well-known bus name on the user's session bus. This means that the - * uniqueness of your application is scoped to the current session. It - * also means that your application may provide additional services - * (through registration of other object paths) at that bus name. - * - * The registration of these object paths should be done with the shared - * GDBus session bus. Note that due to the internal architecture of - * GDBus, method calls can be dispatched at any time (even if a main - * loop is not running). For this reason, you must ensure that any - * object paths that you wish to register are registered before - * #GApplication attempts to acquire the bus name of your application - * (which happens in g_application_register()). Unfortunately, this - * means that you cannot use g_application_get_is_remote() to decide if - * you want to register object paths. - * * GApplication provides convenient life cycle management by maintaining * a use count for the primary application instance. * The use count can be changed using g_application_hold() and * g_application_release(). If it drops to zero, the application exits. - * - * GApplication also implements the #GActionGroup interface and lets you - * easily export actions by adding them with g_application_set_action_group(). - * When invoking an action by calling g_action_group_activate_action() on - * the application, it is always invoked in the primary instance. The actions - * are also exported on the session bus, and GIO provides the #GDBusActionGroup - * wrapper to conveniently access them remotely. Additionally, - * g_application_set_menu() can be used to export representation data - * for the actions, in the form of a #GMenuModel. - * - * There is a number of different entry points into a #GApplication: + * Higher-level classes such as #GtkApplication employ the use count to + * ensure that the application stays alive as long as it has any opened + * windows. + * + * Another feature that GApplication (optionally) provides is process + * uniqueness. Applications can make use of this functionality by + * providing a unique application ID. If given, only one application + * with this ID can be running at a time per 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. The already running instance of the program is + * called the primary instance; for non-unique + * applications this is the always the current instance. + * On Linux, the D-Bus session bus is used for communication. + * + * The use of #GApplication differs from some other commonly-used + * uniqueness libraries (such as libunique) in important ways. The + * application is not expected to manually register itself and check if + * it is the primary instance. Instead, the main() + * function of a #GApplication should do very little more than + * instantiating the application instance, possibly connecting signal + * handlers, then calling g_application_run(). All checks for + * uniqueness are done internally. If the application is the primary + * instance then the startup signal is emitted and the mainloop runs. + * If the application is not the primary instance then a signal is sent + * to the primary instance and g_application_run() promptly returns. + * See the code examples below. + * + * If used, the expected form of an application identifier is very close + * to that of of a + * DBus bus name. + * Examples include: "com.example.MyApp", "org.example.internal-apps.Calculator". + * For details on valid application identifiers, see g_application_id_is_valid(). + * + * On Linux, the application identifier is claimed as a well-known bus name + * on the user's session bus. This means that the uniqueness of your + * application is scoped to the current session. It also means that your + * application may provide additional services (through registration of other + * object paths) at that bus name. The registration of these object paths + * should be done with the shared GDBus session bus. Note that due to the + * internal architecture of GDBus, method calls can be dispatched at any time + * (even if a main loop is not running). For this reason, you must ensure that + * any object paths that you wish to register are registered before #GApplication + * attempts to acquire the bus name of your application (which happens in + * g_application_register()). Unfortunately, this means that you cannot use + * g_application_get_is_remote() to decide if you want to register object paths. + * + * GApplication also implements the #GActionGroup and #GActionMap + * interfaces and lets you easily export actions by adding them with + * g_action_map_add_action(). When invoking an action by calling + * g_action_group_activate_action() on the application, it is always + * invoked in the primary instance. The actions are also exported on + * the session bus, and GIO provides the #GDBusActionGroup wrapper to + * conveniently access them remotely. GIO provides a #GDBusMenuModel wrapper + * for remote access to exported #GMenuModels. + * + * There is a number of different entry points into a GApplication: * * via 'Activate' (i.e. just starting the application) * via 'Open' (i.e. opening some files) @@ -111,7 +132,7 @@ * in the form of a #GVariant dictionary mapping strings to variants. * To use platform data, override the @before_emit or @after_emit virtual * functions in your #GApplication subclass. When dealing with - * #GApplicationCommandline objects, the platform data is directly + * #GApplicationCommandLine objects, the platform data is directly * available via g_application_command_line_get_cwd(), * g_application_command_line_get_environ() and * g_application_command_line_get_platform_data(). @@ -121,7 +142,7 @@ * "cwd"), and optionally the environment (ie the set of environment * variables and their values) of the calling process (key "environ"). * The environment is only added to the platform data if the - * #G_APPLICATION_SEND_ENVIONMENT flag is set. GApplication subclasses + * %G_APPLICATION_SEND_ENVIRONMENT flag is set. #GApplication subclasses * can add their own platform data by overriding the @add_platform_data * virtual function. For instance, #GtkApplication adds startup notification * data in this way. @@ -146,6 +167,67 @@ * * * + * + * A GApplication with menus + * + * + * FIXME: MISSING XINCLUDE CONTENT + * + * + * + * + * Using extra D-Bus hooks with a GApplication + * + * + * FIXME: MISSING XINCLUDE CONTENT + * + * + * + */ + +/** + * GApplicationClass: + * @startup: invoked on the primary instance immediately after registration + * @shutdown: invoked only on the registered primary instance immediately + * after the main loop terminates + * @activate: invoked on the primary instance when an activation occurs + * @open: invoked on the primary instance when there are files to open + * @command_line: invoked on the primary instance when a command-line is + * not handled locally + * @local_command_line: invoked (locally) when the process has been invoked + * via commandline execution (as opposed to, say, D-Bus activation - which + * is not currently supported by GApplication). The virtual function has + * the chance to inspect (and possibly replace) the list of command line + * arguments. See g_application_run() for more information. + * @before_emit: invoked on the primary instance before 'activate', 'open', + * 'command-line' or any action invocation, gets the 'platform data' from + * the calling instance + * @after_emit: invoked on the primary instance after 'activate', 'open', + * 'command-line' or any action invocation, gets the 'platform data' from + * the calling instance + * @add_platform_data: invoked (locally) to add 'platform data' to be sent to + * the primary instance when activating, opening or invoking actions + * @quit_mainloop: Used to be invoked on the primary instance when the use + * count of the application drops to zero (and after any inactivity + * timeout, if requested). Not used anymore since 2.32 + * @run_mainloop: Used to be invoked on the primary instance from + * g_application_run() if the use-count is non-zero. Since 2.32, + * GApplication is iterating the main context directly and is not + * using @run_mainloop anymore + * @dbus_register: invoked locally during registration, if the application is + * using its D-Bus backend. You can use this to export extra objects on the + * bus, that need to exist before the application tries to own the bus name. + * The function is passed the #GDBusConnection to to session bus, and the + * object path that #GApplication will use to export is D-Bus API. + * If this function returns %TRUE, registration will proceed; otherwise + * registration will abort. Since: 2.34 + * @dbus_unregister: invoked locally during unregistration, if the application + * is using its D-Bus backend. Use this to undo anything done by the + * @dbus_register vfunc. Since: 2.34 + * + * Virtual function table for #GApplication. + * + * Since: 2.28 */ struct _GApplicationPrivate @@ -154,19 +236,24 @@ struct _GApplicationPrivate gchar *id; GActionGroup *actions; - GMenuModel *menu; + GMenuModel *app_menu; + GMenuModel *menubar; guint inactivity_timeout_id; guint inactivity_timeout; guint use_count; + guint busy_count; guint is_registered : 1; guint is_remote : 1; guint did_startup : 1; guint did_shutdown : 1; + guint must_quit_now : 1; - GActionGroup *remote_actions; - GApplicationImpl *impl; + GRemoteActionGroup *remote_actions; + GApplicationImpl *impl; + + GNotificationBackend *notifications; }; enum @@ -177,8 +264,7 @@ enum PROP_IS_REGISTERED, PROP_IS_REMOTE, PROP_INACTIVITY_TIMEOUT, - PROP_ACTION_GROUP, - PROP_MENU + PROP_ACTION_GROUP }; enum @@ -195,9 +281,97 @@ enum static guint g_application_signals[NR_SIGNALS]; static void g_application_action_group_iface_init (GActionGroupInterface *); +static void g_application_action_map_iface_init (GActionMapInterface *); G_DEFINE_TYPE_WITH_CODE (GApplication, g_application, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (G_TYPE_ACTION_GROUP, - g_application_action_group_iface_init)) + G_ADD_PRIVATE (GApplication) + G_IMPLEMENT_INTERFACE (G_TYPE_ACTION_GROUP, g_application_action_group_iface_init) + G_IMPLEMENT_INTERFACE (G_TYPE_ACTION_MAP, g_application_action_map_iface_init)) + +/* GApplicationExportedActions {{{1 */ + +/* We create a subclass of GSimpleActionGroup that implements + * GRemoteActionGroup and deals with the platform data using + * GApplication's before/after_emit vfuncs. This is the action group we + * will be exporting. + * + * We could implement GRemoteActionGroup on GApplication directly, but + * this would be potentially extremely confusing to have exposed as part + * of the public API of GApplication. We certainly don't want anyone in + * the same process to be calling these APIs... + */ +typedef GSimpleActionGroupClass GApplicationExportedActionsClass; +typedef struct +{ + GSimpleActionGroup parent_instance; + GApplication *application; +} GApplicationExportedActions; + +static GType g_application_exported_actions_get_type (void); +static void g_application_exported_actions_iface_init (GRemoteActionGroupInterface *iface); +G_DEFINE_TYPE_WITH_CODE (GApplicationExportedActions, g_application_exported_actions, G_TYPE_SIMPLE_ACTION_GROUP, + G_IMPLEMENT_INTERFACE (G_TYPE_REMOTE_ACTION_GROUP, g_application_exported_actions_iface_init)) + +static void +g_application_exported_actions_activate_action_full (GRemoteActionGroup *remote, + const gchar *action_name, + GVariant *parameter, + GVariant *platform_data) +{ + GApplicationExportedActions *exported = (GApplicationExportedActions *) remote; + + G_APPLICATION_GET_CLASS (exported->application) + ->before_emit (exported->application, platform_data); + + g_action_group_activate_action (G_ACTION_GROUP (exported), action_name, parameter); + + G_APPLICATION_GET_CLASS (exported->application) + ->after_emit (exported->application, platform_data); +} + +static void +g_application_exported_actions_change_action_state_full (GRemoteActionGroup *remote, + const gchar *action_name, + GVariant *value, + GVariant *platform_data) +{ + GApplicationExportedActions *exported = (GApplicationExportedActions *) remote; + + G_APPLICATION_GET_CLASS (exported->application) + ->before_emit (exported->application, platform_data); + + g_action_group_change_action_state (G_ACTION_GROUP (exported), action_name, value); + + G_APPLICATION_GET_CLASS (exported->application) + ->after_emit (exported->application, platform_data); +} + +static void +g_application_exported_actions_init (GApplicationExportedActions *actions) +{ +} + +static void +g_application_exported_actions_iface_init (GRemoteActionGroupInterface *iface) +{ + iface->activate_action_full = g_application_exported_actions_activate_action_full; + iface->change_action_state_full = g_application_exported_actions_change_action_state_full; +} + +static void +g_application_exported_actions_class_init (GApplicationExportedActionsClass *class) +{ +} + +static GActionGroup * +g_application_exported_actions_new (GApplication *application) +{ + GApplicationExportedActions *actions; + + actions = g_object_new (g_application_exported_actions_get_type (), NULL); + actions->application = application; + + return G_ACTION_GROUP (actions); +} /* vfunc defaults {{{1 */ static void @@ -370,6 +544,22 @@ g_application_real_add_platform_data (GApplication *application, { } +static gboolean +g_application_real_dbus_register (GApplication *application, + GDBusConnection *connection, + const gchar *object_path, + GError **error) +{ + return TRUE; +} + +static void +g_application_real_dbus_unregister (GApplication *application, + GDBusConnection *connection, + const gchar *object_path) +{ +} + /* GObject implementation stuff {{{1 */ static void g_application_set_property (GObject *object, @@ -396,13 +586,8 @@ g_application_set_property (GObject *object, break; case PROP_ACTION_GROUP: - g_application_set_action_group (application, - g_value_get_object (value)); - break; - - case PROP_MENU: - g_application_set_menu (application, - g_value_get_object (value)); + g_clear_object (&application->priv->actions); + application->priv->actions = g_value_dup_object (value); break; default: @@ -415,14 +600,16 @@ g_application_set_property (GObject *object, * @application: a #GApplication * @action_group: (allow-none): a #GActionGroup, or %NULL * - * Sets or unsets the group of actions associated with the application. - * - * These actions can be invoked remotely. - * - * It is an error to call this function after the application has been - * registered. + * This used to be how actions were associated with a #GApplication. + * Now there is #GActionMap for that. * * Since: 2.28 + * + * Deprecated:2.32:Use the #GActionMap interface instead. Never ever + * mix use of this API with use of #GActionMap on the same @application + * or things will go very badly wrong. This function is known to + * introduce buggy behaviour (ie: signals not emitted on changes to the + * action group), so you should really use #GActionMap instead. **/ void g_application_set_action_group (GApplication *application, @@ -440,54 +627,6 @@ g_application_set_action_group (GApplication *application, g_object_ref (application->priv->actions); } -/** - * g_application_set_menu: - * @application: a #GApplication - * @menu: (allow-none): a #GMenuModel, or %NULL - * - * Sets or unsets the menu associated with the application. The menu - * provides representation data for the exported actions of @application. - * - * It is an error to call this function after the application has been - * registered. - * - * Since: 2.32 - */ -void -g_application_set_menu (GApplication *application, - GMenuModel *menu) -{ - g_return_if_fail (G_IS_APPLICATION (application)); - g_return_if_fail (!application->priv->is_registered); - - if (application->priv->menu != NULL) - g_object_unref (application->priv->menu); - - application->priv->menu = menu; - - if (application->priv->menu != NULL) - g_object_ref (application->priv->menu); -} - -/** - * g_application_get_menu: - * @application: a #GApplication - * - * Returns the menu model that has been set - * with g_application_set_menu(). - * - * Returns: the #GMenuModel associated with @application - * - * Since: 2.32 - */ -GMenuModel * -g_application_get_menu (GApplication *application) -{ - g_return_val_if_fail (G_IS_APPLICATION (application), NULL); - - return application->priv->menu; -} - static void g_application_get_property (GObject *object, guint prop_id, @@ -533,8 +672,6 @@ g_application_constructed (GObject *object) { GApplication *application = G_APPLICATION (object); - g_assert (application->priv->id != NULL); - if (g_application_get_default () == NULL) g_application_set_default (application); } @@ -551,6 +688,12 @@ g_application_finalize (GObject *object) if (g_application_get_default () == application) g_application_set_default (NULL); + if (application->priv->actions) + g_object_unref (application->priv->actions); + + if (application->priv->notifications) + g_object_unref (application->priv->notifications); + G_OBJECT_CLASS (g_application_parent_class) ->finalize (object); } @@ -558,9 +701,21 @@ g_application_finalize (GObject *object) static void g_application_init (GApplication *application) { - application->priv = G_TYPE_INSTANCE_GET_PRIVATE (application, - G_TYPE_APPLICATION, - GApplicationPrivate); + application->priv = g_application_get_instance_private (application); + + application->priv->actions = g_application_exported_actions_new (application); + + /* application->priv->actions is the one and only ref on the group, so when + * we dispose, the action group will die, disconnecting all signals. + */ + g_signal_connect_swapped (application->priv->actions, "action-added", + G_CALLBACK (g_action_group_action_added), application); + g_signal_connect_swapped (application->priv->actions, "action-enabled-changed", + G_CALLBACK (g_action_group_action_enabled_changed), application); + g_signal_connect_swapped (application->priv->actions, "action-state-changed", + G_CALLBACK (g_action_group_action_state_changed), application); + g_signal_connect_swapped (application->priv->actions, "action-removed", + G_CALLBACK (g_action_group_action_removed), application); } static void @@ -582,6 +737,8 @@ g_application_class_init (GApplicationClass *class) class->command_line = g_application_real_command_line; class->local_command_line = g_application_real_local_command_line; class->add_platform_data = g_application_real_add_platform_data; + class->dbus_register = g_application_real_dbus_register; + class->dbus_unregister = g_application_real_dbus_unregister; g_object_class_install_property (object_class, PROP_APPLICATION_ID, g_param_spec_string ("application-id", @@ -621,14 +778,7 @@ g_application_class_init (GApplicationClass *class) P_("Action group"), P_("The group of actions that the application exports"), G_TYPE_ACTION_GROUP, - G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS)); - - g_object_class_install_property (object_class, PROP_MENU, - g_param_spec_object ("menu", - P_("Menu model"), - P_("The menu that the application exports"), - G_TYPE_MENU_MODEL, - G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS)); + G_PARAM_DEPRECATED | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS)); /** * GApplication::startup: @@ -638,7 +788,7 @@ g_application_class_init (GApplicationClass *class) * after registration. See g_application_register(). */ g_application_signals[SIGNAL_STARTUP] = - g_signal_new ("startup", G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST, + g_signal_new ("startup", G_TYPE_APPLICATION, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GApplicationClass, startup), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); @@ -691,7 +841,7 @@ g_application_class_init (GApplicationClass *class) * * The ::command-line signal is emitted on the primary instance when * a commandline is not handled locally. See g_application_run() and - * the #GApplicationCommandline documentation for more information. + * the #GApplicationCommandLine documentation for more information. * * Returns: An integer that is set as the exit status for the calling * process. See g_application_command_line_set_exit_status(). @@ -702,8 +852,6 @@ g_application_class_init (GApplicationClass *class) g_signal_accumulator_first_wins, NULL, NULL, G_TYPE_INT, 1, G_TYPE_APPLICATION_COMMAND_LINE); - - g_type_class_add_private (class, sizeof (GApplicationPrivate)); } static GVariant * @@ -812,14 +960,16 @@ g_application_id_is_valid (const gchar *application_id) /* Public Constructor {{{1 */ /** * g_application_new: - * @application_id: the application id + * @application_id: (allow-none): the application id * @flags: the application flags * * Creates a new #GApplication instance. * - * This function calls g_type_init() for you. + * If non-%NULL, the application id must be valid. See + * g_application_id_is_valid(). * - * The application id must be valid. See g_application_id_is_valid(). + * If no application ID is given then some features of #GApplication + * (most notably application uniqueness) will be disabled. * * Returns: a new #GApplication instance **/ @@ -827,9 +977,7 @@ GApplication * g_application_new (const gchar *application_id, GApplicationFlags flags) { - g_return_val_if_fail (g_application_id_is_valid (application_id), NULL); - - g_type_init (); + g_return_val_if_fail (application_id == NULL || g_application_id_is_valid (application_id), NULL); return g_object_new (G_TYPE_APPLICATION, "application-id", application_id, @@ -859,14 +1007,15 @@ g_application_get_application_id (GApplication *application) /** * g_application_set_application_id: * @application: a #GApplication - * @application_id: the identifier for @application + * @application_id: (allow-none): the identifier for @application * * Sets the unique identifier for @application. * * The application id can only be modified if @application has not yet * been registered. * - * The application id must be valid. See g_application_id_is_valid(). + * If non-%NULL, the application id must be valid. See + * g_application_id_is_valid(). * * Since: 2.28 **/ @@ -878,7 +1027,7 @@ g_application_set_application_id (GApplication *application, if (g_strcmp0 (application->priv->id, application_id) != 0) { - g_return_if_fail (g_application_id_is_valid (application_id)); + g_return_if_fail (application_id == NULL || g_application_id_is_valid (application_id)); g_return_if_fail (!application->priv->is_registered); g_free (application->priv->id); @@ -988,7 +1137,7 @@ g_application_set_inactivity_timeout (GApplication *application, g_object_notify (G_OBJECT (application), "inactivity-timeout"); } } -/* Read-only property getters (is registered, is remote) {{{1 */ +/* Read-only property getters (is registered, is remote, dbus stuff) {{{1 */ /** * g_application_get_is_registered: * @application: a #GApplication @@ -1038,11 +1187,74 @@ g_application_get_is_remote (GApplication *application) return application->priv->is_remote; } +/** + * g_application_get_dbus_connection: + * @application: a #GApplication + * + * Gets the #GDBusConnection being used by the application, or %NULL. + * + * If #GApplication is using its D-Bus backend then this function will + * return the #GDBusConnection being used for uniqueness and + * communication with the desktop environment and other instances of the + * application. + * + * If #GApplication is not using D-Bus then this function will return + * %NULL. This includes the situation where the D-Bus backend would + * normally be in use but we were unable to connect to the bus. + * + * This function must not be called before the application has been + * registered. See g_application_get_is_registered(). + * + * Returns: (transfer none): a #GDBusConnection, or %NULL + * + * Since: 2.34 + **/ +GDBusConnection * +g_application_get_dbus_connection (GApplication *application) +{ + g_return_val_if_fail (G_IS_APPLICATION (application), FALSE); + g_return_val_if_fail (application->priv->is_registered, FALSE); + + return g_application_impl_get_dbus_connection (application->priv->impl); +} + +/** + * g_application_get_dbus_object_path: + * @application: a #GApplication + * + * Gets the D-Bus object path being used by the application, or %NULL. + * + * If #GApplication is using its D-Bus backend then this function will + * return the D-Bus object path that #GApplication is using. If the + * application is the primary instance then there is an object published + * at this path. If the application is not the primary instance then + * the result of this function is undefined. + * + * If #GApplication is not using D-Bus then this function will return + * %NULL. This includes the situation where the D-Bus backend would + * normally be in use but we were unable to connect to the bus. + * + * This function must not be called before the application has been + * registered. See g_application_get_is_registered(). + * + * Returns: the object path, or %NULL + * + * Since: 2.34 + **/ +const gchar * +g_application_get_dbus_object_path (GApplication *application) +{ + g_return_val_if_fail (G_IS_APPLICATION (application), FALSE); + g_return_val_if_fail (application->priv->is_registered, FALSE); + + return g_application_impl_get_dbus_object_path (application->priv->impl); +} + /* Register {{{1 */ /** * g_application_register: * @application: a #GApplication - * @cancellable: a #GCancellable, or %NULL + * @cancellable: (allow-none): a #GCancellable, or %NULL * @error: a pointer to a NULL #GError, or %NULL * * Attempts registration of the application. @@ -1053,6 +1265,9 @@ g_application_get_is_remote (GApplication *application) * application identifier as a unique bus name on the session bus using * GDBus. * + * If there is no application ID or if %G_APPLICATION_NON_UNIQUE was + * given, then this process will always become the primary instance. + * * Due to the internal architecture of GDBus, method calls can be * dispatched at any time (even if a main loop is not running). For * this reason, you must ensure that any object paths that you wish to @@ -1062,7 +1277,8 @@ g_application_get_is_remote (GApplication *application) * returned with no work performed. * * The #GApplication::startup signal is emitted if registration succeeds - * and @application is the primary instance. + * and @application is the primary instance (including the non-unique + * case). * * In the event of an error (such as @cancellable being cancelled, or a * failure to connect to the session bus), %FALSE is returned and @error @@ -1085,17 +1301,18 @@ g_application_register (GApplication *application, if (!application->priv->is_registered) { - if (~application->priv->flags & G_APPLICATION_NON_UNIQUE) - { - application->priv->impl = - g_application_impl_register (application, application->priv->id, - application->priv->flags, - &application->priv->remote_actions, - cancellable, error); - - if (application->priv->impl == NULL) - return FALSE; - } + if (application->priv->id == NULL) + application->priv->flags |= G_APPLICATION_NON_UNIQUE; + + application->priv->impl = + g_application_impl_register (application, application->priv->id, + application->priv->flags, + application->priv->actions, + &application->priv->remote_actions, + cancellable, error); + + if (application->priv->impl == NULL) + return FALSE; application->priv->is_remote = application->priv->remote_actions != NULL; application->priv->is_registered = TRUE; @@ -1132,6 +1349,8 @@ g_application_register (GApplication *application, void g_application_hold (GApplication *application) { + g_return_if_fail (G_IS_APPLICATION (application)); + if (application->priv->inactivity_timeout_id) { g_source_remove (application->priv->inactivity_timeout_id); @@ -1148,7 +1367,7 @@ inactivity_timeout_expired (gpointer data) application->priv->inactivity_timeout_id = 0; - return FALSE; + return G_SOURCE_REMOVE; } @@ -1166,6 +1385,8 @@ inactivity_timeout_expired (gpointer data) void g_application_release (GApplication *application) { + g_return_if_fail (G_IS_APPLICATION (application)); + application->priv->use_count--; if (application->priv->use_count == 0 && application->priv->inactivity_timeout) @@ -1180,7 +1401,7 @@ g_application_release (GApplication *application) * * Activates the application. * - * In essence, this results in the #GApplication::activate() signal being + * In essence, this results in the #GApplication::activate signal being * emitted in the primary instance. * * The application must be registered before calling this function. @@ -1280,7 +1501,7 @@ g_application_open (GApplication *application, * If local_command_line() returns %FALSE then the application is registered * and the #GApplication::command-line signal is emitted in the primary * instance (which may or may not be this instance). The signal handler - * gets passed a #GApplicationCommandline object that (among other things) + * gets passed a #GApplicationCommandLine object that (among other things) * contains the remaining commandline arguments that have not been handled * by local_command_line(). * @@ -1300,7 +1521,7 @@ g_application_open (GApplication *application, * * If you need to handle commandline arguments that are not filenames, * and you don't mind commandline handling to happen in the primary - * instance, you should set %G_APPLICATION_HANDLED_COMMAND_LINE and + * instance, you should set %G_APPLICATION_HANDLES_COMMAND_LINE and * process the commandline arguments in your #GApplication::command-line * signal handler, either manually or using the #GOptionContext API. * @@ -1316,9 +1537,19 @@ g_application_open (GApplication *application, * non-zero then the default main context is iterated until the use count * falls to zero, at which point 0 is returned. * - * If the %G_APPLICATION_IS_SERVICE flag is set, then the exiting at - * use count of zero is delayed for a while (ie: the instance stays - * around to provide its service to others). + * If the %G_APPLICATION_IS_SERVICE flag is set, then the service will + * run for as much as 10 seconds with a use count of zero while waiting + * for the message that caused the activation to arrive. After that, + * if the use count falls to zero the application will exit immediately, + * except in the case that g_application_set_inactivity_timeout() is in + * use. + * + * This function sets the prgname (g_set_prgname()), if not already set, + * to the basename of argv[0]. Since 2.38, if %G_APPLICATION_IS_SERVICE + * is specified, the prgname is set to the application ID. The main + * impact of this is is that the wmclass of windows created by Gtk+ will + * be set accordingly, which helps the window manager determine which + * application is showing the window. * * Returns: the exit status * @@ -1335,19 +1566,27 @@ g_application_run (GApplication *application, g_return_val_if_fail (G_IS_APPLICATION (application), 1); g_return_val_if_fail (argc == 0 || argv != NULL, 1); + g_return_val_if_fail (!application->priv->must_quit_now, 1); arguments = g_new (gchar *, argc + 1); for (i = 0; i < argc; i++) arguments[i] = g_strdup (argv[i]); arguments[i] = NULL; - if (g_get_prgname () == NULL && argc > 0) + if (g_get_prgname () == NULL) { - gchar *prgname; + if (application->priv->flags & G_APPLICATION_IS_SERVICE) + { + g_set_prgname (application->priv->id); + } + else if (argc > 0) + { + gchar *prgname; - prgname = g_path_get_basename (argv[0]); - g_set_prgname (prgname); - g_free (prgname); + prgname = g_path_get_basename (argv[0]); + g_set_prgname (prgname); + g_free (prgname); + } } if (!G_APPLICATION_GET_CLASS (application) @@ -1398,11 +1637,14 @@ g_application_run (GApplication *application, while (application->priv->use_count || application->priv->inactivity_timeout_id) { + if (application->priv->must_quit_now) + break; + g_main_context_iteration (NULL, TRUE); status = 0; } - if (!application->priv->is_remote) + if (application->priv->is_registered && !application->priv->is_remote) { g_signal_emit (application, g_application_signals[SIGNAL_SHUTDOWN], 0); @@ -1428,7 +1670,7 @@ g_application_list_actions (GActionGroup *action_group) g_return_val_if_fail (application->priv->is_registered, NULL); if (application->priv->remote_actions != NULL) - return g_action_group_list_actions (application->priv->remote_actions); + return g_action_group_list_actions (G_ACTION_GROUP (application->priv->remote_actions)); else if (application->priv->actions != NULL) return g_action_group_list_actions (application->priv->actions); @@ -1452,7 +1694,7 @@ g_application_query_action (GActionGroup *group, g_return_val_if_fail (application->priv->is_registered, FALSE); if (application->priv->remote_actions != NULL) - return g_action_group_query_action (application->priv->remote_actions, + return g_action_group_query_action (G_ACTION_GROUP (application->priv->remote_actions), action_name, enabled, parameter_type, @@ -1484,11 +1726,11 @@ g_application_change_action_state (GActionGroup *action_group, g_return_if_fail (application->priv->is_registered); if (application->priv->remote_actions) - return g_action_group_change_action_state (application->priv->remote_actions, action_name, value); + g_remote_action_group_change_action_state_full (application->priv->remote_actions, + action_name, value, get_platform_data (application)); else - g_action_group_change_action_state (application->priv->actions, - action_name, value); + g_action_group_change_action_state (application->priv->actions, action_name, value); } static void @@ -1503,11 +1745,44 @@ g_application_activate_action (GActionGroup *action_group, g_return_if_fail (application->priv->is_registered); if (application->priv->remote_actions) - return g_action_group_change_action_state (application->priv->remote_actions, action_name, parameter); + g_remote_action_group_activate_action_full (application->priv->remote_actions, + action_name, parameter, get_platform_data (application)); else - g_action_group_activate_action (application->priv->actions, - action_name, parameter); + g_action_group_activate_action (application->priv->actions, action_name, parameter); +} + +static GAction * +g_application_lookup_action (GActionMap *action_map, + const gchar *action_name) +{ + GApplication *application = G_APPLICATION (action_map); + + g_return_val_if_fail (G_IS_ACTION_MAP (application->priv->actions), NULL); + + return g_action_map_lookup_action (G_ACTION_MAP (application->priv->actions), action_name); +} + +static void +g_application_add_action (GActionMap *action_map, + GAction *action) +{ + GApplication *application = G_APPLICATION (action_map); + + g_return_if_fail (G_IS_ACTION_MAP (application->priv->actions)); + + g_action_map_add_action (G_ACTION_MAP (application->priv->actions), action); +} + +static void +g_application_remove_action (GActionMap *action_map, + const gchar *action_name) +{ + GApplication *application = G_APPLICATION (action_map); + + g_return_if_fail (G_IS_ACTION_MAP (application->priv->actions)); + + g_action_map_remove_action (G_ACTION_MAP (application->priv->actions), action_name); } static void @@ -1519,13 +1794,20 @@ g_application_action_group_iface_init (GActionGroupInterface *iface) iface->activate_action = g_application_activate_action; } +static void +g_application_action_map_iface_init (GActionMapInterface *iface) +{ + iface->lookup_action = g_application_lookup_action; + iface->add_action = g_application_add_action; + iface->remove_action = g_application_remove_action; +} + /* Default Application {{{1 */ static GApplication *default_app; /** * g_application_get_default: - * @returns: (transfer none): the default application for this process, or %NULL * * Returns the default #GApplication instance for this process. * @@ -1535,6 +1817,8 @@ static GApplication *default_app; * * If there is no default application then %NULL is returned. * + * Returns: (transfer none): the default application for this process, or %NULL + * * Since: 2.32 **/ GApplication * @@ -1545,7 +1829,7 @@ g_application_get_default (void) /** * g_application_set_default: - * @application: the application to set as default, or %NULL + * @application: (allow-none): the application to set as default, or %NULL * * Sets or unsets the default application for the process, as returned * by g_application_get_default(). @@ -1562,5 +1846,177 @@ g_application_set_default (GApplication *application) default_app = application; } +/** + * g_application_quit: + * @application: a #GApplication + * + * Immediately quits the application. + * + * Upon return to the mainloop, g_application_run() will return, + * calling only the 'shutdown' function before doing so. + * + * The hold count is ignored. + * + * The result of calling g_application_run() again after it returns is + * unspecified. + * + * Since: 2.32 + **/ +void +g_application_quit (GApplication *application) +{ + g_return_if_fail (G_IS_APPLICATION (application)); + + application->priv->must_quit_now = TRUE; +} + +/** + * g_application_mark_busy: + * @application: a #GApplication + * + * Increases the busy count of @application. + * + * Use this function to indicate that the application is busy, for instance + * while a long running operation is pending. + * + * The busy state will be exposed to other processes, so a session shell will + * use that information to indicate the state to the user (e.g. with a + * spinner). + * + * To cancel the busy indication, use g_application_unmark_busy(). + * + * Since: 2.38 + **/ +void +g_application_mark_busy (GApplication *application) +{ + gboolean was_busy; + + g_return_if_fail (G_IS_APPLICATION (application)); + + was_busy = (application->priv->busy_count > 0); + application->priv->busy_count++; + + if (!was_busy) + g_application_impl_set_busy_state (application->priv->impl, TRUE); +} + +/** + * g_application_unmark_busy: + * @application: a #GApplication + * + * Decreases the busy count of @application. + * + * When the busy count reaches zero, the new state will be propagated + * to other processes. + * + * This function must only be called to cancel the effect of a previous + * call to g_application_mark_busy(). + * + * Since: 2.38 + **/ +void +g_application_unmark_busy (GApplication *application) +{ + g_return_if_fail (G_IS_APPLICATION (application)); + g_return_if_fail (application->priv->busy_count > 0); + + application->priv->busy_count--; + + if (application->priv->busy_count == 0) + g_application_impl_set_busy_state (application->priv->impl, FALSE); +} + +/* Notifications {{{1 */ + +/** + * g_application_send_notification: + * @application: a #GApplication + * @id: (allow-none): id of the notification, or %NULL + * @notification: the #GNotification to send + * + * Sends a notification on behalf of @application to the desktop shell. + * There is no guarantee that the notification is displayed immediately, + * or even at all. + * + * Notifications may persist after the application exits. It will be + * D-Bus-activated when the notification or one of its actions is + * activated. + * + * Modifying @notification after this call has no effect. However, the + * object can be reused for a later call to this function. + * + * @id may be any string that uniquely identifies the event for the + * application. It does not need to be in any special format. For + * example, "new-message" might be appropriate for a notification about + * new messages. + * + * If a previous notification was sent with the same @id, it will be + * replaced with @notification and shown again as if it was a new + * notification. This works even for notifications sent from a previous + * execution of the application, as long as @id is the same string. + * + * @id may be %NULL, but it is impossible to replace or withdraw + * notifications without an id. + * + * If @notification is no longer relevant, it can be withdrawn with + * g_application_withdraw_notification(). + * + * Since: 2.40 + */ +void +g_application_send_notification (GApplication *application, + const gchar *id, + GNotification *notification) +{ + gchar *generated_id = NULL; + + g_return_if_fail (G_IS_APPLICATION (application)); + g_return_if_fail (G_IS_NOTIFICATION (notification)); + g_return_if_fail (g_application_get_is_registered (application)); + g_return_if_fail (!g_application_get_is_remote (application)); + + if (application->priv->notifications == NULL) + application->priv->notifications = g_notification_backend_new_default (application); + + if (id == NULL) + { + generated_id = g_dbus_generate_guid (); + id = generated_id; + } + + g_notification_backend_send_notification (application->priv->notifications, id, notification); + + g_free (generated_id); +} + +/** + * g_application_withdraw_notification: + * @application: a #GApplication + * @id: id of a previously sent notification + * + * Withdraws a notification that was sent with + * g_application_send_notification(). + * + * This call does nothing if a notification with @id doesn't exist or + * the notification was never sent. + * + * This function works even for notifications sent in previous + * executions of this application, as long @id is the same as it was for + * the sent notification. + * + * Since: 2.40 + */ +void +g_application_withdraw_notification (GApplication *application, + const gchar *id) +{ + g_return_if_fail (G_IS_APPLICATION (application)); + g_return_if_fail (id != NULL); + + if (application->priv->notifications) + g_notification_backend_withdraw_notification (application->priv->notifications, id); +} + /* Epilogue {{{1 */ /* vim:set foldmethod=marker: */