X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkapplication.c;h=c82577723712f590e6a5ad42044396d4def5e26d;hb=9d0febc9a64a5bfb0fcfc3a88de4757f6c1ff090;hp=5f428e241ea381045683ccdda04001d765c4247b;hpb=72c04c064a1b35673ef6e65bd1c0d3389c029bd4;p=~andy%2Fgtk
diff --git a/gtk/gtkapplication.c b/gtk/gtkapplication.c
index 5f428e241..c82577723 100644
--- a/gtk/gtkapplication.c
+++ b/gtk/gtkapplication.c
@@ -12,9 +12,7 @@
* 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.
+ * License along with this library. If not, see .
*
* Author: Ryan Lortie
*/
@@ -30,14 +28,19 @@
#include
#include "gtkapplicationprivate.h"
+#include "gtkclipboard.h"
#include "gtkmarshalers.h"
#include "gtkmain.h"
+#include "gtkrecentmanager.h"
#include "gtkaccelmapprivate.h"
#include "gactionmuxer.h"
+#include "gtkintl.h"
#ifdef GDK_WINDOWING_QUARTZ
#include "gtkquartz-menu.h"
#import
+#include
+#include "gtkmessagedialog.h"
#endif
#include
@@ -55,9 +58,10 @@
* a one-size-fits-all application model.
*
* Currently, GtkApplication handles GTK+ initialization, application
- * uniqueness, provides some basic scriptability and desktop shell integration
- * by exporting actions and menus and manages a list of toplevel windows whose
- * life-cycle is automatically tied to the life-cycle of your application.
+ * uniqueness, session management, provides some basic scriptability and
+ * desktop shell integration by exporting actions and menus and manages a
+ * list of toplevel windows whose life-cycle is automatically tied to the
+ * life-cycle of your application.
*
* While GtkApplication works fine with plain #GtkWindows, it is recommended
* to use it together with #GtkApplicationWindow.
@@ -72,10 +76,10 @@
* 'open' #GApplication methods.
*
* To set an application menu on a GtkApplication, use
- * g_application_set_app_menu(). The #GMenuModel that this function
+ * gtk_application_set_app_menu(). The #GMenuModel that this function
* expects is usually constructed using #GtkBuilder, as seen in the
* following example. To set a menubar that will be automatically picked
- * up by #GApplicationWindows, use g_application_set_menubar(). GTK+
+ * up by #GApplicationWindows, use gtk_application_set_menubar(). GTK+
* makes these menus appear as expected, depending on the platform
* the application is running on.
*
@@ -98,6 +102,19 @@
*
*
*
+ *
+ * GtkApplication optionally registers with a session manager
+ * of the users session (if you set the #GtkApplication:register-session
+ * property) and offers various functionality related to the session
+ * life-cycle.
+ *
+ * An application can block various ways to end the session with
+ * the gtk_application_inhibit() function. Typical use cases for
+ * this kind of inhibiting are long-running, uninterruptible operations,
+ * such as burning a CD or performing a disk backup. The session
+ * manager may not honor the inhibitor, but it can be expected to
+ * inform the user about the negative consequences of ending the
+ * session while inhibitors are present.
*/
enum {
@@ -108,30 +125,112 @@ enum {
static guint gtk_application_signals[LAST_SIGNAL];
+enum {
+ PROP_ZERO,
+ PROP_REGISTER_SESSION,
+ PROP_APP_MENU,
+ PROP_MENUBAR
+};
+
G_DEFINE_TYPE (GtkApplication, gtk_application, G_TYPE_APPLICATION)
struct _GtkApplicationPrivate
{
GList *windows;
+ gboolean register_session;
+
+ GMenuModel *app_menu;
+ GMenuModel *menubar;
+
#ifdef GDK_WINDOWING_X11
- GDBusConnection *session;
- gchar *window_prefix;
+ GDBusConnection *session_bus;
+ const gchar *application_id;
+ gchar *object_path;
+
+ gchar *app_menu_path;
+ guint app_menu_id;
+
+ gchar *menubar_path;
+ guint menubar_id;
+
guint next_id;
+
+ GDBusProxy *sm_proxy;
+ GDBusProxy *client_proxy;
+ gchar *app_id;
+ gchar *client_path;
#endif
#ifdef GDK_WINDOWING_QUARTZ
GActionMuxer *muxer;
GMenu *combined;
+
+ GSList *inhibitors;
+ gint quit_inhibit;
+ guint next_cookie;
#endif
};
#ifdef GDK_WINDOWING_X11
+static void
+gtk_application_x11_publish_menu (GtkApplication *application,
+ const gchar *type,
+ GMenuModel *model,
+ guint *id,
+ gchar **path)
+{
+ gint i;
+
+ /* unexport any existing menu */
+ if (*id)
+ {
+ g_dbus_connection_unexport_menu_model (application->priv->session_bus, *id);
+ g_free (*path);
+ *path = NULL;
+ *id = 0;
+ }
+
+ /* export the new menu, if there is one */
+ if (model != NULL)
+ {
+ /* try getting the preferred name */
+ *path = g_strconcat (application->priv->object_path, "/menus/", type, NULL);
+ *id = g_dbus_connection_export_menu_model (application->priv->session_bus, *path, model, NULL);
+
+ /* keep trying until we get a working name... */
+ for (i = 0; *id == 0; i++)
+ {
+ g_free (*path);
+ *path = g_strdup_printf ("%s/menus/%s%d", application->priv->object_path, type, i);
+ *id = g_dbus_connection_export_menu_model (application->priv->session_bus, *path, model, NULL);
+ }
+ }
+}
+
+static void
+gtk_application_set_app_menu_x11 (GtkApplication *application,
+ GMenuModel *app_menu)
+{
+ gtk_application_x11_publish_menu (application, "appmenu", app_menu,
+ &application->priv->app_menu_id,
+ &application->priv->app_menu_path);
+}
+
+static void
+gtk_application_set_menubar_x11 (GtkApplication *application,
+ GMenuModel *menubar)
+{
+ gtk_application_x11_publish_menu (application, "menubar", menubar,
+ &application->priv->menubar_id,
+ &application->priv->menubar_path);
+}
+
static void
gtk_application_window_added_x11 (GtkApplication *application,
GtkWindow *window)
{
- if (application->priv->session == NULL)
+ if (application->priv->session_bus == NULL)
return;
if (GTK_IS_APPLICATION_WINDOW (window))
@@ -150,8 +249,8 @@ gtk_application_window_added_x11 (GtkApplication *application,
guint window_id;
window_id = application->priv->next_id++;
- window_path = g_strdup_printf ("%s%d", application->priv->window_prefix, window_id);
- success = gtk_application_window_publish (app_window, application->priv->session, window_path);
+ window_path = g_strdup_printf ("%s/window/%d", application->priv->object_path, window_id);
+ success = gtk_application_window_publish (app_window, application->priv->session_bus, window_path);
g_free (window_path);
}
while (!success);
@@ -162,7 +261,7 @@ static void
gtk_application_window_removed_x11 (GtkApplication *application,
GtkWindow *window)
{
- if (application->priv->session == NULL)
+ if (application->priv->session_bus == NULL)
return;
if (GTK_IS_APPLICATION_WINDOW (window))
@@ -170,11 +269,11 @@ gtk_application_window_removed_x11 (GtkApplication *application,
}
static gchar *
-window_prefix_from_appid (const gchar *appid)
+object_path_from_appid (const gchar *appid)
{
gchar *appid_path, *iter;
- appid_path = g_strconcat ("/", appid, "/windows/", NULL);
+ appid_path = g_strconcat ("/", appid, NULL);
for (iter = appid_path; *iter; iter++)
{
if (*iter == '.')
@@ -187,30 +286,70 @@ window_prefix_from_appid (const gchar *appid)
return appid_path;
}
+static void gtk_application_startup_session_dbus (GtkApplication *app);
+
static void
gtk_application_startup_x11 (GtkApplication *application)
{
const gchar *application_id;
application_id = g_application_get_application_id (G_APPLICATION (application));
- application->priv->session = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
- application->priv->window_prefix = window_prefix_from_appid (application_id);
+ application->priv->session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
+ application->priv->object_path = object_path_from_appid (application_id);
+
+ gtk_application_startup_session_dbus (GTK_APPLICATION (application));
}
static void
gtk_application_shutdown_x11 (GtkApplication *application)
{
- g_free (application->priv->window_prefix);
- application->priv->window_prefix = NULL;
- if (application->priv->session)
- {
- g_object_unref (application->priv->session);
- application->priv->session = NULL;
- }
+ g_free (application->priv->object_path);
+ application->priv->object_path = NULL;
+ g_clear_object (&application->priv->session_bus);
+
+ g_clear_object (&application->priv->sm_proxy);
+ g_clear_object (&application->priv->client_proxy);
+ g_free (application->priv->app_id);
+ g_free (application->priv->client_path);
+}
+
+const gchar *
+gtk_application_get_dbus_object_path (GtkApplication *application)
+{
+ return application->priv->object_path;
+}
+
+const gchar *
+gtk_application_get_app_menu_object_path (GtkApplication *application)
+{
+ return application->priv->app_menu_path;
+}
+
+const gchar *
+gtk_application_get_menubar_object_path (GtkApplication *application)
+{
+ return application->priv->menubar_path;
}
+
#endif
#ifdef GDK_WINDOWING_QUARTZ
+
+typedef struct {
+ guint cookie;
+ GtkApplicationInhibitFlags flags;
+ char *reason;
+ GtkWindow *window;
+} GtkApplicationQuartzInhibitor;
+
+static void
+gtk_application_quartz_inhibitor_free (GtkApplicationQuartzInhibitor *inhibitor)
+{
+ g_free (inhibitor->reason);
+ g_clear_object (&inhibitor->window);
+ g_slice_free (GtkApplicationQuartzInhibitor, inhibitor);
+}
+
static void
gtk_application_menu_changed_quartz (GObject *object,
GParamSpec *pspec,
@@ -220,12 +359,14 @@ gtk_application_menu_changed_quartz (GObject *object,
GMenu *combined;
combined = g_menu_new ();
- g_menu_append_submenu (combined, "Application", g_application_get_app_menu (application));
+ g_menu_append_submenu (combined, "Application", gtk_application_get_app_menu (application));
g_menu_append_section (combined, NULL, gtk_application_get_menubar (application));
gtk_quartz_set_main_menu (G_MENU_MODEL (combined), G_ACTION_OBSERVABLE (application->priv->muxer));
}
+static void gtk_application_startup_session_quartz (GtkApplication *app);
+
static void
gtk_application_startup_quartz (GtkApplication *application)
{
@@ -237,6 +378,8 @@ gtk_application_startup_quartz (GtkApplication *application)
g_signal_connect (application, "notify::app-menu", G_CALLBACK (gtk_application_menu_changed_quartz), NULL);
g_signal_connect (application, "notify::menubar", G_CALLBACK (gtk_application_menu_changed_quartz), NULL);
gtk_application_menu_changed_quartz (G_OBJECT (application), NULL, NULL);
+
+ gtk_application_startup_session_quartz (application);
}
static void
@@ -246,6 +389,10 @@ gtk_application_shutdown_quartz (GtkApplication *application)
g_object_unref (application->priv->muxer);
application->priv->muxer = NULL;
+
+ g_slist_free_full (application->priv->inhibitors,
+ (GDestroyNotify) gtk_application_quartz_inhibitor_free);
+ application->priv->inhibitors = NULL;
}
static void
@@ -310,6 +457,12 @@ gtk_application_shutdown (GApplication *application)
gtk_application_shutdown_quartz (GTK_APPLICATION (application));
#endif
+ /* Try storing all clipboard data we have */
+ _gtk_clipboard_store_all ();
+
+ /* Synchronize the recent manager singleton */
+ _gtk_recent_manager_sync ();
+
G_APPLICATION_CLASS (gtk_application_parent_class)
->shutdown (application);
}
@@ -466,23 +619,71 @@ extract_accels_from_menu (GMenuModel *model,
}
static void
-gtk_application_notify (GObject *object,
- GParamSpec *pspec)
+gtk_application_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- if (strcmp (pspec->name, "app-menu") == 0 ||
- strcmp (pspec->name, "menubar") == 0)
+ GtkApplication *application = GTK_APPLICATION (object);
+
+ switch (prop_id)
{
- GMenuModel *model;
- g_object_get (object, pspec->name, &model, NULL);
- if (model)
- {
- extract_accels_from_menu (model, GTK_APPLICATION (object));
- g_object_unref (model);
- }
+ case PROP_REGISTER_SESSION:
+ g_value_set_boolean (value, application->priv->register_session);
+ break;
+
+ case PROP_APP_MENU:
+ g_value_set_object (value, gtk_application_get_app_menu (application));
+ break;
+
+ case PROP_MENUBAR:
+ g_value_set_object (value, gtk_application_get_menubar (application));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gtk_application_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkApplication *application = GTK_APPLICATION (object);
+
+ switch (prop_id)
+ {
+ case PROP_REGISTER_SESSION:
+ application->priv->register_session = g_value_get_boolean (value);
+ break;
+
+ case PROP_APP_MENU:
+ gtk_application_set_app_menu (application, g_value_get_object (value));
+ break;
+
+ case PROP_MENUBAR:
+ gtk_application_set_menubar (application, g_value_get_object (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
}
+}
+
+static void
+gtk_application_finalize (GObject *object)
+{
+ GtkApplication *application = GTK_APPLICATION (object);
+
+ g_clear_object (&application->priv->app_menu);
+ g_clear_object (&application->priv->menubar);
- if (G_OBJECT_CLASS (gtk_application_parent_class)->notify)
- G_OBJECT_CLASS (gtk_application_parent_class)->notify (object, pspec);
+ G_OBJECT_CLASS (gtk_application_parent_class)
+ ->finalize (object);
}
static void
@@ -491,7 +692,9 @@ gtk_application_class_init (GtkApplicationClass *class)
GObjectClass *object_class = G_OBJECT_CLASS (class);
GApplicationClass *application_class = G_APPLICATION_CLASS (class);
- object_class->notify = gtk_application_notify;
+ object_class->get_property = gtk_application_get_property;
+ object_class->set_property = gtk_application_set_property;
+ object_class->finalize = gtk_application_finalize;
application_class->add_platform_data = gtk_application_add_platform_data;
application_class->before_emit = gtk_application_before_emit;
@@ -538,6 +741,33 @@ gtk_application_class_init (GtkApplicationClass *class)
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, GTK_TYPE_WINDOW);
+
+ /**
+ * GtkApplication:register-session:
+ *
+ * Set this property to %TRUE to register with the session manager.
+ *
+ * Since: 3.4
+ */
+ g_object_class_install_property (object_class, PROP_REGISTER_SESSION,
+ g_param_spec_boolean ("register-session",
+ P_("Register session"),
+ P_("Register with the session manager"),
+ FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (object_class, PROP_APP_MENU,
+ g_param_spec_object ("app-menu",
+ P_("Application menu"),
+ P_("The GMenuModel for the application menu"),
+ G_TYPE_MENU_MODEL,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (object_class, PROP_MENUBAR,
+ g_param_spec_object ("menubar",
+ P_("Menubar"),
+ P_("The GMenuModel for the menubar"),
+ G_TYPE_MENU_MODEL,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}
/**
@@ -550,10 +780,14 @@ gtk_application_class_init (GtkApplicationClass *class)
* This function calls g_type_init() for you. gtk_init() is called
* as soon as the application gets registered as the primary instance.
*
+ * Concretely, gtk_init() is called in the default handler for the
+ * startup() signal. Therefore, #GtkApplication subclasses should
+ * chain up in their startup() handler before using any GTK+ API.
+ *
* Note that commandline arguments are not passed to gtk_init().
* All GTK+ functionality that is available via commandline arguments
* can also be achieved by setting suitable environment variables
- * such as G_DEBUG, so this should not be a big
+ * such as G_DEBUG, so this should not be a big
* problem. If you absolutely must support GTK+ commandline arguments,
* you can explicitly call gtk_init() before creating the application
* instance.
@@ -561,6 +795,8 @@ gtk_application_class_init (GtkApplicationClass *class)
* The application id must be valid. See g_application_id_is_valid().
*
* Returns: a new #GtkApplication instance
+ *
+ * Since: 3.0
*/
GtkApplication *
gtk_application_new (const gchar *application_id,
@@ -680,8 +916,8 @@ gtk_application_get_windows (GtkApplication *application)
* with a "win." prefix.
*
* GtkApplication also extracts accelerators out of 'accel' attributes
- * in the #GMenuModels passed to g_application_set_app_menu() and
- * g_application_set_menubar(), which is usually more convenient
+ * in the #GMenuModels passed to gtk_application_set_app_menu() and
+ * gtk_application_set_menubar(), which is usually more convenient
* than calling this function for each accelerator.
*
* Since: 3.4
@@ -756,7 +992,7 @@ gtk_application_remove_accelerator (GtkApplication *application,
/**
* gtk_application_set_app_menu:
* @application: a #GtkApplication
- * @model: (allow-none): a #GMenuModel, or %NULL
+ * @app_menu: (allow-none): a #GMenuModel, or %NULL
*
* Sets or unsets the application menu for @application.
*
@@ -773,9 +1009,28 @@ gtk_application_remove_accelerator (GtkApplication *application,
*/
void
gtk_application_set_app_menu (GtkApplication *application,
- GMenuModel *model)
+ GMenuModel *app_menu)
{
- g_object_set (application, "app-menu", model, NULL);
+ g_return_if_fail (GTK_IS_APPLICATION (application));
+
+ if (app_menu != application->priv->app_menu)
+ {
+ if (application->priv->app_menu != NULL)
+ g_object_unref (application->priv->app_menu);
+
+ application->priv->app_menu = app_menu;
+
+ if (application->priv->app_menu != NULL)
+ g_object_ref (application->priv->app_menu);
+
+ extract_accels_from_menu (app_menu, application);
+
+#ifdef GDK_WINDOWING_X11
+ gtk_application_set_app_menu_x11 (application, app_menu);
+#endif
+
+ g_object_notify (G_OBJECT (application), "app-menu");
+ }
}
/**
@@ -783,7 +1038,7 @@ gtk_application_set_app_menu (GtkApplication *application,
* @application: a #GtkApplication
*
* Returns the menu model that has been set with
- * g_application_set_app_menu().
+ * gtk_application_set_app_menu().
*
* Returns: (transfer none): the application menu of @application
*
@@ -792,18 +1047,15 @@ gtk_application_set_app_menu (GtkApplication *application,
GMenuModel *
gtk_application_get_app_menu (GtkApplication *application)
{
- GMenuModel *app_menu;
-
- g_object_get (application, "app-menu", &app_menu, NULL);
- g_object_unref (app_menu);
+ g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL);
- return app_menu;
+ return application->priv->app_menu;
}
/**
* gtk_application_set_menubar:
* @application: a #GtkApplication
- * @model: (allow-none): a #GMenuModel, or %NULL
+ * @menubar: (allow-none): a #GMenuModel, or %NULL
*
* Sets or unsets the menubar for windows of @application.
*
@@ -821,9 +1073,28 @@ gtk_application_get_app_menu (GtkApplication *application)
*/
void
gtk_application_set_menubar (GtkApplication *application,
- GMenuModel *model)
+ GMenuModel *menubar)
{
- g_object_set (application, "menubar", model, NULL);
+ g_return_if_fail (GTK_IS_APPLICATION (application));
+
+ if (menubar != application->priv->menubar)
+ {
+ if (application->priv->menubar != NULL)
+ g_object_unref (application->priv->menubar);
+
+ application->priv->menubar = menubar;
+
+ if (application->priv->menubar != NULL)
+ g_object_ref (application->priv->menubar);
+
+ extract_accels_from_menu (menubar, application);
+
+#ifdef GDK_WINDOWING_X11
+ gtk_application_set_menubar_x11 (application, menubar);
+#endif
+
+ g_object_notify (G_OBJECT (application), "menubar");
+ }
}
/**
@@ -831,7 +1102,7 @@ gtk_application_set_menubar (GtkApplication *application,
* @application: a #GtkApplication
*
* Returns the menu model that has been set with
- * g_application_set_menubar().
+ * gtk_application_set_menubar().
*
* Returns: (transfer none): the menubar for windows of @application
*
@@ -840,10 +1111,503 @@ gtk_application_set_menubar (GtkApplication *application,
GMenuModel *
gtk_application_get_menubar (GtkApplication *application)
{
- GMenuModel *menubar;
+ g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL);
+
+ return application->priv->menubar;
+}
+
+#if defined(GDK_WINDOWING_X11)
+
+/* D-Bus Session Management
+ *
+ * The protocol and the D-Bus API are described here:
+ * http://live.gnome.org/SessionManagement/GnomeSession
+ * http://people.gnome.org/~mccann/gnome-session/docs/gnome-session.html
+ */
+
+static void
+unregister_client (GtkApplication *app)
+{
+ GError *error = NULL;
+
+ g_debug ("Unregistering client");
+
+ g_dbus_proxy_call_sync (app->priv->sm_proxy,
+ "UnregisterClient",
+ g_variant_new ("(o)", app->priv->client_path),
+ G_DBUS_CALL_FLAGS_NONE,
+ G_MAXINT,
+ NULL,
+ &error);
+
+ if (error)
+ {
+ g_warning ("Failed to unregister client: %s", error->message);
+ g_error_free (error);
+ }
+
+ g_clear_object (&app->priv->client_proxy);
+
+ g_free (app->priv->client_path);
+ app->priv->client_path = NULL;
+}
+
+static void
+gtk_application_quit_response (GtkApplication *application,
+ gboolean will_quit,
+ const gchar *reason)
+{
+ g_debug ("Calling EndSessionResponse %d '%s'", will_quit, reason);
+
+ g_dbus_proxy_call (application->priv->client_proxy,
+ "EndSessionResponse",
+ g_variant_new ("(bs)", will_quit, reason ? reason : ""),
+ G_DBUS_CALL_FLAGS_NONE,
+ G_MAXINT,
+ NULL, NULL, NULL);
+}
+static void
+client_proxy_signal (GDBusProxy *proxy,
+ const gchar *sender_name,
+ const gchar *signal_name,
+ GVariant *parameters,
+ GtkApplication *app)
+{
+ if (strcmp (signal_name, "QueryEndSession") == 0)
+ {
+ g_debug ("Received QueryEndSession");
+ gtk_application_quit_response (app, TRUE, NULL);
+ }
+ else if (strcmp (signal_name, "CancelEndSession") == 0)
+ {
+ g_debug ("Received CancelEndSession");
+ }
+ else if (strcmp (signal_name, "EndSession") == 0)
+ {
+ g_debug ("Received EndSession");
+ gtk_application_quit_response (app, TRUE, NULL);
+ unregister_client (app);
+ g_application_quit (G_APPLICATION (app));
+ }
+ else if (strcmp (signal_name, "Stop") == 0)
+ {
+ g_debug ("Received Stop");
+ unregister_client (app);
+ g_application_quit (G_APPLICATION (app));
+ }
+}
+
+static void
+gtk_application_startup_session_dbus (GtkApplication *app)
+{
+ static gchar *client_id;
+ GError *error = NULL;
+ GVariant *res;
+
+ if (app->priv->session_bus == NULL)
+ return;
+
+ if (client_id == NULL)
+ {
+ const gchar *desktop_autostart_id;
+
+ desktop_autostart_id = g_getenv ("DESKTOP_AUTOSTART_ID");
+ /* Unset DESKTOP_AUTOSTART_ID in order to avoid child processes to
+ * use the same client id.
+ */
+ g_unsetenv ("DESKTOP_AUTOSTART_ID");
+ client_id = g_strdup (desktop_autostart_id ? desktop_autostart_id : "");
+ }
+
+ g_debug ("Connecting to session manager");
+
+ app->priv->sm_proxy = g_dbus_proxy_new_sync (app->priv->session_bus,
+ G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
+ G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
+ NULL,
+ "org.gnome.SessionManager",
+ "/org/gnome/SessionManager",
+ "org.gnome.SessionManager",
+ NULL,
+ &error);
+ if (error)
+ {
+ g_warning ("Failed to get a session proxy: %s", error->message);
+ g_error_free (error);
+ return;
+ }
+
+ /* FIXME: should we reuse the D-Bus application id here ? */
+ app->priv->app_id = g_strdup (g_get_prgname ());
+
+ if (!app->priv->register_session)
+ return;
+
+ g_debug ("Registering client '%s' '%s'", app->priv->app_id, client_id);
+
+ res = g_dbus_proxy_call_sync (app->priv->sm_proxy,
+ "RegisterClient",
+ g_variant_new ("(ss)", app->priv->app_id, client_id),
+ G_DBUS_CALL_FLAGS_NONE,
+ G_MAXINT,
+ NULL,
+ &error);
+
+ if (error)
+ {
+ g_warning ("Failed to register client: %s", error->message);
+ g_error_free (error);
+ g_clear_object (&app->priv->sm_proxy);
+ return;
+ }
+
+ g_variant_get (res, "(o)", &app->priv->client_path);
+ g_variant_unref (res);
+
+ g_debug ("Registered client at '%s'", app->priv->client_path);
+
+ app->priv->client_proxy = g_dbus_proxy_new_sync (app->priv->session_bus, 0,
+ NULL,
+ "org.gnome.SessionManager",
+ app->priv->client_path,
+ "org.gnome.SessionManager.ClientPrivate",
+ NULL,
+ &error);
+ if (error)
+ {
+ g_warning ("Failed to get client proxy: %s", error->message);
+ g_error_free (error);
+ g_clear_object (&app->priv->sm_proxy);
+ g_free (app->priv->client_path);
+ app->priv->client_path = NULL;
+ return;
+ }
+
+ g_signal_connect (app->priv->client_proxy, "g-signal", G_CALLBACK (client_proxy_signal), app);
+}
+
+
+
+/**
+ * GtkApplicationInhibitFlags:
+ * @GTK_APPLICATION_INHIBIT_LOGOUT: Inhibit ending the user session
+ * by logging out or by shutting down the computer
+ * @GTK_APPLICATION_INHIBIT_SWITCH: Inhibit user switching
+ * @GTK_APPLICATION_INHIBIT_SUSPEND: Inhibit suspending the
+ * session or computer
+ * @GTK_APPLICATION_INHIBIT_IDLE: Inhibit the session being
+ * marked as idle (and possibly locked)
+ *
+ * Types of user actions that may be blocked by gtk_application_inhibit().
+ *
+ * Since: 3.4
+ */
+
+/**
+ * gtk_application_inhibit:
+ * @application: the #GApplication
+ * @window: (allow-none): a #GtkWindow, or %NULL
+ * @flags: what types of actions should be inhibited
+ * @reason: (allow-none): a short, human-readable string that explains
+ * why these operations are inhibited
+ *
+ * Inform the session manager that certain types of actions should be
+ * inhibited. This is not guaranteed to work on all platforms and for
+ * all types of actions.
+ *
+ * Applications should invoke this method when they begin an operation
+ * that should not be interrupted, such as creating a CD or DVD. The
+ * types of actions that may be blocked are specified by the @flags
+ * parameter. When the application completes the operation it should
+ * call g_application_uninhibit() to remove the inhibitor. Note that
+ * an application can have multiple inhibitors, and all of the must
+ * be individually removed. Inhibitors are also cleared when the
+ * application exits.
+ *
+ * Applications should not expect that they will always be able to block
+ * the action. In most cases, users will be given the option to force
+ * the action to take place.
+ *
+ * Reasons should be short and to the point.
+ *
+ * If @window is given, the session manager may point the user to
+ * this window to find out more about why the action is inhibited.
+ *
+ * Returns: A non-zero cookie that is used to uniquely identify this
+ * request. It should be used as an argument to g_application_uninhibit()
+ * in order to remove the request. If the platform does not support
+ * inhibiting or the request failed for some reason, 0 is returned.
+ *
+ * Since: 3.4
+ */
+guint
+gtk_application_inhibit (GtkApplication *application,
+ GtkWindow *window,
+ GtkApplicationInhibitFlags flags,
+ const gchar *reason)
+{
+ GVariant *res;
+ GError *error = NULL;
+ guint cookie;
+ guint xid;
+
+ g_return_val_if_fail (GTK_IS_APPLICATION (application), 0);
+ g_return_val_if_fail (!g_application_get_is_remote (G_APPLICATION (application)), 0);
+ g_return_val_if_fail (application->priv->sm_proxy != NULL, 0);
+
+ if (window != NULL)
+ xid = GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (window)));
+ else
+ xid = 0;
+
+ res = g_dbus_proxy_call_sync (application->priv->sm_proxy,
+ "Inhibit",
+ g_variant_new ("(susu)",
+ application->priv->app_id,
+ xid,
+ reason,
+ flags),
+ G_DBUS_CALL_FLAGS_NONE,
+ G_MAXINT,
+ NULL,
+ &error);
+ if (error)
+ {
+ g_warning ("Calling Inhibit failed: %s", error->message);
+ g_error_free (error);
+ return 0;
+ }
+
+ g_variant_get (res, "(u)", &cookie);
+ g_variant_unref (res);
+
+ return cookie;
+}
+
+/**
+ * gtk_application_uninhibit:
+ * @application: the #GApplication
+ * @cookie: a cookie that was returned by g_application_inhibit()
+ *
+ * Removes an inhibitor that has been established with g_application_inhibit().
+ * Inhibitors are also cleared when the application exits.
+ *
+ * Since: 3.4
+ */
+void
+gtk_application_uninhibit (GtkApplication *application,
+ guint cookie)
+{
+ g_return_if_fail (GTK_IS_APPLICATION (application));
+ g_return_if_fail (!g_application_get_is_remote (G_APPLICATION (application)));
+ g_return_if_fail (application->priv->sm_proxy != NULL);
+
+ g_dbus_proxy_call (application->priv->sm_proxy,
+ "Uninhibit",
+ g_variant_new ("(u)", cookie),
+ G_DBUS_CALL_FLAGS_NONE,
+ G_MAXINT,
+ NULL, NULL, NULL);
+}
+
+/**
+ * gtk_application_is_inhibited:
+ * @application: the #GApplication
+ * @flags: what types of actions should be queried
+ *
+ * Determines if any of the actions specified in @flags are
+ * currently inhibited (possibly by another application).
+ *
+ * Returns: %TRUE if any of the actions specified in @flags are inhibited
+ *
+ * Since: 3.4
+ */
+gboolean
+gtk_application_is_inhibited (GtkApplication *application,
+ GtkApplicationInhibitFlags flags)
+{
+ GVariant *res;
+ GError *error = NULL;
+ gboolean inhibited;
+
+ g_return_val_if_fail (GTK_IS_APPLICATION (application), FALSE);
+ g_return_val_if_fail (!g_application_get_is_remote (G_APPLICATION (application)), FALSE);
+ g_return_val_if_fail (application->priv->sm_proxy != NULL, FALSE);
+
+ res = g_dbus_proxy_call_sync (application->priv->sm_proxy,
+ "IsInhibited",
+ g_variant_new ("(u)", flags),
+ G_DBUS_CALL_FLAGS_NONE,
+ G_MAXINT,
+ NULL,
+ &error);
+ if (error)
+ {
+ g_warning ("Calling IsInhibited failed: %s", error->message);
+ g_error_free (error);
+ return FALSE;
+ }
+
+ g_variant_get (res, "(b)", &inhibited);
+ g_variant_unref (res);
+
+ return inhibited;
+}
+
+#elif defined(GDK_WINDOWING_QUARTZ)
+
+/* OS X implementation copied from EggSMClient, but simplified since
+ * it doesn't need to interact with the user.
+ */
+
+static gboolean
+idle_will_quit (gpointer data)
+{
+ GtkApplication *app = data;
+
+ if (app->priv->quit_inhibit == 0)
+ g_application_quit (G_APPLICATION (app));
+ else
+ {
+ GtkApplicationQuartzInhibitor *inhibitor;
+ GSList *iter;
+ GtkWidget *dialog;
+
+ for (iter = app->priv->inhibitors; iter; iter = iter->next)
+ {
+ inhibitor = iter->data;
+ if (inhibitor->flags & GTK_APPLICATION_INHIBIT_LOGOUT)
+ break;
+ }
+ g_assert (inhibitor != NULL);
+
+ dialog = gtk_message_dialog_new (inhibitor->window,
+ GTK_DIALOG_MODAL,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_OK,
+ _("%s cannot quit at this time:\n\n%s"),
+ g_get_application_name (),
+ inhibitor->reason);
+ g_signal_connect_swapped (dialog,
+ "response",
+ G_CALLBACK (gtk_widget_destroy),
+ dialog);
+ gtk_widget_show_all (dialog);
+ }
+
+ return G_SOURCE_REMOVE;
+}
+
+static pascal OSErr
+quit_requested (const AppleEvent *aevt,
+ AppleEvent *reply,
+ long refcon)
+{
+ GtkApplication *app = GSIZE_TO_POINTER ((gsize)refcon);
+
+ /* Don't emit the "quit" signal immediately, since we're
+ * called from a weird point in the guts of gdkeventloop-quartz.c
+ */
+ g_idle_add_full (G_PRIORITY_DEFAULT, idle_will_quit, app, NULL);
+
+ return app->priv->quit_inhibit == 0 ? noErr : userCanceledErr;
+}
+
+static void
+gtk_application_startup_session_quartz (GtkApplication *app)
+{
+ if (app->priv->register_session)
+ AEInstallEventHandler (kCoreEventClass, kAEQuitApplication,
+ NewAEEventHandlerUPP (quit_requested),
+ (long)GPOINTER_TO_SIZE (app), false);
+}
+
+guint
+gtk_application_inhibit (GtkApplication *application,
+ GtkWindow *window,
+ GtkApplicationInhibitFlags flags,
+ const gchar *reason)
+{
+ GtkApplicationQuartzInhibitor *inhibitor;
+
+ g_return_val_if_fail (GTK_IS_APPLICATION (application), 0);
+ g_return_val_if_fail (flags != 0, 0);
+
+ inhibitor = g_slice_new (GtkApplicationQuartzInhibitor);
+ inhibitor->cookie = ++application->priv->next_cookie;
+ inhibitor->flags = flags;
+ inhibitor->reason = g_strdup (reason);
+ inhibitor->window = window ? g_object_ref (window) : NULL;
+
+ application->priv->inhibitors = g_slist_prepend (application->priv->inhibitors, inhibitor);
+
+ if (flags & GTK_APPLICATION_INHIBIT_LOGOUT)
+ application->priv->quit_inhibit++;
+
+ return inhibitor->cookie;
+}
+
+void
+gtk_application_uninhibit (GtkApplication *application,
+ guint cookie)
+{
+ GSList *iter;
+
+ for (iter = application->priv->inhibitors; iter; iter = iter->next)
+ {
+ GtkApplicationQuartzInhibitor *inhibitor = iter->data;
+
+ if (inhibitor->cookie == cookie)
+ {
+ if (inhibitor->flags & GTK_APPLICATION_INHIBIT_LOGOUT)
+ application->priv->quit_inhibit--;
+ gtk_application_quartz_inhibitor_free (inhibitor);
+ application->priv->inhibitors = g_slist_delete_link (application->priv->inhibitors, iter);
+ return;
+ }
+ }
+
+ g_warning ("Invalid inhibitor cookie");
+}
+
+gboolean
+gtk_application_is_inhibited (GtkApplication *application,
+ GtkApplicationInhibitFlags flags)
+{
+ if (flags & GTK_APPLICATION_INHIBIT_LOGOUT)
+ return application->priv->quit_inhibit > 0;
+
+ return FALSE;
+}
+
+#else
+
+/* Trivial implementation.
+ *
+ * For the inhibit API on Windows, see
+ * http://msdn.microsoft.com/en-us/library/ms700677%28VS.85%29.aspx
+ */
+
+guint
+gtk_application_inhibit (GtkApplication *application,
+ GtkWindow *window,
+ GtkApplicationInhibitFlags flags,
+ const gchar *reason)
+{
+ return 0;
+}
- g_object_get (application, "menubar", &menubar, NULL);
- g_object_unref (menubar);
+void
+gtk_application_uninhibit (GtkApplication *application,
+ guint cookie)
+{
+}
- return menubar;
+gboolean
+gtk_application_is_inhibited (GtkApplication *application,
+ GtkApplicationInhibitFlags flags)
+{
+ return FALSE;
}
+
+#endif