[gnome-power-manager] Don't automatically suspend if there are suspend inhibits

[Chris Coulson <ccoulson src gnome org>]

commit b9a8c88d76b3c58af3d95b45200a2173586deac8
Author: Chris Coulson <chrisccoulson googlemail com>
Date:   Wed Jan 27 21:17:04 2010 +0000

    Don't automatically suspend if there are suspend inhibits
    
    Check for suspend inhibits before registering the gpm_idle_sleep_cb
    timeout callback, to avoid automatically suspending if this action is
    inhibited by another application. Fixes #607748

 src/gpm-idle.c    |   35 ++++++++++++++-------
 src/gpm-session.c |   84 +++++++++++++++++++++++++++++++++++++++++-----------
 src/gpm-session.h |    6 ++-
 3 files changed, 93 insertions(+), 32 deletions(-)
---
diff --git a/src/gpm-idle.c b/src/gpm-idle.c
index f96abe3..33d251c 100644
--- a/src/gpm-idle.c
+++ b/src/gpm-idle.c
@@ -203,14 +203,16 @@ static void
 gpm_idle_evaluate (GpmIdle *idle)
 {
 	gboolean is_idle;
-	gboolean is_inhibited;
+	gboolean is_idle_inhibited;
+	gboolean is_suspend_inhibited;
 	gchar *tooltip;
 	gchar *what_to_do;
 	gchar *nag_message;
 
 	is_idle = gpm_session_get_idle (idle->priv->session);
-	is_inhibited = gpm_session_get_inhibited (idle->priv->session);
-	egg_debug ("session_idle=%i, session_inhibited=%i, x_idle=%i", is_idle, is_inhibited, idle->priv->x_idle);
+	is_idle_inhibited = gpm_session_get_idle_inhibited (idle->priv->session);
+	is_suspend_inhibited = gpm_session_get_suspend_inhibited (idle->priv->session);
+	egg_debug ("session_idle=%i, idle_inhibited=%i, suspend_inhibited=%i, x_idle=%i", is_idle, is_idle_inhibited, is_suspend_inhibited, idle->priv->x_idle);
 
 	/* TRANSLATORS: this is what the user should read for more information about the blanking problem (%s is a URL) */
 	what_to_do = g_strdup_printf (_("Please see %s for more information."),
@@ -221,11 +223,13 @@ gpm_idle_evaluate (GpmIdle *idle)
 				       what_to_do);
 
 	/* debug */
-	tooltip = g_strdup_printf ("%s, %s, %s.\n%s",
+	tooltip = g_strdup_printf ("%s, %s, %s, %s.\n%s",
 				   /* TRANSLATORS: this is for debugging, if the session is idle */
 				   is_idle ? _("Session idle") : _("Session active"),
-				   /* TRANSLATORS: has something inhibited the session */
-				   is_inhibited ? _("inhibited") : _("not inhibited"),
+				   /* TRANSLATORS: has something inhibited the session from going idle */
+				   is_idle_inhibited ? _("idle inhibited") : _("idle not inhibited"),
+				   /* TRANSLATORS: has something inhibited the system from being suspended */
+				   is_suspend_inhibited ? _("suspend inhibited") : _("suspend not inhibited"),
 				   /* TRANSLATORS: is the screen idle or awake */
 				   idle->priv->x_idle ? _("screen idle") : _("screen awake"),
 				   nag_message);
@@ -247,8 +251,8 @@ gpm_idle_evaluate (GpmIdle *idle)
 		goto out;
 	}
 
-	/* are we inhibited */
-	if (is_inhibited) {
+	/* are we inhibited from going idle */
+	if (is_idle_inhibited) {
 		egg_debug ("inhibited, so using normal state");
 		gpm_idle_set_mode (idle, GPM_IDLE_MODE_NORMAL);
 		if (idle->priv->timeout_blank_id != 0) {
@@ -276,8 +280,15 @@ gpm_idle_evaluate (GpmIdle *idle)
 		idle->priv->timeout_blank_id = g_timeout_add_seconds (idle->priv->timeout_blank, (GSourceFunc) gpm_idle_blank_cb, idle);
 	}
 
-	/* only do the sleep timeout when the session is idle */
-	if (is_idle) {
+	/* are we inhibited from sleeping */
+	if (is_suspend_inhibited) {
+		egg_debug ("suspend inhibited");
+		if (idle->priv->timeout_sleep_id != 0) {
+			g_source_remove (idle->priv->timeout_sleep_id);
+			idle->priv->timeout_sleep_id = 0;
+		}
+	} else if (is_idle) {
+	/* only do the sleep timeout when the session is idle and we aren't inhibited from sleeping */
 		if (idle->priv->timeout_sleep_id == 0 &&
 		    idle->priv->timeout_sleep != 0) {
 			egg_debug ("setting up sleep callback %is", idle->priv->timeout_sleep);
@@ -362,9 +373,9 @@ gpm_idle_session_idle_changed_cb (GpmSession *session, gboolean is_idle, GpmIdle
  * gpm_idle_session_inhibited_changed_cb:
  **/
 static void
-gpm_idle_session_inhibited_changed_cb (GpmSession *session, gboolean is_inhibited, GpmIdle *idle)
+gpm_idle_session_inhibited_changed_cb (GpmSession *session, gboolean is_idle_inhibited, gboolean is_suspend_inhibited, GpmIdle *idle)
 {
-	egg_debug ("Received gnome session inhibited changed: %i", is_inhibited);
+	egg_debug ("Received gnome session inhibited changed: idle=(%i), suspend=(%i)", is_idle_inhibited, is_suspend_inhibited);
 	gpm_idle_evaluate (idle);
 }
 
diff --git a/src/gpm-session.c b/src/gpm-session.c
index 68c1f08..bfccc7c 100644
--- a/src/gpm-session.c
+++ b/src/gpm-session.c
@@ -29,6 +29,7 @@
 #include "gpm-session.h"
 #include "gpm-common.h"
 #include "egg-debug.h"
+#include "gpm-marshal.h"
 
 static void     gpm_session_finalize   (GObject		*object);
 
@@ -64,7 +65,8 @@ struct GpmSessionPrivate
 	DBusGProxy		*proxy_client_private;
 	DBusGProxy		*proxy_prop;
 	gboolean		 is_idle_old;
-	gboolean		 is_inhibited_old;
+	gboolean		 is_idle_inhibited_old;
+	gboolean		 is_suspend_inhibited_old;
 };
 
 enum {
@@ -112,13 +114,23 @@ gpm_session_get_idle (GpmSession *session)
 }
 
 /**
- * gpm_session_get_inhibited:
+ * gpm_session_get_idle_inhibited:
  **/
 gboolean
-gpm_session_get_inhibited (GpmSession *session)
+gpm_session_get_idle_inhibited (GpmSession *session)
 {
 	g_return_val_if_fail (GPM_IS_SESSION (session), FALSE);
-	return session->priv->is_inhibited_old;
+	return session->priv->is_idle_inhibited_old;
+}
+
+/**
+ * gpm_session_get_suspend_inhibited:
+ **/
+gboolean
+gpm_session_get_suspend_inhibited (GpmSession *session)
+{
+	g_return_val_if_fail (GPM_IS_SESSION (session), FALSE);
+	return session->priv->is_suspend_inhibited_old;
 }
 
 /**
@@ -174,10 +186,10 @@ out:
 }
 
 /**
- * gpm_session_is_inhibited:
+ * gpm_session_is_idle_inhibited:
  **/
 static gboolean
-gpm_session_is_inhibited (GpmSession *session)
+gpm_session_is_idle_inhibited (GpmSession *session)
 {
 	gboolean ret;
 	gboolean is_inhibited = FALSE;
@@ -205,6 +217,37 @@ out:
 }
 
 /**
+ * gpm_session_is_suspend_inhibited:
+ **/
+static gboolean
+gpm_session_is_suspend_inhibited (GpmSession *session)
+{
+	gboolean ret;
+	gboolean is_inhibited = FALSE;
+	GError *error = NULL;
+
+	/* no gnome-session */
+	if (session->priv->proxy == NULL) {
+		egg_warning ("no gnome-session");
+		goto out;
+	}
+
+	/* find out if this change altered the inhibited state */
+	ret = dbus_g_proxy_call (session->priv->proxy, "IsInhibited", &error,
+				 G_TYPE_UINT, GPM_SESSION_INHIBIT_MASK_SUSPEND,
+				 G_TYPE_INVALID,
+				 G_TYPE_BOOLEAN, &is_inhibited,
+				 G_TYPE_INVALID);
+	if (!ret) {
+		egg_warning ("failed to get inhibit status: %s", error->message);
+		g_error_free (error);
+		is_inhibited = FALSE;
+	}
+out:
+	return is_inhibited;
+}
+
+/**
  * gpm_session_stop_cb:
  **/
 static void
@@ -333,13 +376,16 @@ out:
 static void
 gpm_session_inhibit_changed_cb (DBusGProxy *proxy, const gchar *id, GpmSession *session)
 {
-	gboolean is_inhibited;
-
-	is_inhibited = gpm_session_is_inhibited (session);
-	if (is_inhibited != session->priv->is_inhibited_old) {
-		egg_debug ("emitting inhibited-changed : (%i)", is_inhibited);
-		session->priv->is_inhibited_old = is_inhibited;
-		g_signal_emit (session, signals [INHIBITED_CHANGED], 0, is_inhibited);
+	gboolean is_idle_inhibited;
+	gboolean is_suspend_inhibited;
+
+	is_idle_inhibited = gpm_session_is_idle_inhibited (session);
+	is_suspend_inhibited = gpm_session_is_suspend_inhibited (session);
+	if (is_idle_inhibited != session->priv->is_idle_inhibited_old || is_suspend_inhibited != session->priv->is_suspend_inhibited_old) {
+		egg_debug ("emitting inhibited-changed : idle=(%i), suspend=(%i)", is_idle_inhibited, is_suspend_inhibited);
+		session->priv->is_idle_inhibited_old = is_idle_inhibited;
+		session->priv->is_suspend_inhibited_old = is_suspend_inhibited;
+		g_signal_emit (session, signals [INHIBITED_CHANGED], 0, is_idle_inhibited, is_suspend_inhibited);
 	}
 }
 
@@ -366,8 +412,8 @@ gpm_session_class_init (GpmSessionClass *klass)
 			      G_TYPE_FROM_CLASS (object_class),
 			      G_SIGNAL_RUN_LAST,
 			      G_STRUCT_OFFSET (GpmSessionClass, inhibited_changed),
-			      NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN,
-			      G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
+			      NULL, NULL, gpm_marshal_VOID__BOOLEAN_BOOLEAN,
+			      G_TYPE_NONE, 2, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
 	signals [STOP] =
 		g_signal_new ("stop",
 			      G_TYPE_FROM_CLASS (object_class),
@@ -410,7 +456,8 @@ gpm_session_init (GpmSession *session)
 
 	session->priv = GPM_SESSION_GET_PRIVATE (session);
 	session->priv->is_idle_old = FALSE;
-	session->priv->is_inhibited_old = FALSE;
+	session->priv->is_idle_inhibited_old = FALSE;
+	session->priv->is_suspend_inhibited_old = FALSE;
 	session->priv->proxy_client_private = NULL;
 
 	connection = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
@@ -458,9 +505,10 @@ gpm_session_init (GpmSession *session)
 	dbus_g_proxy_connect_signal (session->priv->proxy, "InhibitorRemoved", G_CALLBACK (gpm_session_inhibit_changed_cb), session, NULL);
 
 	/* coldplug */
-	session->priv->is_inhibited_old = gpm_session_is_inhibited (session);
+	session->priv->is_idle_inhibited_old = gpm_session_is_idle_inhibited (session);
+	session->priv->is_suspend_inhibited_old = gpm_session_is_suspend_inhibited (session);
 	session->priv->is_idle_old = gpm_session_is_idle (session);
-	egg_debug ("idle: %i, inhibited: %i", session->priv->is_idle_old, session->priv->is_inhibited_old);
+	egg_debug ("idle: %i, idle_inhibited: %i, suspend_inhibited: %i", session->priv->is_idle_old, session->priv->is_idle_inhibited_old, session->priv->is_suspend_inhibited_old);
 }
 
 /**
diff --git a/src/gpm-session.h b/src/gpm-session.h
index c1d097e..ad45e46 100644
--- a/src/gpm-session.h
+++ b/src/gpm-session.h
@@ -47,7 +47,8 @@ typedef struct
 	void		(* idle_changed)		(GpmSession	*session,
 							 gboolean	 is_idle);
 	void		(* inhibited_changed)		(GpmSession	*session,
-							 gboolean	 is_inhibited);
+							 gboolean	 is_idle_inhibited,
+							 gboolean        is_suspend_inhibited);
 	/* just exit */
 	void		(* stop)			(GpmSession	*session);
 	/* reply with EndSessionResponse */
@@ -64,7 +65,8 @@ GpmSession	*gpm_session_new			(void);
 
 gboolean	 gpm_session_logout			(GpmSession	*session);
 gboolean	 gpm_session_get_idle			(GpmSession	*session);
-gboolean	 gpm_session_get_inhibited		(GpmSession	*session);
+gboolean	 gpm_session_get_idle_inhibited		(GpmSession	*session);
+gboolean	 gpm_session_get_suspend_inhibited	(GpmSession	*session);
 gboolean	 gpm_session_register_client		(GpmSession	*session,
 							 const gchar	*app_id,
 							 const gchar	*client_startup_id);