Merge lp:~robert-ancell/unity-control-center/xrandr into lp:unity-control-center

[Robert Ancell]

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

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:12784
http://jenkins.qa.ubuntu.com/job/unity-control-center-ci/101/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-control-center-utopic-amd64-ci/3
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-control-center-utopic-armhf-ci/3
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-control-center-utopic-i386-ci/3

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-control-center-ci/101/rebuild

review: Approve (continuous-integration)

[Robert Ancell (robert-ancell)]

See lp:~robert-ancell/unity-settings-daemon/xrandr for associated u-s-d MP.

[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

[Robert Ancell (robert-ancell)]

This is obsolete and replaced by https://code.launchpad.net/~robert-ancell/unity-control-center/libusd/+merge/232676

Unmerged revisions

12784. By Robert Ancell on 2014-06-26

install check_gl_texture_size

12783. By Robert Ancell on 2014-06-25

Fix some renaming

12782. By Robert Ancell on 2014-06-25

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

=== modified file 'configure.ac'
--- configure.ac	2014-02-26 20:00:59 +0000
+++ configure.ac	2014-06-26 03:13:28 +0000
@@ -104,6 +104,8 @@
 CLUTTER_REQUIRED_VERSION=1.11.3
 GOA_REQUIRED_VERSION=3.5.90
 ACCOUNTSSERVICE_REQUIRED_VERSION=0.6.30
+XRANDR_REQUIRED=1.3
+XEXT_REQUIRED=1.1
 
 COMMON_MODULES="gtk+-3.0 >= $GTK_REQUIRED_VERSION
  glib-2.0 >= $GLIB_REQUIRED_VERSION
@@ -115,6 +117,8 @@
 
 PKG_CHECK_MODULES(LIBUNITY_CONTROL_CENTER, $COMMON_MODULES)
 PKG_CHECK_MODULES(LIBLANGUAGE, $COMMON_MODULES gnome-desktop-3.0 fontconfig)
+PKG_CHECK_MODULES(LIBRR, $COMMON_MODULES xrandr >= $XRANDR_REQUIRED xext >= $XEXT_REQUIRED)
+PKG_CHECK_MODULES(CHECK_GL_TEXTURE_SIZE, gl x11)
 PKG_CHECK_MODULES(LIBSHORTCUTS, $COMMON_MODULES x11)
 PKG_CHECK_MODULES(SHELL, $COMMON_MODULES libgnome-menu-3.0 gio-unix-2.0 x11)
 PKG_CHECK_MODULES(APPEARANCE_PANEL, $COMMON_MODULES libxml-2.0 gnome-desktop-3.0
 
=== modified file 'debian/unity-control-center.install'
--- debian/unity-control-center.install	2014-02-24 17:28:38 +0000
+++ debian/unity-control-center.install	2014-06-26 03:13:28 +0000
@@ -1,5 +1,6 @@
 etc/xdg/menus
 usr/bin
+usr/lib/unity-control-center
 usr/lib/*/unity-control-center-1/panels/*.so
 usr/share/applications
 usr/share/bash-completion
 
=== modified file 'panels/common/Makefile.am'
--- panels/common/Makefile.am	2013-11-29 06:28:37 +0000
+++ panels/common/Makefile.am	2014-06-26 03:13:28 +0000
@@ -1,14 +1,17 @@
 # This is used in PANEL_CFLAGS
 cappletname = common
 
-noinst_LTLIBRARIES = liblanguage.la
+noinst_LTLIBRARIES = liblanguage.la librr.la
 noinst_PROGRAMS = list-languages
+libexec_PROGRAMS = check_gl_texture_size
 
 AM_CPPFLAGS =						\
 	$(PANEL_CFLAGS)					\
 	$(LIBLANGUAGE_CFLAGS)				\
 	-DDATADIR=\""$(datadir)"\"			\
+	-DLIBEXECDIR=\""$(libexecdir)\""			\
 	-DUIDIR=\""$(pkgdatadir)/ui"\"			\
+	-DPNP_IDS=\""$(datadir)/hwdata/pnp.ids"\"			\
 	-DLIBLOCALEDIR=\""$(prefix)/lib/locale"\"       \
 	-DGNOMELOCALEDIR=\""$(datadir)/locale"\"        \
 	-DUM_PIXMAP_DIR=\""$(pkgdatadir)/pixmaps"\"
@@ -32,6 +35,31 @@
 list_languages_LDADD = liblanguage.la
 list_languages_CFLAGS = $(LIBLANGUAGE_CFLAGS)
 
+librr_la_SOURCES =		\
+	cc-pnp-ids.c \
+	cc-pnp-ids.h \
+	cc-rr.c \
+	cc-rr.h \
+	cc-rr-config.c \
+	cc-rr-config.h \
+	cc-rr-output-info.c \
+	cc-rr-private.h \
+	display-name.c \
+	edid-parse.c \
+	edid.h
+
+librr_la_LIBADD = 		\
+	$(PANEL_LIBS)			    \
+	$(LIBRR_LIBS)
+
+librr_la_LDFLAGS = $(PANEL_LDFLAGS)
+
+check_gl_texture_size_CPPFLAGS = \
+	$(CHECK_GL_TEXTURE_SIZE_CFLAGS)
+
+check_gl_texture_size_LDADD = \
+	$(CHECK_GL_TEXTURE_SIZE_LIBS)
+
 uidir = $(pkgdatadir)/ui
 
 dist_ui_DATA = \
 
=== added file 'panels/common/cc-pnp-ids.c'
--- panels/common/cc-pnp-ids.c	1970-01-01 00:00:00 +0000
+++ panels/common/cc-pnp-ids.c	2014-06-26 03:13:28 +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 <cc-pnp-ids.h>
+
+static void cc_pnp_ids_finalize (GObject *object);
+
+#define CC_PNP_IDS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CC_TYPE_PNP_IDS, CCPnpIdsPrivate))
+
+struct _CCPnpIdsPrivate
+{
+        gchar      *table_data;
+        GHashTable *pnp_table;
+};
+
+static gpointer cc_pnp_ids_object = NULL;
+
+G_DEFINE_TYPE (CCPnpIds, cc_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
+cc_pnp_ids_load (CCPnpIds *pnp_ids, GError **error)
+{
+        gchar *retval = NULL;
+        CCPnpIdsPrivate *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;
+}
+
+/**
+ * cc_pnp_ids_get_pnp_id:
+ * @pnp_ids: a #CCPnpIds 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 *
+cc_pnp_ids_get_pnp_id (CCPnpIds *pnp_ids, const gchar *pnp_id)
+{
+        CCPnpIdsPrivate *priv = pnp_ids->priv;
+        const char *found;
+        GError *error = NULL;
+        guint size;
+
+        g_return_val_if_fail (CC_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 (cc_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
+cc_pnp_ids_class_init (CCPnpIdsClass *klass)
+{
+        GObjectClass *object_class = G_OBJECT_CLASS (klass);
+        object_class->finalize = cc_pnp_ids_finalize;
+        g_type_class_add_private (klass, sizeof (CCPnpIdsPrivate));
+}
+
+static void
+cc_pnp_ids_init (CCPnpIds *pnp_ids)
+{
+        pnp_ids->priv = CC_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
+cc_pnp_ids_finalize (GObject *object)
+{
+        CCPnpIds *pnp_ids = CC_PNP_IDS (object);
+        CCPnpIdsPrivate *priv = pnp_ids->priv;
+
+        g_free (priv->table_data);
+        g_hash_table_unref (priv->pnp_table);
+
+        G_OBJECT_CLASS (cc_pnp_ids_parent_class)->finalize (object);
+}
+
+/**
+ * cc_pnp_ids_new:
+ *
+ * Returns a reference to a #CCPnpIds object, or creates
+ * a new one if none have been created.
+ *
+ * Returns: (transfer full): a #CCPnpIds object.
+ */
+CCPnpIds *
+cc_pnp_ids_new (void)
+{
+        if (cc_pnp_ids_object != NULL) {
+                g_object_ref (cc_pnp_ids_object);
+        } else {
+                cc_pnp_ids_object = g_object_new (CC_TYPE_PNP_IDS, NULL);
+                g_object_add_weak_pointer (cc_pnp_ids_object, &cc_pnp_ids_object);
+        }
+        return CC_PNP_IDS (cc_pnp_ids_object);
+}
+
 
=== added file 'panels/common/cc-pnp-ids.h'
--- panels/common/cc-pnp-ids.h	1970-01-01 00:00:00 +0000
+++ panels/common/cc-pnp-ids.h	2014-06-26 03:13:28 +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 __CC_PNP_IDS_H
+#define __CC_PNP_IDS_H
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define CC_TYPE_PNP_IDS                 (cc_pnp_ids_get_type ())
+#define CC_PNP_IDS(o)                   (G_TYPE_CHECK_INSTANCE_CAST ((o), CC_TYPE_PNP_IDS, CCPnpIds))
+#define CC_PNP_IDS_CLASS(k)             (G_TYPE_CHECK_CLASS_CAST((k), CC_TYPE_PNP_IDS, CCPnpIdsClass))
+#define CC_IS_PNP_IDS(o)                (G_TYPE_CHECK_INSTANCE_TYPE ((o), CC_TYPE_PNP_IDS))
+#define CC_IS_PNP_IDS_CLASS(k)          (G_TYPE_CHECK_CLASS_TYPE ((k), CC_TYPE_PNP_IDS))
+#define CC_PNP_IDS_GET_CLASS(o)         (G_TYPE_INSTANCE_GET_CLASS ((o), CC_TYPE_PNP_IDS, CCPnpIdsClass))
+#define CC_PNP_IDS_ERROR                (cc_pnp_ids_error_quark ())
+
+typedef struct _CCPnpIdsPrivate        CCPnpIdsPrivate;
+typedef struct _CCPnpIds               CCPnpIds;
+typedef struct _CCPnpIdsClass          CCPnpIdsClass;
+
+struct _CCPnpIds
+{
+         GObject          parent;
+         CCPnpIdsPrivate *priv;
+};
+
+struct _CCPnpIdsClass
+{
+        GObjectClass    parent_class;
+};
+
+GType         cc_pnp_ids_get_type                    (void);
+CCPnpIds     *cc_pnp_ids_new                         (void);
+gchar        *cc_pnp_ids_get_pnp_id                  (CCPnpIds   *pnp_ids,
+                                                     const gchar *pnp_id);
+
+G_END_DECLS
+
+#endif /* __CC_PNP_IDS_H */
+
 
=== added file 'panels/common/cc-rr-config.c'
--- panels/common/cc-rr-config.c	1970-01-01 00:00:00 +0000
+++ panels/common/cc-rr-config.c	2014-06-26 03:13:28 +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 "cc-rr-config.h"
+
+#include "edid.h"
+#include "cc-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   (CCRRScreen      *screen,
+					       CCRROutputInfo **outputs,
+					       GError            **error);
+static void             crtc_assignment_free  (CrtcAssignment   *assign);
+
+enum {
+  PROP_0,
+  PROP_SCREEN,
+  PROP_LAST
+};
+
+G_DEFINE_TYPE (CCRRConfig, cc_rr_config, G_TYPE_OBJECT)
+
+typedef struct Parser Parser;
+
+/* Parser for monitor configurations */
+struct Parser
+{
+    int			config_file_version;
+    CCRROutputInfo *	output;
+    CCRRConfig *	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 (CC_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 (CC_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 CC_RR_ROTATION_0 */
+	if (parser->output->priv->rotation == 0)
+	    parser->output->priv->rotation = CC_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 =
+	    (CCRROutputInfo **)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 |= CC_RR_ROTATION_0;
+	}
+	else if (strcmp (text, "left") == 0)
+	{
+	    parser->output->priv->rotation |= CC_RR_ROTATION_90;
+	}
+	else if (strcmp (text, "upside_down") == 0)
+	{
+	    parser->output->priv->rotation |= CC_RR_ROTATION_180;
+	}
+	else if (strcmp (text, "right") == 0)
+	{
+	    parser->output->priv->rotation |= CC_RR_ROTATION_270;
+	}
+    }
+    else if (stack_is (parser, "reflect_x", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	if (strcmp (text, "yes") == 0)
+	{
+	    parser->output->priv->rotation |= CC_RR_REFLECT_X;
+	}
+    }
+    else if (stack_is (parser, "reflect_y", "output", "configuration", TOPLEVEL_ELEMENT, NULL))
+    {
+	if (strcmp (text, "yes") == 0)
+	{
+	    parser->output->priv->rotation |= CC_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)
+    {
+	CCRROutputInfo *output = parser->outputs->pdata[i];
+
+	g_object_unref (output);
+    }
+
+    g_ptr_array_free (parser->outputs, TRUE);
+
+    for (i = 0; i < parser->configurations->len; ++i)
+    {
+	CCRRConfig *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 CCRRConfig **
+configurations_read_from_file (const gchar *filename, GError **error)
+{
+    Parser *parser = g_new0 (Parser, 1);
+    CCRRConfig **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 = (CCRRConfig **)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
+cc_rr_config_init (CCRRConfig *self)
+{
+    self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CC_TYPE_RR_CONFIG, CCRRConfigPrivate);
+
+    self->priv->clone = FALSE;
+    self->priv->screen = NULL;
+    self->priv->outputs = NULL;
+}
+
+static void
+cc_rr_config_set_property (GObject *gobject, guint property_id, const GValue *value, GParamSpec *property)
+{
+    CCRRConfig *self = CC_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
+cc_rr_config_finalize (GObject *gobject)
+{
+    CCRRConfig *self = CC_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++) {
+	    CCRROutputInfo *output = self->priv->outputs[i];
+	    g_object_unref (output);
+	}
+	g_free (self->priv->outputs);
+    }
+
+    G_OBJECT_CLASS (cc_rr_config_parent_class)->finalize (gobject);
+}
+
+gboolean
+cc_rr_config_load_current (CCRRConfig *config, GError **error)
+{
+    GPtrArray *a;
+    CCRROutput **rr_outputs;
+    int i;
+    int clone_width = -1;
+    int clone_height = -1;
+    int last_x;
+
+    g_return_val_if_fail (CC_IS_RR_CONFIG (config), FALSE);
+
+    a = g_ptr_array_new ();
+    rr_outputs = cc_rr_screen_list_outputs (config->priv->screen);
+
+    config->priv->clone = FALSE;
+    
+    for (i = 0; rr_outputs[i] != NULL; ++i)
+    {
+	CCRROutput *rr_output = rr_outputs[i];
+	CCRROutputInfo *output = g_object_new (CC_TYPE_RR_OUTPUT_INFO, NULL);
+	CCRRMode *mode = NULL;
+	const guint8 *edid_data = cc_rr_output_get_edid_data (rr_output, NULL);
+	CCRRCrtc *crtc;
+
+	output->priv->name = g_strdup (cc_rr_output_get_name (rr_output));
+	output->priv->connected = cc_rr_output_is_connected (rr_output);
+	output->priv->display_name = g_strdup (cc_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 = CC_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 = cc_rr_output_get_crtc (rr_output);
+	    mode = crtc? cc_rr_crtc_get_current_mode (crtc) : NULL;
+	    
+	    if (crtc && mode)
+	    {
+		output->priv->on = TRUE;
+		
+		cc_rr_crtc_get_position (crtc, &output->priv->x, &output->priv->y);
+		output->priv->width = cc_rr_mode_get_width (mode);
+		output->priv->height = cc_rr_mode_get_height (mode);
+		output->priv->rate = cc_rr_mode_get_freq (mode);
+		output->priv->rotation = cc_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 = cc_rr_output_get_preferred_mode (rr_output);
+	    
+	    if (!mode)
+	    {
+		CCRRMode **modes = cc_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 = cc_rr_mode_get_width (mode);
+		output->priv->pref_height = cc_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 = cc_rr_output_get_is_primary (rr_output);
+ 
+	g_ptr_array_add (a, output);
+    }
+
+    g_ptr_array_add (a, NULL);
+    
+    config->priv->outputs = (CCRROutputInfo **)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)
+    {
+	CCRROutputInfo *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)
+    {
+	CCRROutputInfo *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 (cc_rr_config_match (config, config));
+
+    return TRUE;
+}
+
+gboolean
+cc_rr_config_load_filename (CCRRConfig *result, const char *filename, GError **error)
+{
+    CCRRConfig *current;
+    CCRRConfig **configs;
+    gboolean found = FALSE;
+
+    g_return_val_if_fail (CC_IS_RR_CONFIG (result), FALSE);
+    g_return_val_if_fail (filename != NULL, FALSE);
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+    current = cc_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 (cc_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 = (CCRROutputInfo **) g_ptr_array_free (array, FALSE);
+
+		found = TRUE;
+		break;
+	    }
+	    g_object_unref (configs[i]);
+	}
+	g_free (configs);
+
+	if (!found)
+	    g_set_error (error, CC_RR_ERROR, CC_RR_ERROR_NO_MATCHING_CONFIG,
+			 _("none of the saved display configurations matched the active configuration"));
+    }
+
+    g_object_unref (current);
+    return found;
+}
+
+static void
+cc_rr_config_class_init (CCRRConfigClass *klass)
+{
+    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+    g_type_class_add_private (klass, sizeof (CCRROutputInfoPrivate));
+
+    gobject_class->set_property = cc_rr_config_set_property;
+    gobject_class->finalize = cc_rr_config_finalize;
+
+    g_object_class_install_property (gobject_class, PROP_SCREEN,
+				     g_param_spec_object ("screen", "Screen", "The CCRRScreen this config applies to", CC_TYPE_RR_SCREEN,
+							  G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
+}
+
+CCRRConfig *
+cc_rr_config_new_current (CCRRScreen *screen, GError **error)
+{
+    CCRRConfig *self = g_object_new (CC_TYPE_RR_CONFIG, "screen", screen, NULL);
+
+    if (cc_rr_config_load_current (self, error))
+      return self;
+    else
+      {
+	g_object_unref (self);
+	return NULL;
+      }
+}
+
+CCRRConfig *
+cc_rr_config_new_stored (CCRRScreen *screen, GError **error)
+{
+    CCRRConfig *self = g_object_new (CC_TYPE_RR_CONFIG, "screen", screen, NULL);
+    char *filename;
+    gboolean success;
+
+    filename = cc_rr_config_get_intended_filename ();
+
+    success = cc_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 (CCRROutputInfo *output1, CCRROutputInfo *output2)
+{
+    g_assert (CC_IS_RR_OUTPUT_INFO (output1));
+    g_assert (CC_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 (CCRROutputInfo *output1, CCRROutputInfo *output2)
+{
+    g_assert (CC_IS_RR_OUTPUT_INFO (output1));
+    g_assert (CC_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 CCRROutputInfo *
+find_output (CCRRConfig *config, const char *name)
+{
+    int i;
+
+    for (i = 0; config->priv->outputs[i] != NULL; ++i)
+    {
+	CCRROutputInfo *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
+cc_rr_config_match (CCRRConfig *c1, CCRRConfig *c2)
+{
+    int i;
+    g_return_val_if_fail (CC_IS_RR_CONFIG (c1), FALSE);
+    g_return_val_if_fail (CC_IS_RR_CONFIG (c2), FALSE);
+
+    for (i = 0; c1->priv->outputs[i] != NULL; ++i)
+    {
+	CCRROutputInfo *output1 = c1->priv->outputs[i];
+	CCRROutputInfo *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
+cc_rr_config_equal (CCRRConfig  *c1,
+		       CCRRConfig  *c2)
+{
+    int i;
+    g_return_val_if_fail (CC_IS_RR_CONFIG (c1), FALSE);
+    g_return_val_if_fail (CC_IS_RR_CONFIG (c2), FALSE);
+
+    for (i = 0; c1->priv->outputs[i] != NULL; ++i)
+    {
+	CCRROutputInfo *output1 = c1->priv->outputs[i];
+	CCRROutputInfo *output2;
+
+	output2 = find_output (c2, output1->priv->name);
+	if (!output2 || !output_equal (output1, output2))
+	    return FALSE;
+    }
+    
+    return TRUE;
+}
+
+static CCRROutputInfo **
+make_outputs (CCRRConfig *config)
+{
+    GPtrArray *outputs;
+    CCRROutputInfo *first_on;
+    int i;
+
+    outputs = g_ptr_array_new ();
+
+    first_on = NULL;
+    
+    for (i = 0; config->priv->outputs[i] != NULL; ++i)
+    {
+	CCRROutputInfo *old = config->priv->outputs[i];
+	CCRROutputInfo *new = g_object_new (CC_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 (CCRROutputInfo **)g_ptr_array_free (outputs, FALSE);
+}
+
+gboolean
+cc_rr_config_applicable (CCRRConfig  *configuration,
+			    CCRRScreen  *screen,
+			    GError        **error)
+{
+    CCRROutputInfo **outputs;
+    CrtcAssignment *assign;
+    gboolean result;
+    int i;
+
+    g_return_val_if_fail (CC_IS_RR_CONFIG (configuration), FALSE);
+    g_return_val_if_fail (CC_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 *
+cc_rr_config_get_backup_filename (void)
+{
+    ensure_config_directory ();
+    return g_build_filename (g_get_user_config_dir (), CONFIG_BACKUP_BASENAME, NULL);
+}
+
+char *
+cc_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 (CCRRRotation r)
+{
+    if (r & CC_RR_ROTATION_0)
+	return "normal";
+    if (r & CC_RR_ROTATION_90)
+	return "left";
+    if (r & CC_RR_ROTATION_180)
+	return "upside_down";
+    if (r & CC_RR_ROTATION_270)
+	return "right";
+
+    return "normal";
+}
+
+static const char *
+yes_no (int x)
+{
+    return x? "yes" : "no";
+}
+
+static const char *
+get_reflect_x (CCRRRotation r)
+{
+    return yes_no (r & CC_RR_REFLECT_X);
+}
+
+static const char *
+get_reflect_y (CCRRRotation r)
+{
+    return yes_no (r & CC_RR_REFLECT_Y);
+}
+
+static void
+emit_configuration (CCRRConfig *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)
+    {
+	CCRROutputInfo *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
+cc_rr_config_sanitize (CCRRConfig *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)
+    {
+	CCRROutputInfo *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)
+    {
+	CCRROutputInfo *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
+cc_rr_config_ensure_primary (CCRRConfig *configuration)
+{
+        int i;
+        CCRROutputInfo  *laptop;
+        CCRROutputInfo  *top_left;
+        gboolean found;
+	CCRRConfigPrivate *priv;
+
+	g_return_val_if_fail (CC_IS_RR_CONFIG (configuration), FALSE);
+
+        laptop = NULL;
+        top_left = NULL;
+        found = FALSE;
+	priv = configuration->priv;
+
+        for (i = 0; priv->outputs[i] != NULL; ++i) {
+                CCRROutputInfo *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
+                    && _cc_rr_output_name_is_laptop (info->priv->name)) {
+                        /* shame we can't find the connector type
+                           as with cc_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
+cc_rr_config_save (CCRRConfig *configuration, GError **error)
+{
+    CCRRConfig **configurations;
+    GString *output;
+    int i;
+    gchar *intended_filename;
+    gchar *backup_filename;
+    gboolean result;
+
+    g_return_val_if_fail (CC_IS_RR_CONFIG (configuration), FALSE);
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+    output = g_string_new ("");
+
+    backup_filename = cc_rr_config_get_backup_filename ();
+    intended_filename = cc_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 (!cc_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
+cc_rr_config_apply_with_time (CCRRConfig *config,
+				 CCRRScreen *screen,
+				 guint32        timestamp,
+				 GError       **error)
+{
+    CrtcAssignment *assignment;
+    CCRROutputInfo **outputs;
+    gboolean result = FALSE;
+    int i;
+
+    g_return_val_if_fail (CC_IS_RR_CONFIG (config), FALSE);
+    g_return_val_if_fail (CC_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;
+}
+
+/* cc_rr_config_apply_from_filename_with_time:
+ * @screen: A #CCRRScreen
+ * @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 cc_rr_config_get_intended_filename() or
+ * cc_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 #CC_RR_ERROR.  Note that an
+ * error code of #CC_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
+cc_rr_config_apply_from_filename_with_time (CCRRScreen *screen, const char *filename, guint32 timestamp, GError **error)
+{
+    CCRRConfig *stored;
+
+    g_return_val_if_fail (CC_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 (CC_TYPE_RR_CONFIG, "screen", screen, NULL);
+
+    if (cc_rr_config_load_filename (stored, filename, error))
+    {
+	gboolean result;
+
+        cc_rr_config_ensure_primary (stored);
+	result = cc_rr_config_apply_with_time (stored, screen, timestamp, error);
+
+	g_object_unref (stored);
+	return result;
+    }
+    else
+    {
+	g_object_unref (stored);
+	return FALSE;
+    }
+}
+
+/**
+ * cc_rr_config_get_outputs:
+ *
+ * Returns: (array zero-terminated=1) (element-type GnomeDesktop.RROutputInfo) (transfer none): the output configuration for this #CCRRConfig
+ */
+CCRROutputInfo **
+cc_rr_config_get_outputs (CCRRConfig *self)
+{
+    g_return_val_if_fail (CC_IS_RR_CONFIG (self), NULL);
+
+    return self->priv->outputs;
+}
+
+/**
+ * cc_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
+cc_rr_config_get_clone (CCRRConfig *self)
+{
+    g_return_val_if_fail (CC_IS_RR_CONFIG (self), FALSE);
+
+    return self->priv->clone;
+}
+
+void
+cc_rr_config_set_clone (CCRRConfig *self, gboolean clone)
+{
+    g_return_if_fail (CC_IS_RR_CONFIG (self));
+
+    self->priv->clone = clone;
+}
+
+/*
+ * CRTC assignment
+ */
+typedef struct CrtcInfo CrtcInfo;
+
+struct CrtcInfo
+{
+    CCRRMode    *mode;
+    int        x;
+    int        y;
+    CCRRRotation rotation;
+    GPtrArray *outputs;
+};
+
+struct CrtcAssignment
+{
+    CCRRScreen *screen;
+    GHashTable *info;
+    CCRROutput *primary;
+};
+
+static gboolean
+can_clone (CrtcInfo *info,
+	   CCRROutput *output)
+{
+    int i;
+
+    for (i = 0; i < info->outputs->len; ++i)
+    {
+	CCRROutput *clone = info->outputs->pdata[i];
+
+	if (!cc_rr_output_can_clone (clone, output))
+	    return FALSE;
+    }
+
+    return TRUE;
+}
+
+static gboolean
+crtc_assignment_assign (CrtcAssignment   *assign,
+			CCRRCrtc      *crtc,
+			CCRRMode      *mode,
+			int               x,
+			int               y,
+			CCRRRotation   rotation,
+                        gboolean          primary,
+			CCRROutput    *output,
+			GError          **error)
+{
+    CrtcInfo *info = g_hash_table_lookup (assign->info, crtc);
+    guint32 crtc_id;
+    const char *output_name;
+
+    crtc_id = cc_rr_crtc_get_id (crtc);
+    output_name = cc_rr_output_get_name (output);
+
+    if (!cc_rr_crtc_can_drive_output (crtc, output))
+    {
+	g_set_error (error, CC_RR_ERROR, CC_RR_ERROR_CRTC_ASSIGNMENT,
+		     _("CRTC %d cannot drive output %s"), crtc_id, output_name);
+	return FALSE;
+    }
+
+    if (!cc_rr_output_supports_mode (output, mode))
+    {
+	g_set_error (error, CC_RR_ERROR, CC_RR_ERROR_CRTC_ASSIGNMENT,
+		     _("output %s does not support mode %dx%d@%dHz"),
+		     output_name,
+		     cc_rr_mode_get_width (mode),
+		     cc_rr_mode_get_height (mode),
+		     cc_rr_mode_get_freq (mode));
+	return FALSE;
+    }
+
+    if (!cc_rr_crtc_supports_rotation (crtc, rotation))
+    {
+	g_set_error (error, CC_RR_ERROR, CC_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, CC_RR_ERROR, CC_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,
+			 cc_rr_mode_get_id (info->mode), cc_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, CC_RR_ERROR, CC_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,
+			  CCRRCrtc         *crtc,
+			  CCRROutput       *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)
+{
+    CCRRCrtc *crtc = key;
+    CrtcInfo *info = value;
+    ConfigureCrtcState *state = data;
+
+    if (state->has_error)
+	return;
+
+    if (!cc_rr_crtc_set_config_with_time (crtc,
+					     state->timestamp,
+					     info->x, info->y,
+					     info->mode,
+					     info->rotation,
+					     (CCRROutput **)info->outputs->pdata,
+					     info->outputs->len,
+					     state->error))
+	state->has_error = TRUE;
+}
+
+static gboolean
+mode_is_rotated (CrtcInfo *info)
+{
+    if ((info->rotation & CC_RR_ROTATION_270)		||
+	(info->rotation & CC_RR_ROTATION_90))
+    {
+	return TRUE;
+    }
+    return FALSE;
+}
+
+static gboolean
+crtc_is_rotated (CCRRCrtc *crtc)
+{
+    CCRRRotation r = cc_rr_crtc_get_current_rotation (crtc);
+
+    if ((r & CC_RR_ROTATION_270)		||
+	(r & CC_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 (CCRRScreen *screen,
+		   CCRROutputInfo **outputs,
+		   CrtcAssignment *assignment,
+		   GError **error)
+{
+    CCRRCrtc **crtcs = cc_rr_screen_list_crtcs (screen);
+    CCRROutputInfo *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)
+    {
+	CCRRCrtc *crtc = crtcs[i];
+	int crtc_id = cc_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)
+	{
+	    CCRROutput *cc_rr_output = cc_rr_screen_get_output_by_name (screen, output->priv->name);
+	    CCRRMode **modes = cc_rr_output_list_modes (cc_rr_output);
+	    int j;
+
+	    for (j = 0; modes[j] != NULL; ++j)
+	    {
+		CCRRMode *mode = modes[j];
+		int mode_width;
+		int mode_height;
+		int mode_freq;
+
+		mode_width = cc_rr_mode_get_width (mode);
+		mode_height = cc_rr_mode_get_height (mode);
+		mode_freq = cc_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,
+			    cc_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, cc_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, CC_RR_ERROR, CC_RR_ERROR_CRTC_ASSIGNMENT,
+			 _("could not assign CRTCs to outputs:\n%s"),
+			 str);
+	else
+	    g_set_error (error, CC_RR_ERROR, CC_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)
+    {
+	CCRRCrtc *crtc = list->data;
+	CrtcInfo *info = g_hash_table_lookup (assign->info, crtc);
+	int w, h;
+
+	w = cc_rr_mode_get_width (info->mode);
+	h = cc_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 (CCRRScreen *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 (CCRRScreen *screen, CCRROutputInfo **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);
+
+	cc_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, CC_RR_ERROR, CC_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, CC_RR_ERROR, CC_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;
+    }
+
+fail:
+    crtc_assignment_free (assignment);
+    
+    return NULL;
+}
+
+static gboolean
+crtc_assignment_apply (CrtcAssignment *assign, guint32 timestamp, GError **error)
+{
+    CCRRCrtc **all_crtcs = cc_rr_screen_list_crtcs (assign->screen);
+    int width, height;
+    int i;
+    int min_width, max_width, min_height, max_height;
+    int width_mm, height_mm;
+    gboolean success = TRUE;
+
+    /* Compute size of the screen */
+    get_required_virtual_size (assign, &width, &height);
+
+    cc_rr_screen_get_ranges (
+	assign->screen, &min_width, &max_width, &min_height, &max_height);
+
+    /* We should never get here if the dimensions don't fit in the virtual size,
+     * but just in case we do, fix it up.
+     */
+    width = MAX (min_width, width);
+    width = MIN (max_width, width);
+    height = MAX (min_height, height);
+    height = MIN (max_height, height);
+
+    /* FMQ: do we need to check the sizes instead of clamping them? */
+
+    /* Grab the server while we fiddle with the CRTCs and the screen, so that
+     * apps that listen for RANDR notifications will only receive the final
+     * status.
+     */
+
+    gdk_x11_display_grab (gdk_screen_get_display (assign->screen->priv->gdk_screen));
+
+    /* Turn off all crtcs that are currently displaying outside the new screen,
+     * or are not used in the new setup
+     */
+    for (i = 0; all_crtcs[i] != NULL; ++i)
+    {
+	CCRRCrtc *crtc = all_crtcs[i];
+	CCRRMode *mode = cc_rr_crtc_get_current_mode (crtc);
+	int x, y;
+
+	if (mode)
+	{
+	    int w, h;
+	    cc_rr_crtc_get_position (crtc, &x, &y);
+
+	    w = cc_rr_mode_get_width (mode);
+	    h = cc_rr_mode_get_height (mode);
+
+	    if (crtc_is_rotated (crtc))
+	    {
+		int tmp = h;
+		h = w;
+		w = tmp;
+	    }
+	    
+	    if (x + w > width || y + h > height || !g_hash_table_lookup (assign->info, crtc))
+	    {
+		if (!cc_rr_crtc_set_config_with_time (crtc, timestamp, 0, 0, NULL, CC_RR_ROTATION_0, NULL, 0, error))
+		{
+		    success = FALSE;
+		    break;
+		}
+		
+	    }
+	}
+    }
+
+    /* The 'physical size' of an X screen is meaningless if that screen
+     * can consist of many monitors. So just pick a size that make the
+     * dpi 96.
+     *
+     * Firefox and Evince apparently believe what X tells them.
+     */
+    width_mm = (width / DPI_FALLBACK) * 25.4 + 0.5;
+    height_mm = (height / DPI_FALLBACK) * 25.4 + 0.5;
+
+    if (success)
+    {
+	ConfigureCrtcState state;
+
+	cc_rr_screen_set_size (assign->screen, width, height, width_mm, height_mm);
+
+	state.timestamp = timestamp;
+	state.has_error = FALSE;
+	state.error = error;
+	
+	g_hash_table_foreach (assign->info, configure_crtc, &state);
+
+	success = !state.has_error;
+    }
+
+    cc_rr_screen_set_primary_output (assign->screen, assign->primary);
+
+    gdk_x11_display_ungrab (gdk_screen_get_display (assign->screen->priv->gdk_screen));
+
+    return success;
+}
 
=== added file 'panels/common/cc-rr-config.h'
--- panels/common/cc-rr-config.h	1970-01-01 00:00:00 +0000
+++ panels/common/cc-rr-config.h	2014-06-26 03:13:28 +0000
@@ -0,0 +1,151 @@
+/* gnome-rr-config.h
+ * -*- 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]>
+ */
+#ifndef CC_RR_CONFIG_H
+#define CC_RR_CONFIG_H
+
+#include <glib.h>
+#include <glib-object.h>
+#include "cc-rr.h"
+
+typedef struct _CCRROutputInfo CCRROutputInfo;
+typedef struct _CCRROutputInfoClass CCRROutputInfoClass;
+typedef struct _CCRROutputInfoPrivate CCRROutputInfoPrivate;
+
+struct _CCRROutputInfo
+{
+    GObject parent;
+
+    /*< private >*/
+    CCRROutputInfoPrivate *priv;
+};
+
+struct _CCRROutputInfoClass
+{
+    GObjectClass parent_class;
+};
+
+#define CC_TYPE_RR_OUTPUT_INFO                  (cc_rr_output_info_get_type())
+#define CC_RR_OUTPUT_INFO(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), CC_TYPE_RR_OUTPUT_INFO, CCRROutputInfo))
+#define CC_IS_RR_OUTPUT_INFO(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CC_TYPE_RR_OUTPUT_INFO))
+#define CC_RR_OUTPUT_INFO_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), CC_TYPE_RR_OUTPUT_INFO, CCRROutputInfoClass))
+#define CC_IS_RR_OUTPUT_INFO_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), CC_TYPE_RR_OUTPUT_INFO))
+#define CC_RR_OUTPUT_INFO_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), CC_TYPE_RR_OUTPUT_INFO, CCRROutputInfoClass))
+
+GType cc_rr_output_info_get_type (void);
+
+char *cc_rr_output_info_get_name (CCRROutputInfo *self);
+
+gboolean cc_rr_output_info_is_active  (CCRROutputInfo *self);
+void     cc_rr_output_info_set_active (CCRROutputInfo *self, gboolean active);
+
+void cc_rr_output_info_get_geometry (CCRROutputInfo *self, int *x, int *y, int *width, int *height);
+void cc_rr_output_info_set_geometry (CCRROutputInfo *self, int  x, int  y, int  width, int  height);
+
+int  cc_rr_output_info_get_refresh_rate (CCRROutputInfo *self);
+void cc_rr_output_info_set_refresh_rate (CCRROutputInfo *self, int rate);
+
+CCRRRotation cc_rr_output_info_get_rotation (CCRROutputInfo *self);
+void            cc_rr_output_info_set_rotation (CCRROutputInfo *self, CCRRRotation rotation);
+
+gboolean cc_rr_output_info_is_connected     (CCRROutputInfo *self);
+void     cc_rr_output_info_get_vendor       (CCRROutputInfo *self, gchar* vendor);
+guint    cc_rr_output_info_get_product      (CCRROutputInfo *self);
+guint    cc_rr_output_info_get_serial       (CCRROutputInfo *self);
+double   cc_rr_output_info_get_aspect_ratio (CCRROutputInfo *self);
+char    *cc_rr_output_info_get_display_name (CCRROutputInfo *self);
+
+gboolean cc_rr_output_info_get_primary (CCRROutputInfo *self);
+void     cc_rr_output_info_set_primary (CCRROutputInfo *self, gboolean primary);
+
+int cc_rr_output_info_get_preferred_width  (CCRROutputInfo *self);
+int cc_rr_output_info_get_preferred_height (CCRROutputInfo *self);
+
+typedef struct _CCRRConfig CCRRConfig;
+typedef struct _CCRRConfigClass CCRRConfigClass;
+typedef struct _CCRRConfigPrivate CCRRConfigPrivate;
+
+struct _CCRRConfig
+{
+    GObject parent;
+
+    /*< private >*/
+    CCRRConfigPrivate *priv;
+};
+
+struct _CCRRConfigClass
+{
+    GObjectClass parent_class;
+};
+
+#define CC_TYPE_RR_CONFIG                  (cc_rr_config_get_type())
+#define CC_RR_CONFIG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), CC_TYPE_RR_CONFIG, CCRRConfig))
+#define CC_IS_RR_CONFIG(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CC_TYPE_RR_CONFIG))
+#define CC_RR_CONFIG_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), CC_TYPE_RR_CONFIG, CCRRConfigClass))
+#define CC_IS_RR_CONFIG_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), CC_TYPE_RR_CONFIG))
+#define CC_RR_CONFIG_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), CC_TYPE_RR_CONFIG, CCRRConfigClass))
+
+GType               cc_rr_config_get_type     (void);
+
+CCRRConfig      *cc_rr_config_new_current  (CCRRScreen  *screen,
+						  GError        **error);
+CCRRConfig      *cc_rr_config_new_stored   (CCRRScreen  *screen,
+						  GError        **error);
+gboolean                cc_rr_config_load_current (CCRRConfig  *self,
+						      GError        **error);
+gboolean                cc_rr_config_load_filename (CCRRConfig  *self,
+						       const gchar    *filename,
+						       GError        **error);
+gboolean            cc_rr_config_match        (CCRRConfig  *config1,
+						  CCRRConfig  *config2);
+gboolean            cc_rr_config_equal	 (CCRRConfig  *config1,
+						  CCRRConfig  *config2);
+gboolean            cc_rr_config_save         (CCRRConfig  *configuration,
+						  GError        **error);
+void                cc_rr_config_sanitize     (CCRRConfig  *configuration);
+gboolean            cc_rr_config_ensure_primary (CCRRConfig  *configuration);
+
+gboolean	    cc_rr_config_apply_with_time (CCRRConfig  *configuration,
+						     CCRRScreen  *screen,
+						     guint32         timestamp,
+						     GError        **error);
+
+gboolean            cc_rr_config_apply_from_filename_with_time (CCRRScreen  *screen,
+								   const char     *filename,
+								   guint32         timestamp,
+								   GError        **error);
+
+gboolean            cc_rr_config_applicable   (CCRRConfig  *configuration,
+						  CCRRScreen  *screen,
+						  GError        **error);
+
+gboolean            cc_rr_config_get_clone    (CCRRConfig  *configuration);
+void                cc_rr_config_set_clone    (CCRRConfig  *configuration, gboolean clone);
+CCRROutputInfo **cc_rr_config_get_outputs  (CCRRConfig  *configuration);
+
+char *cc_rr_config_get_backup_filename (void);
+char *cc_rr_config_get_intended_filename (void);
+
+#endif
 
=== added file 'panels/common/cc-rr-output-info.c'
--- panels/common/cc-rr-output-info.c	1970-01-01 00:00:00 +0000
+++ panels/common/cc-rr-output-info.c	2014-06-26 03:13:28 +0000
@@ -0,0 +1,242 @@
+/* gnome-rr-output-info.c
+ * -*- c-basic-offset: 4 -*-
+ *
+ * Copyright 2010 Giovanni Campagna
+ *
+ * This file is part of the Gnome Desktop Library.
+ *
+ * The Gnome Desktop 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 Desktop 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.
+ */
+
+#include <config.h>
+
+#include "cc-rr-config.h"
+
+#include "edid.h"
+#include "cc-rr-private.h"
+
+G_DEFINE_TYPE (CCRROutputInfo, cc_rr_output_info, G_TYPE_OBJECT)
+
+static void
+cc_rr_output_info_init (CCRROutputInfo *self)
+{
+    self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CC_TYPE_RR_OUTPUT_INFO, CCRROutputInfoPrivate);
+
+    self->priv->name = NULL;
+    self->priv->on = FALSE;
+    self->priv->display_name = NULL;
+}
+
+static void
+cc_rr_output_info_finalize (GObject *gobject)
+{
+    CCRROutputInfo *self = CC_RR_OUTPUT_INFO (gobject);
+
+    g_free (self->priv->name);
+    g_free (self->priv->display_name);
+
+    G_OBJECT_CLASS (cc_rr_output_info_parent_class)->finalize (gobject);
+}
+
+static void
+cc_rr_output_info_class_init (CCRROutputInfoClass *klass)
+{
+    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+    g_type_class_add_private (klass, sizeof (CCRROutputInfoPrivate));
+
+    gobject_class->finalize = cc_rr_output_info_finalize;
+}
+
+/**
+ * cc_rr_output_info_get_name:
+ *
+ * Returns: (transfer none): the output name
+ */
+char *cc_rr_output_info_get_name (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), NULL);
+
+    return self->priv->name;
+}
+
+/**
+ * cc_rr_output_info_is_active:
+ *
+ * Returns: whether there is a CRTC assigned to this output (i.e. a signal is being sent to it)
+ */
+gboolean cc_rr_output_info_is_active (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), FALSE);
+
+    return self->priv->on;
+}
+
+void cc_rr_output_info_set_active (CCRROutputInfo *self, gboolean active)
+{
+    g_return_if_fail (CC_IS_RR_OUTPUT_INFO (self));
+
+    self->priv->on = active;
+}
+
+/**
+ * cc_rr_output_info_get_geometry:
+ * @self: a #CCRROutputInfo
+ * @x: (out) (allow-none):
+ * @y: (out) (allow-none):
+ * @width: (out) (allow-none):
+ * @height: (out) (allow-none):
+ */
+void cc_rr_output_info_get_geometry (CCRROutputInfo *self, int *x, int *y, int *width, int *height)
+{
+    g_return_if_fail (CC_IS_RR_OUTPUT_INFO (self));
+
+    if (x)
+	*x = self->priv->x;
+    if (y)
+	*y = self->priv->y;
+    if (width)
+	*width = self->priv->width;
+    if (height)
+	*height = self->priv->height;
+}
+
+void cc_rr_output_info_set_geometry (CCRROutputInfo *self, int  x, int  y, int  width, int  height)
+{
+    g_return_if_fail (CC_IS_RR_OUTPUT_INFO (self));
+
+    self->priv->x = x;
+    self->priv->y = y;
+    self->priv->width = width;
+    self->priv->height = height;
+}
+
+int cc_rr_output_info_get_refresh_rate (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), 0);
+
+    return self->priv->rate;
+}
+
+void cc_rr_output_info_set_refresh_rate (CCRROutputInfo *self, int rate)
+{
+    g_return_if_fail (CC_IS_RR_OUTPUT_INFO (self));
+
+    self->priv->rate = rate;
+}
+
+CCRRRotation cc_rr_output_info_get_rotation (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), CC_RR_ROTATION_0);
+
+    return self->priv->rotation;
+}
+
+void cc_rr_output_info_set_rotation (CCRROutputInfo *self, CCRRRotation rotation)
+{
+    g_return_if_fail (CC_IS_RR_OUTPUT_INFO (self));
+
+    self->priv->rotation = rotation;
+}
+
+/**
+ * cc_rr_output_info_is_connected:
+ *
+ * Returns: whether the output is physically connected to a monitor
+ */
+gboolean cc_rr_output_info_is_connected (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), FALSE);
+
+    return self->priv->connected;
+}
+
+/**
+ * cc_rr_output_info_get_vendor:
+ * @self: a #CCRROutputInfo
+ * @vendor: (out caller-allocates) (array fixed-size=4):
+ */
+void cc_rr_output_info_get_vendor (CCRROutputInfo *self, gchar* vendor)
+{
+    g_return_if_fail (CC_IS_RR_OUTPUT_INFO (self));
+    g_return_if_fail (vendor != NULL);
+
+    vendor[0] = self->priv->vendor[0];
+    vendor[1] = self->priv->vendor[1];
+    vendor[2] = self->priv->vendor[2];
+    vendor[3] = self->priv->vendor[3];
+}
+
+guint cc_rr_output_info_get_product (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), 0);
+
+    return self->priv->product;
+}
+
+guint cc_rr_output_info_get_serial (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), 0);
+
+    return self->priv->serial;
+}
+
+double cc_rr_output_info_get_aspect_ratio (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), 0);
+
+    return self->priv->aspect;
+}
+
+/**
+ * cc_rr_output_info_get_display_name:
+ *
+ * Returns: (transfer none): the display name of this output
+ */
+char *cc_rr_output_info_get_display_name (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), NULL);
+
+    return self->priv->display_name;
+}
+
+gboolean cc_rr_output_info_get_primary (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), FALSE);
+
+    return self->priv->primary;
+}
+
+void cc_rr_output_info_set_primary (CCRROutputInfo *self, gboolean primary)
+{
+    g_return_if_fail (CC_IS_RR_OUTPUT_INFO (self));
+
+    self->priv->primary = primary;
+}
+
+int cc_rr_output_info_get_preferred_width (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), 0);
+
+    return self->priv->pref_width;
+}
+
+int cc_rr_output_info_get_preferred_height (CCRROutputInfo *self)
+{
+    g_return_val_if_fail (CC_IS_RR_OUTPUT_INFO (self), 0);
+
+    return self->priv->pref_height;
+}
 
=== added file 'panels/common/cc-rr-private.h'
--- panels/common/cc-rr-private.h	1970-01-01 00:00:00 +0000
+++ panels/common/cc-rr-private.h	2014-06-26 03:13:28 +0000
@@ -0,0 +1,79 @@
+#ifndef CC_RR_PRIVATE_H
+#define CC_RR_PRIVATE_H
+
+#include <X11/Xlib.h>
+
+#include <X11/extensions/Xrandr.h>
+
+typedef struct ScreenInfo ScreenInfo;
+
+struct ScreenInfo
+{
+    int			min_width;
+    int			max_width;
+    int			min_height;
+    int			max_height;
+
+    XRRScreenResources *resources;
+    
+    CCRROutput **	outputs;
+    CCRRCrtc **	crtcs;
+    CCRRMode **	modes;
+    
+    CCRRScreen *	screen;
+
+    CCRRMode **	clone_modes;
+
+    RROutput            primary;
+};
+
+struct CCRRScreenPrivate
+{
+    GdkScreen *			gdk_screen;
+    GdkWindow *			gdk_root;
+    Display *			xdisplay;
+    Screen *			xscreen;
+    Window			xroot;
+    ScreenInfo *		info;
+    
+    int				randr_event_base;
+    int				rr_major_version;
+    int				rr_minor_version;
+    
+    Atom                        connector_type_atom;
+    gboolean                    dpms_capable;
+};
+
+struct _CCRROutputInfoPrivate
+{
+    char *		name;
+
+    gboolean		on;
+    int			width;
+    int			height;
+    int			rate;
+    int			x;
+    int			y;
+    CCRRRotation	rotation;
+
+    gboolean		connected;
+    gchar		vendor[4];
+    guint		product;
+    guint		serial;
+    double		aspect;
+    int			pref_width;
+    int			pref_height;
+    char *		display_name;
+    gboolean            primary;
+};
+
+struct _CCRRConfigPrivate
+{
+  gboolean clone;
+  CCRRScreen *screen;
+  CCRROutputInfo **outputs;
+};
+
+gboolean _cc_rr_output_name_is_laptop (const char *name);
+
+#endif
 
=== added file 'panels/common/cc-rr.c'
--- panels/common/cc-rr.c	1970-01-01 00:00:00 +0000
+++ panels/common/cc-rr.c	2014-06-26 03:13:28 +0000
@@ -0,0 +1,2622 @@
+/* gnome-rr.c
+ *
+ * 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]>
+ */
+
+#include <config.h>
+#include <glib/gi18n-lib.h>
+#include <string.h>
+#include <X11/Xlib.h>
+
+#include <X11/extensions/Xrandr.h>
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <X11/Xatom.h>
+#include <X11/extensions/dpms.h>
+
+#undef GNOME_DISABLE_DEPRECATED
+#include "cc-rr.h"
+#include "cc-rr-config.h"
+
+#include "edid.h"
+#include "cc-rr-private.h"
+
+#define DISPLAY(o) ((o)->info->screen->priv->xdisplay)
+
+#define SERVERS_RANDR_IS_AT_LEAST_1_3(priv) (priv->rr_major_version > 1 || (priv->rr_major_version == 1 && priv->rr_minor_version >= 3))
+
+enum {
+    SCREEN_PROP_0,
+    SCREEN_PROP_GDK_SCREEN,
+    SCREEN_PROP_LAST,
+};
+
+enum {
+    SCREEN_CHANGED,
+    SCREEN_OUTPUT_CONNECTED,
+    SCREEN_OUTPUT_DISCONNECTED,
+    SCREEN_SIGNAL_LAST,
+};
+
+gint screen_signals[SCREEN_SIGNAL_LAST];
+
+struct CCRROutput
+{
+    ScreenInfo *	info;
+    RROutput		id;
+    
+    char *		name;
+    char *		display_name;
+    CCRRCrtc *	current_crtc;
+    gboolean		connected;
+    gulong		width_mm;
+    gulong		height_mm;
+    CCRRCrtc **	possible_crtcs;
+    CCRROutput **	clones;
+    CCRRMode **	modes;
+    int			n_preferred;
+    guint8 *		edid_data;
+    gsize		edid_size;
+    char *              connector_type;
+    gint		backlight_min;
+    gint		backlight_max;
+};
+
+struct CCRROutputWrap
+{
+    RROutput		id;
+};
+
+struct CCRRCrtc
+{
+    ScreenInfo *	info;
+    RRCrtc		id;
+    
+    CCRRMode *	current_mode;
+    CCRROutput **	current_outputs;
+    CCRROutput **	possible_outputs;
+    int			x;
+    int			y;
+    
+    CCRRRotation	current_rotation;
+    CCRRRotation	rotations;
+    int			gamma_size;
+};
+
+struct CCRRMode
+{
+    ScreenInfo *	info;
+    RRMode		id;
+    char *		name;
+    int			width;
+    int			height;
+    int			freq;		/* in mHz */
+};
+
+/* CCRRCrtc */
+static CCRRCrtc *  crtc_new          (ScreenInfo         *info,
+					 RRCrtc              id);
+static CCRRCrtc *  crtc_copy         (const CCRRCrtc  *from);
+static void           crtc_free         (CCRRCrtc        *crtc);
+
+static gboolean       crtc_initialize   (CCRRCrtc        *crtc,
+					 XRRScreenResources *res,
+					 GError            **error);
+
+/* CCRROutput */
+static CCRROutput *output_new        (ScreenInfo         *info,
+					 RROutput            id);
+
+static gboolean       output_initialize (CCRROutput      *output,
+					 XRRScreenResources *res,
+					 GError            **error);
+
+static CCRROutput *output_copy       (const CCRROutput *from);
+static void           output_free       (CCRROutput      *output);
+
+/* CCRRMode */
+static CCRRMode *  mode_new          (ScreenInfo         *info,
+					 RRMode              id);
+
+static void           mode_initialize   (CCRRMode        *mode,
+					 XRRModeInfo        *info);
+
+static CCRRMode *  mode_copy         (const CCRRMode  *from);
+static void           mode_free         (CCRRMode        *mode);
+
+static void cc_rr_screen_finalize (GObject*);
+static void cc_rr_screen_set_property (GObject*, guint, const GValue*, GParamSpec*);
+static void cc_rr_screen_get_property (GObject*, guint, GValue*, GParamSpec*);
+static gboolean cc_rr_screen_initable_init (GInitable*, GCancellable*, GError**);
+static void cc_rr_screen_initable_iface_init (GInitableIface *iface);
+G_DEFINE_TYPE_WITH_CODE (CCRRScreen, cc_rr_screen, G_TYPE_OBJECT,
+        G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, cc_rr_screen_initable_iface_init))
+
+G_DEFINE_BOXED_TYPE (CCRRCrtc, cc_rr_crtc, crtc_copy, crtc_free)
+G_DEFINE_BOXED_TYPE (CCRROutput, cc_rr_output, output_copy, output_free)
+G_DEFINE_BOXED_TYPE (CCRRMode, cc_rr_mode, mode_copy, mode_free)
+
+/* Errors */
+
+/**
+ * cc_rr_error_quark:
+ *
+ * Returns the #GQuark that will be used for #GError values returned by the
+ * CCRR API.
+ *
+ * Return value: a #GQuark used to identify errors coming from the CCRR API.
+ */
+GQuark
+cc_rr_error_quark (void)
+{
+    return g_quark_from_static_string ("cc-rr-error-quark");
+}
+
+/* Screen */
+static CCRROutput *
+cc_rr_output_by_id (ScreenInfo *info, RROutput id)
+{
+    CCRROutput **output;
+    
+    g_assert (info != NULL);
+    
+    for (output = info->outputs; *output; ++output)
+    {
+	if ((*output)->id == id)
+	    return *output;
+    }
+    
+    return NULL;
+}
+
+static CCRRCrtc *
+crtc_by_id (ScreenInfo *info, RRCrtc id)
+{
+    CCRRCrtc **crtc;
+    
+    if (!info)
+        return NULL;
+    
+    for (crtc = info->crtcs; *crtc; ++crtc)
+    {
+	if ((*crtc)->id == id)
+	    return *crtc;
+    }
+    
+    return NULL;
+}
+
+static CCRRMode *
+mode_by_id (ScreenInfo *info, RRMode id)
+{
+    CCRRMode **mode;
+    
+    g_assert (info != NULL);
+    
+    for (mode = info->modes; *mode; ++mode)
+    {
+	if ((*mode)->id == id)
+	    return *mode;
+    }
+    
+    return NULL;
+}
+
+static void
+screen_info_free (ScreenInfo *info)
+{
+    CCRROutput **output;
+    CCRRCrtc **crtc;
+    CCRRMode **mode;
+    
+    g_assert (info != NULL);
+
+    if (info->resources)
+    {
+	XRRFreeScreenResources (info->resources);
+	
+	info->resources = NULL;
+    }
+    
+    if (info->outputs)
+    {
+	for (output = info->outputs; *output; ++output)
+	    output_free (*output);
+	g_free (info->outputs);
+    }
+    
+    if (info->crtcs)
+    {
+	for (crtc = info->crtcs; *crtc; ++crtc)
+	    crtc_free (*crtc);
+	g_free (info->crtcs);
+    }
+    
+    if (info->modes)
+    {
+	for (mode = info->modes; *mode; ++mode)
+	    mode_free (*mode);
+	g_free (info->modes);
+    }
+
+    if (info->clone_modes)
+    {
+	/* The modes themselves were freed above */
+	g_free (info->clone_modes);
+    }
+    
+    g_free (info);
+}
+
+static gboolean
+has_similar_mode (CCRROutput *output, CCRRMode *mode)
+{
+    int i;
+    CCRRMode **modes = cc_rr_output_list_modes (output);
+    int width = cc_rr_mode_get_width (mode);
+    int height = cc_rr_mode_get_height (mode);
+
+    for (i = 0; modes[i] != NULL; ++i)
+    {
+	CCRRMode *m = modes[i];
+
+	if (cc_rr_mode_get_width (m) == width	&&
+	    cc_rr_mode_get_height (m) == height)
+	{
+	    return TRUE;
+	}
+    }
+
+    return FALSE;
+}
+
+static void
+gather_clone_modes (ScreenInfo *info)
+{
+    int i;
+    GPtrArray *result = g_ptr_array_new ();
+
+    for (i = 0; info->outputs[i] != NULL; ++i)
+    {
+	int j;
+	CCRROutput *output1, *output2;
+
+	output1 = info->outputs[i];
+	
+	if (!output1->connected)
+	    continue;
+	
+	for (j = 0; output1->modes[j] != NULL; ++j)
+	{
+	    CCRRMode *mode = output1->modes[j];
+	    gboolean valid;
+	    int k;
+
+	    valid = TRUE;
+	    for (k = 0; info->outputs[k] != NULL; ++k)
+	    {
+		output2 = info->outputs[k];
+		
+		if (!output2->connected)
+		    continue;
+		
+		if (!has_similar_mode (output2, mode))
+		{
+		    valid = FALSE;
+		    break;
+		}
+	    }
+
+	    if (valid)
+		g_ptr_array_add (result, mode);
+	}
+    }
+
+    g_ptr_array_add (result, NULL);
+    
+    info->clone_modes = (CCRRMode **)g_ptr_array_free (result, FALSE);
+}
+
+static gboolean
+fill_screen_info_from_resources (ScreenInfo *info,
+				 XRRScreenResources *resources,
+				 GError **error)
+{
+    int i;
+    GPtrArray *a;
+    CCRRCrtc **crtc;
+    CCRROutput **output;
+
+    info->resources = resources;
+
+    /* We create all the structures before initializing them, so
+     * that they can refer to each other.
+     */
+    a = g_ptr_array_new ();
+    for (i = 0; i < resources->ncrtc; ++i)
+    {
+	CCRRCrtc *crtc = crtc_new (info, resources->crtcs[i]);
+
+	g_ptr_array_add (a, crtc);
+    }
+    g_ptr_array_add (a, NULL);
+    info->crtcs = (CCRRCrtc **)g_ptr_array_free (a, FALSE);
+
+    a = g_ptr_array_new ();
+    for (i = 0; i < resources->noutput; ++i)
+    {
+	CCRROutput *output = output_new (info, resources->outputs[i]);
+
+	g_ptr_array_add (a, output);
+    }
+    g_ptr_array_add (a, NULL);
+    info->outputs = (CCRROutput **)g_ptr_array_free (a, FALSE);
+
+    a = g_ptr_array_new ();
+    for (i = 0;  i < resources->nmode; ++i)
+    {
+	CCRRMode *mode = mode_new (info, resources->modes[i].id);
+
+	g_ptr_array_add (a, mode);
+    }
+    g_ptr_array_add (a, NULL);
+    info->modes = (CCRRMode **)g_ptr_array_free (a, FALSE);
+
+    /* Initialize */
+    for (crtc = info->crtcs; *crtc; ++crtc)
+    {
+	if (!crtc_initialize (*crtc, resources, error))
+	    return FALSE;
+    }
+
+    for (output = info->outputs; *output; ++output)
+    {
+	if (!output_initialize (*output, resources, error))
+	    return FALSE;
+    }
+
+    for (i = 0; i < resources->nmode; ++i)
+    {
+	CCRRMode *mode = mode_by_id (info, resources->modes[i].id);
+
+	mode_initialize (mode, &(resources->modes[i]));
+    }
+
+    gather_clone_modes (info);
+
+    return TRUE;
+}
+
+static gboolean
+fill_out_screen_info (Display *xdisplay,
+		      Window xroot,
+		      ScreenInfo *info,
+		      gboolean needs_reprobe,
+		      GError **error)
+{
+    XRRScreenResources *resources;
+    CCRRScreenPrivate *priv;
+    
+    g_assert (xdisplay != NULL);
+    g_assert (info != NULL);
+
+    priv = info->screen->priv;
+
+    /* First update the screen resources */
+
+    if (needs_reprobe)
+        resources = XRRGetScreenResources (xdisplay, xroot);
+    else
+    {
+	/* XRRGetScreenResourcesCurrent is less expensive than
+	 * XRRGetScreenResources, however it is available only
+	 * in RandR 1.3 or higher
+	 */
+        if (SERVERS_RANDR_IS_AT_LEAST_1_3 (priv))
+            resources = XRRGetScreenResourcesCurrent (xdisplay, xroot);
+        else
+            resources = XRRGetScreenResources (xdisplay, xroot);
+    }
+
+    if (resources)
+    {
+	if (!fill_screen_info_from_resources (info, resources, error))
+	    return FALSE;
+    }
+    else
+    {
+	g_set_error (error, CC_RR_ERROR, CC_RR_ERROR_RANDR_ERROR,
+		     /* Translators: a CRTC is a CRT Controller (this is X terminology). */
+		     _("could not get the screen resources (CRTCs, outputs, modes)"));
+	return FALSE;
+    }
+
+    /* Then update the screen size range.  We do this after XRRGetScreenResources() so that
+     * the X server will already have an updated view of the outputs.
+     */
+
+    if (needs_reprobe) {
+	gboolean success;
+
+        gdk_error_trap_push ();
+	success = XRRGetScreenSizeRange (xdisplay, xroot,
+					 &(info->min_width),
+					 &(info->min_height),
+					 &(info->max_width),
+					 &(info->max_height));
+	gdk_flush ();
+	if (gdk_error_trap_pop ()) {
+	    g_set_error (error, CC_RR_ERROR, CC_RR_ERROR_UNKNOWN,
+			 _("unhandled X error while getting the range of screen sizes"));
+	    return FALSE;
+	}
+
+	if (!success) {
+	    g_set_error (error, CC_RR_ERROR, CC_RR_ERROR_RANDR_ERROR,
+			 _("could not get the range of screen sizes"));
+            return FALSE;
+        }
+    }
+    else
+    {
+        cc_rr_screen_get_ranges (info->screen, 
+					 &(info->min_width),
+					 &(info->max_width),
+					 &(info->min_height),
+					 &(info->max_height));
+    }
+
+    info->primary = None;
+    if (SERVERS_RANDR_IS_AT_LEAST_1_3 (priv)) {
+        gdk_error_trap_push ();
+        info->primary = XRRGetOutputPrimary (xdisplay, xroot);
+	gdk_error_trap_pop_ignored ();
+    }
+
+    /* can the screen do DPMS? */
+    gdk_error_trap_push ();
+    priv->dpms_capable = DPMSCapable (priv->xdisplay);
+    gdk_error_trap_pop_ignored ();
+
+    return TRUE;
+}
+
+static ScreenInfo *
+screen_info_new (CCRRScreen *screen, gboolean needs_reprobe, GError **error)
+{
+    ScreenInfo *info = g_new0 (ScreenInfo, 1);
+    CCRRScreenPrivate *priv;
+
+    g_assert (screen != NULL);
+
+    priv = screen->priv;
+
+    info->outputs = NULL;
+    info->crtcs = NULL;
+    info->modes = NULL;
+    info->screen = screen;
+    
+    if (fill_out_screen_info (priv->xdisplay, priv->xroot, info, needs_reprobe, error))
+    {
+	return info;
+    }
+    else
+    {
+	screen_info_free (info);
+	return NULL;
+    }
+}
+
+static CCRROutput *
+find_output_by_id (CCRROutput **haystack, guint32 id)
+{
+    guint i;
+
+    for (i = 0; haystack[i] != NULL; i++)
+    {
+	if (cc_rr_output_get_id (haystack[i]) == id)
+	    return haystack[i];
+    }
+    return NULL;
+}
+
+static void
+diff_outputs_and_emit_signals (ScreenInfo *old, ScreenInfo *new)
+{
+    guint i;
+    guint32 id_old, id_new;
+    CCRROutput *output_old;
+    CCRROutput *output_new;
+
+    /* have any outputs been removed or disconnected */
+    for (i = 0; old->outputs[i] != NULL; i++)
+    {
+        id_old = cc_rr_output_get_id (old->outputs[i]);
+        output_new = find_output_by_id (new->outputs, id_old);
+	if (output_new == NULL)
+	{
+	    /* output removed (and disconnected) */
+	    if (cc_rr_output_is_connected (old->outputs[i]))
+	     {
+	        g_signal_emit (G_OBJECT (new->screen),
+			       screen_signals[SCREEN_OUTPUT_DISCONNECTED], 0,
+			       old->outputs[i]);
+             }
+	    continue;
+	}
+	if (cc_rr_output_is_connected (old->outputs[i]) &&
+	    !cc_rr_output_is_connected (output_new))
+	{
+	    /* output disconnected */
+	    g_signal_emit (G_OBJECT (new->screen),
+			   screen_signals[SCREEN_OUTPUT_DISCONNECTED], 0,
+			   old->outputs[i]);
+        }
+    }
+
+    /* have any outputs been created or connected */
+    for (i = 0; new->outputs[i] != NULL; i++)
+    {
+        id_new = cc_rr_output_get_id (new->outputs[i]);
+        output_old = find_output_by_id (old->outputs, id_new);
+	if (output_old == NULL)
+	{
+	    /* output created */
+	    if (cc_rr_output_is_connected (new->outputs[i]))
+	     {
+	        g_signal_emit (G_OBJECT (new->screen),
+			       screen_signals[SCREEN_OUTPUT_CONNECTED], 0,
+			       new->outputs[i]);
+            }
+	    continue;
+	}
+	if (!cc_rr_output_is_connected (output_old) &&
+	    cc_rr_output_is_connected (new->outputs[i]))
+	{
+	    /* output connected */
+	    g_signal_emit (G_OBJECT (new->screen),
+			   screen_signals[SCREEN_OUTPUT_CONNECTED], 0,
+			   new->outputs[i]);
+         }
+    }
+}
+
+static gboolean
+screen_update (CCRRScreen *screen, gboolean force_callback, gboolean needs_reprobe, GError **error)
+{
+    ScreenInfo *info;
+    gboolean changed = FALSE;
+    
+    g_assert (screen != NULL);
+
+    info = screen_info_new (screen, needs_reprobe, error);
+    if (!info)
+	    return FALSE;
+
+    if (info->resources->configTimestamp != screen->priv->info->resources->configTimestamp)
+	    changed = TRUE;
+
+    /* work out if any outputs have changed connected state */
+    diff_outputs_and_emit_signals (screen->priv->info, info);
+
+    screen_info_free (screen->priv->info);
+	
+    screen->priv->info = info;
+
+    if (changed || force_callback)
+        g_signal_emit (G_OBJECT (screen), screen_signals[SCREEN_CHANGED], 0);
+    
+    return changed;
+}
+
+static GdkFilterReturn
+screen_on_event (GdkXEvent *xevent,
+		 GdkEvent *event,
+		 gpointer data)
+{
+    CCRRScreen *screen = data;
+    CCRRScreenPrivate *priv = screen->priv;
+    XEvent *e = xevent;
+    int event_num;
+
+    if (!e)
+	return GDK_FILTER_CONTINUE;
+
+    event_num = e->type - priv->randr_event_base;
+
+    if (event_num == RRScreenChangeNotify) {
+	/* We don't reprobe the hardware; we just fetch the X server's latest
+	 * state.  The server already knows the new state of the outputs; that's
+	 * why it sent us an event!
+	 */
+        screen_update (screen, TRUE, FALSE, NULL); /* NULL-GError */
+#if 0
+	/* Enable this code to get a dialog showing the RANDR timestamps, for debugging purposes */
+	{
+	    GtkWidget *dialog;
+	    XRRScreenChangeNotifyEvent *rr_event;
+	    static int dialog_num;
+
+	    rr_event = (XRRScreenChangeNotifyEvent *) e;
+
+	    dialog = gtk_message_dialog_new (NULL,
+					     0,
+					     GTK_MESSAGE_INFO,
+					     GTK_BUTTONS_CLOSE,
+					     "RRScreenChangeNotify timestamps (%d):\n"
+					     "event change: %u\n"
+					     "event config: %u\n"
+					     "event serial: %lu\n"
+					     "----------------------"
+					     "screen change: %u\n"
+					     "screen config: %u\n",
+					     dialog_num++,
+					     (guint32) rr_event->timestamp,
+					     (guint32) rr_event->config_timestamp,
+					     rr_event->serial,
+					     (guint32) priv->info->resources->timestamp,
+					     (guint32) priv->info->resources->configTimestamp);
+	    g_signal_connect (dialog, "response",
+			      G_CALLBACK (gtk_widget_destroy), NULL);
+	    gtk_widget_show (dialog);
+	}
+#endif
+    }
+#if 0
+    /* WHY THIS CODE IS DISABLED:
+     *
+     * Note that in cc_rr_screen_new(), we only select for
+     * RRScreenChangeNotifyMask.  We used to select for other values in
+     * RR*NotifyMask, but we weren't really doing anything useful with those
+     * events.  We only care about "the screens changed in some way or another"
+     * for now.
+     *
+     * If we ever run into a situtation that could benefit from processing more
+     * detailed events, we can enable this code again.
+     *
+     * Note that the X server sends RRScreenChangeNotify in conjunction with the
+     * more detailed events from RANDR 1.2 - see xserver/randr/randr.c:TellChanged().
+     */
+    else if (event_num == RRNotify)
+    {
+	/* Other RandR events */
+
+	XRRNotifyEvent *event = (XRRNotifyEvent *)e;
+
+	/* Here we can distinguish between RRNotify events supported
+	 * since RandR 1.2 such as RRNotify_OutputProperty.  For now, we
+	 * don't have anything special to do for particular subevent types, so
+	 * we leave this as an empty switch().
+	 */
+	switch (event->subtype)
+	{
+	default:
+	    break;
+	}
+
+	/* No need to reprobe hardware here */
+	screen_update (screen, TRUE, FALSE, NULL); /* NULL-GError */
+    }
+#endif
+
+    /* Pass the event on to GTK+ */
+    return GDK_FILTER_CONTINUE;
+}
+
+static gboolean
+cc_rr_screen_initable_init (GInitable *initable, GCancellable *canc, GError **error)
+{
+    CCRRScreen *self = CC_RR_SCREEN (initable);
+    CCRRScreenPrivate *priv = self->priv;
+    Display *dpy = GDK_SCREEN_XDISPLAY (self->priv->gdk_screen);
+    int event_base;
+    int ignore;
+
+    priv->connector_type_atom = XInternAtom (dpy, "ConnectorType", FALSE);
+
+    if (XRRQueryExtension (dpy, &event_base, &ignore))
+    {
+        priv->randr_event_base = event_base;
+
+        XRRQueryVersion (dpy, &priv->rr_major_version, &priv->rr_minor_version);
+        if (priv->rr_major_version < 1 || (priv->rr_major_version == 1 && priv->rr_minor_version < 2)) {
+            g_set_error (error, CC_RR_ERROR, CC_RR_ERROR_NO_RANDR_EXTENSION,
+                    "RANDR extension is too old (must be at least 1.2)");
+            return FALSE;
+        }
+
+        priv->info = screen_info_new (self, TRUE, error);
+
+        if (!priv->info) {
+            return FALSE;
+        }
+
+        XRRSelectInput (priv->xdisplay,
+                priv->xroot,
+                RRScreenChangeNotifyMask);
+        gdk_x11_register_standard_event_type (gdk_screen_get_display (priv->gdk_screen),
+                          event_base,
+                          RRNotify + 1);
+        gdk_window_add_filter (priv->gdk_root, screen_on_event, self);
+
+        return TRUE;
+    }
+    else
+    {
+      g_set_error (error, CC_RR_ERROR, CC_RR_ERROR_NO_RANDR_EXTENSION,
+                   _("RANDR extension is not present"));
+
+      return FALSE;
+   }
+}
+
+void
+cc_rr_screen_initable_iface_init (GInitableIface *iface)
+{
+    iface->init = cc_rr_screen_initable_init;
+}
+
+void
+cc_rr_screen_finalize (GObject *gobject)
+{
+    CCRRScreen *screen = CC_RR_SCREEN (gobject);
+
+    gdk_window_remove_filter (screen->priv->gdk_root, screen_on_event, screen);
+
+    if (screen->priv->info)
+      screen_info_free (screen->priv->info);
+
+    G_OBJECT_CLASS (cc_rr_screen_parent_class)->finalize (gobject);
+}
+
+void
+cc_rr_screen_set_property (GObject *gobject, guint property_id, const GValue *value, GParamSpec *property)
+{
+    CCRRScreen *self = CC_RR_SCREEN (gobject);
+    CCRRScreenPrivate *priv = self->priv;
+
+    switch (property_id)
+    {
+    case SCREEN_PROP_GDK_SCREEN:
+        priv->gdk_screen = g_value_get_object (value);
+        priv->gdk_root = gdk_screen_get_root_window (priv->gdk_screen);
+        priv->xroot = gdk_x11_window_get_xid (priv->gdk_root);
+        priv->xdisplay = GDK_SCREEN_XDISPLAY (priv->gdk_screen);
+        priv->xscreen = gdk_x11_screen_get_xscreen (priv->gdk_screen);
+        return;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, property_id, property);
+        return;
+    }
+}
+
+void
+cc_rr_screen_get_property (GObject *gobject, guint property_id, GValue *value, GParamSpec *property)
+{
+    CCRRScreen *self = CC_RR_SCREEN (gobject);
+    CCRRScreenPrivate *priv = self->priv;
+
+    switch (property_id)
+    {
+    case SCREEN_PROP_GDK_SCREEN:
+        g_value_set_object (value, priv->gdk_screen);
+        return;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, property_id, property);
+        return;
+    }
+}
+
+void
+cc_rr_screen_class_init (CCRRScreenClass *klass)
+{
+    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+    g_type_class_add_private (klass, sizeof (CCRRScreenPrivate));
+
+    bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
+    bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+
+    gobject_class->set_property = cc_rr_screen_set_property;
+    gobject_class->get_property = cc_rr_screen_get_property;
+    gobject_class->finalize = cc_rr_screen_finalize;
+
+    g_object_class_install_property(
+            gobject_class,
+            SCREEN_PROP_GDK_SCREEN,
+            g_param_spec_object (
+                    "gdk-screen",
+                    "GDK Screen",
+                    "The GDK Screen represented by this CCRRScreen",
+                    GDK_TYPE_SCREEN,
+                    G_PARAM_READWRITE |
+		    G_PARAM_CONSTRUCT_ONLY |
+		    G_PARAM_STATIC_STRINGS)
+            );
+
+    screen_signals[SCREEN_CHANGED] = g_signal_new("changed",
+            G_TYPE_FROM_CLASS (gobject_class),
+            G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
+            G_STRUCT_OFFSET (CCRRScreenClass, changed),
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__VOID,
+            G_TYPE_NONE,
+	    0);
+
+    /**
+     * CCRRScreen::output-connected:
+     * @screen: the #CCRRScreen that emitted the signal
+     * @output: the #CCRROutput that was connected
+     *
+     * This signal is emitted when a display device is connected to a
+     * port, or a port is hotplugged with an active output. The latter
+     * can happen if a laptop is docked, and the dock provides a new
+     * active output.
+     *
+     * The @output value is not a #GObject. The returned @output value can
+     * only assume to be valid during the emission of the signal (i.e. within
+     * your signal handler only), as it may change later when the @screen
+     * is modified due to an event from the X server, or due to another
+     * place in the application modifying the @screen and the @output.
+     * Therefore, deal with changes to the @output right in your signal
+     * handler, instead of keeping the @output reference for an async or
+     * idle function.
+     **/
+    screen_signals[SCREEN_OUTPUT_CONNECTED] = g_signal_new("output-connected",
+            G_TYPE_FROM_CLASS (gobject_class),
+            G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
+            G_STRUCT_OFFSET (CCRRScreenClass, output_connected),
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__POINTER,
+            G_TYPE_NONE,
+            1, G_TYPE_POINTER);
+
+    /**
+     * CCRRScreen::output-disconnected:
+     * @screen: the #CCRRScreen that emitted the signal
+     * @output: the #CCRROutput that was disconnected
+     *
+     * This signal is emitted when a display device is disconnected from
+     * a port, or a port output is hot-unplugged. The latter can happen
+     * if a laptop is undocked, and the dock provided the output.
+     *
+     * The @output value is not a #GObject. The returned @output value can
+     * only assume to be valid during the emission of the signal (i.e. within
+     * your signal handler only), as it may change later when the @screen
+     * is modified due to an event from the X server, or due to another
+     * place in the application modifying the @screen and the @output.
+     * Therefore, deal with changes to the @output right in your signal
+     * handler, instead of keeping the @output reference for an async or
+     * idle function.
+     **/
+    screen_signals[SCREEN_OUTPUT_DISCONNECTED] = g_signal_new("output-disconnected",
+            G_TYPE_FROM_CLASS (gobject_class),
+            G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
+            G_STRUCT_OFFSET (CCRRScreenClass, output_disconnected),
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__POINTER,
+            G_TYPE_NONE,
+            1, G_TYPE_POINTER);
+}
+
+void
+cc_rr_screen_init (CCRRScreen *self)
+{
+    CCRRScreenPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CC_TYPE_RR_SCREEN, CCRRScreenPrivate);
+    self->priv = priv;
+
+    priv->gdk_screen = NULL;
+    priv->gdk_root = NULL;
+    priv->xdisplay = NULL;
+    priv->xroot = None;
+    priv->xscreen = NULL;
+    priv->info = NULL;
+    priv->rr_major_version = 0;
+    priv->rr_minor_version = 0;
+}
+
+/* Weak reference callback set in cc_rr_screen_new(); we remove the GObject data from the GdkScreen. */
+static void
+rr_screen_weak_notify_cb (gpointer data, GObject *where_the_object_was)
+{
+    GdkScreen *screen = GDK_SCREEN (data);
+
+    g_object_set_data (G_OBJECT (screen), "CCRRScreen", NULL);
+}
+
+/**
+ * cc_rr_screen_new:
+ * @screen: the #GdkScreen on which to operate
+ * @error: will be set if XRandR is not supported
+ *
+ * Creates a unique #CCRRScreen instance for the specified @screen.
+ *
+ * Returns: a unique #CCRRScreen instance, specific to the @screen, or NULL
+ * if this could not be created, for instance if the driver does not support
+ * Xrandr 1.2.  Each #GdkScreen thus has a single instance of #CCRRScreen.
+ */
+CCRRScreen *
+cc_rr_screen_new (GdkScreen *screen,
+		     GError **error)
+{
+    CCRRScreen *rr_screen;
+
+    g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+    g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+
+    rr_screen = g_object_get_data (G_OBJECT (screen), "CCRRScreen");
+    if (rr_screen)
+	g_object_ref (rr_screen);
+    else {
+	rr_screen = g_initable_new (CC_TYPE_RR_SCREEN, NULL, error, "gdk-screen", screen, NULL);
+	if (rr_screen) {
+	    g_object_set_data (G_OBJECT (screen), "CCRRScreen", rr_screen);
+	    g_object_weak_ref (G_OBJECT (rr_screen), rr_screen_weak_notify_cb, screen);
+	}
+    }
+
+    return rr_screen;
+}
+
+void
+cc_rr_screen_set_size (CCRRScreen *screen,
+			  int	      width,
+			  int       height,
+			  int       mm_width,
+			  int       mm_height)
+{
+    g_return_if_fail (CC_IS_RR_SCREEN (screen));
+
+    gdk_error_trap_push ();
+    XRRSetScreenSize (screen->priv->xdisplay, screen->priv->xroot,
+		      width, height, mm_width, mm_height);
+    gdk_error_trap_pop_ignored ();
+}
+
+/**
+ * cc_rr_screen_get_ranges:
+ * @screen: a #CCRRScreen
+ * @min_width: (out): the minimum width
+ * @max_width: (out): the maximum width
+ * @min_height: (out): the minimum height
+ * @max_height: (out): the maximum height
+ *
+ * Get the ranges of the screen
+ */
+void
+cc_rr_screen_get_ranges (CCRRScreen *screen,
+			    int	          *min_width,
+			    int	          *max_width,
+			    int           *min_height,
+			    int	          *max_height)
+{
+    CCRRScreenPrivate *priv;
+
+    g_return_if_fail (CC_IS_RR_SCREEN (screen));
+
+    priv = screen->priv;
+    
+    if (min_width)
+	*min_width = priv->info->min_width;
+    
+    if (max_width)
+	*max_width = priv->info->max_width;
+    
+    if (min_height)
+	*min_height = priv->info->min_height;
+    
+    if (max_height)
+	*max_height = priv->info->max_height;
+}
+
+/**
+ * cc_rr_screen_get_timestamps:
+ * @screen: a #CCRRScreen
+ * @change_timestamp_ret: (out): Location in which to store the timestamp at which the RANDR configuration was last changed
+ * @config_timestamp_ret: (out): Location in which to store the timestamp at which the RANDR configuration was last obtained
+ *
+ * Queries the two timestamps that the X RANDR extension maintains.  The X
+ * server will prevent change requests for stale configurations, those whose
+ * timestamp is not equal to that of the latest request for configuration.  The
+ * X server will also prevent change requests that have an older timestamp to
+ * the latest change request.
+ */
+void
+cc_rr_screen_get_timestamps (CCRRScreen *screen,
+				guint32       *change_timestamp_ret,
+				guint32       *config_timestamp_ret)
+{
+    CCRRScreenPrivate *priv;
+
+    g_return_if_fail (CC_IS_RR_SCREEN (screen));
+
+    priv = screen->priv;
+
+    if (change_timestamp_ret)
+	*change_timestamp_ret = priv->info->resources->timestamp;
+
+    if (config_timestamp_ret)
+	*config_timestamp_ret = priv->info->resources->configTimestamp;
+}
+
+static gboolean
+force_timestamp_update (CCRRScreen *screen)
+{
+    CCRRScreenPrivate *priv = screen->priv;
+    CCRRCrtc *crtc;
+    XRRCrtcInfo *current_info;
+    Status status;
+    gboolean timestamp_updated;
+
+    timestamp_updated = FALSE;
+
+    crtc = priv->info->crtcs[0];
+
+    if (crtc == NULL)
+	goto out;
+
+    current_info = XRRGetCrtcInfo (priv->xdisplay,
+				   priv->info->resources,
+				   crtc->id);
+
+    if (current_info == NULL)
+	goto out;
+
+    gdk_error_trap_push ();
+    status = XRRSetCrtcConfig (priv->xdisplay,
+			       priv->info->resources,
+			       crtc->id,
+			       current_info->timestamp,
+			       current_info->x,
+			       current_info->y,
+			       current_info->mode,
+			       current_info->rotation,
+			       current_info->outputs,
+			       current_info->noutput);
+
+    XRRFreeCrtcInfo (current_info);
+
+    gdk_flush ();
+    if (gdk_error_trap_pop ())
+	goto out;
+
+    if (status == RRSetConfigSuccess)
+	timestamp_updated = TRUE;
+out:
+    return timestamp_updated;
+}
+
+/**
+ * cc_rr_screen_refresh:
+ * @screen: a #CCRRScreen
+ * @error: location to store error, or %NULL
+ *
+ * Refreshes the screen configuration, and calls the screen's callback if it
+ * exists and if the screen's configuration changed.
+ *
+ * Return value: TRUE if the screen's configuration changed; otherwise, the
+ * function returns FALSE and a NULL error if the configuration didn't change,
+ * or FALSE and a non-NULL error if there was an error while refreshing the
+ * configuration.
+ */
+gboolean
+cc_rr_screen_refresh (CCRRScreen *screen,
+			 GError       **error)
+{
+    gboolean refreshed;
+
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+    gdk_x11_display_grab (gdk_screen_get_display (screen->priv->gdk_screen));
+
+    refreshed = screen_update (screen, FALSE, TRUE, error);
+    force_timestamp_update (screen); /* this is to keep other clients from thinking that the X server re-detected things by itself - bgo#621046 */
+
+    gdk_x11_display_ungrab (gdk_screen_get_display (screen->priv->gdk_screen));
+
+    return refreshed;
+}
+
+/**
+ * cc_rr_screen_get_dpms_mode:
+ * @mode: (out): The current #CCRRDpmsMode of this screen
+ **/
+gboolean
+cc_rr_screen_get_dpms_mode (CCRRScreen *screen,
+                               CCRRDpmsMode *mode,
+                               GError **error)
+{
+    BOOL enabled = FALSE;
+    CARD16 state;
+    gboolean ret = FALSE;
+
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+    g_return_val_if_fail (mode != NULL, FALSE);
+
+    if (!screen->priv->dpms_capable) {
+        g_set_error_literal (error,
+                             CC_RR_ERROR,
+                             CC_RR_ERROR_NO_DPMS_EXTENSION,
+                             "Display is not DPMS capable");
+        goto out;
+    }
+
+    if (!DPMSInfo (screen->priv->xdisplay,
+                   &state,
+                   &enabled)) {
+        g_set_error_literal (error,
+                             CC_RR_ERROR,
+                             CC_RR_ERROR_UNKNOWN,
+                             "Unable to get DPMS state");
+        goto out;
+    }
+
+    /* DPMS not enabled is a valid mode */
+    if (!enabled) {
+        *mode = CC_RR_DPMS_DISABLED;
+        ret = TRUE;
+        goto out;
+    }
+
+    switch (state) {
+    case DPMSModeOn:
+        *mode = CC_RR_DPMS_ON;
+        break;
+    case DPMSModeStandby:
+        *mode = CC_RR_DPMS_STANDBY;
+        break;
+    case DPMSModeSuspend:
+        *mode = CC_RR_DPMS_SUSPEND;
+        break;
+    case DPMSModeOff:
+        *mode = CC_RR_DPMS_OFF;
+        break;
+    default:
+        g_assert_not_reached ();
+        break;
+    }
+    ret = TRUE;
+out:
+    return ret;
+}
+
+/**
+ * cc_rr_screen_clear_dpms_timeouts:
+ **/
+static gboolean
+cc_rr_screen_clear_dpms_timeouts (CCRRScreen *screen,
+                                     GError **error)
+{
+    gdk_error_trap_push ();
+    /* DPMSSetTimeouts() return value is often a lie, so ignore it */
+    DPMSSetTimeouts (screen->priv->xdisplay, 0, 0, 0);
+    if (gdk_error_trap_pop ()) {
+        g_set_error_literal (error,
+                             CC_RR_ERROR,
+                             CC_RR_ERROR_UNKNOWN,
+                             "Could not set DPMS timeouts");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+/**
+ * cc_rr_screen_set_dpms_mode:
+ *
+ * This method also disables the DPMS timeouts.
+ **/
+gboolean
+cc_rr_screen_set_dpms_mode (CCRRScreen *screen,
+                               CCRRDpmsMode mode,
+                               GError **error)
+{
+    CARD16 state = 0;
+    gboolean ret;
+    CCRRDpmsMode current_mode;
+
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+    /* set, if the new mode is different */
+    ret = cc_rr_screen_get_dpms_mode (screen, &current_mode, error);
+    if (!ret)
+        goto out;
+    if (current_mode == mode) {
+        ret = cc_rr_screen_clear_dpms_timeouts (screen, error);
+        goto out;
+    }
+
+    switch (mode) {
+    case CC_RR_DPMS_ON:
+        state = DPMSModeOn;
+        break;
+    case CC_RR_DPMS_STANDBY:
+        state = DPMSModeStandby;
+        break;
+    case CC_RR_DPMS_SUSPEND:
+        state = DPMSModeSuspend;
+        break;
+    case CC_RR_DPMS_OFF:
+        state = DPMSModeOff;
+        break;
+    default:
+        g_assert_not_reached ();
+        break;
+    }
+
+    gdk_error_trap_push ();
+    /* DPMSForceLevel() return value is often a lie, so ignore it */
+    DPMSForceLevel (screen->priv->xdisplay, state);
+    XSync (screen->priv->xdisplay, False);
+    if (gdk_error_trap_pop ()) {
+        ret = FALSE;
+        g_set_error_literal (error,
+                             CC_RR_ERROR,
+                             CC_RR_ERROR_UNKNOWN,
+                             "Could not change DPMS mode");
+        goto out;
+    }
+
+    ret = cc_rr_screen_clear_dpms_timeouts (screen, error);
+    if (!ret)
+        goto out;
+out:
+    return ret;
+}
+
+/**
+ * cc_rr_screen_list_modes:
+ *
+ * List available XRandR modes
+ *
+ * Returns: (array zero-terminated=1) (transfer none):
+ */
+CCRRMode **
+cc_rr_screen_list_modes (CCRRScreen *screen)
+{
+    g_return_val_if_fail (CC_IS_RR_SCREEN (screen), NULL);
+    g_return_val_if_fail (screen->priv->info != NULL, NULL);
+    
+    return screen->priv->info->modes;
+}
+
+/**
+ * cc_rr_screen_list_clone_modes:
+ *
+ * List available XRandR clone modes
+ *
+ * Returns: (array zero-terminated=1) (transfer none):
+ */
+CCRRMode **
+cc_rr_screen_list_clone_modes   (CCRRScreen *screen)
+{
+    g_return_val_if_fail (CC_IS_RR_SCREEN (screen), NULL);
+    g_return_val_if_fail (screen->priv->info != NULL, NULL);
+
+    return screen->priv->info->clone_modes;
+}
+
+/**
+ * cc_rr_screen_list_crtcs:
+ *
+ * List all CRTCs
+ *
+ * Returns: (array zero-terminated=1) (transfer none):
+ */
+CCRRCrtc **
+cc_rr_screen_list_crtcs (CCRRScreen *screen)
+{
+    g_return_val_if_fail (CC_IS_RR_SCREEN (screen), NULL);
+    g_return_val_if_fail (screen->priv->info != NULL, NULL);
+    
+    return screen->priv->info->crtcs;
+}
+
+/**
+ * cc_rr_screen_list_outputs:
+ *
+ * List all outputs
+ *
+ * Returns: (array zero-terminated=1) (transfer none):
+ */
+CCRROutput **
+cc_rr_screen_list_outputs (CCRRScreen *screen)
+{
+    g_return_val_if_fail (CC_IS_RR_SCREEN (screen), NULL);
+    g_return_val_if_fail (screen->priv->info != NULL, NULL);
+    
+    return screen->priv->info->outputs;
+}
+
+/**
+ * cc_rr_screen_get_crtc_by_id:
+ *
+ * Returns: (transfer none): the CRTC identified by @id
+ */
+CCRRCrtc *
+cc_rr_screen_get_crtc_by_id (CCRRScreen *screen,
+				guint32        id)
+{
+    CCRRCrtc **crtcs;
+    int i;
+    
+    g_return_val_if_fail (CC_IS_RR_SCREEN (screen), NULL);
+    g_return_val_if_fail (screen->priv->info != NULL, NULL);
+
+    crtcs = screen->priv->info->crtcs;
+    
+    for (i = 0; crtcs[i] != NULL; ++i)
+    {
+	if (crtcs[i]->id == id)
+	    return crtcs[i];
+    }
+    
+    return NULL;
+}
+
+/**
+ * cc_rr_screen_get_output_by_id:
+ *
+ * Returns: (transfer none): the output identified by @id
+ */
+CCRROutput *
+cc_rr_screen_get_output_by_id (CCRRScreen *screen,
+				  guint32        id)
+{
+    CCRROutput **outputs;
+    int i;
+    
+    g_return_val_if_fail (CC_IS_RR_SCREEN (screen), NULL);
+    g_return_val_if_fail (screen->priv->info != NULL, NULL);
+
+    outputs = screen->priv->info->outputs;
+
+    for (i = 0; outputs[i] != NULL; ++i)
+    {
+	if (outputs[i]->id == id)
+	    return outputs[i];
+    }
+    
+    return NULL;
+}
+
+/* CCRROutput */
+static CCRROutput *
+output_new (ScreenInfo *info, RROutput id)
+{
+    CCRROutput *output = g_slice_new0 (CCRROutput);
+    
+    output->id = id;
+    output->info = info;
+    
+    return output;
+}
+
+static guint8 *
+get_property (Display *dpy,
+	      RROutput output,
+	      Atom atom,
+	      gsize *len)
+{
+    unsigned char *prop;
+    int actual_format;
+    unsigned long nitems, bytes_after;
+    Atom actual_type;
+    guint8 *result;
+    
+    XRRGetOutputProperty (dpy, output, atom,
+			  0, 100, False, False,
+			  AnyPropertyType,
+			  &actual_type, &actual_format,
+			  &nitems, &bytes_after, &prop);
+    
+    if (actual_type == XA_INTEGER && actual_format == 8)
+    {
+	result = g_memdup (prop, nitems);
+	if (len)
+	    *len = nitems;
+    }
+    else
+    {
+	result = NULL;
+    }
+    
+    XFree (prop);
+    
+    return result;
+}
+
+static guint8 *
+read_edid_data (CCRROutput *output, gsize *len)
+{
+    Atom edid_atom;
+    guint8 *result;
+
+    edid_atom = XInternAtom (DISPLAY (output), "EDID", FALSE);
+    result = get_property (DISPLAY (output),
+			   output->id, edid_atom, len);
+
+    if (!result)
+    {
+	edid_atom = XInternAtom (DISPLAY (output), "EDID_DATA", FALSE);
+	result = get_property (DISPLAY (output),
+			       output->id, edid_atom, len);
+    }
+
+    if (!result)
+    {
+	edid_atom = XInternAtom (DISPLAY (output), "XFree86_DDC_EDID1_RAWDATA", FALSE);
+	result = get_property (DISPLAY (output),
+			       output->id, edid_atom, len);
+    }
+
+    if (result)
+    {
+	if (*len % 128 == 0)
+	    return result;
+	else
+	    g_free (result);
+    }
+    
+    return NULL;
+}
+
+static char *
+get_connector_type_string (CCRROutput *output)
+{
+    char *result;
+    unsigned char *prop;
+    int actual_format;
+    unsigned long nitems, bytes_after;
+    Atom actual_type;
+    Atom connector_type;
+    char *connector_type_str;
+
+    result = NULL;
+
+    if (XRRGetOutputProperty (DISPLAY (output), output->id, output->info->screen->priv->connector_type_atom,
+			      0, 100, False, False,
+			      AnyPropertyType,
+			      &actual_type, &actual_format,
+			      &nitems, &bytes_after, &prop) != Success)
+	return NULL;
+
+    if (!(actual_type == XA_ATOM && actual_format == 32 && nitems == 1))
+	goto out;
+
+    connector_type = *((Atom *) prop);
+
+    connector_type_str = XGetAtomName (DISPLAY (output), connector_type);
+    if (connector_type_str) {
+	result = g_strdup (connector_type_str); /* so the caller can g_free() it */
+	XFree (connector_type_str);
+    }
+
+out:
+
+    XFree (prop);
+
+    return result;
+}
+
+static void
+update_brightness_limits (CCRROutput *output)
+{
+    gint rc;
+    Atom atom;
+    XRRPropertyInfo *info;
+
+    gdk_error_trap_push ();
+    atom = XInternAtom (DISPLAY (output), "Backlight", FALSE);
+    info = XRRQueryOutputProperty (DISPLAY (output), output->id, atom);
+    rc = gdk_error_trap_pop ();
+    if (rc != Success)
+    {
+        if (rc != BadName)
+          g_warning ("could not get output property for %s, rc: %i",
+		     output->name, rc);
+        goto out;
+    }
+    if (info == NULL)
+    {
+        g_warning ("could not get output property for %s",
+		   output->name);
+        goto out;
+    }
+    if (!info->range || info->num_values != 2)
+    {
+        g_debug ("backlight %s was not range", output->name);
+        goto out;
+    }
+    output->backlight_min = info->values[0];
+    output->backlight_max = info->values[1];
+out:
+    if (info != NULL)
+    {
+        XFree (info);
+    }
+}
+
+static gboolean
+output_initialize (CCRROutput *output, XRRScreenResources *res, GError **error)
+{
+    XRROutputInfo *info = XRRGetOutputInfo (
+	DISPLAY (output), res, output->id);
+    GPtrArray *a;
+    int i;
+    
+#if 0
+    g_print ("Output %lx Timestamp: %u\n", output->id, (guint32)info->timestamp);
+#endif
+    
+    if (!info || !output->info)
+    {
+	/* FIXME: see the comment in crtc_initialize() */
+	/* Translators: here, an "output" is a video output */
+	g_set_error (error, CC_RR_ERROR, CC_RR_ERROR_RANDR_ERROR,
+		     _("could not get information about output %d"),
+		     (int) output->id);
+	return FALSE;
+    }
+    
+    output->name = g_strdup (info->name); /* FIXME: what is nameLen used for? */
+    output->display_name = NULL; /* set first time the getter is used */
+    output->current_crtc = crtc_by_id (output->info, info->crtc);
+    output->width_mm = info->mm_width;
+    output->height_mm = info->mm_height;
+    output->connected = (info->connection == RR_Connected);
+    output->connector_type = get_connector_type_string (output);
+
+    /* Possible crtcs */
+    a = g_ptr_array_new ();
+    
+    for (i = 0; i < info->ncrtc; ++i)
+    {
+	CCRRCrtc *crtc = crtc_by_id (output->info, info->crtcs[i]);
+	
+	if (crtc)
+	    g_ptr_array_add (a, crtc);
+    }
+    g_ptr_array_add (a, NULL);
+    output->possible_crtcs = (CCRRCrtc **)g_ptr_array_free (a, FALSE);
+    
+    /* Clones */
+    a = g_ptr_array_new ();
+    for (i = 0; i < info->nclone; ++i)
+    {
+	CCRROutput *cc_rr_output = cc_rr_output_by_id (output->info, info->clones[i]);
+	
+	if (cc_rr_output)
+	    g_ptr_array_add (a, cc_rr_output);
+    }
+    g_ptr_array_add (a, NULL);
+    output->clones = (CCRROutput **)g_ptr_array_free (a, FALSE);
+    
+    /* Modes */
+    a = g_ptr_array_new ();
+    for (i = 0; i < info->nmode; ++i)
+    {
+	CCRRMode *mode = mode_by_id (output->info, info->modes[i]);
+	
+	if (mode)
+	    g_ptr_array_add (a, mode);
+    }
+    g_ptr_array_add (a, NULL);
+    output->modes = (CCRRMode **)g_ptr_array_free (a, FALSE);
+    
+    output->n_preferred = info->npreferred;
+    
+    /* Edid data */
+    output->edid_data = read_edid_data (output, &output->edid_size);
+
+    /* brightness data */
+    if (output->connected)
+        update_brightness_limits (output);
+
+    XRRFreeOutputInfo (info);
+
+    return TRUE;
+}
+
+static CCRROutput*
+output_copy (const CCRROutput *from)
+{
+    GPtrArray *array;
+    CCRRCrtc **p_crtc;
+    CCRROutput **p_output;
+    CCRRMode **p_mode;
+    CCRROutput *output = g_slice_new0 (CCRROutput);
+
+    output->id = from->id;
+    output->info = from->info;
+    output->name = g_strdup (from->name);
+    output->current_crtc = from->current_crtc;
+    output->width_mm = from->width_mm;
+    output->height_mm = from->height_mm;
+    output->connected = from->connected;
+    output->n_preferred = from->n_preferred;
+    output->connector_type = g_strdup (from->connector_type);
+    output->backlight_min = -1;
+    output->backlight_max = -1;
+
+    array = g_ptr_array_new ();
+    for (p_crtc = from->possible_crtcs; *p_crtc != NULL; p_crtc++)
+    {
+        g_ptr_array_add (array, *p_crtc);
+    }
+    output->possible_crtcs = (CCRRCrtc**) g_ptr_array_free (array, FALSE);
+
+    array = g_ptr_array_new ();
+    for (p_output = from->clones; *p_output != NULL; p_output++)
+    {
+        g_ptr_array_add (array, *p_output);
+    }
+    output->clones = (CCRROutput**) g_ptr_array_free (array, FALSE);
+
+    array = g_ptr_array_new ();
+    for (p_mode = from->modes; *p_mode != NULL; p_mode++)
+    {
+        g_ptr_array_add (array, *p_mode);
+    }
+    output->modes = (CCRRMode**) g_ptr_array_free (array, FALSE);
+
+    output->edid_size = from->edid_size;
+    output->edid_data = g_memdup (from->edid_data, from->edid_size);
+
+    return output;
+}
+
+static void
+output_free (CCRROutput *output)
+{
+    g_free (output->clones);
+    g_free (output->modes);
+    g_free (output->possible_crtcs);
+    g_free (output->edid_data);
+    g_free (output->name);
+    g_free (output->display_name);
+    g_free (output->connector_type);
+    g_slice_free (CCRROutput, output);
+}
+
+guint32
+cc_rr_output_get_id (CCRROutput *output)
+{
+    g_assert(output != NULL);
+    
+    return output->id;
+}
+
+const guint8 *
+cc_rr_output_get_edid_data (CCRROutput *output, gsize *size)
+{
+    g_return_val_if_fail (output != NULL, NULL);
+    if (size)
+        *size = output->edid_size;
+    return output->edid_data;
+}
+
+/**
+ * cc_rr_output_get_ids_from_edid:
+ * @output: a #CCRROutput
+ * @vendor: (out) (allow-none):
+ * @product: (out) (allow-none):
+ * @serial: (out) (allow-none):
+ */
+gboolean
+cc_rr_output_get_ids_from_edid (CCRROutput         *output,
+                                   char                 **vendor,
+                                   int                   *product,
+                                   int                   *serial)
+{
+    MonitorInfo *info;
+
+    g_return_val_if_fail (output != NULL, FALSE);
+
+    if (!output->edid_data)
+        return FALSE;
+    info = decode_edid (output->edid_data);
+    if (!info)
+        return FALSE;
+    if (vendor)
+        *vendor = g_memdup (info->manufacturer_code, 4);
+    if (product)
+        *product = info->product_code;
+    if (serial)
+        *serial = info->serial_number;
+
+    g_free (info);
+
+    return TRUE;
+
+}
+
+static void
+ensure_display_name (CCRROutput *output)
+{
+    if (output->display_name != NULL)
+        return;
+
+    if (cc_rr_output_is_laptop (output))
+        output->display_name = g_strdup (_("Built-in Display"));
+
+    if (output->display_name == NULL
+        && output->edid_data != NULL) {
+        MonitorInfo *info;
+
+        info = decode_edid (output->edid_data);
+        if (info != NULL)
+            output->display_name = make_display_name (info);
+
+        g_free (info);
+    }
+
+    if (output->display_name == NULL) {
+        char *inches;
+        inches = make_display_size_string (output->width_mm, output->height_mm);
+        if (inches != NULL) {
+            /* Translators: %s is the size of the monitor in inches */
+            output->display_name = g_strdup_printf (_("%s Display"), inches);
+        }
+        g_free (inches);
+    }
+
+    /* last chance on the stairway */
+    if (output->display_name == NULL) {
+      output->display_name = g_strdup (_("Unknown Display"));
+    }
+}
+
+const char *
+cc_rr_output_get_display_name (CCRROutput *output)
+{
+    g_return_val_if_fail (output != NULL, NULL);
+
+    ensure_display_name (output);
+
+    return output->display_name;
+}
+
+/**
+ * cc_rr_output_get_backlight_min:
+ *
+ * Returns: The mimimum backlight value, or -1 if not supported
+ */
+gint
+cc_rr_output_get_backlight_min (CCRROutput *output)
+{
+    g_return_val_if_fail (output != NULL, -1);
+    return output->backlight_min;
+}
+
+/**
+ * cc_rr_output_get_backlight_max:
+ *
+ * Returns: The maximum backlight value, or -1 if not supported
+ */
+gint
+cc_rr_output_get_backlight_max (CCRROutput *output)
+{
+    g_return_val_if_fail (output != NULL, -1);
+    return output->backlight_max;
+}
+
+/**
+ * cc_rr_output_get_backlight:
+ *
+ * Returns: The currently set backlight brightness
+ */
+gint
+cc_rr_output_get_backlight (CCRROutput *output, GError **error)
+{
+    guint now = -1;
+    unsigned long nitems;
+    unsigned long bytes_after;
+    guint *prop;
+    Atom atom;
+    Atom actual_type;
+    int actual_format;
+    gint retval;
+
+    g_return_val_if_fail (output != NULL, -1);
+
+    gdk_error_trap_push ();
+    atom = XInternAtom (DISPLAY (output), "Backlight", FALSE);
+    retval = XRRGetOutputProperty (DISPLAY (output), output->id, atom,
+				   0, 4, False, False, None,
+				   &actual_type, &actual_format,
+				   &nitems, &bytes_after, ((unsigned char **)&prop));
+    gdk_flush ();
+    if (gdk_error_trap_pop ())
+    {
+        g_set_error_literal (error,
+			     CC_RR_ERROR,
+			     CC_RR_ERROR_UNKNOWN,
+			     "unhandled X error while getting the range of backlight values");
+        goto out;
+    }
+
+    if (retval != Success) {
+        g_set_error_literal (error,
+			     CC_RR_ERROR,
+			     CC_RR_ERROR_RANDR_ERROR,
+			     "could not get the range of backlight values");
+        goto out;
+    }
+    if (actual_type == XA_INTEGER &&
+        nitems == 1 &&
+        actual_format == 32)
+    {
+        memcpy (&now, prop, sizeof (guint));
+    }
+    else
+    {
+	g_set_error (error,
+		     CC_RR_ERROR,
+		     CC_RR_ERROR_RANDR_ERROR,
+		     "failed to get correct property type, got %lu,%i",
+		     nitems, actual_format);
+    }
+out:
+    XFree (prop);
+    return now;
+}
+
+/**
+ * cc_rr_output_set_backlight:
+ * @value: the absolute value which is min >= this <= max
+ *
+ * Returns: %TRUE for success
+ */
+gboolean
+cc_rr_output_set_backlight (CCRROutput *output, gint value, GError **error)
+{
+    gboolean ret = FALSE;
+    Atom atom;
+
+    g_return_val_if_fail (output != NULL, FALSE);
+
+    /* check this is sane */
+    if (value < output->backlight_min ||
+        value > output->backlight_max)
+    {
+	g_set_error (error,
+		     CC_RR_ERROR,
+		     CC_RR_ERROR_BOUNDS_ERROR,
+		     "out of brightness range: %i, has to be %i -> %i",
+		     value,
+		     output->backlight_max, output->backlight_min);
+	goto out;
+    }
+
+    /* don't abort on error */
+    gdk_error_trap_push ();
+    atom = XInternAtom (DISPLAY (output), "Backlight", FALSE);
+    XRRChangeOutputProperty (DISPLAY (output), output->id, atom,