moved from Mate-Extra

1 files changed, 729 insertions, 0 deletions

diff --git a/src/gpm-idle.c b/src/gpm-idle.c
new file mode 100644
index 0000000..0a7c33c
--- /dev/null
+++ b/src/gpm-idle.c
@@ -0,0 +1,729 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2005 William Jon McCann <[email protected]>
+ * Copyright (C) 2005-2009 Richard Hughes <[email protected]>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <errno.h>
+
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif /* HAVE_UNISTD_H */
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "egg-debug.h"
+#include "egg-idletime.h"
+
+#include "gpm-idle.h"
+#include "gpm-load.h"
+#include "gpm-session.h"
+
+#define GPM_IDLE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GPM_TYPE_IDLE, GpmIdlePrivate))
+
+/* Sets the idle percent limit, i.e. how hard the computer can work
+   while considered "at idle" */
+#define GPM_IDLE_CPU_LIMIT			5
+#define	GPM_IDLE_IDLETIME_ID			1
+
+struct GpmIdlePrivate
+{
+	EggIdletime	*idletime;
+	GpmLoad		*load;
+	GpmSession	*session;
+	GpmIdleMode	 mode;
+	guint		 timeout_dim;		/* in seconds */
+	guint		 timeout_blank;		/* in seconds */
+	guint		 timeout_sleep;		/* in seconds */
+	guint		 timeout_blank_id;
+	guint		 timeout_sleep_id;
+	gboolean	 x_idle;
+	gboolean	 check_type_cpu;
+};
+
+enum {
+	IDLE_CHANGED,
+	LAST_SIGNAL
+};
+
+static guint signals [LAST_SIGNAL] = { 0 };
+static gpointer gpm_idle_object = NULL;
+
+G_DEFINE_TYPE (GpmIdle, gpm_idle, G_TYPE_OBJECT)
+
+/**
+ * gpm_idle_mode_to_string:
+ **/
+static const gchar *
+gpm_idle_mode_to_string (GpmIdleMode mode)
+{
+	if (mode == GPM_IDLE_MODE_NORMAL)
+		return "normal";
+	if (mode == GPM_IDLE_MODE_DIM)
+		return "dim";
+	if (mode == GPM_IDLE_MODE_BLANK)
+		return "blank";
+	if (mode == GPM_IDLE_MODE_SLEEP)
+		return "sleep";
+	return "unknown";
+}
+
+/**
+ * gpm_idle_set_mode:
+ * @mode: The new mode, e.g. GPM_IDLE_MODE_SLEEP
+ **/
+static void
+gpm_idle_set_mode (GpmIdle *idle, GpmIdleMode mode)
+{
+	g_return_if_fail (GPM_IS_IDLE (idle));
+
+	if (mode != idle->priv->mode) {
+		idle->priv->mode = mode;
+		egg_debug ("Doing a state transition: %s", gpm_idle_mode_to_string (mode));
+		g_signal_emit (idle, signals [IDLE_CHANGED], 0, mode);
+	}
+}
+
+/**
+ * gpm_idle_set_check_cpu:
+ * @check_type_cpu: If we should check the CPU before mode becomes
+ *		    GPM_IDLE_MODE_SLEEP and the event is done.
+ **/
+void
+gpm_idle_set_check_cpu (GpmIdle *idle, gboolean check_type_cpu)
+{
+	g_return_if_fail (GPM_IS_IDLE (idle));
+	egg_debug ("Setting the CPU load check to %i", check_type_cpu);
+	idle->priv->check_type_cpu = check_type_cpu;
+}
+
+/**
+ * gpm_idle_get_mode:
+ * Return value: The current mode, e.g. GPM_IDLE_MODE_SLEEP
+ **/
+GpmIdleMode
+gpm_idle_get_mode (GpmIdle *idle)
+{
+	return idle->priv->mode;
+}
+
+/**
+ * gpm_idle_blank_cb:
+ **/
+static gboolean
+gpm_idle_blank_cb (GpmIdle *idle)
+{
+	if (idle->priv->mode > GPM_IDLE_MODE_BLANK) {
+		egg_debug ("ignoring current mode %s", gpm_idle_mode_to_string (idle->priv->mode));
+		return FALSE;
+	}
+	gpm_idle_set_mode (idle, GPM_IDLE_MODE_BLANK);
+	return FALSE;
+}
+
+/**
+ * gpm_idle_sleep_cb:
+ **/
+static gboolean
+gpm_idle_sleep_cb (GpmIdle *idle)
+{
+	gdouble load;
+	gboolean ret = FALSE;
+
+	/* get our computed load value */
+	if (idle->priv->check_type_cpu) {
+		load = gpm_load_get_current (idle->priv->load);
+		if (load > GPM_IDLE_CPU_LIMIT) {
+			/* check if system is "idle" enough */
+			egg_debug ("Detected that the CPU is busy");
+			ret = TRUE;
+			goto out;
+		}
+	}
+	gpm_idle_set_mode (idle, GPM_IDLE_MODE_SLEEP);
+out:
+	return ret;
+}
+
+/**
+ * gpm_idle_evaluate:
+ **/
+static void
+gpm_idle_evaluate (GpmIdle *idle)
+{
+	gboolean is_idle;
+	gboolean is_idle_inhibited;
+	gboolean is_suspend_inhibited;
+
+	is_idle = gpm_session_get_idle (idle->priv->session);
+	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);
+
+	/* check we are really idle */
+	if (!idle->priv->x_idle) {
+		gpm_idle_set_mode (idle, GPM_IDLE_MODE_NORMAL);
+		egg_debug ("X not idle");
+		if (idle->priv->timeout_blank_id != 0) {
+			g_source_remove (idle->priv->timeout_blank_id);
+			idle->priv->timeout_blank_id = 0;
+		}
+		if (idle->priv->timeout_sleep_id != 0) {
+			g_source_remove (idle->priv->timeout_sleep_id);
+			idle->priv->timeout_sleep_id = 0;
+		}
+		goto out;
+	}
+
+	/* 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) {
+			g_source_remove (idle->priv->timeout_blank_id);
+			idle->priv->timeout_blank_id = 0;
+		}
+		if (idle->priv->timeout_sleep_id != 0) {
+			g_source_remove (idle->priv->timeout_sleep_id);
+			idle->priv->timeout_sleep_id = 0;
+		}
+		goto out;
+	}
+
+	/* normal to dim */
+	if (idle->priv->mode == GPM_IDLE_MODE_NORMAL) {
+		egg_debug ("normal to dim");
+		gpm_idle_set_mode (idle, GPM_IDLE_MODE_DIM);
+	}
+
+	/* set up blank callback even when session is not idle,
+	 * but only if we actually want to blank. */
+	if (idle->priv->timeout_blank_id == 0 &&
+	    idle->priv->timeout_blank != 0) {
+		egg_debug ("setting up blank callback for %is", idle->priv->timeout_blank);
+		idle->priv->timeout_blank_id = g_timeout_add_seconds (idle->priv->timeout_blank, (GSourceFunc) gpm_idle_blank_cb, 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);
+			idle->priv->timeout_sleep_id = g_timeout_add_seconds (idle->priv->timeout_sleep, (GSourceFunc) gpm_idle_sleep_cb, idle);
+		}
+	}
+out:
+	return;
+}
+
+/**
+ *  gpm_idle_adjust_timeout_dim:
+ *  @idle_time: The new timeout we want to set, in seconds.
+ *  @timeout: Current idle time, in seconds.
+ *
+ *  On slow machines, or machines that have lots to load duing login,
+ *  the current idle time could be bigger than the requested timeout.
+ *  In this case the scheduled idle timeout will never fire, unless
+ *  some user activity (keyboard, mouse) resets the current idle time.
+ *  Instead of relying on user activity to correct this issue, we need
+ *  to adjust timeout, as related to current idle time, so the idle
+ *  timeout will fire as designed.
+ *
+ *  Return value: timeout to set, adjusted acccording to current idle time.
+ **/
+static guint
+gpm_idle_adjust_timeout_dim (guint idle_time, guint timeout)
+{
+	/* allow 2 sec margin for messaging delay. */
+	idle_time += 2;
+
+	/* Double timeout until it's larger than current idle time.
+	 * Give up for ultra slow machines. (86400 sec = 24 hours) */
+	while (timeout < idle_time && timeout < 86400 && timeout > 0) {
+		timeout *= 2;
+	}
+	return timeout;
+}
+
+/**
+ * gpm_idle_set_timeout_dim:
+ * @timeout: The new timeout we want to set, in seconds
+ **/
+gboolean
+gpm_idle_set_timeout_dim (GpmIdle *idle, guint timeout)
+{
+	gint64 idle_time_in_msec;
+	guint timeout_adjusted;
+
+	g_return_val_if_fail (GPM_IS_IDLE (idle), FALSE);
+
+	idle_time_in_msec = egg_idletime_get_time (idle->priv->idletime);
+	timeout_adjusted  = gpm_idle_adjust_timeout_dim (idle_time_in_msec / 1000, timeout);
+	egg_debug ("Current idle time=%lldms, timeout was %us, becomes %us after adjustment",
+		   (long long int)idle_time_in_msec, timeout, timeout_adjusted);
+	timeout = timeout_adjusted;
+
+	egg_debug ("Setting dim idle timeout: %ds", timeout);
+	if (idle->priv->timeout_dim != timeout) {
+		idle->priv->timeout_dim = timeout;
+
+		if (timeout > 0)
+			egg_idletime_alarm_set (idle->priv->idletime, GPM_IDLE_IDLETIME_ID, timeout * 1000);
+		else
+			egg_idletime_alarm_remove (idle->priv->idletime, GPM_IDLE_IDLETIME_ID);
+	}
+	return TRUE;
+}
+
+/**
+ * gpm_idle_set_timeout_blank:
+ * @timeout: The new timeout we want to set, in seconds
+ **/
+gboolean
+gpm_idle_set_timeout_blank (GpmIdle *idle, guint timeout)
+{
+	g_return_val_if_fail (GPM_IS_IDLE (idle), FALSE);
+
+	egg_debug ("Setting blank idle timeout: %ds", timeout);
+	if (idle->priv->timeout_blank != timeout) {
+		idle->priv->timeout_blank = timeout;
+		gpm_idle_evaluate (idle);
+	}
+	return TRUE;
+}
+
+/**
+ * gpm_idle_set_timeout_sleep:
+ * @timeout: The new timeout we want to set, in seconds
+ **/
+gboolean
+gpm_idle_set_timeout_sleep (GpmIdle *idle, guint timeout)
+{
+	g_return_val_if_fail (GPM_IS_IDLE (idle), FALSE);
+
+	egg_debug ("Setting sleep idle timeout: %ds", timeout);
+	if (idle->priv->timeout_sleep != timeout) {
+		idle->priv->timeout_sleep = timeout;
+		gpm_idle_evaluate (idle);
+	}
+	return TRUE;
+}
+
+/**
+ * gpm_idle_session_idle_changed_cb:
+ * @is_idle: If the session is idle
+ *
+ * The SessionIdleChanged callback from mate-session.
+ **/
+static void
+gpm_idle_session_idle_changed_cb (GpmSession *session, gboolean is_idle, GpmIdle *idle)
+{
+	egg_debug ("Received mate session idle changed: %i", is_idle);
+	gpm_idle_evaluate (idle);
+}
+
+/**
+ * gpm_idle_session_inhibited_changed_cb:
+ **/
+static void
+gpm_idle_session_inhibited_changed_cb (GpmSession *session, gboolean is_idle_inhibited, gboolean is_suspend_inhibited, GpmIdle *idle)
+{
+	egg_debug ("Received mate session inhibited changed: idle=(%i), suspend=(%i)", is_idle_inhibited, is_suspend_inhibited);
+	gpm_idle_evaluate (idle);
+}
+
+/**
+ * gpm_idle_idletime_alarm_expired_cb:
+ *
+ * We're idle, something timed out
+ **/
+static void
+gpm_idle_idletime_alarm_expired_cb (EggIdletime *idletime, guint alarm_id, GpmIdle *idle)
+{
+	egg_debug ("idletime alarm: %i", alarm_id);
+
+	/* set again */
+	idle->priv->x_idle = TRUE;
+	gpm_idle_evaluate (idle);
+}
+
+/**
+ * gpm_idle_idletime_reset_cb:
+ *
+ * We're no longer idle, the user moved
+ **/
+static void
+gpm_idle_idletime_reset_cb (EggIdletime *idletime, GpmIdle *idle)
+{
+	egg_debug ("idletime reset");
+
+	idle->priv->x_idle = FALSE;
+	gpm_idle_evaluate (idle);
+}
+
+/**
+ * gpm_idle_finalize:
+ * @object: This class instance
+ **/
+static void
+gpm_idle_finalize (GObject *object)
+{
+	GpmIdle *idle;
+
+	g_return_if_fail (object != NULL);
+	g_return_if_fail (GPM_IS_IDLE (object));
+
+	idle = GPM_IDLE (object);
+
+	g_return_if_fail (idle->priv != NULL);
+
+	if (idle->priv->timeout_blank_id != 0)
+		g_source_remove (idle->priv->timeout_blank_id);
+	if (idle->priv->timeout_sleep_id != 0)
+		g_source_remove (idle->priv->timeout_sleep_id);
+
+	g_object_unref (idle->priv->load);
+	g_object_unref (idle->priv->session);
+
+	egg_idletime_alarm_remove (idle->priv->idletime, GPM_IDLE_IDLETIME_ID);
+	g_object_unref (idle->priv->idletime);
+
+	G_OBJECT_CLASS (gpm_idle_parent_class)->finalize (object);
+}
+
+/**
+ * gpm_idle_class_init:
+ * @klass: This class instance
+ **/
+static void
+gpm_idle_class_init (GpmIdleClass *klass)
+{
+	GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->finalize = gpm_idle_finalize;
+
+	signals [IDLE_CHANGED] =
+		g_signal_new ("idle-changed",
+			      G_TYPE_FROM_CLASS (object_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (GpmIdleClass, idle_changed),
+			      NULL, NULL, g_cclosure_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
+
+	g_type_class_add_private (klass, sizeof (GpmIdlePrivate));
+}
+
+/**
+ * gpm_idle_init:
+ *
+ * Gets a DBUS connection, and aquires the session connection so we can
+ * get session changed events.
+ *
+ **/
+static void
+gpm_idle_init (GpmIdle *idle)
+{
+	idle->priv = GPM_IDLE_GET_PRIVATE (idle);
+
+	idle->priv->timeout_dim = G_MAXUINT;
+	idle->priv->timeout_blank = G_MAXUINT;
+	idle->priv->timeout_sleep = G_MAXUINT;
+	idle->priv->timeout_blank_id = 0;
+	idle->priv->timeout_sleep_id = 0;
+	idle->priv->x_idle = FALSE;
+	idle->priv->load = gpm_load_new ();
+	idle->priv->session = gpm_session_new ();
+	g_signal_connect (idle->priv->session, "idle-changed", G_CALLBACK (gpm_idle_session_idle_changed_cb), idle);
+	g_signal_connect (idle->priv->session, "inhibited-changed", G_CALLBACK (gpm_idle_session_inhibited_changed_cb), idle);
+
+	idle->priv->idletime = egg_idletime_new ();
+	g_signal_connect (idle->priv->idletime, "reset", G_CALLBACK (gpm_idle_idletime_reset_cb), idle);
+	g_signal_connect (idle->priv->idletime, "alarm-expired", G_CALLBACK (gpm_idle_idletime_alarm_expired_cb), idle);
+
+	gpm_idle_evaluate (idle);
+}
+
+/**
+ * gpm_idle_new:
+ * Return value: A new GpmIdle instance.
+ **/
+GpmIdle *
+gpm_idle_new (void)
+{
+	if (gpm_idle_object != NULL) {
+		g_object_ref (gpm_idle_object);
+	} else {
+		gpm_idle_object = g_object_new (GPM_TYPE_IDLE, NULL);
+		g_object_add_weak_pointer (gpm_idle_object, &gpm_idle_object);
+	}
+	return GPM_IDLE (gpm_idle_object);
+}
+
+/***************************************************************************
+ ***                          MAKE CHECK TESTS                           ***
+ ***************************************************************************/
+#ifdef EGG_TEST
+#include "egg-test.h"
+#include "gpm-dpms.h"
+
+static GpmIdleMode _mode = 0;
+
+static void
+gpm_idle_test_idle_changed_cb (GpmIdle *idle, GpmIdleMode mode, EggTest *test)
+{
+	_mode = mode;
+	egg_debug ("idle-changed %s", gpm_idle_mode_to_string (mode));
+	egg_test_loop_quit (test);
+}
+
+static gboolean
+gpm_idle_test_delay_cb (EggTest *test)
+{
+	egg_warning ("timing out");
+	egg_test_loop_quit (test);
+	return FALSE;
+}
+
+void
+gpm_idle_test (gpointer data)
+{
+	GpmIdle *idle;
+	gboolean ret;
+	EggTest *test = (EggTest *) data;
+	GpmIdleMode mode;
+	GpmDpms *dpms;
+
+	if (!egg_test_start (test, "GpmIdle"))
+		return;
+
+	/************************************************************/
+	egg_test_title (test, "get object");
+	idle = gpm_idle_new ();
+	if (idle != NULL)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "got no object");
+
+	/* set up defaults */
+	gpm_idle_set_check_cpu (idle, FALSE);
+	gpm_idle_set_timeout_dim (idle, 4);
+	gpm_idle_set_timeout_blank (idle, 5);
+	gpm_idle_set_timeout_sleep (idle, 15);
+	g_signal_connect (idle, "idle-changed",
+			  G_CALLBACK (gpm_idle_test_idle_changed_cb), test);
+
+	/************************************************************/
+	egg_test_title (test, "check cpu type");
+	egg_test_assert (test, (idle->priv->check_type_cpu == FALSE));
+
+	/************************************************************/
+	egg_test_title (test, "check timeout dim");
+	egg_test_assert (test, (idle->priv->timeout_dim == 4));
+
+	/************************************************************/
+	egg_test_title (test, "check timeout blank");
+	egg_test_assert (test, (idle->priv->timeout_blank == 5));
+
+	/************************************************************/
+	egg_test_title (test, "check timeout sleep");
+	egg_test_assert (test, (idle->priv->timeout_sleep == 15));
+
+	/************************************************************/
+	egg_test_title (test, "check x_idle");
+	egg_test_assert (test, (idle->priv->x_idle == FALSE));
+
+	/************************************************************/
+	egg_test_title (test, "check blank id");
+	egg_test_assert (test, (idle->priv->timeout_blank_id == 0));
+
+	/************************************************************/
+	egg_test_title (test, "check sleep id");
+	egg_test_assert (test, (idle->priv->timeout_sleep_id == 0));
+
+	/************************************************************/
+	egg_test_title (test, "check normal at startup");
+	mode = gpm_idle_get_mode (idle);
+	if (mode == GPM_IDLE_MODE_NORMAL)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	g_print ("*****************************\n");
+	g_print ("*** DO NOT MOVE THE MOUSE ***\n");
+	g_print ("*****************************\n");
+	egg_test_loop_wait (test, 2000 + 10000);
+	egg_test_loop_check (test);
+
+	/************************************************************/
+	egg_test_title (test, "check callback mode");
+	if (_mode == GPM_IDLE_MODE_DIM)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	egg_test_title (test, "check current mode");
+	mode = gpm_idle_get_mode (idle);
+	if (mode == GPM_IDLE_MODE_DIM)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	egg_test_title (test, "check x_idle");
+	egg_test_assert (test, (idle->priv->x_idle == TRUE));
+
+	/************************************************************/
+	egg_test_title (test, "check blank id");
+	egg_test_assert (test, (idle->priv->timeout_blank_id != 0));
+
+	/************************************************************/
+	egg_test_title (test, "check sleep id");
+	egg_test_assert (test, (idle->priv->timeout_sleep_id == 0));
+
+	/************************************************************/
+	egg_test_loop_wait (test, 5000 + 1000);
+	egg_test_loop_check (test);
+
+	/************************************************************/
+	egg_test_title (test, "check callback mode");
+	if (_mode == GPM_IDLE_MODE_BLANK)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	egg_test_title (test, "check current mode");
+	mode = gpm_idle_get_mode (idle);
+	if (mode == GPM_IDLE_MODE_BLANK)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	g_print ("**********************\n");
+	g_print ("*** MOVE THE MOUSE ***\n");
+	g_print ("**********************\n");
+	egg_test_loop_wait (test, G_MAXUINT);
+	egg_test_loop_check (test);
+
+	/************************************************************/
+	egg_test_title (test, "check callback mode");
+	if (_mode == GPM_IDLE_MODE_NORMAL)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	egg_test_title (test, "check current mode");
+	mode = gpm_idle_get_mode (idle);
+	if (mode == GPM_IDLE_MODE_NORMAL)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	egg_test_title (test, "check x_idle");
+	egg_test_assert (test, (idle->priv->x_idle == FALSE));
+
+	/************************************************************/
+	egg_test_title (test, "check blank id");
+	egg_test_assert (test, (idle->priv->timeout_blank_id == 0));
+
+	/************************************************************/
+	g_print ("*****************************\n");
+	g_print ("*** DO NOT MOVE THE MOUSE ***\n");
+	g_print ("*****************************\n");
+	egg_test_loop_wait (test, 4000 + 1500);
+	egg_test_loop_check (test);
+
+	/************************************************************/
+	egg_test_title (test, "check current mode");
+	mode = gpm_idle_get_mode (idle);
+	if (mode == GPM_IDLE_MODE_DIM)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	egg_test_title (test, "check x_idle");
+	egg_test_assert (test, (idle->priv->x_idle == TRUE));
+
+	egg_test_loop_wait (test, 15000);
+	egg_test_loop_check (test);
+
+	/************************************************************/
+	egg_test_title (test, "check current mode");
+	mode = gpm_idle_get_mode (idle);
+	if (mode == GPM_IDLE_MODE_BLANK)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	egg_test_title (test, "set dpms off");
+	dpms = gpm_dpms_new ();
+	ret = gpm_dpms_set_mode (dpms, GPM_DPMS_MODE_OFF, NULL);
+	egg_test_assert (test, ret);
+
+	/* wait for normal event to be suppressed */
+	g_timeout_add (2000, (GSourceFunc) gpm_idle_test_delay_cb, test);
+	egg_test_loop_wait (test, G_MAXUINT);
+	egg_test_loop_check (test);
+
+	/************************************************************/
+	egg_test_title (test, "check current mode");
+	mode = gpm_idle_get_mode (idle);
+	if (mode == GPM_IDLE_MODE_BLANK)
+		egg_test_success (test, NULL);
+	else
+		egg_test_failed (test, "mode: %s", gpm_idle_mode_to_string (mode));
+
+	/************************************************************/
+	egg_test_title (test, "check x_idle");
+	egg_test_assert (test, (idle->priv->x_idle == TRUE));
+
+	gpm_dpms_set_mode (dpms, GPM_DPMS_MODE_ON, NULL);
+
+	g_object_unref (idle);
+	g_object_unref (dpms);
+
+	egg_test_end (test);
+}
+
+#endif
+