Merge lp:~tombeckmann/switchboard-plug-display/mutter-dbus into lp:~elementary-apps/switchboard-plug-display/trunk

[Tom Beckmann]

This branch aims to fix the issue with multimonitors resetting after a gala restart by calling mutter's dbus directly instead of using xrandr via gnome-desktop. This fix won't be necessary once we get a more recent version of libgnome-desktop, however backports aren't planned for this lib for Freya, so this branch would be a requirement for Freya.

Unmerged revisions

79. By Tom Beckmann on 2014-12-25

various fixes, may work now

78. By Tom Beckmann on 2014-12-23

clean up gnome-desktop file to prevent conflicts, add actual integration

77. By Tom Beckmann on 2014-12-22

prepare call to mutter dbus for applying

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-07-30 00:58:06 +0000
+++ src/CMakeLists.txt	2014-12-25 21:32:50 +0000
@@ -18,6 +18,7 @@
     DisplayPlug.vala
     DisplayPopover.vala
     Monitor.vala
+    MutterDisplayConfig.vala
     OutputList.vala
     SettingsDaemon.vala
     Utils.vala
@@ -29,13 +30,17 @@
     clutter-1.0
     gnome-desktop-3.0
     gdk-x11-3.0
+    crtc-assignment
 OPTIONS
     --thread
     --vapidir=${CMAKE_SOURCE_DIR}/vapi
 )
 
-add_library (${CMAKE_PROJECT_NAME} MODULE ${VALA_C})
+include_directories (${CMAKE_SOURCE_DIR}/src)
+add_definitions (-w -g)
+
+add_library (${CMAKE_PROJECT_NAME} MODULE ${VALA_C} crtc-assignment.c)
 target_link_libraries (${CMAKE_PROJECT_NAME} ${DEPS_LIBRARIES}) 
 
 # Installation
-install (TARGETS ${CMAKE_PROJECT_NAME} DESTINATION ${PKGDATADIR})
\ No newline at end of file
+install (TARGETS ${CMAKE_PROJECT_NAME} DESTINATION ${PKGDATADIR})

=== modified file 'src/Configuration.vala'
--- src/Configuration.vala	2014-07-29 17:45:48 +0000
+++ src/Configuration.vala	2014-12-25 21:32:50 +0000
@@ -15,6 +15,8 @@
     public Gnome.RRScreen screen { get; private set; }
     public Gnome.RRConfig current_config { get; private set; }
 
+    MutterWMHelper mutter_wm_helper;
+
     SettingsDaemon? settings_daemon = null;
     private Configuration () {
         try {
@@ -24,6 +26,8 @@
             report_error (e.message);
         }
 
+        mutter_wm_helper = new MutterWMHelper ();
+
         try {
             settings_daemon = get_settings_daemon ();
         } catch (Error e) {
@@ -68,13 +72,18 @@
         apply_state_changed (false);
         current_config.sanitize ();
         current_config.ensure_primary ();
+        print ("BLAH BLAH\n");
 
 #if !HAS_GNOME312
         try {
-            var other_screen = new Gnome.RRScreen (Gdk.Screen.get_default ());
-            var other_config = new Gnome.RRConfig.current (other_screen);
-            other_config.ensure_primary ();
-            other_config.save ();
+            if (mutter_wm_helper.supported) {
+                mutter_wm_helper.apply_config (current_config, screen);
+            } else {
+                var other_screen = new Gnome.RRScreen (Gdk.Screen.get_default ());
+                var other_config = new Gnome.RRConfig.current (other_screen);
+                other_config.ensure_primary ();
+                other_config.save ();
+            }
         } catch (Error e) {}
 #endif
 
@@ -183,4 +192,4 @@
 
         update_outputs (current_config);
     }
-}
\ No newline at end of file
+}

=== added file 'src/MutterDisplayConfig.vala'
--- src/MutterDisplayConfig.vala	1970-01-01 00:00:00 +0000
+++ src/MutterDisplayConfig.vala	2014-12-25 21:32:50 +0000
@@ -0,0 +1,103 @@
+
+public struct CrtcConfig
+{
+	uint id;
+	int new_mode;
+	int x;
+	int y;
+	uint transform;
+	uint[] outputs;
+	HashTable<string, Variant> properties;
+}
+
+public struct OutputConfig
+{
+	uint id;
+	HashTable<string, Variant> properties;
+}
+
+[DBus (name = "org.gnome.Mutter.DisplayConfig")]
+public interface MutterDisplayConfig : Object
+{
+	[DBus (signature = "ua(uxiiiiiuaua{sv})a(uxiausauaua{sv})a(uxuud)ii")]
+    public abstract Variant get_resources () throws Error;
+	public abstract void apply_configuration (uint serial, bool persistent, CrtcConfig[] crtcs, OutputConfig[] outputs) throws Error;
+}
+
+public class MutterWMHelper : Object
+{
+	public bool supported { get; private set; default = false; }
+
+	MutterDisplayConfig mutter_proxy;
+
+	public MutterWMHelper ()
+	{
+		try {
+			mutter_proxy = Bus.get_proxy_sync (BusType.SESSION,
+				"org.pantheon.gala", "/org/gnome/Mutter/DisplayConfig");
+		} catch (Error e) {
+			return;
+		}
+
+		supported = mutter_proxy != null;
+	}
+
+	public void apply_config (Gnome.RRConfig config, Gnome.RRScreen screen)
+	{
+		CrtcAssignment assignment;
+		Gnome.RRCrtc crtc;
+		CrtcInfo info;
+		CrtcConfig[] crtcs = {};
+		OutputConfig[] outputs = {};
+
+		var mutter_info = mutter_proxy.get_resources ();
+		var serial = mutter_info.get_uint32 ();
+
+		try {
+			get_crtc_assignment (config, screen, out assignment);
+		} catch (Error e) {
+			warning (e.message);
+			return;
+		}
+
+		if (assignment == null) {
+			return;
+		}
+
+		var iter = HashTableIter<Gnome.RRCrtc,CrtcInfo?> (assignment.info);
+		while (iter.next (out crtc, out info)) {
+			uint[] output_list = {};
+
+			for (var i = 0; i < info.outputs.len; i++) {
+				output_list += ((Gnome.RROutput) info.outputs.index (i)).get_id ();
+			}
+
+			crtcs += CrtcConfig () {
+				id = crtc.get_id (),
+				new_mode = info.mode != null ? (int) info.mode.get_id () : -1,
+				x = info.x,
+				y = info.y,
+				transform = rotation_to_transform (info.rotation),
+				outputs = output_list,
+				properties = null
+			};
+		}
+
+		for (var i = 0; assignment.outputs[i] != null; i++) {
+			var output = assignment.outputs[i];
+			var rr_output = screen.get_output_by_name (output.get_name ());
+			var properties = new HashTable<string,Variant> (direct_hash, direct_equal);
+
+			properties.@set ("primary", output.get_primary ());
+			properties.@set ("presentation", false);
+
+			outputs += OutputConfig () {
+				id = rr_output.get_id (),
+				properties = properties
+			};
+		}
+
+		mutter_proxy.apply_configuration (serial, true, crtcs, outputs);
+	}
+}
+

=== added file 'src/crtc-assignment.c'
--- src/crtc-assignment.c	1970-01-01 00:00:00 +0000
+++ src/crtc-assignment.c	2014-12-25 21:32:50 +0000
@@ -0,0 +1,677 @@
+/* gnome-rr-config.c
+ * -*- c-basic-offset: 4 -*-
+ *
+ * Copyright 2007, 2008, 2013 Red Hat, Inc.
+ * Copyright 2010 Giovanni Campagna <[e-mail]>
+ * 
+ * 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]>
+ */
+
+#define GNOME_DESKTOP_USE_UNSTABLE_API
+
+#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 "crtc-assignment.h"
+
+//#include "edid.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>
+ */
+
+/**
+ * some things copied from gnome-rr-private.h
+ *
+ * copying the entire file didn't seem very useful as it included
+ * a bunch of things that we don't need
+ */
+struct _GnomeRRConfigPrivate
+{
+  gboolean clone;
+  GnomeRRScreen *screen;
+  GnomeRROutputInfo **outputs;
+};
+struct _GnomeRROutputInfoPrivate
+{
+    char *		name;
+
+    gboolean		on;
+    int			width;
+    int			height;
+    int			rate;
+    int			x;
+    int			y;
+    GnomeRRRotation	rotation;
+    GnomeRRRotation	available_rotations;
+
+    gboolean		connected;
+    char *		vendor;
+    char *		product;
+    char *		serial;
+    double		aspect;
+    int			pref_width;
+    int			pref_height;
+    char *		display_name;
+    gboolean            primary;
+};
+
+static gboolean         crtc_assignment_apply (CrtcAssignment   *assign,
+					       gboolean          persistent,
+					       GError          **error);
+static CrtcAssignment  *crtc_assignment_new   (GnomeRRScreen      *screen,
+					       GnomeRROutputInfo **outputs,
+					       GError            **error);
+
+static GnomeRROutputInfo **
+make_outputs (GnomeRRConfig *config)
+{
+    GPtrArray *outputs;
+    GnomeRROutputInfo *first_on;
+    int i;
+
+    outputs = g_ptr_array_new ();
+
+    first_on = NULL;
+    
+    for (i = 0; config->priv->outputs[i] != NULL; ++i)
+    {
+	GnomeRROutputInfo *old = config->priv->outputs[i];
+	GnomeRROutputInfo *new = g_object_new (GNOME_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 (GnomeRROutputInfo **)g_ptr_array_free (outputs, FALSE);
+}
+
+gboolean
+get_crtc_assignment (GnomeRRConfig   *config,
+    		     GnomeRRScreen   *screen,
+		     CrtcAssignment  *assignment,
+                     GError         **error)
+{
+    GnomeRROutputInfo **outputs;
+    gboolean result = FALSE;
+    int i;
+
+    g_return_val_if_fail (GNOME_IS_RR_CONFIG (config), FALSE);
+    g_return_val_if_fail (GNOME_IS_RR_SCREEN (screen), FALSE);
+
+    outputs = make_outputs (config);
+
+    assignment = crtc_assignment_new (screen, outputs, error);
+
+    if (assignment)
+    {
+      return TRUE;
+    }
+
+    for (i = 0; outputs[i] != NULL; i++)
+	g_object_unref (outputs[i]);
+    g_free (outputs);
+
+    return FALSE;
+}
+
+
+/*
+ * CRTC assignment
+ */
+
+static gboolean
+can_clone (CrtcInfo *info,
+	   GnomeRROutput *output)
+{
+    int i;
+
+    for (i = 0; i < info->outputs->len; ++i)
+    {
+	GnomeRROutput *clone = info->outputs->pdata[i];
+
+	if (!gnome_rr_output_can_clone (clone, output))
+	    return FALSE;
+    }
+
+    return TRUE;
+}
+
+static gboolean
+crtc_assignment_assign (CrtcAssignment   *assign,
+			GnomeRRCrtc      *crtc,
+			GnomeRRMode      *mode,
+			int               x,
+			int               y,
+			GnomeRRRotation   rotation,
+                        gboolean          primary,
+			GnomeRROutput    *output,
+			GError          **error)
+{
+    CrtcInfo *info = g_hash_table_lookup (assign->info, crtc);
+    guint32 crtc_id;
+    const char *output_name;
+
+    crtc_id = gnome_rr_crtc_get_id (crtc);
+    output_name = gnome_rr_output_get_name (output);
+
+    if (!gnome_rr_crtc_can_drive_output (crtc, output))
+    {
+	g_set_error (error, GNOME_RR_ERROR, GNOME_RR_ERROR_CRTC_ASSIGNMENT,
+		     _("CRTC %d cannot drive output %s"), crtc_id, output_name);
+	return FALSE;
+    }
+
+    if (!gnome_rr_output_supports_mode (output, mode))
+    {
+	g_set_error (error, GNOME_RR_ERROR, GNOME_RR_ERROR_CRTC_ASSIGNMENT,
+		     _("output %s does not support mode %dx%d@%dHz"),
+		     output_name,
+		     gnome_rr_mode_get_width (mode),
+		     gnome_rr_mode_get_height (mode),
+		     gnome_rr_mode_get_freq (mode));
+	return FALSE;
+    }
+
+    if (!gnome_rr_crtc_supports_rotation (crtc, rotation))
+    {
+	g_set_error (error, GNOME_RR_ERROR, GNOME_RR_ERROR_CRTC_ASSIGNMENT,
+		     _("CRTC %d does not support rotation=%d"),
+		     crtc_id, rotation);
+	return FALSE;
+    }
+
+    if (info)
+    {
+	if (!(info->mode == mode	&&
+	      info->x == x		&&
+	      info->y == y		&&
+	      info->rotation == rotation))
+	{
+	    g_set_error (error, GNOME_RR_ERROR, GNOME_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 = %d, new rotation = %d"),
+			 output_name,
+			 gnome_rr_mode_get_id (info->mode), gnome_rr_mode_get_id (mode),
+			 info->x, info->y,
+			 x, y,
+			 info->rotation, rotation);
+	    return FALSE;
+	}
+
+	if (!can_clone (info, output))
+	{
+	    g_set_error (error, GNOME_RR_ERROR, GNOME_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,
+			  GnomeRRCrtc         *crtc,
+			  GnomeRROutput       *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);
+    }
+}
+
+void
+crtc_assignment_free (CrtcAssignment *assign)
+{
+    if (!assign)
+      return;
+
+    if (assign->info)
+      g_hash_table_destroy (assign->info);
+
+    g_free (assign);
+}
+
+static gboolean
+mode_is_rotated (CrtcInfo *info)
+{
+    if ((info->rotation & GNOME_RR_ROTATION_270)		||
+	(info->rotation & GNOME_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 (GnomeRRScreen *screen,
+		   GnomeRROutputInfo **outputs,
+		   CrtcAssignment *assignment,
+		   GError **error)
+{
+    GnomeRRCrtc **crtcs = gnome_rr_screen_list_crtcs (screen);
+    GnomeRROutputInfo *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)
+    {
+	GnomeRRCrtc *crtc = crtcs[i];
+	int crtc_id = gnome_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)
+	{
+	    GnomeRROutput *gnome_rr_output = gnome_rr_screen_get_output_by_name (screen, output->priv->name);
+	    GnomeRRMode **modes = gnome_rr_output_list_modes (gnome_rr_output);
+	    int j;
+
+	    for (j = 0; modes[j] != NULL; ++j)
+	    {
+		GnomeRRMode *mode = modes[j];
+		int mode_width;
+		int mode_height;
+		int mode_freq;
+
+		mode_width = gnome_rr_mode_get_width (mode);
+		mode_height = gnome_rr_mode_get_height (mode);
+		mode_freq = gnome_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,
+			    gnome_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, gnome_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, GNOME_RR_ERROR, GNOME_RR_ERROR_CRTC_ASSIGNMENT,
+			 _("could not assign CRTCs to outputs:\n%s"),
+			 str);
+	else
+	    g_set_error (error, GNOME_RR_ERROR, GNOME_RR_ERROR_CRTC_ASSIGNMENT,
+			 _("none of the selected modes were compatible with the possible modes:\n%s"),
+			 str);
+
+	g_free (str);
+    }
+
+    return success;
+}
+
+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)
+    {
+	GnomeRRCrtc *crtc = list->data;
+	CrtcInfo *info = g_hash_table_lookup (assign->info, crtc);
+	int w, h;
+
+	w = gnome_rr_mode_get_width (info->mode);
+	h = gnome_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 CrtcAssignment *
+crtc_assignment_new (GnomeRRScreen      *screen,
+		     GnomeRROutputInfo **outputs,
+		     GError            **error)
+{
+    CrtcAssignment *assignment = g_new0 (CrtcAssignment, 1);
+
+    assignment->outputs = outputs;
+    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;
+
+	get_required_virtual_size (assignment, &width, &height);
+
+	gnome_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, GNOME_RR_ERROR, GNOME_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;
+	}
+
+	assignment->screen = screen;
+	
+	return assignment;
+    }
+
+fail:
+    crtc_assignment_free (assignment);
+    
+    return NULL;
+}
+
+#define ROTATION_MASK 0x7F
+
+wl_output_transform
+rotation_to_transform (GnomeRRRotation rotation)
+{
+  static const wl_output_transform y_reflected_map[] = {
+    WL_OUTPUT_TRANSFORM_FLIPPED_180,
+    WL_OUTPUT_TRANSFORM_FLIPPED_90,
+    WL_OUTPUT_TRANSFORM_FLIPPED,
+    WL_OUTPUT_TRANSFORM_FLIPPED_270
+  };
+  wl_output_transform ret;
+
+  switch (rotation & ROTATION_MASK)
+    {
+    default:
+    case GNOME_RR_ROTATION_0:
+      ret = WL_OUTPUT_TRANSFORM_NORMAL;
+      break;
+    case GNOME_RR_ROTATION_90:
+      ret = WL_OUTPUT_TRANSFORM_90;
+      break;
+    case GNOME_RR_ROTATION_180:
+      ret = WL_OUTPUT_TRANSFORM_180;
+      break;
+    case GNOME_RR_ROTATION_270:
+      ret = WL_OUTPUT_TRANSFORM_270;
+      break;
+    }
+
+  if (rotation & GNOME_RR_REFLECT_X)
+    return ret + 4;
+  else if (rotation & GNOME_RR_REFLECT_Y)
+    return y_reflected_map[ret];
+  else
+    return ret;
+}
+
+/*
+static gboolean
+crtc_assignment_apply (CrtcAssignment *assign, gboolean persistent, GError **error)
+{
+    GVariantBuilder crtc_builder, output_builder, nested_outputs;
+    GHashTableIter iter;
+    GnomeRRCrtc *crtc;
+    CrtcInfo *info;
+    unsigned i;
+
+    g_variant_builder_init (&crtc_builder, G_VARIANT_TYPE ("a(uiiiuaua{sv})"));
+    g_variant_builder_init (&output_builder, G_VARIANT_TYPE ("a(ua{sv})"));
+
+    g_hash_table_iter_init (&iter, assign->info);
+    while (g_hash_table_iter_next (&iter, (void*) &crtc, (void*) &info))
+    {
+	g_variant_builder_init (&nested_outputs, G_VARIANT_TYPE ("au"));
+	for (i = 0; i < info->outputs->len; i++)
+	{
+	    GnomeRROutput *output = g_ptr_array_index (info->outputs, i);
+
+	    g_variant_builder_add (&nested_outputs, "u",
+				   gnome_rr_output_get_id (output));
+	}
+
+	g_variant_builder_add (&crtc_builder, "(uiiiuaua{sv})",
+			       gnome_rr_crtc_get_id (crtc),
+			       info->mode ?
+			       gnome_rr_mode_get_id (info->mode) : -1,
+			       info->x,
+			       info->y,
+			       rotation_to_transform (info->rotation),
+			       &nested_outputs,
+			       NULL);
+    }
+
+    for (i = 0; assign->outputs[i]; i++)
+    {
+	GnomeRROutputInfo *output = assign->outputs[i];
+	GnomeRROutput *gnome_rr_output = gnome_rr_screen_get_output_by_name (assign->screen,
+									     output->priv->name);
+
+	g_variant_builder_add (&output_builder, "(u@a{sv})",
+			       gnome_rr_output_get_id (gnome_rr_output),
+			       g_variant_new_parsed ("{ 'primary': <%b>,"
+						     "  'presentation': <%b> }",
+						     output->priv->primary,
+						     FALSE));
+    }
+
+    return _gnome_rr_screen_apply_configuration (assign->screen,
+						 persistent,
+						 g_variant_builder_end (&crtc_builder),
+						 g_variant_builder_end (&output_builder),
+						 error);
+}*/

=== added file 'src/crtc-assignment.h'
--- src/crtc-assignment.h	1970-01-01 00:00:00 +0000
+++ src/crtc-assignment.h	2014-12-25 21:32:50 +0000
@@ -0,0 +1,45 @@
+#include <gnome-desktop-3.0/libgnome-desktop/gnome-rr.h>
+#include <gnome-desktop-3.0/libgnome-desktop/gnome-rr-config.h>
+
+typedef struct CrtcAssignment CrtcAssignment;
+
+struct CrtcAssignment
+{
+    GnomeRROutputInfo **outputs;
+    GnomeRRScreen *screen;
+    GHashTable *info;
+    GnomeRROutput *primary;
+};
+
+typedef struct CrtcInfo CrtcInfo;
+
+struct CrtcInfo
+{
+    GnomeRRMode    *mode;
+    int        x;
+    int        y;
+    GnomeRRRotation rotation;
+    GPtrArray *outputs;
+};
+
+#ifdef GDK_WINDOWING_WAYLAND
+#include <gdk/gdkwayland.h>
+#else
+enum wl_output_transform {
+  WL_OUTPUT_TRANSFORM_NORMAL,
+  WL_OUTPUT_TRANSFORM_90,
+  WL_OUTPUT_TRANSFORM_180,
+  WL_OUTPUT_TRANSFORM_270,
+  WL_OUTPUT_TRANSFORM_FLIPPED,
+  WL_OUTPUT_TRANSFORM_FLIPPED_90,
+  WL_OUTPUT_TRANSFORM_FLIPPED_180,
+  WL_OUTPUT_TRANSFORM_FLIPPED_270
+};
+#endif
+
+typedef enum wl_output_transform wl_output_transform;
+
+void crtc_assignment_free (CrtcAssignment *assign);
+void crtc_info_free (CrtcInfo *info);
+
+gboolean get_crtc_assignment (GnomeRRConfig *config, GnomeRRScreen *screen, CrtcAssignment *assignment, GError **error);

=== added file 'vapi/crtc-assignment.vapi'
--- vapi/crtc-assignment.vapi	1970-01-01 00:00:00 +0000
+++ vapi/crtc-assignment.vapi	2014-12-25 21:32:50 +0000
@@ -0,0 +1,40 @@
+
+[CCode (cheader_filename = "crtc-assignment.h")]
+public class CrtcAssignment
+{
+	[CCode (array_null_terminated = true)]
+	public Gnome.RROutputInfo[] outputs;
+	public Gnome.RRScreen screen;
+	public GLib.HashTable<Gnome.RRCrtc,CrtcInfo?> info;
+	public Gnome.RROutput primary;
+}
+
+[CCode (cheader_filename = "crtc-assignment.h", has_destroy_function = "false")]
+public struct CrtcInfo
+{
+	Gnome.RRMode mode;
+	int x;
+	int y;
+	Gnome.RRRotation rotation;
+	GLib.PtrArray outputs;
+}
+
+[CCode (cheader_filename = "crtc-assignment.h")]
+public enum wl_output_transform {
+  WL_OUTPUT_TRANSFORM_NORMAL,
+  WL_OUTPUT_TRANSFORM_90,
+  WL_OUTPUT_TRANSFORM_180,
+  WL_OUTPUT_TRANSFORM_270,
+  WL_OUTPUT_TRANSFORM_FLIPPED,
+  WL_OUTPUT_TRANSFORM_FLIPPED_90,
+  WL_OUTPUT_TRANSFORM_FLIPPED_180,
+  WL_OUTPUT_TRANSFORM_FLIPPED_270
+}
+
+[CCode (cheader_filename = "crtc-assignment.h")]
+public bool get_crtc_assignment (Gnome.RRConfig config,
+	Gnome.RRScreen screen, out CrtcAssignment assignment) throws GLib.Error;
+
+[CCode (cheader_filename = "crtc-assignment.h")]
+public wl_output_transform rotation_to_transform (Gnome.RRRotation rotation);
+