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

[Robert Ancell]

Move libgnome-desktop RandR code into u-s-d since newer versions remove this unstable API

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4046
http://jenkins.qa.ubuntu.com/job/unity-settings-daemon-ci/30/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-settings-daemon-utopic-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-settings-daemon-utopic-armhf-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-settings-daemon-utopic-i386-ci/4/console

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

review: Needs Fixing (continuous-integration)

[lp:~robert-ancell/unity-settings-daemon/xrandr]

4047. By Robert Ancell on 2014-06-26

Build-dep on libgl1-mesa-dev

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Tim Lunn (darkxst)]

You also need to copy the idle monitor code across to u-s-d, since while the api for idle monitor still exists within gnome-desktop it is just using dbus calls into mutter where the actual code lives (since 3.10)

https://git.gnome.org/browse/gnome-desktop/commit/?id=545c774e967fa2f21f9b8ee1acbb50bffcee01d0

[Sebastien Bacher (seb128)]

Just adding up for discussion, Tim commented on IRC as well saying that he thinks it would less work to just take the new gnome-desktop (there are pending merge requests to port u-s-d/u-c-c to the new api) and ship the upstream code as a standalone service (he worked on that before trusty and that seems to be working). That's something we might consider trying

[Robert Ancell (robert-ancell)]

It's certainly an option. I feel the daemon is going to be some cost for little benefit because we're only really interested in the X case for u-s-d/u-c-c. For the Mir case it seems likely that u-s-d/u-c-c wouldn't exist. So why not talk to X directly?

Also discussed was forking libgnome-desktop into a special lib for u-s-d/u-c-c. That would reduce the duplication and keep the behaviour the same.

[Robert Ancell (robert-ancell)]

Laney expressed an interest in continuing the daemon method from bug 1228765. I'm OK with that if he wants to do the work. We can leave these MPs open until we decide if that method is worth completing.

[Robert Ancell (robert-ancell)]

> You also need to copy the idle monitor code across to u-s-d

Sure, though that can be a separate MP

[Robert Ancell (robert-ancell)]

See lp:~robert-ancell/unity-control-center/xrandr for associated u-c-c MP.

[Robert Ancell (robert-ancell)]

See lp:~robert-ancell/unity-settings-daemon/idle for idle code removal.

[Robert Ancell (robert-ancell)]

The decision was made to continue with this method - please review.

[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

[Tim Lunn (darkxst)]

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

[Iain Lane (laney)]

I just tried this, and there's some bugs

I don't get the right theme in gtk2 apps or context menus apps (get Raleigh instead). u-s-d.log says:

  ** (unity-settings-daemon:9923): WARNING **: You can only run one xsettings manager at a time; exiting

  ** (unity-settings-daemon:9923): WARNING **: Unable to start gnome_xsettings manager: Could not initialize xsettings manager.

  (unity-settings-daemon:9923): GLib-GObject-WARNING **: cannot register existing type 'GsdIdleMonitor'

  (unity-settings-daemon:9923): GLib-GObject-CRITICAL **: g_type_add_interface_static: assertion 'G_TYPE_IS_INSTANTIATABLE (instance_type)' failed

  (unity-settings-daemon:9923): GLib-CRITICAL **: g_once_init_leave: assertion 'result != 0' failed

When trying to apply a change to the display configuration I get

  GDBus.Error:org.freedesktop.DBus.Error.UnknownMethod: No such interface 'org.gnome.SettingsDaemon.XRANDR_2' on object at path /org/gnome/SettingsDaemon/XRANDR

in a dialog.

review: Needs Fixing

[Iain Lane (laney)]

xsettings> I don't know why, but there's now a lightdm-owned u-s-d running on my system after I log in. Killing that manually gets rid of this one. Still don't get media keys or a theme though.

GsdIdleMonitor> Seems to be a bug, not sure what's wrong right now but you can see where it's happening with G_DEBUG=fatal-warnings.

Also we need <https://code.launchpad.net/~darkxst/unity-settings-daemon/xkb/+merge/224919> after building with new gnome-desktop.

[Robert Ancell (robert-ancell)]

This doesn't work because the four plugins all have copies of the GsdRRConfig class (and others) and try and register it multiple times. If the code is to be shared it needs to go into a shared library or have multiple copies with different names (seems impractical here).

[lp:~robert-ancell/unity-settings-daemon/xrandr]

4048. By Robert Ancell on 2014-08-29

Move RR code into a shared library so multiple modules don't define the same classes. Also add the Idle monitor

4049. By Robert Ancell on 2014-08-29

Package libunity-settings-daemon

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[lp:~robert-ancell/unity-settings-daemon/xrandr]

4050. By Robert Ancell on 2014-08-29

Add symbols file

[Robert Ancell (robert-ancell)]

I've updated this branch to now use a shared library that is also used by unity-control-center (https://code.launchpad.net/~robert-ancell/unity-control-center/libusd/+merge/232676).

This solution works better because it means that multiple modules can use the functionality without duplicating symbols. This is also more similar to us bringing libgnome-desktop into u-s-d - we can continue to copy over parts that libgnome-desktop changes in the future.

[lp:~robert-ancell/unity-settings-daemon/xrandr]

4051. By Robert Ancell on 2014-08-29

Merge with trunk

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[lp:~robert-ancell/unity-settings-daemon/xrandr]

4052. By Robert Ancell on 2014-08-29

Move libunity-settings-daemon into its own package so we can build unity-control-center without installing unity-settings-daemon

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Iain Lane (laney)]

I didn't have problems with the latest branches, thanks for the work

review: Approve

=== modified file 'configure.ac'
--- configure.ac	2014-02-15 08:33:21 +0000
+++ configure.ac	2014-08-29 10:24:26 +0000
@@ -55,6 +55,8 @@
 UPOWER_REQUIRED_VERSION=0.9.11
 IBUS_REQUIRED_VERSION=1.4.99
 GSETTINGS_DESKTOP_SCHEMAS_REQUIRED_VERSION=3.7.2.1
+XRANDR_REQUIRED_VERSION=1.3
+XEXT_REQUIRED_VERSION=1.1
 
 EXTRA_COMPILE_WARNINGS(yes)
 
@@ -140,6 +142,13 @@
 PKG_CHECK_MODULES(COMMON, x11 kbproto xi)
 
 dnl ---------------------------------------------------------------------------
+dnl - libunity-settings-daemon
+dnl ---------------------------------------------------------------------------
+
+PKG_CHECK_MODULES(LIBUNITY_SETTINGS_DAEMON, gtk+-3.0 >= $GTK_REQUIRED_VERSION xrandr >= $XRANDR_REQUIRED_VERSION xext >= $XEXT_REQUIRED_VERSION)
+PKG_CHECK_MODULES(CHECK_GL_TEXTURE_SIZE, gl x11)
+
+dnl ---------------------------------------------------------------------------
 dnl - automount
 dnl ---------------------------------------------------------------------------
 
@@ -521,6 +530,7 @@
 data/Makefile
 data/unity-settings-daemon.pc
 data/unity-settings-daemon-uninstalled.pc
+data/libunity-settings-daemon.pc
 po/Makefile.in
 man/Makefile
 tests/Makefile

=== modified file 'data/Makefile.am'
--- data/Makefile.am	2014-02-06 10:43:50 +0000
+++ data/Makefile.am	2014-08-29 10:24:26 +0000
@@ -16,7 +16,7 @@
 	$(AM_V_GEN) sed -e "s|\@libexecdir\@|$(libexecdir)|" $< > $@.tmp && mv $@.tmp $@
 
 pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = unity-settings-daemon.pc
+pkgconfig_DATA = unity-settings-daemon.pc libunity-settings-daemon.pc
 
 @INTLTOOL_XML_NOMERGE_RULE@
 
@@ -25,6 +25,7 @@
 	$(desktop_in_files)			\
 	$(gsettings_ENUM_FILES)			\
 	unity-settings-daemon.pc.in		\
+	libunity-settings-daemon.pc.in		\
 	$(api_DATA)				\
 	$(NULL)
 

=== added file 'data/libunity-settings-daemon.pc.in'
--- data/libunity-settings-daemon.pc.in	1970-01-01 00:00:00 +0000
+++ data/libunity-settings-daemon.pc.in	2014-08-29 10:24:26 +0000
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+libexecdir=@libexecdir@
+
+Name: libunity-settings-daemon
+Description: Helper library for accessing settings
+Requires: glib-2.0 gdk-3.0
+Version: @VERSION@
+Libs: -L${libdir} -lunity-settings-daemon
+Cflags: -I${includedir}/unity-settings-daemon-@GSD_API_VERSION@

=== modified file 'debian/control'
--- debian/control	2014-02-26 18:25:15 +0000
+++ debian/control	2014-08-29 10:24:26 +0000
@@ -40,7 +40,8 @@
                libgnomekbd-dev (>= 3.5.1),
                libxklavier-dev,
                libsystemd-login-dev (>= 183),
-               libibus-1.0-dev (>= 1.5.0)
+               libibus-1.0-dev (>= 1.5.0),
+               libgl1-mesa-dev,
 Standards-Version: 3.9.3
 
 Package: unity-settings-daemon
@@ -95,3 +96,20 @@
 Description: Headers for building applications communicating with unity-settings-daemon
  This package contains header files required to build applications that
  communicate with the Unity settings daemon over D-Bus.
+
+Package: libunity-settings-daemon1
+Architecture: any
+Depends: ${shlibs:Depends},
+         ${misc:Depends},
+         libglib2.0-dev,
+         libgtk-3-dev
+Description: Helper library for accessing settings
+ This package contains a helper library for unity-control-center
+
+Package: libunity-settings-daemon-dev
+Architecture: any
+Depends: ${shlibs:Depends},
+         ${misc:Depends},
+         libunity-settings-daemon1 (= ${binary:Version})
+Description: Helper library for accessing settings (development files)
+ This package contains a headers for using libunity-settings-daemon

=== added file 'debian/libunity-settings-daemon1.install'
--- debian/libunity-settings-daemon1.install	1970-01-01 00:00:00 +0000
+++ debian/libunity-settings-daemon1.install	2014-08-29 10:24:26 +0000
@@ -0,0 +1,1 @@
+usr/lib/libunity-settings-daemon.so.*

=== added file 'debian/libunity-settings-daemon1.symbols'
--- debian/libunity-settings-daemon1.symbols	1970-01-01 00:00:00 +0000
+++ debian/libunity-settings-daemon1.symbols	2014-08-29 10:24:26 +0000
@@ -0,0 +1,105 @@
+libunity-settings-daemon.so.1 libunity-settings-daemon1 #MINVER#
+ gsd_idle_monitor_add_idle_watch@Base 14.04.0
+ gsd_idle_monitor_add_user_active_watch@Base 14.04.0
+ gsd_idle_monitor_get_idletime@Base 14.04.0
+ gsd_idle_monitor_get_type@Base 14.04.0
+ gsd_idle_monitor_new@Base 14.04.0
+ gsd_idle_monitor_new_for_device@Base 14.04.0
+ gsd_idle_monitor_remove_watch@Base 14.04.0
+ gsd_pnp_ids_get_pnp_id@Base 14.04.0
+ gsd_pnp_ids_get_type@Base 14.04.0
+ gsd_pnp_ids_new@Base 14.04.0
+ gsd_rr_config_applicable@Base 14.04.0
+ gsd_rr_config_apply_from_filename_with_time@Base 14.04.0
+ gsd_rr_config_apply_with_time@Base 14.04.0
+ gsd_rr_config_ensure_primary@Base 14.04.0
+ gsd_rr_config_equal@Base 14.04.0
+ gsd_rr_config_get_backup_filename@Base 14.04.0
+ gsd_rr_config_get_clone@Base 14.04.0
+ gsd_rr_config_get_intended_filename@Base 14.04.0
+ gsd_rr_config_get_outputs@Base 14.04.0
+ gsd_rr_config_get_type@Base 14.04.0
+ gsd_rr_config_load_current@Base 14.04.0
+ gsd_rr_config_load_filename@Base 14.04.0
+ gsd_rr_config_match@Base 14.04.0
+ gsd_rr_config_new_current@Base 14.04.0
+ gsd_rr_config_new_stored@Base 14.04.0
+ gsd_rr_config_sanitize@Base 14.04.0
+ gsd_rr_config_save@Base 14.04.0
+ gsd_rr_config_set_clone@Base 14.04.0
+ gsd_rr_crtc_can_drive_output@Base 14.04.0
+ gsd_rr_crtc_get_current_mode@Base 14.04.0
+ gsd_rr_crtc_get_current_rotation@Base 14.04.0
+ gsd_rr_crtc_get_gamma@Base 14.04.0
+ gsd_rr_crtc_get_id@Base 14.04.0
+ gsd_rr_crtc_get_position@Base 14.04.0
+ gsd_rr_crtc_get_rotations@Base 14.04.0
+ gsd_rr_crtc_get_type@Base 14.04.0
+ gsd_rr_crtc_set_config_with_time@Base 14.04.0
+ gsd_rr_crtc_set_gamma@Base 14.04.0
+ gsd_rr_crtc_supports_rotation@Base 14.04.0
+ gsd_rr_error_quark@Base 14.04.0
+ gsd_rr_mode_get_freq@Base 14.04.0
+ gsd_rr_mode_get_height@Base 14.04.0
+ gsd_rr_mode_get_id@Base 14.04.0
+ gsd_rr_mode_get_type@Base 14.04.0
+ gsd_rr_mode_get_width@Base 14.04.0
+ gsd_rr_output_can_clone@Base 14.04.0
+ gsd_rr_output_get_backlight@Base 14.04.0
+ gsd_rr_output_get_backlight_max@Base 14.04.0
+ gsd_rr_output_get_backlight_min@Base 14.04.0
+ gsd_rr_output_get_connector_type@Base 14.04.0
+ gsd_rr_output_get_crtc@Base 14.04.0
+ gsd_rr_output_get_current_mode@Base 14.04.0
+ gsd_rr_output_get_display_name@Base 14.04.0
+ gsd_rr_output_get_edid_data@Base 14.04.0
+ gsd_rr_output_get_height_mm@Base 14.04.0
+ gsd_rr_output_get_id@Base 14.04.0
+ gsd_rr_output_get_ids_from_edid@Base 14.04.0
+ gsd_rr_output_get_is_primary@Base 14.04.0
+ gsd_rr_output_get_name@Base 14.04.0
+ gsd_rr_output_get_position@Base 14.04.0
+ gsd_rr_output_get_preferred_mode@Base 14.04.0
+ gsd_rr_output_get_type@Base 14.04.0
+ gsd_rr_output_get_width_mm@Base 14.04.0
+ gsd_rr_output_info_get_aspect_ratio@Base 14.04.0
+ gsd_rr_output_info_get_display_name@Base 14.04.0
+ gsd_rr_output_info_get_geometry@Base 14.04.0
+ gsd_rr_output_info_get_name@Base 14.04.0
+ gsd_rr_output_info_get_preferred_height@Base 14.04.0
+ gsd_rr_output_info_get_preferred_width@Base 14.04.0
+ gsd_rr_output_info_get_primary@Base 14.04.0
+ gsd_rr_output_info_get_product@Base 14.04.0
+ gsd_rr_output_info_get_refresh_rate@Base 14.04.0
+ gsd_rr_output_info_get_rotation@Base 14.04.0
+ gsd_rr_output_info_get_serial@Base 14.04.0
+ gsd_rr_output_info_get_type@Base 14.04.0
+ gsd_rr_output_info_get_vendor@Base 14.04.0
+ gsd_rr_output_info_is_active@Base 14.04.0
+ gsd_rr_output_info_is_connected@Base 14.04.0
+ gsd_rr_output_info_set_active@Base 14.04.0
+ gsd_rr_output_info_set_geometry@Base 14.04.0
+ gsd_rr_output_info_set_primary@Base 14.04.0
+ gsd_rr_output_info_set_refresh_rate@Base 14.04.0
+ gsd_rr_output_info_set_rotation@Base 14.04.0
+ gsd_rr_output_is_connected@Base 14.04.0
+ gsd_rr_output_is_laptop@Base 14.04.0
+ gsd_rr_output_list_modes@Base 14.04.0
+ gsd_rr_output_set_backlight@Base 14.04.0
+ gsd_rr_output_supports_mode@Base 14.04.0
+ gsd_rr_screen_get_crtc_by_id@Base 14.04.0
+ gsd_rr_screen_get_dpms_mode@Base 14.04.0
+ gsd_rr_screen_get_output_by_id@Base 14.04.0
+ gsd_rr_screen_get_output_by_name@Base 14.04.0
+ gsd_rr_screen_get_ranges@Base 14.04.0
+ gsd_rr_screen_get_timestamps@Base 14.04.0
+ gsd_rr_screen_get_type@Base 14.04.0
+ gsd_rr_screen_list_clone_modes@Base 14.04.0
+ gsd_rr_screen_list_crtcs@Base 14.04.0
+ gsd_rr_screen_list_modes@Base 14.04.0
+ gsd_rr_screen_list_outputs@Base 14.04.0
+ gsd_rr_screen_new@Base 14.04.0
+ gsd_rr_screen_refresh@Base 14.04.0
+ gsd_rr_screen_set_dpms_mode@Base 14.04.0
+ gsd_rr_screen_set_primary_output@Base 14.04.0
+ gsd_rr_screen_set_size@Base 14.04.0

=== modified file 'debian/rules'
--- debian/rules	2013-12-04 23:55:26 +0000
+++ debian/rules	2014-08-29 10:24:26 +0000
@@ -6,7 +6,7 @@
 
 LDFLAGS += -Wl,-O1 -Wl,-z,defs -Wl,--warn-unresolved-symbols -Wl,--as-needed
 
-DEB_DH_MAKESHLIBS_ARGS_ALL += --no-act
+DEB_DH_MAKESHLIBS_ARGS_ALL += -X/usr/lib/unity-settings-daemon-1.0
 DEB_CONFIGURE_SCRIPT := ./autogen.sh
 DEB_CONFIGURE_EXTRA_FLAGS = --enable-systemd --disable-packagekit --enable-ibus
 

=== modified file 'debian/unity-settings-daemon-dev.install'
--- debian/unity-settings-daemon-dev.install	2013-12-04 23:55:26 +0000
+++ debian/unity-settings-daemon-dev.install	2014-08-29 10:24:26 +0000
@@ -1,2 +1,3 @@
 usr/include
 usr/lib/pkgconfig
+usr/lib/libunity-settings-daemon.so

=== modified file 'debian/unity-settings-daemon.install'
--- debian/unity-settings-daemon.install	2014-02-06 10:43:50 +0000
+++ debian/unity-settings-daemon.install	2014-08-29 10:24:26 +0000
@@ -5,4 +5,3 @@
 usr/share/unity-settings-daemon
 usr/share/polkit-1
 debian/source_unity-settings-daemon.py /usr/share/apport/package-hooks
-

=== modified file 'gnome-settings-daemon/Makefile.am'
--- gnome-settings-daemon/Makefile.am	2013-12-04 23:55:26 +0000
+++ gnome-settings-daemon/Makefile.am	2014-08-29 10:24:26 +0000
@@ -5,6 +5,7 @@
 	-DGNOME_SETTINGS_LOCALEDIR=\""$(datadir)/locale"\"	\
 	-DLIBEXECDIR=\""$(libexecdir)"\" 			\
 	-DGNOME_SETTINGS_PLUGINDIR=\""$(plugindir)"\"		\
+	-I$(top_srcdir)/plugins/common/			\
 	$(WARN_CFLAGS)						\
 	$(DISABLE_DEPRECATED_CFLAGS)				\
 	$(SETTINGS_DAEMON_CFLAGS)				\
@@ -14,6 +15,52 @@
 
 privlibdir = $(pkglibdir)-$(GSD_API_VERSION)
 
+lib_LTLIBRARIES = libunity-settings-daemon.la
+libexec_PROGRAMS = check_gl_texture_size
+
+libunity_settings_daemon_la_SOURCES =		\
+	gsd-pnp-ids.c \
+	gsd-pnp-ids.h \
+	gsd-rr.c \
+	gsd-rr.h \
+	gsd-rr-config.c \
+	gsd-rr-config.h \
+	gsd-rr-output-info.c \
+	gsd-rr-private.h \
+	display-name.c \
+	edid-parse.c \
+	edid.h \
+	gsd-idle-monitor.c \
+	gsd-idle-monitor.h
+
+libunity_settings_daemon_include_HEADERS =		\
+	gsd-pnp-ids.h \
+	gsd-rr.h \
+	gsd-rr-config.h \
+	gsd-idle-monitor.h
+
+libunity_settings_daemon_includedir = $(includedir)/unity-settings-daemon-$(GSD_API_VERSION)/libunity-settings-daemon
+
+libunity_settings_daemon_la_CFLAGS = 		\
+	-DLIBEXECDIR=\""$(libexecdir)\""			\
+	-DPNP_IDS=\""$(datadir)/hwdata/pnp.ids"\"			\
+	-DGNOMELOCALEDIR=\""$(datadir)/locale"\"        \
+	$(LIBUNITY_SETTINGS_DAEMON_CFLAGS)
+
+libunity_settings_daemon_la_LIBADD = 		\
+	-lm \
+	$(LIBUNITY_SETTINGS_DAEMON_LIBS)
+
+libunity_settings_daemon_la_LDFLAGS = 		\
+	-version-info 1:0:0 \
+	-export-symbols-regex \^gsd_.*
+
+check_gl_texture_size_CPPFLAGS = \
+	$(CHECK_GL_TEXTURE_SIZE_CFLAGS)
+
+check_gl_texture_size_LDADD = \
+	$(CHECK_GL_TEXTURE_SIZE_LIBS)
+
 privlib_LTLIBRARIES =		\
 	libgsd.la		\
 	$(NULL)
@@ -84,6 +131,7 @@
 
 unity_settings_daemon_LDADD = 		\
 	libgsd.la		\
+	libunity-settings-daemon.la		\
 	$(SETTINGS_DAEMON_LIBS)		\
 	$(LIBNOTIFY_LIBS)		\
 	$(GNOME_DESKTOP_LIBS)		\

=== added file 'gnome-settings-daemon/check_gl_texture_size.c'
--- gnome-settings-daemon/check_gl_texture_size.c	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/check_gl_texture_size.c	2014-08-29 10:24:26 +0000
@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <unistd.h>
+
+#include <X11/Xlib.h>
+#include <GL/gl.h>
+#include <GL/glx.h>
+
+int main (int argc, char **argv)
+{
+  Display *dpy = XOpenDisplay (NULL);
+  
+  Window win;
+  int attribSingle[] = {
+    GLX_RGBA,
+    GLX_RED_SIZE, 1,
+    GLX_GREEN_SIZE, 1,
+    GLX_BLUE_SIZE, 1,
+    None };
+  
+  int attribDouble[] = {
+    GLX_RGBA,
+    GLX_RED_SIZE, 1,
+    GLX_GREEN_SIZE, 1,
+    GLX_BLUE_SIZE, 1,
+    GLX_DOUBLEBUFFER,
+    None };
+  
+  XSetWindowAttributes attr;
+  unsigned long mask;
+  GLXContext ctx = NULL;
+  XVisualInfo *visinfo;
+  
+  int exit_status = EXIT_SUCCESS;
+  
+  GLint max_texture_size = 0;
+
+  if (!dpy) {
+    /* We have, for some reason, been unable to connect to X
+     * Bail cleanly, and leave a little note */
+    fprintf (stderr, "check_gl_texture_size: Unable to open display %s", getenv("DISPLAY"));
+    exit (EXIT_FAILURE);
+  }
+  
+  visinfo = glXChooseVisual (dpy, DefaultScreen (dpy), attribSingle);
+  if (!visinfo)
+    visinfo = glXChooseVisual (dpy, DefaultScreen (dpy), attribDouble);
+  
+  if (visinfo)
+    ctx = glXCreateContext (dpy, visinfo, NULL, GL_TRUE);
+  
+  if (!visinfo) {
+    exit_status = EXIT_FAILURE;
+    goto child_out;
+  }
+  
+  if (!ctx) {
+    XFree (visinfo);
+    exit_status = EXIT_FAILURE;
+    goto child_out;
+  }
+  
+  attr.background_pixel = 0;
+  attr.border_pixel = 0;
+  attr.colormap = XCreateColormap (dpy, DefaultRootWindow (dpy),
+				   visinfo->visual, AllocNone);
+  attr.event_mask = StructureNotifyMask | ExposureMask;
+  mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+  win = XCreateWindow (dpy, DefaultRootWindow (dpy), 0, 0, 100, 100,
+		       0, visinfo->depth, InputOutput,
+		       visinfo->visual, mask, &attr);
+  
+  if (!glXMakeCurrent (dpy, win, ctx)) {
+    exit_status = EXIT_FAILURE;
+    goto child_out;
+  }
+
+  glGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_texture_size);
+  
+  printf ("%u", max_texture_size);
+
+child_out:
+  XCloseDisplay (dpy);
+  exit (exit_status);
+}

=== added file 'gnome-settings-daemon/display-name.c'
--- gnome-settings-daemon/display-name.c	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/display-name.c	2014-08-29 10:24:26 +0000
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2007 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* Author: Soren Sandmann <[e-mail]> */
+
+#include <config.h>
+#include <glib/gi18n-lib.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+
+#include "gsd-pnp-ids.h"
+#include "edid.h"
+
+static const char *
+find_vendor (const char *code)
+{
+    const char *vendor_name;
+    GsdPnpIds *pnp_ids;
+
+    pnp_ids = gsd_pnp_ids_new ();
+    vendor_name = gsd_pnp_ids_get_pnp_id (pnp_ids, code);
+    g_object_unref (pnp_ids);
+
+    if (vendor_name)
+        return vendor_name;
+
+    return code;
+}
+
+static const double known_diagonals[] = {
+    12.1,
+    13.3,
+    15.6
+};
+
+static char *
+diagonal_to_str (double d)
+{
+    int i;
+
+    for (i = 0; i < G_N_ELEMENTS (known_diagonals); i++)
+    {
+        double delta;
+
+        delta = fabs(known_diagonals[i] - d);
+        if (delta < 0.1)
+            return g_strdup_printf ("%0.1lf\"", known_diagonals[i]);
+    }
+
+    return g_strdup_printf ("%d\"", (int) (d + 0.5));
+}
+
+char *
+make_display_size_string (int width_mm,
+                          int height_mm)
+{
+  char *inches = NULL;
+
+  if (width_mm > 0 && height_mm > 0)
+    {
+      double d = sqrt (width_mm * width_mm + height_mm * height_mm);
+
+      inches = diagonal_to_str (d / 25.4);
+    }
+
+  return inches;
+}
+
+char *
+make_display_name (const MonitorInfo *info)
+{
+    const char *vendor;
+    int width_mm, height_mm;
+    char *inches, *ret;
+
+    if (info)
+    {
+	vendor = find_vendor (info->manufacturer_code);
+    }
+    else
+    {
+        /* Translators: "Unknown" here is used to identify a monitor for which
+         * we don't know the vendor. When a vendor is known, the name of the
+         * vendor is used. */
+	vendor = C_("Monitor vendor", "Unknown");
+    }
+
+    if (info && info->width_mm != -1 && info->height_mm)
+    {
+	width_mm = info->width_mm;
+	height_mm = info->height_mm;
+    }
+    else if (info && info->n_detailed_timings)
+    {
+	width_mm = info->detailed_timings[0].width_mm;
+	height_mm = info->detailed_timings[0].height_mm;
+    }
+    else
+    {
+	width_mm = -1;
+	height_mm = -1;
+    }
+    
+    if (width_mm != -1 && height_mm != -1)
+    {
+	double d = sqrt (width_mm * width_mm + height_mm * height_mm);
+
+	inches = diagonal_to_str (d / 25.4);
+    }
+    else
+    {
+	inches = NULL;
+    }
+
+    if (!inches)
+	return g_strdup (vendor);
+
+    ret = g_strdup_printf ("%s %s", vendor, inches);
+    g_free (inches);
+
+    return ret;
+}

=== added file 'gnome-settings-daemon/edid-parse.c'
--- gnome-settings-daemon/edid-parse.c	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/edid-parse.c	2014-08-29 10:24:26 +0000
@@ -0,0 +1,540 @@
+/*
+ * Copyright 2007 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* Author: Soren Sandmann <[e-mail]> */
+
+#include "edid.h"
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <glib.h>
+
+static int
+get_bit (int in, int bit)
+{
+    return (in & (1 << bit)) >> bit;
+}
+
+static int
+get_bits (int in, int begin, int end)
+{
+    int mask = (1 << (end - begin + 1)) - 1;
+    
+    return (in >> begin) & mask;
+}
+
+static int
+decode_header (const uchar *edid)
+{
+    if (memcmp (edid, "\x00\xff\xff\xff\xff\xff\xff\x00", 8) == 0)
+	return TRUE;
+    return FALSE;
+}
+
+static int
+decode_vendor_and_product_identification (const uchar *edid, MonitorInfo *info)
+{
+    int is_model_year;
+    
+    /* Manufacturer Code */
+    info->manufacturer_code[0]  = get_bits (edid[0x08], 2, 6);
+    info->manufacturer_code[1]  = get_bits (edid[0x08], 0, 1) << 3;
+    info->manufacturer_code[1] |= get_bits (edid[0x09], 5, 7);
+    info->manufacturer_code[2]  = get_bits (edid[0x09], 0, 4);
+    info->manufacturer_code[3]  = '\0';
+    
+    info->manufacturer_code[0] += 'A' - 1;
+    info->manufacturer_code[1] += 'A' - 1;
+    info->manufacturer_code[2] += 'A' - 1;
+
+    /* Product Code */
+    info->product_code = edid[0x0b] << 8 | edid[0x0a];
+
+    /* Serial Number */
+    info->serial_number =
+	edid[0x0c] | edid[0x0d] << 8 | edid[0x0e] << 16 | edid[0x0f] << 24;
+
+    /* Week and Year */
+    is_model_year = FALSE;
+    switch (edid[0x10])
+    {
+    case 0x00:
+	info->production_week = -1;
+	break;
+
+    case 0xff:
+	info->production_week = -1;
+	is_model_year = TRUE;
+	break;
+
+    default:
+	info->production_week = edid[0x10];
+	break;
+    }
+
+    if (is_model_year)
+    {
+	info->production_year = -1;
+	info->model_year = 1990 + edid[0x11];
+    }
+    else
+    {
+	info->production_year = 1990 + edid[0x11];
+	info->model_year = -1;
+    }
+
+    return TRUE;
+}
+
+static int
+decode_edid_version (const uchar *edid, MonitorInfo *info)
+{
+    info->major_version = edid[0x12];
+    info->minor_version = edid[0x13];
+
+    return TRUE;
+}
+
+static int
+decode_display_parameters (const uchar *edid, MonitorInfo *info)
+{
+    /* Digital vs Analog */
+    info->is_digital = get_bit (edid[0x14], 7);
+
+    if (info->is_digital)
+    {
+	int bits;
+	
+	static const int bit_depth[8] =
+	{
+	    -1, 6, 8, 10, 12, 14, 16, -1
+	};
+
+	static const Interface interfaces[6] =
+	{
+	    UNDEFINED, DVI, HDMI_A, HDMI_B, MDDI, DISPLAY_PORT
+	};
+
+	bits = get_bits (edid[0x14], 4, 6);
+	info->connector.digital.bits_per_primary = bit_depth[bits];
+
+	bits = get_bits (edid[0x14], 0, 3);
+	
+	if (bits <= 5)
+	    info->connector.digital.interface = interfaces[bits];
+	else
+	    info->connector.digital.interface = UNDEFINED;
+    }
+    else
+    {
+	int bits = get_bits (edid[0x14], 5, 6);
+	
+	static const double levels[][3] =
+	{
+	    { 0.7,   0.3,    1.0 },
+	    { 0.714, 0.286,  1.0 },
+	    { 1.0,   0.4,    1.4 },
+	    { 0.7,   0.0,    0.7 },
+	};
+
+	info->connector.analog.video_signal_level = levels[bits][0];
+	info->connector.analog.sync_signal_level = levels[bits][1];
+	info->connector.analog.total_signal_level = levels[bits][2];
+
+	info->connector.analog.blank_to_black = get_bit (edid[0x14], 4);
+
+	info->connector.analog.separate_hv_sync = get_bit (edid[0x14], 3);
+	info->connector.analog.composite_sync_on_h = get_bit (edid[0x14], 2);
+	info->connector.analog.composite_sync_on_green = get_bit (edid[0x14], 1);
+
+	info->connector.analog.serration_on_vsync = get_bit (edid[0x14], 0);
+    }
+
+    /* Screen Size / Aspect Ratio */
+    if (edid[0x15] == 0 && edid[0x16] == 0)
+    {
+	info->width_mm = -1;
+	info->height_mm = -1;
+	info->aspect_ratio = -1.0;
+    }
+    else if (edid[0x16] == 0)
+    {
+	info->width_mm = -1;
+	info->height_mm = -1; 
+	info->aspect_ratio = 100.0 / (edid[0x15] + 99);
+    }
+    else if (edid[0x15] == 0)
+    {
+	info->width_mm = -1;
+	info->height_mm = -1;
+	info->aspect_ratio = 100.0 / (edid[0x16] + 99);
+	info->aspect_ratio = 1/info->aspect_ratio; /* portrait */
+    }
+    else
+    {
+	info->width_mm = 10 * edid[0x15];
+	info->height_mm = 10 * edid[0x16];
+    }
+
+    /* Gamma */
+    if (edid[0x17] == 0xFF)
+	info->gamma = -1.0;
+    else
+	info->gamma = (edid[0x17] + 100.0) / 100.0;
+
+    /* Features */
+    info->standby = get_bit (edid[0x18], 7);
+    info->suspend = get_bit (edid[0x18], 6);
+    info->active_off = get_bit (edid[0x18], 5);
+
+    if (info->is_digital)
+    {
+	info->connector.digital.rgb444 = TRUE;
+	if (get_bit (edid[0x18], 3))
+	    info->connector.digital.ycrcb444 = 1;
+	if (get_bit (edid[0x18], 4))
+	    info->connector.digital.ycrcb422 = 1;
+    }
+    else
+    {
+	int bits = get_bits (edid[0x18], 3, 4);
+	ColorType color_type[4] =
+	{
+	    MONOCHROME, RGB, OTHER_COLOR, UNDEFINED_COLOR
+	};
+
+	info->connector.analog.color_type = color_type[bits];
+    }
+
+    info->srgb_is_standard = get_bit (edid[0x18], 2);
+
+    /* In 1.3 this is called "has preferred timing" */
+    info->preferred_timing_includes_native = get_bit (edid[0x18], 1);
+
+    /* FIXME: In 1.3 this indicates whether the monitor accepts GTF */
+    info->continuous_frequency = get_bit (edid[0x18], 0);
+    return TRUE;
+}
+
+static double
+decode_fraction (int high, int low)
+{
+    double result = 0.0;
+    int i;
+
+    high = (high << 2) | low;
+
+    for (i = 0; i < 10; ++i)
+	result += get_bit (high, i) * pow (2, i - 10);
+
+    return result;
+}
+
+static int
+decode_color_characteristics (const uchar *edid, MonitorInfo *info)
+{
+    info->red_x = decode_fraction (edid[0x1b], get_bits (edid[0x19], 6, 7));
+    info->red_y = decode_fraction (edid[0x1c], get_bits (edid[0x19], 5, 4));
+    info->green_x = decode_fraction (edid[0x1d], get_bits (edid[0x19], 2, 3));
+    info->green_y = decode_fraction (edid[0x1e], get_bits (edid[0x19], 0, 1));
+    info->blue_x = decode_fraction (edid[0x1f], get_bits (edid[0x1a], 6, 7));
+    info->blue_y = decode_fraction (edid[0x20], get_bits (edid[0x1a], 4, 5));
+    info->white_x = decode_fraction (edid[0x21], get_bits (edid[0x1a], 2, 3));
+    info->white_y = decode_fraction (edid[0x22], get_bits (edid[0x1a], 0, 1));
+
+    return TRUE;
+}
+
+static int
+decode_established_timings (const uchar *edid, MonitorInfo *info)
+{
+    static const Timing established[][8] = 
+    {
+	{
+	    { 800, 600, 60 },
+	    { 800, 600, 56 },
+	    { 640, 480, 75 },
+	    { 640, 480, 72 },
+	    { 640, 480, 67 },
+	    { 640, 480, 60 },
+	    { 720, 400, 88 },
+	    { 720, 400, 70 }
+	},
+	{
+	    { 1280, 1024, 75 },
+	    { 1024, 768, 75 },
+	    { 1024, 768, 70 },
+	    { 1024, 768, 60 },
+	    { 1024, 768, 87 },
+	    { 832, 624, 75 },
+	    { 800, 600, 75 },
+	    { 800, 600, 72 }
+	},
+	{
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 1152, 870, 75 }
+	},
+    };
+
+    int i, j, idx;
+
+    idx = 0;
+    for (i = 0; i < 3; ++i)
+    {
+	for (j = 0; j < 8; ++j)
+	{
+	    int byte = edid[0x23 + i];
+
+	    if (get_bit (byte, j) && established[i][j].frequency != 0)
+		info->established[idx++] = established[i][j];
+	}
+    }
+    return TRUE;
+}
+
+static int
+decode_standard_timings (const uchar *edid, MonitorInfo *info)
+{
+    int i;
+    
+    for (i = 0; i < 8; i++)
+    {
+	int first = edid[0x26 + 2 * i];
+	int second = edid[0x27 + 2 * i];
+
+	if (first != 0x01 && second != 0x01)
+	{
+	    int w = 8 * (first + 31);
+	    int h = 0;
+
+	    switch (get_bits (second, 6, 7))
+	    {
+	    case 0x00: h = (w / 16) * 10; break;
+	    case 0x01: h = (w / 4) * 3; break;
+	    case 0x02: h = (w / 5) * 4; break;
+	    case 0x03: h = (w / 16) * 9; break;
+	    }
+
+	    info->standard[i].width = w;
+	    info->standard[i].height = h;
+	    info->standard[i].frequency = get_bits (second, 0, 5) + 60;
+	}
+    }
+    
+    return TRUE;
+}
+
+static void
+decode_lf_string (const uchar *s, int n_chars, char *result)
+{
+    int i;
+    for (i = 0; i < n_chars; ++i)
+    {
+	if (s[i] == 0x0a)
+	{
+	    *result++ = '\0';
+	    break;
+	}
+	else if (s[i] == 0x00)
+	{
+	    /* Convert embedded 0's to spaces */
+	    *result++ = ' ';
+	}
+	else
+	{
+	    *result++ = s[i];
+	}
+    }
+}
+
+static void
+decode_display_descriptor (const uchar *desc,
+			   MonitorInfo *info)
+{
+    switch (desc[0x03])
+    {
+    case 0xFC:
+	decode_lf_string (desc + 5, 13, info->dsc_product_name);
+	break;
+    case 0xFF:
+	decode_lf_string (desc + 5, 13, info->dsc_serial_number);
+	break;
+    case 0xFE:
+	decode_lf_string (desc + 5, 13, info->dsc_string);
+	break;
+    case 0xFD:
+	/* Range Limits */
+	break;
+    case 0xFB:
+	/* Color Point */
+	break;
+    case 0xFA:
+	/* Timing Identifications */
+	break;
+    case 0xF9:
+	/* Color Management */
+	break;
+    case 0xF8:
+	/* Timing Codes */
+	break;
+    case 0xF7:
+	/* Established Timings */
+	break;
+    case 0x10:
+	break;
+    }
+}
+
+static void
+decode_detailed_timing (const uchar *timing,
+			DetailedTiming *detailed)
+{
+    int bits;
+    StereoType stereo[] =
+    {
+	NO_STEREO, NO_STEREO, FIELD_RIGHT, FIELD_LEFT,
+	TWO_WAY_RIGHT_ON_EVEN, TWO_WAY_LEFT_ON_EVEN,
+	FOUR_WAY_INTERLEAVED, SIDE_BY_SIDE
+    };
+    
+    detailed->pixel_clock = (timing[0x00] | timing[0x01] << 8) * 10000;
+    detailed->h_addr = timing[0x02] | ((timing[0x04] & 0xf0) << 4);
+    detailed->h_blank = timing[0x03] | ((timing[0x04] & 0x0f) << 8);
+    detailed->v_addr = timing[0x05] | ((timing[0x07] & 0xf0) << 4);
+    detailed->v_blank = timing[0x06] | ((timing[0x07] & 0x0f) << 8);
+    detailed->h_front_porch = timing[0x08] | get_bits (timing[0x0b], 6, 7) << 8;
+    detailed->h_sync = timing[0x09] | get_bits (timing[0x0b], 4, 5) << 8;
+    detailed->v_front_porch =
+	get_bits (timing[0x0a], 4, 7) | get_bits (timing[0x0b], 2, 3) << 4;
+    detailed->v_sync =
+	get_bits (timing[0x0a], 0, 3) | get_bits (timing[0x0b], 0, 1) << 4;
+    detailed->width_mm =  timing[0x0c] | get_bits (timing[0x0e], 4, 7) << 8;
+    detailed->height_mm = timing[0x0d] | get_bits (timing[0x0e], 0, 3) << 8;
+    detailed->right_border = timing[0x0f];
+    detailed->top_border = timing[0x10];
+
+    detailed->interlaced = get_bit (timing[0x11], 7);
+
+    /* Stereo */
+    bits = get_bits (timing[0x11], 5, 6) << 1 | get_bit (timing[0x11], 0);
+    detailed->stereo = stereo[bits];
+
+    /* Sync */
+    bits = timing[0x11];
+
+    detailed->digital_sync = get_bit (bits, 4);
+    if (detailed->digital_sync)
+    {
+	detailed->connector.digital.composite = !get_bit (bits, 3);
+
+	if (detailed->connector.digital.composite)
+	{
+	    detailed->connector.digital.serrations = get_bit (bits, 2);
+	    detailed->connector.digital.negative_vsync = FALSE;
+	}
+	else
+	{
+	    detailed->connector.digital.serrations = FALSE;
+	    detailed->connector.digital.negative_vsync = !get_bit (bits, 2);
+	}
+
+	detailed->connector.digital.negative_hsync = !get_bit (bits, 0);
+    }
+    else
+    {
+	detailed->connector.analog.bipolar = get_bit (bits, 3);
+	detailed->connector.analog.serrations = get_bit (bits, 2);
+	detailed->connector.analog.sync_on_green = !get_bit (bits, 1);
+    }
+}
+
+static int
+decode_descriptors (const uchar *edid, MonitorInfo *info)
+{
+    int i;
+    int timing_idx;
+    
+    timing_idx = 0;
+    
+    for (i = 0; i < 4; ++i)
+    {
+	int index = 0x36 + i * 18;
+
+	if (edid[index + 0] == 0x00 && edid[index + 1] == 0x00)
+	{
+	    decode_display_descriptor (edid + index, info);
+	}
+	else
+	{
+	    decode_detailed_timing (
+		edid + index, &(info->detailed_timings[timing_idx++]));
+	}
+    }
+
+    info->n_detailed_timings = timing_idx;
+
+    return TRUE;
+}
+
+static void
+decode_check_sum (const uchar *edid,
+		  MonitorInfo *info)
+{
+    int i;
+    uchar check = 0;
+
+    for (i = 0; i < 128; ++i)
+	check += edid[i];
+
+    info->checksum = check;
+}
+
+MonitorInfo *
+decode_edid (const uchar *edid)
+{
+    MonitorInfo *info = g_new0 (MonitorInfo, 1);
+
+    decode_check_sum (edid, info);
+    
+    if (decode_header (edid)
+	&& decode_vendor_and_product_identification (edid, info)
+	&& decode_edid_version (edid, info)
+	&& decode_display_parameters (edid, info)
+	&& decode_color_characteristics (edid, info)
+	&& decode_established_timings (edid, info)
+	&& decode_standard_timings (edid, info)
+	&& decode_descriptors (edid, info))
+    {
+	return info;
+    }
+    else
+    {
+	g_free (info);
+	return NULL;
+    }
+}

=== added file 'gnome-settings-daemon/edid.h'
--- gnome-settings-daemon/edid.h	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/edid.h	2014-08-29 10:24:26 +0000
@@ -0,0 +1,195 @@
+/* edid.h
+ *
+ * Copyright 2007, 2008, Red Hat, Inc.
+ * 
+ * This file is part of the Gnome Library.
+ * 
+ * The Gnome Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * The Gnome Library 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
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with the Gnome Library; see the file COPYING.LIB.  If not,
+ * write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ * 
+ * Author: Soren Sandmann <[e-mail]>
+ */
+
+#ifndef EDID_H
+#define EDID_H
+
+typedef unsigned char uchar;
+typedef struct MonitorInfo MonitorInfo;
+typedef struct Timing Timing;
+typedef struct DetailedTiming DetailedTiming;
+
+typedef enum
+{
+    UNDEFINED,
+    DVI,
+    HDMI_A,
+    HDMI_B,
+    MDDI,
+    DISPLAY_PORT
+} Interface;
+
+typedef enum
+{
+    UNDEFINED_COLOR,
+    MONOCHROME,
+    RGB,
+    OTHER_COLOR
+} ColorType;
+
+typedef enum
+{
+    NO_STEREO,
+    FIELD_RIGHT,
+    FIELD_LEFT,
+    TWO_WAY_RIGHT_ON_EVEN,
+    TWO_WAY_LEFT_ON_EVEN,
+    FOUR_WAY_INTERLEAVED,
+    SIDE_BY_SIDE
+} StereoType;
+
+struct Timing
+{
+    int width;
+    int height;
+    int frequency;
+};
+
+struct DetailedTiming
+{
+    int		pixel_clock;
+    int		h_addr;
+    int		h_blank;
+    int		h_sync;
+    int		h_front_porch;
+    int		v_addr;
+    int		v_blank;
+    int		v_sync;
+    int		v_front_porch;
+    int		width_mm;
+    int		height_mm;
+    int		right_border;
+    int		top_border;
+    int		interlaced;
+    StereoType	stereo;
+
+    int		digital_sync;
+    union
+    {
+	struct
+	{
+	    int bipolar;
+	    int serrations;
+	    int sync_on_green;
+	} analog;
+
+	struct
+	{
+	    int composite;
+	    int serrations;
+	    int negative_vsync;
+	    int negative_hsync;
+	} digital;
+    } connector;
+};
+
+struct MonitorInfo
+{
+    int			checksum;
+    char		manufacturer_code[4];
+    int			product_code;
+    unsigned int	serial_number;
+    
+    int			production_week;	/* -1 if not specified */
+    int			production_year;	/* -1 if not specified */
+    int			model_year;		/* -1 if not specified */
+
+    int			major_version;
+    int			minor_version;
+
+    int			is_digital;
+    
+    union
+    {
+	struct
+	{
+	    int		bits_per_primary;
+	    Interface	interface;
+	    int		rgb444;
+	    int		ycrcb444;
+	    int		ycrcb422;
+	} digital;
+
+	struct
+	{
+	    double	video_signal_level;
+	    double	sync_signal_level;
+	    double	total_signal_level;
+
+	    int		blank_to_black;
+
+	    int		separate_hv_sync;
+	    int		composite_sync_on_h;
+	    int		composite_sync_on_green;
+	    int		serration_on_vsync;
+	    ColorType	color_type;
+	} analog;
+    } connector;
+
+    int			width_mm;		/* -1 if not specified */
+    int			height_mm;		/* -1 if not specified */
+    double		aspect_ratio;		/* -1.0 if not specififed */
+
+    double		gamma;			/* -1.0 if not specified */
+
+    int			standby;
+    int			suspend;
+    int			active_off;
+
+    int			srgb_is_standard;
+    int			preferred_timing_includes_native;
+    int			continuous_frequency;
+
+    double		red_x;
+    double		red_y;
+    double		green_x;
+    double		green_y;
+    double		blue_x;
+    double		blue_y;
+    double		white_x;
+    double		white_y;
+
+    Timing		established[24];	/* Terminated by 0x0x0 */
+    Timing		standard[8];
+    
+    int			n_detailed_timings;
+    DetailedTiming	detailed_timings[4];	/* If monitor has a preferred
+						 * mode, it is the first one
+						 * (whether it has, is
+						 * determined by the 
+						 * preferred_timing_includes
+						 * bit.
+						 */
+
+    /* Optional product description */
+    char		dsc_serial_number[14];
+    char		dsc_product_name[14];
+    char		dsc_string[14];		/* Unspecified ASCII data */
+};
+
+MonitorInfo *decode_edid (const uchar *data);
+char *make_display_name (const MonitorInfo *info);
+char *make_display_size_string (int width_mm, int height_mm);
+
+#endif

=== added file 'gnome-settings-daemon/edid_parse.c'
--- gnome-settings-daemon/edid_parse.c	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/edid_parse.c	2014-08-29 10:24:26 +0000
@@ -0,0 +1,540 @@
+/*
+ * Copyright 2007 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* Author: Soren Sandmann <[e-mail]> */
+
+#include "edid.h"
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <glib.h>
+
+static int
+get_bit (int in, int bit)
+{
+    return (in & (1 << bit)) >> bit;
+}
+
+static int
+get_bits (int in, int begin, int end)
+{
+    int mask = (1 << (end - begin + 1)) - 1;
+    
+    return (in >> begin) & mask;
+}
+
+static int
+decode_header (const uchar *edid)
+{
+    if (memcmp (edid, "\x00\xff\xff\xff\xff\xff\xff\x00", 8) == 0)
+	return TRUE;
+    return FALSE;
+}
+
+static int
+decode_vendor_and_product_identification (const uchar *edid, MonitorInfo *info)
+{
+    int is_model_year;
+    
+    /* Manufacturer Code */
+    info->manufacturer_code[0]  = get_bits (edid[0x08], 2, 6);
+    info->manufacturer_code[1]  = get_bits (edid[0x08], 0, 1) << 3;
+    info->manufacturer_code[1] |= get_bits (edid[0x09], 5, 7);
+    info->manufacturer_code[2]  = get_bits (edid[0x09], 0, 4);
+    info->manufacturer_code[3]  = '\0';
+    
+    info->manufacturer_code[0] += 'A' - 1;
+    info->manufacturer_code[1] += 'A' - 1;
+    info->manufacturer_code[2] += 'A' - 1;
+
+    /* Product Code */
+    info->product_code = edid[0x0b] << 8 | edid[0x0a];
+
+    /* Serial Number */
+    info->serial_number =
+	edid[0x0c] | edid[0x0d] << 8 | edid[0x0e] << 16 | edid[0x0f] << 24;
+
+    /* Week and Year */
+    is_model_year = FALSE;
+    switch (edid[0x10])
+    {
+    case 0x00:
+	info->production_week = -1;
+	break;
+
+    case 0xff:
+	info->production_week = -1;
+	is_model_year = TRUE;
+	break;
+
+    default:
+	info->production_week = edid[0x10];
+	break;
+    }
+
+    if (is_model_year)
+    {
+	info->production_year = -1;
+	info->model_year = 1990 + edid[0x11];
+    }
+    else
+    {
+	info->production_year = 1990 + edid[0x11];
+	info->model_year = -1;
+    }
+
+    return TRUE;
+}
+
+static int
+decode_edid_version (const uchar *edid, MonitorInfo *info)
+{
+    info->major_version = edid[0x12];
+    info->minor_version = edid[0x13];
+
+    return TRUE;
+}
+
+static int
+decode_display_parameters (const uchar *edid, MonitorInfo *info)
+{
+    /* Digital vs Analog */
+    info->is_digital = get_bit (edid[0x14], 7);
+
+    if (info->is_digital)
+    {
+	int bits;
+	
+	static const int bit_depth[8] =
+	{
+	    -1, 6, 8, 10, 12, 14, 16, -1
+	};
+
+	static const Interface interfaces[6] =
+	{
+	    UNDEFINED, DVI, HDMI_A, HDMI_B, MDDI, DISPLAY_PORT
+	};
+
+	bits = get_bits (edid[0x14], 4, 6);
+	info->connector.digital.bits_per_primary = bit_depth[bits];
+
+	bits = get_bits (edid[0x14], 0, 3);
+	
+	if (bits <= 5)
+	    info->connector.digital.interface = interfaces[bits];
+	else
+	    info->connector.digital.interface = UNDEFINED;
+    }
+    else
+    {
+	int bits = get_bits (edid[0x14], 5, 6);
+	
+	static const double levels[][3] =
+	{
+	    { 0.7,   0.3,    1.0 },
+	    { 0.714, 0.286,  1.0 },
+	    { 1.0,   0.4,    1.4 },
+	    { 0.7,   0.0,    0.7 },
+	};
+
+	info->connector.analog.video_signal_level = levels[bits][0];
+	info->connector.analog.sync_signal_level = levels[bits][1];
+	info->connector.analog.total_signal_level = levels[bits][2];
+
+	info->connector.analog.blank_to_black = get_bit (edid[0x14], 4);
+
+	info->connector.analog.separate_hv_sync = get_bit (edid[0x14], 3);
+	info->connector.analog.composite_sync_on_h = get_bit (edid[0x14], 2);
+	info->connector.analog.composite_sync_on_green = get_bit (edid[0x14], 1);
+
+	info->connector.analog.serration_on_vsync = get_bit (edid[0x14], 0);
+    }
+
+    /* Screen Size / Aspect Ratio */
+    if (edid[0x15] == 0 && edid[0x16] == 0)
+    {
+	info->width_mm = -1;
+	info->height_mm = -1;
+	info->aspect_ratio = -1.0;
+    }
+    else if (edid[0x16] == 0)
+    {
+	info->width_mm = -1;
+	info->height_mm = -1; 
+	info->aspect_ratio = 100.0 / (edid[0x15] + 99);
+    }
+    else if (edid[0x15] == 0)
+    {
+	info->width_mm = -1;
+	info->height_mm = -1;
+	info->aspect_ratio = 100.0 / (edid[0x16] + 99);
+	info->aspect_ratio = 1/info->aspect_ratio; /* portrait */
+    }
+    else
+    {
+	info->width_mm = 10 * edid[0x15];
+	info->height_mm = 10 * edid[0x16];
+    }
+
+    /* Gamma */
+    if (edid[0x17] == 0xFF)
+	info->gamma = -1.0;
+    else
+	info->gamma = (edid[0x17] + 100.0) / 100.0;
+
+    /* Features */
+    info->standby = get_bit (edid[0x18], 7);
+    info->suspend = get_bit (edid[0x18], 6);
+    info->active_off = get_bit (edid[0x18], 5);
+
+    if (info->is_digital)
+    {
+	info->connector.digital.rgb444 = TRUE;
+	if (get_bit (edid[0x18], 3))
+	    info->connector.digital.ycrcb444 = 1;
+	if (get_bit (edid[0x18], 4))
+	    info->connector.digital.ycrcb422 = 1;
+    }
+    else
+    {
+	int bits = get_bits (edid[0x18], 3, 4);
+	ColorType color_type[4] =
+	{
+	    MONOCHROME, RGB, OTHER_COLOR, UNDEFINED_COLOR
+	};
+
+	info->connector.analog.color_type = color_type[bits];
+    }
+
+    info->srgb_is_standard = get_bit (edid[0x18], 2);
+
+    /* In 1.3 this is called "has preferred timing" */
+    info->preferred_timing_includes_native = get_bit (edid[0x18], 1);
+
+    /* FIXME: In 1.3 this indicates whether the monitor accepts GTF */
+    info->continuous_frequency = get_bit (edid[0x18], 0);
+    return TRUE;
+}
+
+static double
+decode_fraction (int high, int low)
+{
+    double result = 0.0;
+    int i;
+
+    high = (high << 2) | low;
+
+    for (i = 0; i < 10; ++i)
+	result += get_bit (high, i) * pow (2, i - 10);
+
+    return result;
+}
+
+static int
+decode_color_characteristics (const uchar *edid, MonitorInfo *info)
+{
+    info->red_x = decode_fraction (edid[0x1b], get_bits (edid[0x19], 6, 7));
+    info->red_y = decode_fraction (edid[0x1c], get_bits (edid[0x19], 5, 4));
+    info->green_x = decode_fraction (edid[0x1d], get_bits (edid[0x19], 2, 3));
+    info->green_y = decode_fraction (edid[0x1e], get_bits (edid[0x19], 0, 1));
+    info->blue_x = decode_fraction (edid[0x1f], get_bits (edid[0x1a], 6, 7));
+    info->blue_y = decode_fraction (edid[0x20], get_bits (edid[0x1a], 4, 5));
+    info->white_x = decode_fraction (edid[0x21], get_bits (edid[0x1a], 2, 3));
+    info->white_y = decode_fraction (edid[0x22], get_bits (edid[0x1a], 0, 1));
+
+    return TRUE;
+}
+
+static int
+decode_established_timings (const uchar *edid, MonitorInfo *info)
+{
+    static const Timing established[][8] = 
+    {
+	{
+	    { 800, 600, 60 },
+	    { 800, 600, 56 },
+	    { 640, 480, 75 },
+	    { 640, 480, 72 },
+	    { 640, 480, 67 },
+	    { 640, 480, 60 },
+	    { 720, 400, 88 },
+	    { 720, 400, 70 }
+	},
+	{
+	    { 1280, 1024, 75 },
+	    { 1024, 768, 75 },
+	    { 1024, 768, 70 },
+	    { 1024, 768, 60 },
+	    { 1024, 768, 87 },
+	    { 832, 624, 75 },
+	    { 800, 600, 75 },
+	    { 800, 600, 72 }
+	},
+	{
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 0, 0, 0 },
+	    { 1152, 870, 75 }
+	},
+    };
+
+    int i, j, idx;
+
+    idx = 0;
+    for (i = 0; i < 3; ++i)
+    {
+	for (j = 0; j < 8; ++j)
+	{
+	    int byte = edid[0x23 + i];
+
+	    if (get_bit (byte, j) && established[i][j].frequency != 0)
+		info->established[idx++] = established[i][j];
+	}
+    }
+    return TRUE;
+}
+
+static int
+decode_standard_timings (const uchar *edid, MonitorInfo *info)
+{
+    int i;
+    
+    for (i = 0; i < 8; i++)
+    {
+	int first = edid[0x26 + 2 * i];
+	int second = edid[0x27 + 2 * i];
+
+	if (first != 0x01 && second != 0x01)
+	{
+	    int w = 8 * (first + 31);
+	    int h = 0;
+
+	    switch (get_bits (second, 6, 7))
+	    {
+	    case 0x00: h = (w / 16) * 10; break;
+	    case 0x01: h = (w / 4) * 3; break;
+	    case 0x02: h = (w / 5) * 4; break;
+	    case 0x03: h = (w / 16) * 9; break;
+	    }
+
+	    info->standard[i].width = w;
+	    info->standard[i].height = h;
+	    info->standard[i].frequency = get_bits (second, 0, 5) + 60;
+	}
+    }
+    
+    return TRUE;
+}
+
+static void
+decode_lf_string (const uchar *s, int n_chars, char *result)
+{
+    int i;
+    for (i = 0; i < n_chars; ++i)
+    {
+	if (s[i] == 0x0a)
+	{
+	    *result++ = '\0';
+	    break;
+	}
+	else if (s[i] == 0x00)
+	{
+	    /* Convert embedded 0's to spaces */
+	    *result++ = ' ';
+	}
+	else
+	{
+	    *result++ = s[i];
+	}
+    }
+}
+
+static void
+decode_display_descriptor (const uchar *desc,
+			   MonitorInfo *info)
+{
+    switch (desc[0x03])
+    {
+    case 0xFC:
+	decode_lf_string (desc + 5, 13, info->dsc_product_name);
+	break;
+    case 0xFF:
+	decode_lf_string (desc + 5, 13, info->dsc_serial_number);
+	break;
+    case 0xFE:
+	decode_lf_string (desc + 5, 13, info->dsc_string);
+	break;
+    case 0xFD:
+	/* Range Limits */
+	break;
+    case 0xFB:
+	/* Color Point */
+	break;
+    case 0xFA:
+	/* Timing Identifications */
+	break;
+    case 0xF9:
+	/* Color Management */
+	break;
+    case 0xF8:
+	/* Timing Codes */
+	break;
+    case 0xF7:
+	/* Established Timings */
+	break;
+    case 0x10:
+	break;
+    }
+}
+
+static void
+decode_detailed_timing (const uchar *timing,
+			DetailedTiming *detailed)
+{
+    int bits;
+    StereoType stereo[] =
+    {
+	NO_STEREO, NO_STEREO, FIELD_RIGHT, FIELD_LEFT,
+	TWO_WAY_RIGHT_ON_EVEN, TWO_WAY_LEFT_ON_EVEN,
+	FOUR_WAY_INTERLEAVED, SIDE_BY_SIDE
+    };
+    
+    detailed->pixel_clock = (timing[0x00] | timing[0x01] << 8) * 10000;
+    detailed->h_addr = timing[0x02] | ((timing[0x04] & 0xf0) << 4);
+    detailed->h_blank = timing[0x03] | ((timing[0x04] & 0x0f) << 8);
+    detailed->v_addr = timing[0x05] | ((timing[0x07] & 0xf0) << 4);
+    detailed->v_blank = timing[0x06] | ((timing[0x07] & 0x0f) << 8);
+    detailed->h_front_porch = timing[0x08] | get_bits (timing[0x0b], 6, 7) << 8;
+    detailed->h_sync = timing[0x09] | get_bits (timing[0x0b], 4, 5) << 8;
+    detailed->v_front_porch =
+	get_bits (timing[0x0a], 4, 7) | get_bits (timing[0x0b], 2, 3) << 4;
+    detailed->v_sync =
+	get_bits (timing[0x0a], 0, 3) | get_bits (timing[0x0b], 0, 1) << 4;
+    detailed->width_mm =  timing[0x0c] | get_bits (timing[0x0e], 4, 7) << 8;
+    detailed->height_mm = timing[0x0d] | get_bits (timing[0x0e], 0, 3) << 8;
+    detailed->right_border = timing[0x0f];
+    detailed->top_border = timing[0x10];
+
+    detailed->interlaced = get_bit (timing[0x11], 7);
+
+    /* Stereo */
+    bits = get_bits (timing[0x11], 5, 6) << 1 | get_bit (timing[0x11], 0);
+    detailed->stereo = stereo[bits];
+
+    /* Sync */
+    bits = timing[0x11];
+
+    detailed->digital_sync = get_bit (bits, 4);
+    if (detailed->digital_sync)
+    {
+	detailed->connector.digital.composite = !get_bit (bits, 3);
+
+	if (detailed->connector.digital.composite)
+	{
+	    detailed->connector.digital.serrations = get_bit (bits, 2);
+	    detailed->connector.digital.negative_vsync = FALSE;
+	}
+	else
+	{
+	    detailed->connector.digital.serrations = FALSE;
+	    detailed->connector.digital.negative_vsync = !get_bit (bits, 2);
+	}
+
+	detailed->connector.digital.negative_hsync = !get_bit (bits, 0);
+    }
+    else
+    {
+	detailed->connector.analog.bipolar = get_bit (bits, 3);
+	detailed->connector.analog.serrations = get_bit (bits, 2);
+	detailed->connector.analog.sync_on_green = !get_bit (bits, 1);
+    }
+}
+
+static int
+decode_descriptors (const uchar *edid, MonitorInfo *info)
+{
+    int i;
+    int timing_idx;
+    
+    timing_idx = 0;
+    
+    for (i = 0; i < 4; ++i)
+    {
+	int index = 0x36 + i * 18;
+
+	if (edid[index + 0] == 0x00 && edid[index + 1] == 0x00)
+	{
+	    decode_display_descriptor (edid + index, info);
+	}
+	else
+	{
+	    decode_detailed_timing (
+		edid + index, &(info->detailed_timings[timing_idx++]));
+	}
+    }
+
+    info->n_detailed_timings = timing_idx;
+
+    return TRUE;
+}
+
+static void
+decode_check_sum (const uchar *edid,
+		  MonitorInfo *info)
+{
+    int i;
+    uchar check = 0;
+
+    for (i = 0; i < 128; ++i)
+	check += edid[i];
+
+    info->checksum = check;
+}
+
+MonitorInfo *
+decode_edid (const uchar *edid)
+{
+    MonitorInfo *info = g_new0 (MonitorInfo, 1);
+
+    decode_check_sum (edid, info);
+    
+    if (decode_header (edid)
+	&& decode_vendor_and_product_identification (edid, info)
+	&& decode_edid_version (edid, info)
+	&& decode_display_parameters (edid, info)
+	&& decode_color_characteristics (edid, info)
+	&& decode_established_timings (edid, info)
+	&& decode_standard_timings (edid, info)
+	&& decode_descriptors (edid, info))
+    {
+	return info;
+    }
+    else
+    {
+	g_free (info);
+	return NULL;
+    }
+}

=== modified file 'gnome-settings-daemon/gnome-settings-manager.c'
--- gnome-settings-daemon/gnome-settings-manager.c	2012-12-19 16:19:59 +0000
+++ gnome-settings-daemon/gnome-settings-manager.c	2014-08-29 10:24:26 +0000
@@ -30,13 +30,11 @@
 #include <glib-object.h>
 #include <gio/gio.h>
 
-#define GNOME_DESKTOP_USE_UNSTABLE_API
-#include <libgnome-desktop/gnome-pnp-ids.h>
-
 #include "gnome-settings-plugin.h"
 #include "gnome-settings-plugin-info.h"
 #include "gnome-settings-manager.h"
 #include "gnome-settings-profile.h"
+#include "gsd-pnp-ids.h"
 
 #define DEFAULT_SETTINGS_PREFIX "org.gnome.settings-daemon"
 
@@ -64,7 +62,7 @@
         GDBusConnection            *connection;
         GSettings                  *settings;
         char                      **whitelist;
-        GnomePnpIds                *pnp_ids;
+        GsdPnpIds                  *pnp_ids;
         GSList                     *plugins;
 };
 
@@ -399,7 +397,7 @@
         }
 
         g_debug ("loading PNPIDs");
-        manager->priv->pnp_ids = gnome_pnp_ids_new ();
+        manager->priv->pnp_ids = gsd_pnp_ids_new ();
 
         gnome_settings_profile_start ("initializing plugins");
         manager->priv->settings = g_settings_new (DEFAULT_SETTINGS_PREFIX ".plugins");

=== added file 'gnome-settings-daemon/gsd-idle-monitor.c'
--- gnome-settings-daemon/gsd-idle-monitor.c	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/gsd-idle-monitor.c	2014-08-29 10:24:26 +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 'gnome-settings-daemon/gsd-idle-monitor.h'
--- gnome-settings-daemon/gsd-idle-monitor.h	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/gsd-idle-monitor.h	2014-08-29 10:24:26 +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__ */

=== added file 'gnome-settings-daemon/gsd-pnp-ids.c'
--- gnome-settings-daemon/gsd-pnp-ids.c	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/gsd-pnp-ids.c	2014-08-29 10:24:26 +0000
@@ -0,0 +1,341 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2009-2011 Richard Hughes <[e-mail]>
+ *
+ * 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 <glib-object.h>
+
+#include "gsd-pnp-ids.h"
+
+static void gsd_pnp_ids_finalize (GObject *object);
+
+#define GSD_PNP_IDS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GSD_TYPE_PNP_IDS, GsdPnpIdsPrivate))
+
+struct _GsdPnpIdsPrivate
+{
+        gchar      *table_data;
+        GHashTable *pnp_table;
+};
+
+static gpointer gsd_pnp_ids_object = NULL;
+
+G_DEFINE_TYPE (GsdPnpIds, gsd_pnp_ids, G_TYPE_OBJECT)
+
+typedef struct Vendor Vendor;
+struct Vendor
+{
+    const char vendor_id[4];
+    const char vendor_name[28];
+};
+
+/* This list of vendor codes derived from lshw
+ *
+ * http://ezix.org/project/wiki/HardwareLiSter
+ *
+ * Note: we now prefer to use data coming from hwdata (and shipped with
+ * gnome-desktop). See
+ * http://git.fedorahosted.org/git/?p=hwdata.git;a=blob_plain;f=pnp.ids;hb=HEAD
+ * All contributions to the list of vendors should go there.
+ */
+static const struct Vendor vendors[] =
+{
+    { "AIC", "AG Neovo" },
+    { "ACR", "Acer" },
+    { "DEL", "DELL" },
+    { "SAM", "SAMSUNG" },
+    { "SNY", "SONY" },
+    { "SEC", "Epson" },
+    { "WAC", "Wacom" },
+    { "NEC", "NEC" },
+    { "CMO", "CMO" },        /* Chi Mei */
+    { "BNQ", "BenQ" },
+
+    { "ABP", "Advansys" },
+    { "ACC", "Accton" },
+    { "ACE", "Accton" },
+    { "ADP", "Adaptec" },
+    { "ADV", "AMD" },
+    { "AIR", "AIR" },
+    { "AMI", "AMI" },
+    { "ASU", "ASUS" },
+    { "ATI", "ATI" },
+    { "ATK", "Allied Telesyn" },
+    { "AZT", "Aztech" },
+    { "BAN", "Banya" },
+    { "BRI", "Boca Research" },
+    { "BUS", "Buslogic" },
+    { "CCI", "Cache Computers Inc." },
+    { "CHA", "Chase" },
+    { "CMD", "CMD Technology, Inc." },
+    { "COG", "Cogent" },
+    { "CPQ", "Compaq" },
+    { "CRS", "Crescendo" },
+    { "CSC", "Crystal" },
+    { "CSI", "CSI" },
+    { "CTL", "Creative Labs" },
+    { "DBI", "Digi" },
+    { "DEC", "Digital Equipment" },
+    { "DBK", "Databook" },
+    { "EGL", "Eagle Technology" },
+    { "ELS", "ELSA" },
+    { "ESS", "ESS" },
+    { "FAR", "Farallon" },
+    { "FDC", "Future Domain" },
+    { "HWP", "Hewlett-Packard" },
+    { "IBM", "IBM" },
+    { "INT", "Intel" },
+    { "ISA", "Iomega" },
+    { "LEN", "Lenovo" },
+    { "MDG", "Madge" },
+    { "MDY", "Microdyne" },
+    { "MET", "Metheus" },
+    { "MIC", "Micronics" },
+    { "MLX", "Mylex" },
+    { "NVL", "Novell" },
+    { "OLC", "Olicom" },
+    { "PRO", "Proteon" },
+    { "RII", "Racal" },
+    { "RTL", "Realtek" },
+    { "SCM", "SCM" },
+    { "SKD", "SysKonnect" },
+    { "SGI", "SGI" },
+    { "SMC", "SMC" },
+    { "SNI", "Siemens Nixdorf" },
+    { "STL", "Stallion Technologies" },
+    { "SUN", "Sun" },
+    { "SUP", "SupraExpress" },
+    { "SVE", "SVEC" },
+    { "TCC", "Thomas-Conrad" },
+    { "TCI", "Tulip" },
+    { "TCM", "3Com" },
+    { "TCO", "Thomas-Conrad" },
+    { "TEC", "Tecmar" },
+    { "TRU", "Truevision" },
+    { "TOS", "Toshiba" },
+    { "TYN", "Tyan" },
+    { "UBI", "Ungermann-Bass" },
+    { "USC", "UltraStor" },
+    { "VDM", "Vadem" },
+    { "VMI", "Vermont" },
+    { "WDC", "Western Digital" },
+    { "ZDS", "Zeos" },
+
+    /* From http://faydoc.tripod.com/structures/01/0136.htm */
+    { "ACT", "Targa" },
+    { "ADI", "ADI" },
+    { "AOC", "AOC Intl" },
+    { "API", "Acer America" },
+    { "APP", "Apple Computer" },
+    { "ART", "ArtMedia" },
+    { "AST", "AST Research" },
+    { "CPL", "Compal" },
+    { "CTX", "Chuntex Electronic Co." },
+    { "DPC", "Delta Electronics" },
+    { "DWE", "Daewoo" },
+    { "ECS", "ELITEGROUP" },
+    { "EIZ", "EIZO" },
+    { "FCM", "Funai" },
+    { "GSM", "LG Electronics" },
+    { "GWY", "Gateway 2000" },
+    { "HEI", "Hyundai" },
+    { "HIT", "Hitachi" },
+    { "HSL", "Hansol" },
+    { "HTC", "Hitachi" },
+    { "ICL", "Fujitsu ICL" },
+    { "IVM", "Idek Iiyama" },
+    { "KFC", "KFC Computek" },
+    { "LKM", "ADLAS" },
+    { "LNK", "LINK Tech" },
+    { "LTN", "Lite-On" },
+    { "MAG", "MAG InnoVision" },
+    { "MAX", "Maxdata" },
+    { "MEI", "Panasonic" },
+    { "MEL", "Mitsubishi" },
+    { "MIR", "miro" },
+    { "MTC", "MITAC" },
+    { "NAN", "NANAO" },
+    { "NEC", "NEC Tech" },
+    { "NOK", "Nokia" },
+    { "OQI", "OPTIQUEST" },
+    { "PBN", "Packard Bell" },
+    { "PGS", "Princeton" },
+    { "PHL", "Philips" },
+    { "REL", "Relisys" },
+    { "SDI", "Samtron" },
+    { "SMI", "Smile" },
+    { "SPT", "Sceptre" },
+    { "SRC", "Shamrock Technology" },
+    { "STP", "Sceptre" },
+    { "TAT", "Tatung" },
+    { "TRL", "Royal Information Company" },
+    { "TSB", "Toshiba, Inc." },
+    { "UNM", "Unisys" },
+    { "VSC", "ViewSonic" },
+    { "WTC", "Wen Tech" },
+    { "ZCM", "Zenith Data Systems" },
+
+    { "???", "Unknown" },
+};
+
+static gboolean
+gsd_pnp_ids_load (GsdPnpIds *pnp_ids, GError **error)
+{
+        gchar *retval = NULL;
+        GsdPnpIdsPrivate *priv = pnp_ids->priv;
+        guint i;
+
+        /* load the contents */
+        g_debug ("loading: %s", PNP_IDS);
+        if (g_file_get_contents (PNP_IDS, &priv->table_data, NULL, error) == FALSE)
+                return FALSE;
+
+        /* parse into lines */
+        retval = priv->table_data;
+        for (i = 0; priv->table_data[i] != '\0'; i++) {
+
+                /* ignore */
+                if (priv->table_data[i] != '\n')
+                        continue;
+
+                /* convert newline to NULL */
+                priv->table_data[i] = '\0';
+
+                /* the ID to text is a fixed offset */
+                if (retval[0] && retval[1] && retval[2] && retval[3] == '\t' && retval[4]) {
+                        retval[3] = '\0';
+                        g_hash_table_insert (priv->pnp_table,
+                                             retval,
+                                             retval+4);
+                        retval = &priv->table_data[i+1];
+                }
+        }
+
+        g_debug ("Added %i items to the vendor hashtable", i);
+
+        return TRUE;
+}
+
+static const char *
+find_vendor (const char *pnp_id)
+{
+        guint i;
+
+        for (i = 0; i < G_N_ELEMENTS (vendors); i++) {
+                if (g_strcmp0 (vendors[i].vendor_id, pnp_id) == 0)
+                        return vendors[i].vendor_name;
+        }
+
+        return NULL;
+}
+
+/**
+ * gsd_pnp_ids_get_pnp_id:
+ * @pnp_ids: a #GsdPnpIds object
+ * @pnp_id: the PNP ID to look for
+ *
+ * Find the full manufacturer name for the given PNP ID.
+ *
+ * Returns: (transfer full): a new string representing the manufacturer name,
+ * or %NULL when not found.
+ */
+gchar *
+gsd_pnp_ids_get_pnp_id (GsdPnpIds *pnp_ids, const gchar *pnp_id)
+{
+        GsdPnpIdsPrivate *priv = pnp_ids->priv;
+        const char *found;
+        GError *error = NULL;
+        guint size;
+
+        g_return_val_if_fail (GSD_IS_PNP_IDS (pnp_ids), NULL);
+        g_return_val_if_fail (pnp_id != NULL, NULL);
+
+        /* if table is empty, try to load it */
+        size = g_hash_table_size (priv->pnp_table);
+        if (size == 0) {
+                if (gsd_pnp_ids_load (pnp_ids, &error) == FALSE) {
+                        g_warning ("Failed to load PNP ids: %s", error->message);
+                        g_error_free (error);
+                        return NULL;
+                }
+        }
+
+        /* look this up in the table */
+        found = g_hash_table_lookup (priv->pnp_table, pnp_id);
+        if (found == NULL) {
+                found = find_vendor (pnp_id);
+                if (found == NULL)
+                        return NULL;
+        }
+
+        return g_strdup (found);
+}
+
+static void
+gsd_pnp_ids_class_init (GsdPnpIdsClass *klass)
+{
+        GObjectClass *object_class = G_OBJECT_CLASS (klass);
+        object_class->finalize = gsd_pnp_ids_finalize;
+        g_type_class_add_private (klass, sizeof (GsdPnpIdsPrivate));
+}
+
+static void
+gsd_pnp_ids_init (GsdPnpIds *pnp_ids)
+{
+        pnp_ids->priv = GSD_PNP_IDS_GET_PRIVATE (pnp_ids);
+
+        /* we don't keep malloc'd data in the hash; instead we read it
+         * out into priv->table_data and then link to it in the hash */
+        pnp_ids->priv->pnp_table = g_hash_table_new_full (g_str_hash,
+                                                         g_str_equal,
+                                                         NULL,
+                                                         NULL);
+}
+
+static void
+gsd_pnp_ids_finalize (GObject *object)
+{
+        GsdPnpIds *pnp_ids = GSD_PNP_IDS (object);
+        GsdPnpIdsPrivate *priv = pnp_ids->priv;
+
+        g_free (priv->table_data);
+        g_hash_table_unref (priv->pnp_table);
+
+        G_OBJECT_CLASS (gsd_pnp_ids_parent_class)->finalize (object);
+}
+
+/**
+ * gsd_pnp_ids_new:
+ *
+ * Returns a reference to a #GsdPnpIds object, or creates
+ * a new one if none have been created.
+ *
+ * Returns: (transfer full): a #GsdPnpIds object.
+ */
+GsdPnpIds *
+gsd_pnp_ids_new (void)
+{
+        if (gsd_pnp_ids_object != NULL) {
+                g_object_ref (gsd_pnp_ids_object);
+        } else {
+                gsd_pnp_ids_object = g_object_new (GSD_TYPE_PNP_IDS, NULL);
+                g_object_add_weak_pointer (gsd_pnp_ids_object, &gsd_pnp_ids_object);
+        }
+        return GSD_PNP_IDS (gsd_pnp_ids_object);
+}
+

=== added file 'gnome-settings-daemon/gsd-pnp-ids.h'
--- gnome-settings-daemon/gsd-pnp-ids.h	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/gsd-pnp-ids.h	2014-08-29 10:24:26 +0000
@@ -0,0 +1,58 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2009-2010 Richard Hughes <[e-mail]>
+ *
+ * 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.
+ */
+
+#ifndef __GSD_PNP_IDS_H
+#define __GSD_PNP_IDS_H
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define GSD_TYPE_PNP_IDS                 (gsd_pnp_ids_get_type ())
+#define GSD_PNP_IDS(o)                   (G_TYPE_CHECK_INSTANCE_CAST ((o), GSD_TYPE_PNP_IDS, GsdPnpIds))
+#define GSD_PNP_IDS_CLASS(k)             (G_TYPE_CHECK_CLASS_CAST((k), GSD_TYPE_PNP_IDS, GsdPnpIdsClass))
+#define GSD_IS_PNP_IDS(o)                (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSD_TYPE_PNP_IDS))
+#define GSD_IS_PNP_IDS_CLASS(k)          (G_TYPE_CHECK_CLASS_TYPE ((k), GSD_TYPE_PNP_IDS))
+#define GSD_PNP_IDS_GET_CLASS(o)         (G_TYPE_INSTANCE_GET_CLASS ((o), GSD_TYPE_PNP_IDS, GsdPnpIdsClass))
+#define GSD_PNP_IDS_ERROR                (gsd_pnp_ids_error_quark ())
+
+typedef struct _GsdPnpIdsPrivate        GsdPnpIdsPrivate;
+typedef struct _GsdPnpIds               GsdPnpIds;
+typedef struct _GsdPnpIdsClass          GsdPnpIdsClass;
+
+struct _GsdPnpIds
+{
+         GObject          parent;
+         GsdPnpIdsPrivate *priv;
+};
+
+struct _GsdPnpIdsClass
+{
+        GObjectClass    parent_class;
+};
+
+GType         gsd_pnp_ids_get_type                    (void);
+GsdPnpIds     *gsd_pnp_ids_new                         (void);
+gchar        *gsd_pnp_ids_get_pnp_id                  (GsdPnpIds   *pnp_ids,
+                                                     const gchar *pnp_id);
+
+G_END_DECLS
+
+#endif /* __GSD_PNP_IDS_H */
+

=== added file 'gnome-settings-daemon/gsd-rr-config.c'
--- gnome-settings-daemon/gsd-rr-config.c	1970-01-01 00:00:00 +0000
+++ gnome-settings-daemon/gsd-rr-config.c	2014-08-29 10:24:26 +0000
@@ -0,0 +1,2091 @@
+/* gnome-rr-config.c
+ * -*- c-basic-offset: 4 -*-
+ *
+ * Copyright 2007, 2008, Red Hat, Inc.
+ * Copyright 2010 Giovanni Campagna
+ * 
+ * This file is part of the Gnome Library.
+ * 
+ * The Gnome Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * The Gnome Library 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
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with the Gnome Library; see the file COPYING.LIB.  If not,
+ * write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ * 
+ * Author: Soren Sandmann <[e-mail]>
+ */
+
+#include <config.h>
+#include <glib/gi18n-lib.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+#include <glib/gstdio.h>
+
+#include <X11/Xlib.h>
+#include <gdk/gdkx.h>
+
+#include <unistd.h>
+#include <sys/wait.h>
+#include <signal.h>
+
+#include "gsd-rr-config.h"
+
+#include "edid.h"
+#include "gsd-rr-private.h"
+
+#define CONFIG_INTENDED_BASENAME "monitors.xml"
+#define CONFIG_BACKUP_BASENAME "monitors.xml.backup"
+
+/* Look for DPI_FALLBACK in:
+ * http://git.gnome.org/browse/gnome-settings-daemon/tree/plugins/xsettings/gsd-xsettings-manager.c
+ * for the reasoning */
+#define DPI_FALLBACK 96.0
+
+/* In version 0 of the config file format, we had several <configuration>
+ * toplevel elements and no explicit version number.  So, the filed looked
+ * like
+ *
+ *   <configuration>
+ *     ...
+ *   </configuration>
+ *   <configuration>
+ *     ...
+ *   </configuration>
+ *
+ * Since version 1 of the config file, the file has a toplevel <monitors>
+ * element to group all the configurations.  That element has a "version"
+ * attribute which is an integer. So, the file looks like this:
+ *
+ *   <monitors version="1">
+ *     <configuration>
+ *       ...
+ *     </configuration>
+ *     <configuration>
+ *       ...
+ *     </configuration>
+ *   </monitors>
+ */
+
+/* A helper wrapper around the GMarkup parser stuff */
+static gboolean parse_file_gmarkup (const gchar *file,
+				    const GMarkupParser *parser,
+				    gpointer data,
+				    GError **err);
+
+typedef struct CrtcAssignment CrtcAssignment;
+
+static gboolean         crtc_assignment_apply (CrtcAssignment   *assign,
+					       guint32           timestamp,
+					       GError          **error);
+static CrtcAssignment  *crtc_assignment_new   (GsdRRScreen      *screen,
+					       GsdRROutputInfo **outputs,
+					       GError            **error);
+static void             crtc_assignment_free  (CrtcAssignment   *assign);
+
+enum {
+  PROP_0,
+  PROP_SCREEN,
+  PROP_LAST
+};
+
+G_DEFINE_TYPE (GsdRRConfig, gsd_rr_config, G_TYPE_OBJECT)
+
+typedef struct Parser Parser;
+
+/* Parser for monitor configurations */
+struct Parser
+{
+    int			config_file_version;
+    GsdRROutputInfo *	output;
+    GsdRRConfig *	configuration;
+    GPtrArray *		outputs;
+    GPtrArray *		configurations;
+    GQueue *		stack;
+};
+
+static int
+parse_int (const char *text)
+{
+    return strtol (text, NULL, 0);
+}
+
+static guint
+parse_uint (const char *text)
+{
+    return strtoul (text, NULL, 0);
+}
+
+static gboolean
+stack_is (Parser *parser,
+	  const char *s1,
+	  ...)
+{
+    GList *stack = NULL;
+    const char *s;
+    GList *l1, *l2;
+    va_list args;
+    
+    stack = g_list_prepend (stack, (gpointer)s1);
+    
+    va_start (args, s1);
+    
+    s = va_arg (args, const char *);
+    while (s)
+    {
+	stack = g_list_prepend (stack, (gpointer)s);
+	s = va_arg (args, const char *);
+    }
+	
+    l1 = stack;
+    l2 = parser->stack->head;
+    
+    while (l1 && l2)
+    {
+	if (strcmp (l1->data, l2->data) != 0)
+	{
+	    g_list_free (stack);
+	    return FALSE;
+	}
+	
+	l1 = l1->next;
+	l2 = l2->next;
+    }
+    
+    g_list_free (stack);
+    
+    return (!l1 && !l2);
+}
+
+static void
+handle_start_element (GMarkupParseContext *context,
+		      const gchar         *name,
+		      const gchar        **attr_names,
+		      const gchar        **attr_values,
+		      gpointer             user_data,
+		      GError             **err)
+{
+    Parser *parser = user_data;
+
+    if (strcmp (name, "output") == 0)
+    {
+	int i;
+	g_assert (parser->output == NULL);
+
+	parser->output = g_object_new (GSD_TYPE_RR_OUTPUT_INFO, NULL);
+	parser->output->priv->rotation = 0;
+	
+	for (i = 0; attr_names[i] != NULL; ++i)
+	{
+	    if (strcmp (attr_names[i], "name") == 0)
+	    {
+		parser->output->priv->name = g_strdup (attr_values[i]);
+		break;
+	    }
+	}
+
+	if (!parser->output->priv->name)
+	{
+	    /* This really shouldn't happen, but it's better to make
+	     * something up than to crash later.
+	     */
+	    g_warning ("Malformed monitor configuration file");
+	    
+	    parser->output->priv->name = g_strdup ("default");
+	}	
+	parser->output->priv->connected = FALSE;
+	parser->output->priv->on = FALSE;
+	parser->output->priv->primary = FALSE;
+    }
+    else if (strcmp (name, "configuration") == 0)
+    {
+	g_assert (parser->configuration == NULL);
+	
+	parser->configuration = g_object_new (GSD_TYPE_RR_CONFIG, NULL);
+	parser->configuration->priv->clone = FALSE;
+	parser->configuration->priv->outputs = NULL;
+    }
+    else if (strcmp (name, "monitors") == 0)
+    {
+	int i;
+
+	for (i = 0; attr_names[i] != NULL; i++)
+	{
+	    if (strcmp (attr_names[i], "version") == 0)
+	    {
+		parser->config_file_version = parse_int (attr_values[i]);
+		break;
+	    }
+	}
+    }
+
+    g_queue_push_tail (parser->stack, g_strdup (name));
+}
+
+static void
+handle_end_element (GMarkupParseContext *context,
+		    const gchar         *name,
+		    gpointer             user_data,
+		    GError             **err)
+{
+    Parser *parser = user_data;
+    
+    if (strcmp (name, "output") == 0)
+    {
+	/* If no rotation properties were set, just use GSD_RR_ROTATION_0 */
+	if (parser->output->priv->rotation == 0)
+	    parser->output->priv->rotation = GSD_RR_ROTATION_0;
+	
+	g_ptr_array_add (parser->outputs, parser->output);
+
+	parser->output = NULL;
+    }
+    else if (strcmp (name, "configuration") == 0)
+    {
+	g_ptr_array_add (parser->outputs, NULL);
+	parser->configuration->priv->outputs =
+	    (GsdRROutputInfo **)g_ptr_array_free (parser->outputs, FALSE);
+	parser->outputs = g_ptr_array_new ();
+	g_ptr_array_add (parser->configurations, parser->configuration);
+	parser->configuration = NULL;
+    }
+    
+    g_free (g_queue_pop_tail (parser->stack));
+}
+
+#define TOPLEVEL_ELEMENT (parser->config_file_version > 0 ? "monitors" : NULL)
+
+static void
+handle_text (GMarkupParseContext *context,
+	     const gchar         *text,
+	     gsize                text_len,
+	     gpointer             user_data,
+	     GError             **err)
+{
+    Parser *parser = user_data;
+    
+    if (stack_is (parser, "vendor", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	parser->output->priv->connected = TRUE;
+	
+	strncpy ((gchar*) parser->output->priv->vendor, text, 3);
+	parser->output->priv->vendor[3] = 0;
+    }
+    else if (stack_is (parser, "clone", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	if (strcmp (text, "yes") == 0)
+	    parser->configuration->priv->clone = TRUE;
+    }
+    else if (stack_is (parser, "product", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	parser->output->priv->connected = TRUE;
+
+	parser->output->priv->product = parse_int (text);
+    }
+    else if (stack_is (parser, "serial", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	parser->output->priv->connected = TRUE;
+
+	parser->output->priv->serial = parse_uint (text);
+    }
+    else if (stack_is (parser, "width", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	parser->output->priv->on = TRUE;
+
+	parser->output->priv->width = parse_int (text);
+    }
+    else if (stack_is (parser, "x", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	parser->output->priv->on = TRUE;
+
+	parser->output->priv->x = parse_int (text);
+    }
+    else if (stack_is (parser, "y", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	parser->output->priv->on = TRUE;
+
+	parser->output->priv->y = parse_int (text);
+    }
+    else if (stack_is (parser, "height", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	parser->output->priv->on = TRUE;
+
+	parser->output->priv->height = parse_int (text);
+    }
+    else if (stack_is (parser, "rate", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	parser->output->priv->on = TRUE;
+
+	parser->output->priv->rate = parse_int (text);
+    }
+    else if (stack_is (parser, "rotation", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	if (strcmp (text, "normal") == 0)
+	{
+	    parser->output->priv->rotation |= GSD_RR_ROTATION_0;
+	}
+	else if (strcmp (text, "left") == 0)
+	{
+	    parser->output->priv->rotation |= GSD_RR_ROTATION_90;
+	}
+	else if (strcmp (text, "upside_down") == 0)
+	{
+	    parser->output->priv->rotation |= GSD_RR_ROTATION_180;
+	}
+	else if (strcmp (text, "right") == 0)
+	{
+	    parser->output->priv->rotation |= GSD_RR_ROTATION_270;
+	}
+    }
+    else if (stack_is (parser, "reflect_x", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	if (strcmp (text, "yes") == 0)
+	{
+	    parser->output->priv->rotation |= GSD_RR_REFLECT_X;
+	}
+    }
+    else if (stack_is (parser, "reflect_y", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	if (strcmp (text, "yes") == 0)
+	{
+	    parser->output->priv->rotation |= GSD_RR_REFLECT_Y;
+	}
+    }
+    else if (stack_is (parser, "primary", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	if (strcmp (text, "yes") == 0)
+	{
+	    parser->output->priv->primary = TRUE;
+	}
+    }
+    else
+    {
+	/* Ignore other properties so we can expand the format in the future */
+    }
+}
+
+static void
+parser_free (Parser *parser)
+{
+    int i;
+    GList *list;
+
+    g_assert (parser != NULL);
+
+    if (parser->output)
+	g_object_unref (parser->output);
+
+    if (parser->configuration)
+	g_object_unref (parser->configuration);
+
+    for (i = 0; i < parser->outputs->len; ++i)
+    {
+	GsdRROutputInfo *output = parser->outputs->pdata[i];
+
+	g_object_unref (output);
+    }
+
+    g_ptr_array_free (parser->outputs, TRUE);
+
+    for (i = 0; i < parser->configurations->len; ++i)
+    {
+	GsdRRConfig *config = parser->configurations->pdata[i];
+
+	g_object_unref (config);
+    }
+
+    g_ptr_array_free (parser->configurations, TRUE);
+
+    for (list = parser->stack->head; list; list = list->next)
+	g_free (list->data);
+    g_queue_free (parser->stack);
+    
+    g_free (parser);
+}
+
+static GsdRRConfig **
+configurations_read_from_file (const gchar *filename, GError **error)
+{
+    Parser *parser = g_new0 (Parser, 1);
+    GsdRRConfig **result;
+    GMarkupParser callbacks = {
+	handle_start_element,
+	handle_end_element,
+	handle_text,
+	NULL, /* passthrough */
+	NULL, /* error */
+    };
+
+    parser->config_file_version = 0;
+    parser->configurations = g_ptr_array_new ();
+    parser->outputs = g_ptr_array_new ();
+    parser->stack = g_queue_new ();
+    
+    if (!parse_file_gmarkup (filename, &callbacks, parser, error))
+    {
+	result = NULL;
+	
+	g_assert (parser->outputs);
+	goto out;
+    }
+
+    g_assert (parser->outputs);
+    
+    g_ptr_array_add (parser->configurations, NULL);
+    result = (GsdRRConfig **)g_ptr_array_free (parser->configurations, FALSE);
+    parser->configurations = g_ptr_array_new ();
+    
+    g_assert (parser->outputs);
+out:
+    parser_free (parser);
+
+    return result;
+}
+
+static void
+gsd_rr_config_init (GsdRRConfig *self)
+{
+    self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GSD_TYPE_RR_CONFIG, GsdRRConfigPrivate);
+
+    self->priv->clone = FALSE;
+    self->priv->screen = NULL;
+    self->priv->outputs = NULL;
+}
+
+static void
+gsd_rr_config_set_property (GObject *gobject, guint property_id, const GValue *value, GParamSpec *property)
+{
+    GsdRRConfig *self = GSD_RR_CONFIG (gobject);
+
+    switch (property_id) {
+	case PROP_SCREEN:
+	    self->priv->screen = g_value_dup_object (value);
+	    return;
+	default:
+	    G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, property_id, property);
+    }
+}
+
+static void
+gsd_rr_config_finalize (GObject *gobject)
+{
+    GsdRRConfig *self = GSD_RR_CONFIG (gobject);
+
+    if (self->priv->screen)
+	g_object_unref (self->priv->screen);
+
+    if (self->priv->outputs) {
+	int i;
+
+        for (i = 0; self->priv->outputs[i] != NULL; i++) {
+	    GsdRROutputInfo *output = self->priv->outputs[i];
+	    g_object_unref (output);
+	}
+	g_free (self->priv->outputs);
+    }
+
+    G_OBJECT_CLASS (gsd_rr_config_parent_class)->finalize (gobject);
+}
+
+gboolean
+gsd_rr_config_load_current (GsdRRConfig *config, GError **error)
+{
+    GPtrArray *a;
+    GsdRROutput **rr_outputs;
+    int i;
+    int clone_width = -1;
+    int clone_height = -1;
+    int last_x;
+
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (config), FALSE);
+
+    a = g_ptr_array_new ();
+    rr_outputs = gsd_rr_screen_list_outputs (config->priv->screen);
+
+    config->priv->clone = FALSE;
+    
+    for (i = 0; rr_outputs[i] != NULL; ++i)
+    {
+	GsdRROutput *rr_output = rr_outputs[i];
+	GsdRROutputInfo *output = g_object_new (GSD_TYPE_RR_OUTPUT_INFO, NULL);
+	GsdRRMode *mode = NULL;
+	const guint8 *edid_data = gsd_rr_output_get_edid_data (rr_output, NULL);
+	GsdRRCrtc *crtc;
+
+	output->priv->name = g_strdup (gsd_rr_output_get_name (rr_output));
+	output->priv->connected = gsd_rr_output_is_connected (rr_output);
+	output->priv->display_name = g_strdup (gsd_rr_output_get_display_name (rr_output));
+
+	if (!output->priv->connected)
+	{
+	    output->priv->x = -1;
+	    output->priv->y = -1;
+	    output->priv->width = -1;
+	    output->priv->height = -1;
+	    output->priv->rate = -1;
+	    output->priv->rotation = GSD_RR_ROTATION_0;
+	}
+	else
+	{
+	    MonitorInfo *info = NULL;
+
+	    if (edid_data)
+		info = decode_edid (edid_data);
+
+	    if (info)
+	    {
+		memcpy (output->priv->vendor, info->manufacturer_code,
+			sizeof (output->priv->vendor));
+		
+		output->priv->product = info->product_code;
+		output->priv->serial = info->serial_number;
+		output->priv->aspect = info->aspect_ratio;
+	    }
+	    else
+	    {
+		strcpy (output->priv->vendor, "???");
+		output->priv->product = 0;
+		output->priv->serial = 0;
+	    }
+	    g_free (info);
+		
+	    crtc = gsd_rr_output_get_crtc (rr_output);
+	    mode = crtc? gsd_rr_crtc_get_current_mode (crtc) : NULL;
+	    
+	    if (crtc && mode)
+	    {
+		output->priv->on = TRUE;
+		
+		gsd_rr_crtc_get_position (crtc, &output->priv->x, &output->priv->y);
+		output->priv->width = gsd_rr_mode_get_width (mode);
+		output->priv->height = gsd_rr_mode_get_height (mode);
+		output->priv->rate = gsd_rr_mode_get_freq (mode);
+		output->priv->rotation = gsd_rr_crtc_get_current_rotation (crtc);
+
+		if (output->priv->x == 0 && output->priv->y == 0) {
+			if (clone_width == -1) {
+				clone_width = output->priv->width;
+				clone_height = output->priv->height;
+			} else if (clone_width == output->priv->width &&
+				   clone_height == output->priv->height) {
+				config->priv->clone = TRUE;
+			}
+		}
+	    }
+	    else
+	    {
+		output->priv->on = FALSE;
+		config->priv->clone = FALSE;
+	    }
+
+	    /* Get preferred size for the monitor */
+	    mode = gsd_rr_output_get_preferred_mode (rr_output);
+	    
+	    if (!mode)
+	    {
+		GsdRRMode **modes = gsd_rr_output_list_modes (rr_output);
+		
+		/* FIXME: we should pick the "best" mode here, where best is
+		 * sorted wrt
+		 *
+		 * - closest aspect ratio
+		 * - mode area
+		 * - refresh rate
+		 * - We may want to extend randrwrap so that get_preferred
+		 *   returns that - although that could also depend on
+		 *   the crtc.
+		 */
+		if (modes[0])
+		    mode = modes[0];
+	    }
+	    
+	    if (mode)
+	    {
+		output->priv->pref_width = gsd_rr_mode_get_width (mode);
+		output->priv->pref_height = gsd_rr_mode_get_height (mode);
+	    }
+	    else
+	    {
+		/* Pick some random numbers. This should basically never happen */
+		output->priv->pref_width = 1024;
+		output->priv->pref_height = 768;
+	    }
+	}
+
+        output->priv->primary = gsd_rr_output_get_is_primary (rr_output);
+ 
+	g_ptr_array_add (a, output);
+    }
+
+    g_ptr_array_add (a, NULL);
+    
+    config->priv->outputs = (GsdRROutputInfo **)g_ptr_array_free (a, FALSE);
+
+    /* Walk the outputs computing the right-most edge of all
+     * lit-up displays
+     */
+    last_x = 0;
+    for (i = 0; config->priv->outputs[i] != NULL; ++i)
+    {
+	GsdRROutputInfo *output = config->priv->outputs[i];
+
+	if (output->priv->on)
+	{
+	    last_x = MAX (last_x, output->priv->x + output->priv->width);
+	}
+    }
+
+    /* Now position all off displays to the right of the
+     * on displays
+     */
+    for (i = 0; config->priv->outputs[i] != NULL; ++i)
+    {
+	GsdRROutputInfo *output = config->priv->outputs[i];
+
+	if (output->priv->connected && !output->priv->on)
+	{
+	    output->priv->x = last_x;
+	    last_x = output->priv->x + output->priv->width;
+	}
+    }
+    
+    g_assert (gsd_rr_config_match (config, config));
+
+    return TRUE;
+}
+
+gboolean
+gsd_rr_config_load_filename (GsdRRConfig *result, const char *filename, GError **error)
+{
+    GsdRRConfig *current;
+    GsdRRConfig **configs;
+    gboolean found = FALSE;
+
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (result), FALSE);
+    g_return_val_if_fail (filename != NULL, FALSE);
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+    current = gsd_rr_config_new_current (result->priv->screen, error);
+
+    configs = configurations_read_from_file (filename, error);
+
+    if (configs)
+    {
+	int i;
+
+	for (i = 0; configs[i] != NULL; ++i)
+	{
+	    if (gsd_rr_config_match (configs[i], current))
+	    {
+		int j;
+		GPtrArray *array;
+		result->priv->clone = configs[i]->priv->clone;
+
+		array = g_ptr_array_new ();
+		for (j = 0; configs[i]->priv->outputs[j] != NULL; j++) {
+                    g_object_ref (configs[i]->priv->outputs[j]);
+		    g_ptr_array_add (array, configs[i]->priv->outputs[j]);
+		}
+		g_ptr_array_add (array, NULL);
+		result->priv->outputs = (GsdRROutputInfo **) g_ptr_array_free (array, FALSE);
+
+		found = TRUE;
+		break;
+	    }
+	    g_object_unref (configs[i]);
+	}
+	g_free (configs);
+
+	if (!found)
+	    g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_NO_MATCHING_CONFIG,
+			 _("none of the saved display configurations matched the active configuration"));
+    }
+
+    g_object_unref (current);
+    return found;
+}
+
+static void
+gsd_rr_config_class_init (GsdRRConfigClass *klass)
+{
+    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+    g_type_class_add_private (klass, sizeof (GsdRROutputInfoPrivate));
+
+    gobject_class->set_property = gsd_rr_config_set_property;
+    gobject_class->finalize = gsd_rr_config_finalize;
+
+    g_object_class_install_property (gobject_class, PROP_SCREEN,
+				     g_param_spec_object ("screen", "Screen", "The GsdRRScreen this config applies to", GSD_TYPE_RR_SCREEN,
+							  G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
+}
+
+GsdRRConfig *
+gsd_rr_config_new_current (GsdRRScreen *screen, GError **error)
+{
+    GsdRRConfig *self = g_object_new (GSD_TYPE_RR_CONFIG, "screen", screen, NULL);
+
+    if (gsd_rr_config_load_current (self, error))
+      return self;
+    else
+      {
+	g_object_unref (self);
+	return NULL;
+      }
+}
+
+GsdRRConfig *
+gsd_rr_config_new_stored (GsdRRScreen *screen, GError **error)
+{
+    GsdRRConfig *self = g_object_new (GSD_TYPE_RR_CONFIG, "screen", screen, NULL);
+    char *filename;
+    gboolean success;
+
+    filename = gsd_rr_config_get_intended_filename ();
+
+    success = gsd_rr_config_load_filename (self, filename, error);
+
+    g_free (filename);
+
+    if (success)
+      return self;
+    else
+      {
+	g_object_unref (self);
+	return NULL;
+      }
+}
+
+static gboolean
+parse_file_gmarkup (const gchar          *filename,
+		    const GMarkupParser  *parser,
+		    gpointer             data,
+		    GError              **err)
+{
+    GMarkupParseContext *context = NULL;
+    gchar *contents = NULL;
+    gboolean result = TRUE;
+    gsize len;
+
+    if (!g_file_get_contents (filename, &contents, &len, err))
+    {
+	result = FALSE;
+	goto out;
+    }
+    
+    context = g_markup_parse_context_new (parser, 0, data, NULL);
+
+    if (!g_markup_parse_context_parse (context, contents, len, err))
+    {
+	result = FALSE;
+	goto out;
+    }
+
+    if (!g_markup_parse_context_end_parse (context, err))
+    {
+	result = FALSE;
+	goto out;
+    }
+
+out:
+    if (contents)
+	g_free (contents);
+
+    if (context)
+	g_markup_parse_context_free (context);
+
+    return result;
+}
+
+static gboolean
+output_match (GsdRROutputInfo *output1, GsdRROutputInfo *output2)
+{
+    g_assert (GSD_IS_RR_OUTPUT_INFO (output1));
+    g_assert (GSD_IS_RR_OUTPUT_INFO (output2));
+
+    if (strcmp (output1->priv->name, output2->priv->name) != 0)
+	return FALSE;
+
+    if (strcmp (output1->priv->vendor, output2->priv->vendor) != 0)
+	return FALSE;
+
+    if (output1->priv->product != output2->priv->product)
+	return FALSE;
+
+    if (output1->priv->serial != output2->priv->serial)
+	return FALSE;
+
+    if (output1->priv->connected != output2->priv->connected)
+	return FALSE;
+    
+    return TRUE;
+}
+
+static gboolean
+output_equal (GsdRROutputInfo *output1, GsdRROutputInfo *output2)
+{
+    g_assert (GSD_IS_RR_OUTPUT_INFO (output1));
+    g_assert (GSD_IS_RR_OUTPUT_INFO (output2));
+
+    if (!output_match (output1, output2))
+	return FALSE;
+
+    if (output1->priv->on != output2->priv->on)
+	return FALSE;
+
+    if (output1->priv->on)
+    {
+	if (output1->priv->width != output2->priv->width)
+	    return FALSE;
+	
+	if (output1->priv->height != output2->priv->height)
+	    return FALSE;
+	
+	if (output1->priv->rate != output2->priv->rate)
+	    return FALSE;
+	
+	if (output1->priv->x != output2->priv->x)
+	    return FALSE;
+	
+	if (output1->priv->y != output2->priv->y)
+	    return FALSE;
+	
+	if (output1->priv->rotation != output2->priv->rotation)
+	    return FALSE;
+    }
+
+    return TRUE;
+}
+
+static GsdRROutputInfo *
+find_output (GsdRRConfig *config, const char *name)
+{
+    int i;
+
+    for (i = 0; config->priv->outputs[i] != NULL; ++i)
+    {
+	GsdRROutputInfo *output = config->priv->outputs[i];
+	
+	if (strcmp (name, output->priv->name) == 0)
+	    return output;
+    }
+
+    return NULL;
+}
+
+/* Match means "these configurations apply to the same hardware
+ * setups"
+ */
+gboolean
+gsd_rr_config_match (GsdRRConfig *c1, GsdRRConfig *c2)
+{
+    int i;
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (c1), FALSE);
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (c2), FALSE);
+
+    for (i = 0; c1->priv->outputs[i] != NULL; ++i)
+    {
+	GsdRROutputInfo *output1 = c1->priv->outputs[i];
+	GsdRROutputInfo *output2;
+
+	output2 = find_output (c2, output1->priv->name);
+	if (!output2 || !output_match (output1, output2))
+	    return FALSE;
+    }
+    
+    return TRUE;
+}
+
+/* Equal means "the configurations will result in the same
+ * modes being set on the outputs"
+ */
+gboolean
+gsd_rr_config_equal (GsdRRConfig  *c1,
+		       GsdRRConfig  *c2)
+{
+    int i;
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (c1), FALSE);
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (c2), FALSE);
+
+    for (i = 0; c1->priv->outputs[i] != NULL; ++i)
+    {
+	GsdRROutputInfo *output1 = c1->priv->outputs[i];
+	GsdRROutputInfo *output2;
+
+	output2 = find_output (c2, output1->priv->name);
+	if (!output2 || !output_equal (output1, output2))
+	    return FALSE;
+    }
+    
+    return TRUE;
+}
+
+static GsdRROutputInfo **
+make_outputs (GsdRRConfig *config)
+{
+    GPtrArray *outputs;
+    GsdRROutputInfo *first_on;
+    int i;
+
+    outputs = g_ptr_array_new ();
+
+    first_on = NULL;
+    
+    for (i = 0; config->priv->outputs[i] != NULL; ++i)
+    {
+	GsdRROutputInfo *old = config->priv->outputs[i];
+	GsdRROutputInfo *new = g_object_new (GSD_TYPE_RR_OUTPUT_INFO, NULL);
+	*(new->priv) = *(old->priv);
+	if (old->priv->name)
+	    new->priv->name = g_strdup (old->priv->name);
+	if (old->priv->display_name)
+	    new->priv->display_name = g_strdup (old->priv->display_name);
+
+	if (old->priv->on && !first_on)
+	    first_on = old;
+	
+	if (config->priv->clone && new->priv->on)
+	{
+	    g_assert (first_on);
+
+	    new->priv->width = first_on->priv->width;
+	    new->priv->height = first_on->priv->height;
+	    new->priv->rotation = first_on->priv->rotation;
+	    new->priv->x = 0;
+	    new->priv->y = 0;
+	}
+
+	g_ptr_array_add (outputs, new);
+    }
+
+    g_ptr_array_add (outputs, NULL);
+
+    return (GsdRROutputInfo **)g_ptr_array_free (outputs, FALSE);
+}
+
+gboolean
+gsd_rr_config_applicable (GsdRRConfig  *configuration,
+			    GsdRRScreen  *screen,
+			    GError        **error)
+{
+    GsdRROutputInfo **outputs;
+    CrtcAssignment *assign;
+    gboolean result;
+    int i;
+
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (configuration), FALSE);
+    g_return_val_if_fail (GSD_IS_RR_SCREEN (screen), FALSE);
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+    outputs = make_outputs (configuration);
+    assign = crtc_assignment_new (screen, outputs, error);
+
+    if (assign)
+    {
+	result = TRUE;
+	crtc_assignment_free (assign);
+    }
+    else
+    {
+	result = FALSE;
+    }
+
+    for (i = 0; outputs[i] != NULL; i++) {
+	 g_object_unref (outputs[i]);
+    }
+
+    return result;
+}
+
+/* Database management */
+
+static void
+ensure_config_directory (void)
+{
+    g_mkdir_with_parents (g_get_user_config_dir (), 0700);
+}
+
+char *
+gsd_rr_config_get_backup_filename (void)
+{
+    ensure_config_directory ();
+    return g_build_filename (g_get_user_config_dir (), CONFIG_BACKUP_BASENAME, NULL);
+}
+
+char *
+gsd_rr_config_get_intended_filename (void)
+{
+    ensure_config_directory ();
+    return g_build_filename (g_get_user_config_dir (), CONFIG_INTENDED_BASENAME, NULL);
+}
+
+static const char *
+get_rotation_name (GsdRRRotation r)
+{
+    if (r & GSD_RR_ROTATION_0)
+	return "normal";
+    if (r & GSD_RR_ROTATION_90)
+	return "left";
+    if (r & GSD_RR_ROTATION_180)
+	return "upside_down";
+    if (r & GSD_RR_ROTATION_270)
+	return "right";
+
+    return "normal";
+}
+
+static const char *
+yes_no (int x)
+{
+    return x? "yes" : "no";
+}
+
+static const char *
+get_reflect_x (GsdRRRotation r)
+{
+    return yes_no (r & GSD_RR_REFLECT_X);
+}
+
+static const char *
+get_reflect_y (GsdRRRotation r)
+{
+    return yes_no (r & GSD_RR_REFLECT_Y);
+}
+
+static void
+emit_configuration (GsdRRConfig *config,
+		    GString *string)
+{
+    int j;
+
+    g_string_append_printf (string, "  <configuration>\n");
+
+    g_string_append_printf (string, "      <clone>%s</clone>\n", yes_no (config->priv->clone));
+    
+    for (j = 0; config->priv->outputs[j] != NULL; ++j)
+    {
+	GsdRROutputInfo *output = config->priv->outputs[j];
+	
+	g_string_append_printf (
+	    string, "      <output name=\"%s\">\n", output->priv->name);
+	
+	if (output->priv->connected && *output->priv->vendor != '\0')
+	{
+	    g_string_append_printf (
+		string, "          <vendor>%s</vendor>\n", output->priv->vendor);
+	    g_string_append_printf (
+		string, "          <product>0x%04x</product>\n", output->priv->product);
+	    g_string_append_printf (
+		string, "          <serial>0x%08x</serial>\n", output->priv->serial);
+	}
+	
+	/* An unconnected output which is on does not make sense */
+	if (output->priv->connected && output->priv->on)
+	{
+	    g_string_append_printf (
+		string, "          <width>%d</width>\n", output->priv->width);
+	    g_string_append_printf (
+		string, "          <height>%d</height>\n", output->priv->height);
+	    g_string_append_printf (
+		string, "          <rate>%d</rate>\n", output->priv->rate);
+	    g_string_append_printf (
+		string, "          <x>%d</x>\n", output->priv->x);
+	    g_string_append_printf (
+		string, "          <y>%d</y>\n", output->priv->y);
+	    g_string_append_printf (
+		string, "          <rotation>%s</rotation>\n", get_rotation_name (output->priv->rotation));
+	    g_string_append_printf (
+		string, "          <reflect_x>%s</reflect_x>\n", get_reflect_x (output->priv->rotation));
+	    g_string_append_printf (
+		string, "          <reflect_y>%s</reflect_y>\n", get_reflect_y (output->priv->rotation));
+            g_string_append_printf (
+                string, "          <primary>%s</primary>\n", yes_no (output->priv->primary));
+	}
+	
+	g_string_append_printf (string, "      </output>\n");
+    }
+    
+    g_string_append_printf (string, "  </configuration>\n");
+}
+
+void
+gsd_rr_config_sanitize (GsdRRConfig *config)
+{
+    int i;
+    int x_offset, y_offset;
+    gboolean found;
+
+    /* Offset everything by the top/left-most coordinate to
+     * make sure the configuration starts at (0, 0)
+     */
+    x_offset = y_offset = G_MAXINT;
+    for (i = 0; config->priv->outputs[i]; ++i)
+    {
+	GsdRROutputInfo *output = config->priv->outputs[i];
+
+	if (output->priv->on)
+	{
+	    x_offset = MIN (x_offset, output->priv->x);
+	    y_offset = MIN (y_offset, output->priv->y);
+	}
+    }
+
+    for (i = 0; config->priv->outputs[i]; ++i)
+    {
+	GsdRROutputInfo *output = config->priv->outputs[i];
+	
+	if (output->priv->on)
+	{
+	    output->priv->x -= x_offset;
+	    output->priv->y -= y_offset;
+	}
+    }
+
+    /* Only one primary, please */
+    found = FALSE;
+    for (i = 0; config->priv->outputs[i]; ++i)
+    {
+        if (config->priv->outputs[i]->priv->primary)
+        {
+            if (found)
+            {
+                config->priv->outputs[i]->priv->primary = FALSE;
+            }
+            else
+            {
+                found = TRUE;
+            }
+        }
+    }
+}
+
+gboolean
+gsd_rr_config_ensure_primary (GsdRRConfig *configuration)
+{
+        int i;
+        GsdRROutputInfo  *laptop;
+        GsdRROutputInfo  *top_left;
+        gboolean found;
+	GsdRRConfigPrivate *priv;
+
+	g_return_val_if_fail (GSD_IS_RR_CONFIG (configuration), FALSE);
+
+        laptop = NULL;
+        top_left = NULL;
+        found = FALSE;
+	priv = configuration->priv;
+
+        for (i = 0; priv->outputs[i] != NULL; ++i) {
+                GsdRROutputInfo *info = priv->outputs[i];
+
+                if (!info->priv->on) {
+                       info->priv->primary = FALSE;
+                       continue;
+                }
+
+                /* ensure only one */
+                if (info->priv->primary) {
+                        if (found) {
+                                info->priv->primary = FALSE;
+                        } else {
+                                found = TRUE;
+                        }
+                }
+
+                if (top_left == NULL
+                    || (info->priv->x < top_left->priv->x
+                        && info->priv->y < top_left->priv->y)) {
+                        top_left = info;
+                }
+                if (laptop == NULL
+                    && _gsd_rr_output_name_is_laptop (info->priv->name)) {
+                        /* shame we can't find the connector type
+                           as with gsd_rr_output_is_laptop */
+                        laptop = info;
+                }
+        }
+
+        if (!found) {
+                if (laptop != NULL) {
+                        laptop->priv->primary = TRUE;
+                } else if (top_left != NULL) {
+                        /* Note: top_left can be NULL if all outputs are off */
+                        top_left->priv->primary = TRUE;
+                }
+        }
+
+        return !found;
+}
+
+gboolean
+gsd_rr_config_save (GsdRRConfig *configuration, GError **error)
+{
+    GsdRRConfig **configurations;
+    GString *output;
+    int i;
+    gchar *intended_filename;
+    gchar *backup_filename;
+    gboolean result;
+
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (configuration), FALSE);
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+    output = g_string_new ("");
+
+    backup_filename = gsd_rr_config_get_backup_filename ();
+    intended_filename = gsd_rr_config_get_intended_filename ();
+
+    configurations = configurations_read_from_file (intended_filename, NULL); /* NULL-GError */
+    
+    g_string_append_printf (output, "<monitors version=\"1\">\n");
+
+    if (configurations)
+    {
+	for (i = 0; configurations[i] != NULL; ++i)
+	{
+	    if (!gsd_rr_config_match (configurations[i], configuration))
+		emit_configuration (configurations[i], output);
+	    g_object_unref (configurations[i]);
+	}
+
+	g_free (configurations);
+    }
+
+    emit_configuration (configuration, output);
+
+    g_string_append_printf (output, "</monitors>\n");
+
+    /* backup the file first */
+    rename (intended_filename, backup_filename); /* no error checking because the intended file may not even exist */
+
+    result = g_file_set_contents (intended_filename, output->str, -1, error);
+
+    if (!result)
+	rename (backup_filename, intended_filename); /* no error checking because the backup may not even exist */
+
+    g_free (backup_filename);
+    g_free (intended_filename);
+
+    return result;
+}
+
+gboolean
+gsd_rr_config_apply_with_time (GsdRRConfig *config,
+				 GsdRRScreen *screen,
+				 guint32        timestamp,
+				 GError       **error)
+{
+    CrtcAssignment *assignment;
+    GsdRROutputInfo **outputs;
+    gboolean result = FALSE;
+    int i;
+
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (config), FALSE);
+    g_return_val_if_fail (GSD_IS_RR_SCREEN (screen), FALSE);
+
+    outputs = make_outputs (config);
+
+    assignment = crtc_assignment_new (screen, outputs, error);
+
+    for (i = 0; outputs[i] != NULL; i++)
+	g_object_unref (outputs[i]);
+    g_free (outputs);
+    
+    if (assignment)
+    {
+	if (crtc_assignment_apply (assignment, timestamp, error))
+	    result = TRUE;
+
+	crtc_assignment_free (assignment);
+
+	gdk_flush ();
+    }
+
+    return result;
+}
+
+/* gsd_rr_config_apply_from_filename_with_time:
+ * @screen: A #GsdRRScreen
+ * @filename: Path of the file to look in for stored RANDR configurations.
+ * @timestamp: X server timestamp from the event that causes the screen configuration to change (a user's button press, for example)
+ * @error: Location to store error, or %NULL
+ *
+ * Loads the file in @filename and looks for suitable matching RANDR
+ * configurations in the file; if one is found, that configuration will be
+ * applied to the current set of RANDR outputs.
+ *
+ * Typically, @filename is the result of gsd_rr_config_get_intended_filename() or
+ * gsd_rr_config_get_backup_filename().
+ *
+ * Returns: TRUE if the RANDR configuration was loaded and applied from
+ * the specified file, or FALSE otherwise:
+ *
+ * If the file in question is loaded successfully but the configuration cannot
+ * be applied, the @error will have a domain of #GSD_RR_ERROR.  Note that an
+ * error code of #GSD_RR_ERROR_NO_MATCHING_CONFIG is not a real error; it
+ * simply means that there were no stored configurations that match the current
+ * set of RANDR outputs.
+ *
+ * If the file in question cannot be loaded, the @error will have a domain of
+ * #G_FILE_ERROR.  Note that an error code of G_FILE_ERROR_NOENT is not really
+ * an error, either; it means that there was no stored configuration file and so
+ * nothing is changed.
+ */
+gboolean
+gsd_rr_config_apply_from_filename_with_time (GsdRRScreen *screen, const char *filename, guint32 timestamp, GError **error)
+{
+    GsdRRConfig *stored;
+
+    g_return_val_if_fail (GSD_IS_RR_SCREEN (screen), FALSE);
+    g_return_val_if_fail (filename != NULL, FALSE);
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+    stored = g_object_new (GSD_TYPE_RR_CONFIG, "screen", screen, NULL);
+
+    if (gsd_rr_config_load_filename (stored, filename, error))
+    {
+	gboolean result;
+
+        gsd_rr_config_ensure_primary (stored);
+	result = gsd_rr_config_apply_with_time (stored, screen, timestamp, error);
+
+	g_object_unref (stored);
+	return result;
+    }
+    else
+    {
+	g_object_unref (stored);
+	return FALSE;
+    }
+}
+
+/**
+ * gsd_rr_config_get_outputs:
+ *
+ * Returns: (array zero-terminated=1) (element-type GnomeDesktop.RROutputInfo) (transfer none): the output configuration for this #GsdRRConfig
+ */
+GsdRROutputInfo **
+gsd_rr_config_get_outputs (GsdRRConfig *self)
+{
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (self), NULL);
+
+    return self->priv->outputs;
+}
+
+/**
+ * gsd_rr_config_get_clone:
+ *
+ * Returns: whether at least two outputs are at (0, 0) offset and they
+ * have the same width/height.  Those outputs are of course connected and on
+ * (i.e. they have a CRTC assigned).
+ */
+gboolean
+gsd_rr_config_get_clone (GsdRRConfig *self)
+{
+    g_return_val_if_fail (GSD_IS_RR_CONFIG (self), FALSE);
+
+    return self->priv->clone;
+}
+
+void
+gsd_rr_config_set_clone (GsdRRConfig *self, gboolean clone)
+{
+    g_return_if_fail (GSD_IS_RR_CONFIG (self));
+
+    self->priv->clone = clone;
+}
+
+/*
+ * CRTC assignment
+ */
+typedef struct CrtcInfo CrtcInfo;
+
+struct CrtcInfo
+{
+    GsdRRMode    *mode;
+    int        x;
+    int        y;
+    GsdRRRotation rotation;
+    GPtrArray *outputs;
+};
+
+struct CrtcAssignment
+{
+    GsdRRScreen *screen;
+    GHashTable *info;
+    GsdRROutput *primary;
+};
+
+static gboolean
+can_clone (CrtcInfo *info,
+	   GsdRROutput *output)
+{
+    int i;
+
+    for (i = 0; i < info->outputs->len; ++i)
+    {
+	GsdRROutput *clone = info->outputs->pdata[i];
+
+	if (!gsd_rr_output_can_clone (clone, output))
+	    return FALSE;
+    }
+
+    return TRUE;
+}
+
+static gboolean
+crtc_assignment_assign (CrtcAssignment   *assign,
+			GsdRRCrtc      *crtc,
+			GsdRRMode      *mode,
+			int               x,
+			int               y,
+			GsdRRRotation   rotation,
+                        gboolean          primary,
+			GsdRROutput    *output,
+			GError          **error)
+{
+    CrtcInfo *info = g_hash_table_lookup (assign->info, crtc);
+    guint32 crtc_id;
+    const char *output_name;
+
+    crtc_id = gsd_rr_crtc_get_id (crtc);
+    output_name = gsd_rr_output_get_name (output);
+
+    if (!gsd_rr_crtc_can_drive_output (crtc, output))
+    {
+	g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_CRTC_ASSIGNMENT,
+		     _("CRTC %d cannot drive output %s"), crtc_id, output_name);
+	return FALSE;
+    }
+
+    if (!gsd_rr_output_supports_mode (output, mode))
+    {
+	g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_CRTC_ASSIGNMENT,
+		     _("output %s does not support mode %dx%d@%dHz"),
+		     output_name,
+		     gsd_rr_mode_get_width (mode),
+		     gsd_rr_mode_get_height (mode),
+		     gsd_rr_mode_get_freq (mode));
+	return FALSE;
+    }
+
+    if (!gsd_rr_crtc_supports_rotation (crtc, rotation))
+    {
+	g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_CRTC_ASSIGNMENT,
+		     _("CRTC %d does not support rotation=%s"),
+		     crtc_id,
+		     get_rotation_name (rotation));
+	return FALSE;
+    }
+
+    if (info)
+    {
+	if (!(info->mode == mode	&&
+	      info->x == x		&&
+	      info->y == y		&&
+	      info->rotation == rotation))
+	{
+	    g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_CRTC_ASSIGNMENT,
+			 _("output %s does not have the same parameters as another cloned output:\n"
+			   "existing mode = %d, new mode = %d\n"
+			   "existing coordinates = (%d, %d), new coordinates = (%d, %d)\n"
+			   "existing rotation = %s, new rotation = %s"),
+			 output_name,
+			 gsd_rr_mode_get_id (info->mode), gsd_rr_mode_get_id (mode),
+			 info->x, info->y,
+			 x, y,
+			 get_rotation_name (info->rotation), get_rotation_name (rotation));
+	    return FALSE;
+	}
+
+	if (!can_clone (info, output))
+	{
+	    g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_CRTC_ASSIGNMENT,
+			 _("cannot clone to output %s"),
+			 output_name);
+	    return FALSE;
+	}
+
+	g_ptr_array_add (info->outputs, output);
+
+	if (primary && !assign->primary)
+	{
+	    assign->primary = output;
+	}
+
+	return TRUE;
+    }
+    else
+    {	
+	CrtcInfo *info = g_new0 (CrtcInfo, 1);
+	
+	info->mode = mode;
+	info->x = x;
+	info->y = y;
+	info->rotation = rotation;
+	info->outputs = g_ptr_array_new ();
+	
+	g_ptr_array_add (info->outputs, output);
+	
+	g_hash_table_insert (assign->info, crtc, info);
+	    
+        if (primary && !assign->primary)
+        {
+            assign->primary = output;
+        }
+
+	return TRUE;
+    }
+}
+
+static void
+crtc_assignment_unassign (CrtcAssignment *assign,
+			  GsdRRCrtc         *crtc,
+			  GsdRROutput       *output)
+{
+    CrtcInfo *info = g_hash_table_lookup (assign->info, crtc);
+
+    if (info)
+    {
+	g_ptr_array_remove (info->outputs, output);
+
+        if (assign->primary == output)
+        {
+            assign->primary = NULL;
+        }
+
+	if (info->outputs->len == 0)
+	    g_hash_table_remove (assign->info, crtc);
+    }
+}
+
+static void
+crtc_assignment_free (CrtcAssignment *assign)
+{
+    g_hash_table_destroy (assign->info);
+
+    g_free (assign);
+}
+
+typedef struct {
+    guint32 timestamp;
+    gboolean has_error;
+    GError **error;
+} ConfigureCrtcState;
+
+static void
+configure_crtc (gpointer key,
+		gpointer value,
+		gpointer data)
+{
+    GsdRRCrtc *crtc = key;
+    CrtcInfo *info = value;
+    ConfigureCrtcState *state = data;
+
+    if (state->has_error)
+	return;
+
+    if (!gsd_rr_crtc_set_config_with_time (crtc,
+					     state->timestamp,
+					     info->x, info->y,
+					     info->mode,
+					     info->rotation,
+					     (GsdRROutput **)info->outputs->pdata,
+					     info->outputs->len,
+					     state->error))
+	state->has_error = TRUE;
+}
+
+static gboolean
+mode_is_rotated (CrtcInfo *info)
+{
+    if ((info->rotation & GSD_RR_ROTATION_270)		||
+	(info->rotation & GSD_RR_ROTATION_90))
+    {
+	return TRUE;
+    }
+    return FALSE;
+}
+
+static gboolean
+crtc_is_rotated (GsdRRCrtc *crtc)
+{
+    GsdRRRotation r = gsd_rr_crtc_get_current_rotation (crtc);
+
+    if ((r & GSD_RR_ROTATION_270)		||
+	(r & GSD_RR_ROTATION_90))
+    {
+	return TRUE;
+    }
+
+    return FALSE;
+}
+
+static void
+accumulate_error (GString *accumulated_error, GError *error)
+{
+    g_string_append_printf (accumulated_error, "    %s\n", error->message);
+    g_error_free (error);
+}
+
+/* Check whether the given set of settings can be used
+ * at the same time -- ie. whether there is an assignment
+ * of CRTC's to outputs.
+ *
+ * Brute force - the number of objects involved is small
+ * enough that it doesn't matter.
+ */
+static gboolean
+real_assign_crtcs (GsdRRScreen *screen,
+		   GsdRROutputInfo **outputs,
+		   CrtcAssignment *assignment,
+		   GError **error)
+{
+    GsdRRCrtc **crtcs = gsd_rr_screen_list_crtcs (screen);
+    GsdRROutputInfo *output;
+    int i;
+    gboolean tried_mode;
+    GError *my_error;
+    GString *accumulated_error;
+    gboolean success;
+
+    output = *outputs;
+    if (!output)
+	return TRUE;
+
+    /* It is always allowed for an output to be turned off */
+    if (!output->priv->on)
+    {
+	return real_assign_crtcs (screen, outputs + 1, assignment, error);
+    }
+
+    success = FALSE;
+    tried_mode = FALSE;
+    accumulated_error = g_string_new (NULL);
+
+    for (i = 0; crtcs[i] != NULL; ++i)
+    {
+	GsdRRCrtc *crtc = crtcs[i];
+	int crtc_id = gsd_rr_crtc_get_id (crtc);
+	int pass;
+
+	g_string_append_printf (accumulated_error,
+				_("Trying modes for CRTC %d\n"),
+				crtc_id);
+
+	/* Make two passes, one where frequencies must match, then
+	 * one where they don't have to
+	 */
+	for (pass = 0; pass < 2; ++pass)
+	{
+	    GsdRROutput *gsd_rr_output = gsd_rr_screen_get_output_by_name (screen, output->priv->name);
+	    GsdRRMode **modes = gsd_rr_output_list_modes (gsd_rr_output);
+	    int j;
+
+	    for (j = 0; modes[j] != NULL; ++j)
+	    {
+		GsdRRMode *mode = modes[j];
+		int mode_width;
+		int mode_height;
+		int mode_freq;
+
+		mode_width = gsd_rr_mode_get_width (mode);
+		mode_height = gsd_rr_mode_get_height (mode);
+		mode_freq = gsd_rr_mode_get_freq (mode);
+
+		g_string_append_printf (accumulated_error,
+					_("CRTC %d: trying mode %dx%d@%dHz with output at %dx%d@%dHz (pass %d)\n"),
+					crtc_id,
+					mode_width, mode_height, mode_freq,
+					output->priv->width, output->priv->height, output->priv->rate,
+					pass);
+
+		if (mode_width == output->priv->width	&&
+		    mode_height == output->priv->height &&
+		    (pass == 1 || mode_freq == output->priv->rate))
+		{
+		    tried_mode = TRUE;
+
+		    my_error = NULL;
+		    if (crtc_assignment_assign (
+			    assignment, crtc, modes[j],
+			    output->priv->x, output->priv->y,
+			    output->priv->rotation,
+                            output->priv->primary,
+			    gsd_rr_output,
+			    &my_error))
+		    {
+			my_error = NULL;
+			if (real_assign_crtcs (screen, outputs + 1, assignment, &my_error)) {
+			    success = TRUE;
+			    goto out;
+			} else
+			    accumulate_error (accumulated_error, my_error);
+
+			crtc_assignment_unassign (assignment, crtc, gsd_rr_output);
+		    } else
+			accumulate_error (accumulated_error, my_error);
+		}
+	    }
+	}
+    }
+
+out:
+
+    if (success)
+	g_string_free (accumulated_error, TRUE);
+    else {
+	char *str;
+
+	str = g_string_free (accumulated_error, FALSE);
+
+	if (tried_mode)
+	    g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_CRTC_ASSIGNMENT,
+			 _("could not assign CRTCs to outputs:\n%s"),
+			 str);
+	else
+	    g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_CRTC_ASSIGNMENT,
+			 _("none of the selected modes were compatible with the possible modes:\n%s"),
+			 str);
+
+	g_free (str);
+    }
+
+    return success;
+}
+
+static void
+crtc_info_free (CrtcInfo *info)
+{
+    g_ptr_array_free (info->outputs, TRUE);
+    g_free (info);
+}
+
+static void
+get_required_virtual_size (CrtcAssignment *assign, int *width, int *height)
+{
+    GList *active_crtcs = g_hash_table_get_keys (assign->info);
+    GList *list;
+    int d;
+
+    if (!width)
+	width = &d;
+    if (!height)
+	height = &d;
+    
+    /* Compute size of the screen */
+    *width = *height = 1;
+    for (list = active_crtcs; list != NULL; list = list->next)
+    {
+	GsdRRCrtc *crtc = list->data;
+	CrtcInfo *info = g_hash_table_lookup (assign->info, crtc);
+	int w, h;
+
+	w = gsd_rr_mode_get_width (info->mode);
+	h = gsd_rr_mode_get_height (info->mode);
+	
+	if (mode_is_rotated (info))
+	{
+	    int tmp = h;
+	    h = w;
+	    w = tmp;
+	}
+	
+	*width = MAX (*width, info->x + w);
+	*height = MAX (*height, info->y + h);
+    }
+
+    g_list_free (active_crtcs);
+}
+
+static gboolean
+unity_running (void)
+{
+    const gchar *desktop_environment = g_getenv ("DESKTOP_SESSION");
+    
+    return !g_strcmp0 (desktop_environment, "ubuntu");
+}
+
+static gint _max_texture_size_cache = -1;
+
+static gint
+get_max_texture_size (GsdRRScreen *screen)
+{
+    if (_max_texture_size_cache != -1)
+    {
+	return _max_texture_size_cache;
+    } else {
+	/* 
+	 * Spawn a second process to check the GL texture limits
+	 * We do this across a process boundary to ensure that crashes
+	 * in the GL driver (which are unfortunately common) don't take
+	 * down the app.
+	 */
+	int pipe_fd[2];
+	pid_t canary_pid;
+
+	char * const canary_argv[] = { LIBEXECDIR "/check_gl_texture_size", NULL };
+	char *canary_env[2];
+	char display_env[80];
+	  
+	snprintf (display_env, sizeof (display_env), "DISPLAY=%s", DisplayString (screen->priv->xdisplay));
+	canary_env[0] = display_env;
+	canary_env[1] = NULL;
+
+
+	if (pipe (pipe_fd) == -1)
+	{
+	    _max_texture_size_cache = 0;
+	    return 0;
+	}
+	canary_pid = fork ();
+	if (canary_pid == -1)
+	{
+	    _max_texture_size_cache = 0;
+	    return 0;
+	}
+
+	if (canary_pid == 0)
+	{
+	  close (pipe_fd[0]);
+	  dup2 (pipe_fd[1], 1);
+	  close (pipe_fd[1]);
+	 
+	  execve (canary_argv[0], canary_argv, canary_env);
+	} else {
+	    char buffer[10];
+	    gint max_texture_size;
+	    int child_status;
+	    int num_char;
+	    struct timespec fifty_msec = {0, 50000000};
+	    int wait_count = 0;
+	    
+	    close (pipe_fd[1]);
+
+	    /* Empirical testing suggests this check takes < 150msec on my
+	     * crappy Atom netbook with slow rotating HDD.  A 500msec timeout
+	     * should be generous while not being *too* long if it triggers.
+	     *
+	     * Do a sleep/poll dance because we're a library and there's no
+	     * guarantee that waiting on SIGCHLD won't stomp over a client's
+	     * set up.
+	     */
+	    while (waitpid (canary_pid, &child_status, WNOHANG) == 0 && wait_count < 10) {
+		g_debug ("Waiting for GL_MAX_TEXTURE_SIZE helper...");
+	        nanosleep (&fifty_msec, NULL);
+		wait_count++;
+	    }
+
+	    if (WIFEXITED (child_status) && WEXITSTATUS (child_status) == EXIT_SUCCESS) 
+	    {
+	        if ((num_char = read (pipe_fd[0], buffer, sizeof(buffer) - 1)) <= 0) 
+		{
+		    g_warning ("Failed to read GL_MAX_TEXTURE_SIZE from helper.");
+		    max_texture_size = 0;
+		} else {
+		    buffer[num_char] = '\0';
+		    sscanf (buffer, "%u", &max_texture_size);
+		    /* 
+		     * Sanity check the numbers.  No hardware I know of has a
+		     * GL_MAX_TEXTURE_SIZE smaller than 1024.
+		     */
+		    if (max_texture_size < 1024)
+			max_texture_size = 0;
+		}
+	    } else {
+	        if (wait_count == 10) {
+		    g_warning ("Timed out waiting for GL_MAX_TEXTURE_SIZE helper");
+
+		    /* Ensure we don't leave processes sitting around.  Who knows what they're doing? */
+		    kill (canary_pid, SIGTERM);
+		    waitpid (canary_pid, &child_status, 0);
+	        } else {
+		    g_warning ("GL_MAX_TEXTURE_SIZE helper quit unexpectedly");
+		}
+		max_texture_size = 0;
+	    }
+
+	    close (pipe_fd[0]);
+	    g_debug ("Found GL_MAX_TEXTURE_SIZE of %u", max_texture_size);
+	    _max_texture_size_cache = max_texture_size;
+	    return _max_texture_size_cache;
+	}
+    }
+}
+
+static CrtcAssignment *
+crtc_assignment_new (GsdRRScreen *screen, GsdRROutputInfo **outputs, GError **error)
+{
+    CrtcAssignment *assignment = g_new0 (CrtcAssignment, 1);
+
+    assignment->info = g_hash_table_new_full (
+	g_direct_hash, g_direct_equal, NULL, (GFreeFunc)crtc_info_free);
+
+    if (real_assign_crtcs (screen, outputs, assignment, error))
+    {
+	int width, height;
+	int min_width, max_width, min_height, max_height;
+	int max_texture_size;
+
+	get_required_virtual_size (assignment, &width, &height);
+
+	gsd_rr_screen_get_ranges (
+	    screen, &min_width, &max_width, &min_height, &max_height);
+    
+	if (width < min_width || width > max_width ||
+	    height < min_height || height > max_height)
+	{
+	    g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_BOUNDS_ERROR,
+			 /* Translators: the "requested", "minimum", and
+			  * "maximum" words here are not keywords; please
+			  * translate them as usual. */
+			 _("required virtual size does not fit available size: "
+			   "requested=(%d, %d), minimum=(%d, %d), maximum=(%d, %d)"),
+			 width, height,
+			 min_width, min_height,
+			 max_width, max_height);
+	    goto fail;
+	}
+
+	/* Hack:
+         * This should either be solved by
+         * (a) Allowing the compositor to veto RandR changes
+         * (b) Fixing the compositor
+         * 
+         * Nethier of these are feasible at this point, so just fix Unity.
+         */
+
+	if (unity_running ())
+	{
+	    max_texture_size = get_max_texture_size (screen);
+	    if (max_texture_size > 0 && (width > max_texture_size || height > max_texture_size))
+	    {
+		g_set_error (error, GSD_RR_ERROR, GSD_RR_ERROR_BOUNDS_ERROR,
+			     _("Requested size (%d, %d) exceeds 3D hardware limit (%d, %d).\n"
+			       "You must either rearrange the displays so that they fit within a (%d, %d) square."),
+			     width, height, max_texture_size, max_texture_size,
+			     max_texture_size, max_texture_size);
+		goto fail;
+	    }
+	}
+	    
+	
+	assignment->screen = screen;
+	
+	return assignment;
+    }
+