Merge lp:~robert-ancell/unity-settings-daemon/idle into lp:unity-settings-daemon

[Robert Ancell]

Bring unstable idle timer code from gnome-desktop into unity-settings-daemon

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:4045
http://jenkins.qa.ubuntu.com/job/unity-settings-daemon-ci/33/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-settings-daemon-utopic-amd64-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-settings-daemon-utopic-armhf-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-settings-daemon-utopic-i386-ci/7

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-settings-daemon-ci/33/rebuild

review: Approve (continuous-integration)

[Sebastien Bacher (seb128)]

That's quite some changes to review, but mostly a copy of existing code, not I don't think it needs a detailled code review. The changes look fine to me on principle but we should give that a proper round of testing, including multimonitor setups and screensaver/idle usecases

review: Approve

[Tim Lunn (darkxst)]

This lgtm, lots of cut+paste and a bit of renaming, don't think it will cause any issues

[Robert Ancell (robert-ancell)]

This doesn't work because the two plugins both have copies of the GsdIdleMonitor class and try and register it twice. If the code is to be shared it needs to go into a shared library or two copies with different names.

review: Needs Fixing

[Robert Ancell (robert-ancell)]

I've merged this change into https://code.launchpad.net/~robert-ancell/unity-settings-daemon/xrandr/+merge/224548

Unmerged revisions

4045. By Robert Ancell on 2014-07-30

Bring unstable idle timer code from gnome-desktop into unity-settings-daemon

=== modified file 'configure.ac'
--- configure.ac	2014-02-15 08:33:21 +0000
+++ configure.ac	2014-07-30 22:27:08 +0000
@@ -137,7 +137,7 @@
 dnl - common
 dnl ---------------------------------------------------------------------------
 
-PKG_CHECK_MODULES(COMMON, x11 kbproto xi)
+PKG_CHECK_MODULES(COMMON, x11 kbproto xi xext)
 
 dnl ---------------------------------------------------------------------------
 dnl - automount
@@ -169,7 +169,7 @@
 dnl - cursor
 dnl ---------------------------------------------------------------------------
 
-PKG_CHECK_MODULES(CURSOR, xfixes gnome-desktop-3.0 >= $GNOME_DESKTOP_REQUIRED_VERSION)
+PKG_CHECK_MODULES(CURSOR, xfixes)
 
 dnl ---------------------------------------------------------------------------
 dnl - xsettings

=== modified file 'plugins/common/Makefile.am'
--- plugins/common/Makefile.am	2013-12-04 23:55:26 +0000
+++ plugins/common/Makefile.am	2014-07-30 22:27:08 +0000
@@ -5,6 +5,8 @@
 libcommon_la_SOURCES = \
 	gsd-keygrab.c		\
 	gsd-keygrab.h		\
+	gsd-idle-monitor.c	\
+	gsd-idle-monitor.h	\
 	gsd-input-helper.c	\
 	gsd-input-helper.h
 

=== added file 'plugins/common/gsd-idle-monitor.c'
--- plugins/common/gsd-idle-monitor.c	1970-01-01 00:00:00 +0000
+++ plugins/common/gsd-idle-monitor.c	2014-07-30 22:27:08 +0000
@@ -0,0 +1,616 @@
+/* -*- mode: C; c-file-style: "linux"; indent-tabs-mode: t -*-
+ *
+ * Adapted from gnome-session/gnome-session/gs-idle-monitor.c
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <time.h>
+#include <string.h>
+
+#include <X11/Xlib.h>
+#include <X11/extensions/sync.h>
+
+#include <glib.h>
+#include <gdk/gdkx.h>
+#include <gdk/gdk.h>
+
+#include "gsd-idle-monitor.h"
+
+#define GSD_IDLE_MONITOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GSD_TYPE_IDLE_MONITOR, GsdIdleMonitorPrivate))
+
+G_STATIC_ASSERT(sizeof(unsigned long) == sizeof(gpointer));
+
+struct _GsdIdleMonitorPrivate
+{
+	Display	    *display;
+
+	GHashTable  *watches;
+	GHashTable  *alarms;
+	int	     sync_event_base;
+	XSyncCounter counter;
+
+	XSyncAlarm   user_active_alarm;
+
+	GdkDevice   *device;
+};
+
+typedef struct
+{
+	GsdIdleMonitor         *monitor;
+	guint			  id;
+	GsdIdleMonitorWatchFunc callback;
+	gpointer		  user_data;
+	GDestroyNotify		  notify;
+	XSyncAlarm		  xalarm;
+} GsdIdleMonitorWatch;
+
+enum
+{
+	PROP_0,
+	PROP_DEVICE,
+	PROP_LAST,
+};
+
+static GParamSpec *obj_props[PROP_LAST];
+
+static void gsd_idle_monitor_initable_iface_init (GInitableIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GsdIdleMonitor, gsd_idle_monitor, G_TYPE_OBJECT,
+			 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
+						gsd_idle_monitor_initable_iface_init))
+
+static gint64
+_xsyncvalue_to_int64 (XSyncValue value)
+{
+	return ((guint64) XSyncValueHigh32 (value)) << 32
+		| (guint64) XSyncValueLow32 (value);
+}
+
+#define GINT64_TO_XSYNCVALUE(value, ret) XSyncIntsToValue (ret, value, ((guint64)value) >> 32)
+
+static XSyncAlarm
+_xsync_alarm_set (GsdIdleMonitor	*monitor,
+		  XSyncTestType          test_type,
+		  guint64                interval,
+		  gboolean               want_events)
+{
+	XSyncAlarmAttributes attr;
+	XSyncValue	     delta;
+	guint		     flags;
+
+	flags = XSyncCACounter | XSyncCAValueType | XSyncCATestType |
+		XSyncCAValue | XSyncCADelta | XSyncCAEvents;
+
+	XSyncIntToValue (&delta, 0);
+	attr.trigger.counter = monitor->priv->counter;
+	attr.trigger.value_type = XSyncAbsolute;
+	attr.delta = delta;
+	attr.events = want_events;
+
+	GINT64_TO_XSYNCVALUE (interval, &attr.trigger.wait_value);
+	attr.trigger.test_type = test_type;
+	return XSyncCreateAlarm (monitor->priv->display, flags, &attr);
+}
+
+static void
+ensure_alarm_rescheduled (Display    *dpy,
+			  XSyncAlarm  alarm)
+{
+	XSyncAlarmAttributes attr;
+
+	/* Some versions of Xorg have an issue where alarms aren't
+	 * always rescheduled. Calling XSyncChangeAlarm, even
+	 * without any attributes, will reschedule the alarm. */
+	XSyncChangeAlarm (dpy, alarm, 0, &attr);
+}
+
+static void
+set_alarm_enabled (Display    *dpy,
+		   XSyncAlarm  alarm,
+		   gboolean    enabled)
+{
+	XSyncAlarmAttributes attr;
+	attr.events = enabled;
+	XSyncChangeAlarm (dpy, alarm, XSyncCAEvents, &attr);
+}
+
+static void
+fire_watch (gpointer data,
+	    gpointer user_data)
+{
+	GsdIdleMonitorWatch *watch = data;
+	XSyncAlarm alarm = (XSyncAlarm) user_data;
+	GsdIdleMonitor *monitor;
+
+	if (watch->xalarm != alarm) {
+		return;
+	}
+
+	monitor = watch->monitor;
+	g_object_ref (monitor);
+
+	if (watch->callback) {
+		watch->callback (watch->monitor,
+				 watch->id,
+				 watch->user_data);
+	}
+
+	if (watch->xalarm == monitor->priv->user_active_alarm) {
+		gsd_idle_monitor_remove_watch (monitor, watch->id);
+	}
+
+	g_object_unref (monitor);
+}
+
+static void
+handle_alarm_notify_event (GsdIdleMonitor	    *monitor,
+			   XSyncAlarmNotifyEvent    *alarm_event)
+{
+	XSyncAlarm alarm;
+	GList *watches;
+	gboolean has_alarm;
+
+	if (alarm_event->state != XSyncAlarmActive) {
+		return;
+	}
+
+	alarm = alarm_event->alarm;
+
+	has_alarm = FALSE;
+
+	if (alarm == monitor->priv->user_active_alarm) {
+		set_alarm_enabled (monitor->priv->display,
+				   alarm,
+				   FALSE);
+		has_alarm = TRUE;
+	} else if (g_hash_table_contains (monitor->priv->alarms, (gpointer) alarm)) {
+		ensure_alarm_rescheduled (monitor->priv->display,
+					  alarm);
+		has_alarm = TRUE;
+	}
+
+	if (has_alarm) {
+		watches = g_hash_table_get_values (monitor->priv->watches);
+
+		g_list_foreach (watches,
+				fire_watch,
+				(gpointer) alarm);
+
+		g_list_free (watches);
+	}
+}
+
+static GdkFilterReturn
+xevent_filter (GdkXEvent	*xevent,
+	       GdkEvent		*event,
+	       GsdIdleMonitor *monitor)
+{
+	XEvent		      *ev;
+	XSyncAlarmNotifyEvent *alarm_event;
+
+	ev = xevent;
+	if (ev->xany.type != monitor->priv->sync_event_base + XSyncAlarmNotify) {
+		return GDK_FILTER_CONTINUE;
+	}
+
+	alarm_event = xevent;
+	handle_alarm_notify_event (monitor, alarm_event);
+
+	return GDK_FILTER_CONTINUE;
+}
+
+static char *
+counter_name_for_device (GdkDevice *device)
+{
+	if (device) {
+		gint device_id = gdk_x11_device_get_id (device);
+		if (device_id > 0)
+			return g_strdup_printf ("DEVICEIDLETIME %d", device_id);
+	}
+
+	return g_strdup ("IDLETIME");
+}
+
+static XSyncCounter
+find_idletime_counter (GsdIdleMonitor *monitor)
+{
+	int		    i;
+	int		    ncounters;
+	XSyncSystemCounter *counters;
+	XSyncCounter        counter = None;
+	char               *counter_name;
+
+	counter_name = counter_name_for_device (monitor->priv->device);
+	counters = XSyncListSystemCounters (monitor->priv->display, &ncounters);
+	for (i = 0; i < ncounters; i++) {
+		if (counters[i].name != NULL && strcmp (counters[i].name, counter_name) == 0) {
+			counter = counters[i].counter;
+			break;
+		}
+	}
+	XSyncFreeSystemCounterList (counters);
+	g_free (counter_name);
+
+	return counter;
+}
+
+static guint32
+get_next_watch_serial (void)
+{
+	static guint32 serial = 0;
+	g_atomic_int_inc (&serial);
+	return serial;
+}
+
+static void
+idle_monitor_watch_free (GsdIdleMonitorWatch *watch)
+{
+	GsdIdleMonitor *monitor;
+
+	if (watch == NULL) {
+		return;
+	}
+
+	monitor = watch->monitor;
+
+	if (watch->notify != NULL) {
+		watch->notify (watch->user_data);
+	}
+
+	if (watch->xalarm != monitor->priv->user_active_alarm) {
+		XSyncDestroyAlarm (monitor->priv->display, watch->xalarm);
+		g_hash_table_remove (monitor->priv->alarms, (gpointer) watch->xalarm);
+	}
+
+	g_slice_free (GsdIdleMonitorWatch, watch);
+}
+
+static void
+init_xsync (GsdIdleMonitor *monitor)
+{
+	int		    sync_error_base;
+	int		    res;
+	int		    major;
+	int		    minor;
+
+	res = XSyncQueryExtension (monitor->priv->display,
+				   &monitor->priv->sync_event_base,
+				   &sync_error_base);
+	if (! res) {
+		g_warning ("GsdIdleMonitor: Sync extension not present");
+		return;
+	}
+
+	res = XSyncInitialize (monitor->priv->display, &major, &minor);
+	if (! res) {
+		g_warning ("GsdIdleMonitor: Unable to initialize Sync extension");
+		return;
+	}
+
+	monitor->priv->counter = find_idletime_counter (monitor);
+	/* IDLETIME counter not found? */
+	if (monitor->priv->counter == None)
+		return;
+
+	monitor->priv->user_active_alarm = _xsync_alarm_set (monitor, XSyncNegativeTransition, 1, FALSE);
+
+	gdk_window_add_filter (NULL, (GdkFilterFunc)xevent_filter, monitor);
+}
+
+static void
+gsd_idle_monitor_dispose (GObject *object)
+{
+	GsdIdleMonitor *monitor;
+
+	monitor = GSD_IDLE_MONITOR (object);
+
+	g_clear_pointer (&monitor->priv->watches, g_hash_table_destroy);
+	g_clear_pointer (&monitor->priv->alarms, g_hash_table_destroy);
+	g_clear_object (&monitor->priv->device);
+
+	if (monitor->priv->user_active_alarm != None) {
+		XSyncDestroyAlarm (monitor->priv->display, monitor->priv->user_active_alarm);
+		monitor->priv->user_active_alarm = None;
+	}
+
+	gdk_window_remove_filter (NULL, (GdkFilterFunc)xevent_filter, monitor);
+
+	G_OBJECT_CLASS (gsd_idle_monitor_parent_class)->dispose (object);
+}
+
+static void
+gsd_idle_monitor_get_property (GObject    *object,
+				 guint       prop_id,
+				 GValue     *value,
+				 GParamSpec *pspec)
+{
+	GsdIdleMonitor *monitor = GSD_IDLE_MONITOR (object);
+	switch (prop_id)
+	{
+	case PROP_DEVICE:
+		g_value_set_object (value, monitor->priv->device);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+gsd_idle_monitor_set_property (GObject      *object,
+				 guint         prop_id,
+				 const GValue *value,
+				 GParamSpec   *pspec)
+{
+	GsdIdleMonitor *monitor = GSD_IDLE_MONITOR (object);
+	switch (prop_id)
+	{
+	case PROP_DEVICE:
+		monitor->priv->device = g_value_dup_object (value);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+gsd_idle_monitor_constructed (GObject *object)
+{
+	GsdIdleMonitor *monitor = GSD_IDLE_MONITOR (object);
+
+	monitor->priv->display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
+	init_xsync (monitor);
+}
+
+static gboolean
+gsd_idle_monitor_initable_init (GInitable     *initable,
+				  GCancellable  *cancellable,
+				  GError       **error)
+{
+	GsdIdleMonitor *monitor;
+
+	monitor = GSD_IDLE_MONITOR (initable);
+
+	if (monitor->priv->counter == None) {
+		g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+				     "Per-device idletime is not supported");
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void
+gsd_idle_monitor_initable_iface_init (GInitableIface *iface)
+{
+	iface->init = gsd_idle_monitor_initable_init;
+}
+
+static void
+gsd_idle_monitor_class_init (GsdIdleMonitorClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->dispose = gsd_idle_monitor_dispose;
+	object_class->constructed = gsd_idle_monitor_constructed;
+	object_class->get_property = gsd_idle_monitor_get_property;
+	object_class->set_property = gsd_idle_monitor_set_property;
+
+	/**
+	 * GsdIdleMonitor:device:
+	 *
+	 * The device to listen to idletime on.
+	 */
+	obj_props[PROP_DEVICE] =
+		g_param_spec_object ("device",
+				     "Device",
+				     "The device to listen to idletime on",
+				     GDK_TYPE_DEVICE,
+				     G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+	g_object_class_install_property (object_class, PROP_DEVICE, obj_props[PROP_DEVICE]);
+
+	g_type_class_add_private (klass, sizeof (GsdIdleMonitorPrivate));
+}
+
+static void
+gsd_idle_monitor_init (GsdIdleMonitor *monitor)
+{
+	monitor->priv = GSD_IDLE_MONITOR_GET_PRIVATE (monitor);
+
+	monitor->priv->watches = g_hash_table_new_full (NULL,
+							NULL,
+							NULL,
+							(GDestroyNotify)idle_monitor_watch_free);
+
+	monitor->priv->alarms = g_hash_table_new (NULL, NULL);
+}
+
+/**
+ * gsd_idle_monitor_new:
+ *
+ * Returns: a new #GsdIdleMonitor that tracks the server-global
+ * idletime for all devices. To track device-specific idletime,
+ * use gsd_idle_monitor_new_for_device().
+ */
+GsdIdleMonitor *
+gsd_idle_monitor_new (void)
+{
+	return GSD_IDLE_MONITOR (g_initable_new (GSD_TYPE_IDLE_MONITOR, NULL, NULL, NULL));
+}
+
+/**
+ * gsd_idle_monitor_new_for_device:
+ * @device: A #GdkDevice to get the idle time for.
+ *
+ * Returns: a new #GsdIdleMonitor that tracks the device-specific
+ * idletime for @device. If device-specific idletime is not available,
+ * %NULL is returned, and @error is set. To track server-global
+ * idletime for all devices, use gsd_idle_monitor_new().
+ */
+GsdIdleMonitor *
+gsd_idle_monitor_new_for_device (GdkDevice  *device)
+{
+	return GSD_IDLE_MONITOR (g_initable_new (GSD_TYPE_IDLE_MONITOR, NULL, NULL,
+						   "device", device, NULL));
+}
+
+static GsdIdleMonitorWatch *
+make_watch (GsdIdleMonitor          *monitor,
+	    XSyncAlarm                 xalarm,
+	    GsdIdleMonitorWatchFunc  callback,
+	    gpointer                   user_data,
+	    GDestroyNotify             notify)
+{
+	GsdIdleMonitorWatch *watch;
+
+	watch = g_slice_new0 (GsdIdleMonitorWatch);
+	watch->monitor = monitor;
+	watch->id = get_next_watch_serial ();
+	watch->callback = callback;
+	watch->user_data = user_data;
+	watch->notify = notify;
+	watch->xalarm = xalarm;
+
+	g_hash_table_insert (monitor->priv->watches,
+			     GUINT_TO_POINTER (watch->id),
+			     watch);
+	return watch;
+}
+
+/**
+ * gsd_idle_monitor_add_idle_watch:
+ * @monitor: A #GsdIdleMonitor
+ * @interval_msec: The idletime interval, in milliseconds
+ * @callback: (allow-none): The callback to call when the user has
+ *     accumulated @interval_msec milliseconds of idle time.
+ * @user_data: (allow-none): The user data to pass to the callback
+ * @notify: A #GDestroyNotify
+ *
+ * Returns: a watch id
+ *
+ * Adds a watch for a specific idle time. The callback will be called
+ * when the user has accumulated @interval_msec milliseconds of idle time.
+ * This function will return an ID that can either be passed to
+ * gsd_idle_monitor_remove_watch(), or can be used to tell idle time
+ * watches apart if you have more than one.
+ *
+ * Also note that this function will only care about positive transitions
+ * (user's idle time exceeding a certain time). If you want to know about
+ * when the user has become active, use
+ * gsd_idle_monitor_add_user_active_watch().
+ */
+guint
+gsd_idle_monitor_add_idle_watch (GsdIdleMonitor	       *monitor,
+				   guint64	                interval_msec,
+				   GsdIdleMonitorWatchFunc    callback,
+				   gpointer			user_data,
+				   GDestroyNotify		notify)
+{
+	GsdIdleMonitorWatch *watch;
+
+	g_return_val_if_fail (GSD_IS_IDLE_MONITOR (monitor), 0);
+
+	watch = make_watch (monitor,
+			    _xsync_alarm_set (monitor, XSyncPositiveTransition, interval_msec, TRUE),
+			    callback,
+			    user_data,
+			    notify);
+
+	g_hash_table_add (monitor->priv->alarms,
+			  (gpointer) watch->xalarm);
+
+	return watch->id;
+}
+
+/**
+ * gsd_idle_monitor_add_user_active_watch:
+ * @monitor: A #GsdIdleMonitor
+ * @callback: (allow-none): The callback to call when the user is
+ *     active again.
+ * @user_data: (allow-none): The user data to pass to the callback
+ * @notify: A #GDestroyNotify
+ *
+ * Returns: a watch id
+ *
+ * Add a one-time watch to know when the user is active again.
+ * Note that this watch is one-time and will de-activate after the
+ * function is called, for efficiency purposes. It's most convenient
+ * to call this when an idle watch, as added by
+ * gsd_idle_monitor_add_idle_watch(), has triggered.
+ */
+guint
+gsd_idle_monitor_add_user_active_watch (GsdIdleMonitor          *monitor,
+					  GsdIdleMonitorWatchFunc  callback,
+					  gpointer		     user_data,
+					  GDestroyNotify	     notify)
+{
+	GsdIdleMonitorWatch *watch;
+
+	g_return_val_if_fail (GSD_IS_IDLE_MONITOR (monitor), 0);
+
+	set_alarm_enabled (monitor->priv->display,
+			   monitor->priv->user_active_alarm,
+			   TRUE);
+
+	watch = make_watch (monitor,
+			    monitor->priv->user_active_alarm,
+			    callback,
+			    user_data,
+			    notify);
+
+	return watch->id;
+}
+
+/**
+ * gsd_idle_monitor_remove_watch:
+ * @monitor: A #GsdIdleMonitor
+ * @id: A watch ID
+ *
+ * Removes an idle time watcher, previously added by
+ * gsd_idle_monitor_add_idle_watch() or
+ * gsd_idle_monitor_add_user_active_watch().
+ */
+void
+gsd_idle_monitor_remove_watch (GsdIdleMonitor *monitor,
+				 guint		   id)
+{
+	g_return_if_fail (GSD_IS_IDLE_MONITOR (monitor));
+
+	g_hash_table_remove (monitor->priv->watches,
+			     GUINT_TO_POINTER (id));
+}
+
+/**
+ * gsd_idle_monitor_get_idletime:
+ * @monitor: A #GsdIdleMonitor
+ *
+ * Returns: The current idle time, in milliseconds, or -1 for not supported
+ */
+gint64
+gsd_idle_monitor_get_idletime (GsdIdleMonitor *monitor)
+{
+	XSyncValue value;
+
+	if (!XSyncQueryCounter (monitor->priv->display, monitor->priv->counter, &value))
+		return -1;
+
+	return _xsyncvalue_to_int64 (value);
+}

=== added file 'plugins/common/gsd-idle-monitor.h'
--- plugins/common/gsd-idle-monitor.h	1970-01-01 00:00:00 +0000
+++ plugins/common/gsd-idle-monitor.h	2014-07-30 22:27:08 +0000
@@ -0,0 +1,81 @@
+/* -*- mode: C; c-file-style: "linux"; indent-tabs-mode: t -*-
+ *
+ * Adapted from gnome-session/gnome-session/gs-idle-monitor.h
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Authors: William Jon McCann <[e-mail]>
+ */
+
+#ifndef __GSD_IDLE_MONITOR_H__
+#define __GSD_IDLE_MONITOR_H__
+
+#include <glib-object.h>
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#define GSD_TYPE_IDLE_MONITOR         (gsd_idle_monitor_get_type ())
+#define GSD_IDLE_MONITOR(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GSD_TYPE_IDLE_MONITOR, GsdIdleMonitor))
+#define GSD_IDLE_MONITOR_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), GSD_TYPE_IDLE_MONITOR, GsdIdleMonitorClass))
+#define GSD_IS_IDLE_MONITOR(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSD_TYPE_IDLE_MONITOR))
+#define GSD_IS_IDLE_MONITOR_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GSD_TYPE_IDLE_MONITOR))
+#define GSD_IDLE_MONITOR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GSD_TYPE_IDLE_MONITOR, GsdIdleMonitorClass))
+
+typedef struct _GsdIdleMonitor GsdIdleMonitor;
+typedef struct _GsdIdleMonitorClass GsdIdleMonitorClass;
+typedef struct _GsdIdleMonitorPrivate GsdIdleMonitorPrivate;
+
+struct _GsdIdleMonitor
+{
+        GObject                  parent;
+        GsdIdleMonitorPrivate *priv;
+};
+
+struct _GsdIdleMonitorClass
+{
+        GObjectClass          parent_class;
+};
+
+typedef void (*GsdIdleMonitorWatchFunc) (GsdIdleMonitor      *monitor,
+                                           guint                  id,
+                                           gpointer               user_data);
+
+GType              gsd_idle_monitor_get_type     (void);
+
+GsdIdleMonitor * gsd_idle_monitor_new          (void);
+GsdIdleMonitor * gsd_idle_monitor_new_for_device (GdkDevice *device);
+
+guint              gsd_idle_monitor_add_idle_watch    (GsdIdleMonitor         *monitor,
+							 guint64                   interval_msec,
+							 GsdIdleMonitorWatchFunc callback,
+							 gpointer                  user_data,
+							 GDestroyNotify            notify);
+
+guint              gsd_idle_monitor_add_user_active_watch (GsdIdleMonitor          *monitor,
+							     GsdIdleMonitorWatchFunc  callback,
+							     gpointer		     user_data,
+							     GDestroyNotify	     notify);
+
+void               gsd_idle_monitor_remove_watch (GsdIdleMonitor         *monitor,
+                                                    guint                     id);
+
+gint64             gsd_idle_monitor_get_idletime (GsdIdleMonitor         *monitor);
+
+G_END_DECLS
+
+#endif /* __GSD_IDLE_MONITOR_H__ */

=== modified file 'plugins/cursor/gsd-cursor-manager.c'
--- plugins/cursor/gsd-cursor-manager.c	2013-04-15 11:23:06 +0000
+++ plugins/cursor/gsd-cursor-manager.c	2014-07-30 22:27:08 +0000
@@ -38,12 +38,10 @@
 #include <X11/Xatom.h>
 #include <X11/extensions/Xfixes.h>
 
-#define GNOME_DESKTOP_USE_UNSTABLE_API
-#include <libgnome-desktop/gnome-idle-monitor.h>
-
 #include "gnome-settings-profile.h"
 #include "gsd-cursor-manager.h"
 #include "gsd-input-helper.h"
+#include "gsd-idle-monitor.h"
 
 #define XFIXES_CURSOR_HIDING_MAJOR 4
 
@@ -126,7 +124,7 @@
 }
 
 static void
-monitor_became_active (GnomeIdleMonitor *monitor,
+monitor_became_active (GsdIdleMonitor *monitor,
                        guint             watch_id,
                        gpointer          user_data)
 {
@@ -155,7 +153,7 @@
             GsdCursorManager *manager,
             GError          **error)
 {
-        GnomeIdleMonitor *monitor;
+        GsdIdleMonitor *monitor;
 
         if (g_hash_table_lookup (manager->priv->monitors, device) != NULL)
                 return TRUE;
@@ -167,7 +165,7 @@
                 return TRUE;
 
         /* Create IdleMonitors for each pointer device */
-        monitor = gnome_idle_monitor_new_for_device (device);
+        monitor = gsd_idle_monitor_new_for_device (device);
         if (!monitor) {
                 g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                              "Per-device idletime monitor not available");
@@ -176,10 +174,10 @@
         g_hash_table_insert (manager->priv->monitors,
                              device,
                              monitor);
-        gnome_idle_monitor_add_user_active_watch (monitor,
-                                                  monitor_became_active,
-                                                  manager,
-                                                  NULL);
+        gsd_idle_monitor_add_user_active_watch (monitor,
+                                                monitor_became_active,
+                                                manager,
+                                                NULL);
 
         return TRUE;
 }

=== modified file 'plugins/power/gsd-power-manager.c'
--- plugins/power/gsd-power-manager.c	2014-02-08 20:53:08 +0000
+++ plugins/power/gsd-power-manager.c	2014-07-30 22:27:08 +0000
@@ -36,7 +36,6 @@
 
 #define GNOME_DESKTOP_USE_UNSTABLE_API
 #include <libgnome-desktop/gnome-rr.h>
-#include <libgnome-desktop/gnome-idle-monitor.h>
 
 #include <gsd-input-helper.h>
 
@@ -50,6 +49,7 @@
 #include "gnome-settings-session.h"
 #include "gsd-enums.h"
 #include "gsd-power-manager.h"
+#include "gsd-idle-monitor.h"
 
 #define GNOME_SESSION_DBUS_NAME                 "org.gnome.SessionManager"
 #define GNOME_SESSION_DBUS_PATH_PRESENCE        "/org/gnome/SessionManager/Presence"
@@ -214,7 +214,7 @@
         gboolean                 is_virtual_machine;
 
         /* Idles */
-        GnomeIdleMonitor        *idle_monitor;
+        GsdIdleMonitor          *idle_monitor;
         guint                    idle_dim_id;
         guint                    idle_blank_id;
         guint                    idle_sleep_warning_id;
@@ -246,8 +246,8 @@
 static void      main_battery_or_ups_low_changed (GsdPowerManager *manager, gboolean is_low);
 static gboolean  idle_is_session_inhibited (GsdPowerManager *manager, guint mask, gboolean *is_inhibited);
 static void      idle_set_mode (GsdPowerManager *manager, GsdPowerIdleMode mode);
-static void      idle_triggered_idle_cb (GnomeIdleMonitor *monitor, guint watch_id, gpointer user_data);
-static void      idle_became_active_cb (GnomeIdleMonitor *monitor, guint watch_id, gpointer user_data);
+static void      idle_triggered_idle_cb (GsdIdleMonitor *monitor, guint watch_id, gpointer user_data);
+static void      idle_became_active_cb (GsdIdleMonitor *monitor, guint watch_id, gpointer user_data);
 
 G_DEFINE_TYPE (GsdPowerManager, gsd_power_manager, G_TYPE_OBJECT)
 
@@ -2501,10 +2501,10 @@
         /* if we're moving to an idle mode, make sure
          * we add a watch to take us back to normal */
         if (mode != GSD_POWER_IDLE_MODE_NORMAL) {
-                gnome_idle_monitor_add_user_active_watch (manager->priv->idle_monitor,
-                                                          idle_became_active_cb,
-                                                          manager,
-                                                          NULL);
+                gsd_idle_monitor_add_user_active_watch (manager->priv->idle_monitor,
+                                                        idle_became_active_cb,
+                                                        manager,
+                                                        NULL);
         }
 
         /* save current brightness, and set dim level */
@@ -2631,12 +2631,12 @@
 }
 
 static void
-clear_idle_watch (GnomeIdleMonitor *monitor,
+clear_idle_watch (GsdIdleMonitor *monitor,
                   guint            *id)
 {
         if (*id == 0)
                 return;
-        gnome_idle_monitor_remove_watch (monitor, *id);
+        gsd_idle_monitor_remove_watch (monitor, *id);
         *id = 0;
 }
 
@@ -2692,9 +2692,9 @@
         if (timeout_blank != 0) {
                 g_debug ("setting up blank callback for %is", timeout_blank);
 
-                manager->priv->idle_blank_id = gnome_idle_monitor_add_idle_watch (manager->priv->idle_monitor,
-                                                                                  timeout_blank * 1000,
-                                                                                  idle_triggered_idle_cb, manager, NULL);
+                manager->priv->idle_blank_id = gsd_idle_monitor_add_idle_watch (manager->priv->idle_monitor,
+                                                                                timeout_blank * 1000,
+                                                                                idle_triggered_idle_cb, manager, NULL);
         }
 
         /* only do the sleep timeout when the session is idle
@@ -2715,9 +2715,9 @@
         if (timeout_sleep != 0) {
                 g_debug ("setting up sleep callback %is", timeout_sleep);
 
-                manager->priv->idle_sleep_id = gnome_idle_monitor_add_idle_watch (manager->priv->idle_monitor,
-                                                                                  timeout_sleep * 1000,
-                                                                                  idle_triggered_idle_cb, manager, NULL);
+                manager->priv->idle_sleep_id = gsd_idle_monitor_add_idle_watch (manager->priv->idle_monitor,
+                                                                                timeout_sleep * 1000,
+                                                                                idle_triggered_idle_cb, manager, NULL);
                 if (action_type == GSD_POWER_ACTION_LOGOUT ||
                     action_type == GSD_POWER_ACTION_SUSPEND ||
                     action_type == GSD_POWER_ACTION_HIBERNATE) {
@@ -2730,9 +2730,9 @@
 
                         g_debug ("setting up sleep warning callback %is", timeout_sleep_warning);
 
-                        manager->priv->idle_sleep_warning_id = gnome_idle_monitor_add_idle_watch (manager->priv->idle_monitor,
-                                                                                                  timeout_sleep_warning * 1000,
-                                                                                                  idle_triggered_idle_cb, manager, NULL);
+                        manager->priv->idle_sleep_warning_id = gsd_idle_monitor_add_idle_watch (manager->priv->idle_monitor,
+                                                                                                timeout_sleep_warning * 1000,
+                                                                                                idle_triggered_idle_cb, manager, NULL);
                 }
         }
 
@@ -2772,9 +2772,9 @@
         if (timeout_dim != 0) {
                 g_debug ("setting up dim callback for %is", timeout_dim);
 
-                manager->priv->idle_dim_id = gnome_idle_monitor_add_idle_watch (manager->priv->idle_monitor,
-                                                                                timeout_dim * 1000,
-                                                                                idle_triggered_idle_cb, manager, NULL);
+                manager->priv->idle_dim_id = gsd_idle_monitor_add_idle_watch (manager->priv->idle_monitor,
+                                                                              timeout_dim * 1000,
+                                                                              idle_triggered_idle_cb, manager, NULL);
         }
 }
 
@@ -3106,7 +3106,7 @@
 }
 
 static void
-idle_triggered_idle_cb (GnomeIdleMonitor *monitor,
+idle_triggered_idle_cb (GsdIdleMonitor   *monitor,
                         guint             watch_id,
                         gpointer          user_data)
 {
@@ -3131,7 +3131,7 @@
 }
 
 static void
-idle_became_active_cb (GnomeIdleMonitor *monitor,
+idle_became_active_cb (GsdIdleMonitor   *monitor,
                        guint             watch_id,
                        gpointer          user_data)
 {
@@ -3550,7 +3550,7 @@
                                                                   "use-time-for-policy");
 
         /* create IDLETIME watcher */
-        manager->priv->idle_monitor = gnome_idle_monitor_new ();
+        manager->priv->idle_monitor = gsd_idle_monitor_new ();
 
         /* set up the screens */
         g_signal_connect (manager->priv->rr_screen, "changed", G_CALLBACK (on_randr_event), manager);