X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=autorandr.py;h=feee62b58bc4f2e220c9295b9e5b18f32c7194f7;hb=af4a3f82fde54436b5393682364c0340b661c554;hp=01632ee86e1f329e0ec74ca82ae24943a36c0423;hpb=2b0a226d0d370c79901d77c0d70a9f72d9e45a41;p=deb_pkgs%2Fautorandr.git

diff --git a/autorandr.py b/autorandr.py
index 01632ee..feee62b 100755
--- a/autorandr.py
+++ b/autorandr.py
@@ -4,7 +4,7 @@
 # autorandr.py
 # Copyright (c) 2015, Phillip Berndt
 #
-# Experimental autorandr rewrite in Python
+# Autorandr rewrite in Python
 #
 # This script aims to be fully compatible with the original autorandr.
 #
@@ -34,9 +34,13 @@ import subprocess
 import sys
 from distutils.version import LooseVersion as Version
 
+from functools import reduce
 from itertools import chain
 from collections import OrderedDict
 
+import posix
+
+
 virtual_profiles = [
     # (name, description, callback)
     ("common", "Clone all connected outputs at the largest common resolution", None),
@@ -52,10 +56,13 @@ Usage: autorandr [options]
 -s, --save <profile>    save your current setup to profile <profile>
 -l, --load <profile>    load profile <profile>
 -d, --default <profile> make profile <profile> the default profile
+--skip-options <option> comma separated list of xrandr arguments (e.g. "gamma")
+                        to skip both in detecting changes and applying a profile
 --force                 force (re)loading of a profile
 --fingerprint           fingerprint your current hardware setup
 --config                dump your current xrandr setup
 --dry-run               don't change anything, only print the xrandr commands
+--debug                 enable verbose output
 
  To prevent a profile from being loaded, place a script call "block" in its
  directory. The script is evaluated before the screen setup is inspected, and
@@ -66,13 +73,44 @@ Usage: autorandr [options]
  To change this behaviour and switch to a fallback configuration, specify
  --default <profile>.
 
- Another script called "postswitch "can be placed in the directory
- ~/.autorandr as well as in any profile directories: The scripts are executed
- after a mode switch has taken place and can notify window managers.
+ Another script called "postswitch" can be placed in the directory
+ ~/.config/autorandr (or ~/.autorandr if you have an old installation) as well
+ as in any profile directories: The scripts are executed after a mode switch
+ has taken place and can notify window managers.
 
  The following virtual configurations are available:
 """.strip()
 
+class AutorandrException(Exception):
+    def __init__(self, message, original_exception=None, report_bug=False):
+        self.message = message
+        self.report_bug = report_bug
+        if original_exception:
+            self.original_exception = original_exception
+            trace = sys.exc_info()[2]
+            while trace.tb_next:
+                trace = trace.tb_next
+            self.line = trace.tb_lineno
+        else:
+            try:
+                import inspect
+                self.line = inspect.currentframe().f_back.f_lineno
+            except:
+                self.line = None
+            self.original_exception = None
+
+    def __str__(self):
+        retval = [ self.message ]
+        if self.line:
+            retval.append(" (line %d)" % self.line)
+        if self.original_exception:
+            retval.append(":\n  ")
+            retval.append(str(self.original_exception).replace("\n", "\n  "))
+        if self.report_bug:
+            retval.append("\nThis appears to be a bug. Please help improving autorandr by reporting it upstream."
+                         "\nPlease attach the output of `xrandr --verbose` to your bug report if appropriate.")
+        return "".join(retval)
+
 class XrandrOutput(object):
     "Represents an XRandR output"
 
@@ -82,39 +120,63 @@ class XrandrOutput(object):
         (?:                                                                             # Differentiate disconnected and connected in first line
             disconnected |
             unknown\ connection |
-            (?P<connected>connected)\s+                                                 # If connected:
-            (?:
-            (?P<primary>primary\ )?                                                     # Might be primary screen
+            (?P<connected>connected)
+        )
+        \s*
+        (?P<primary>primary\ )?                                                         # Might be primary screen
+        (?:\s*
             (?P<width>[0-9]+)x(?P<height>[0-9]+)                                        # Resolution (might be overridden below!)
-            \+(?P<x>[0-9]+)\+(?P<y>[0-9]+)\s+                                           # Position
+            \+(?P<x>-?[0-9]+)\+(?P<y>-?[0-9]+)\s+                                       # Position
             (?:\(0x[0-9a-fA-F]+\)\s+)?                                                  # XID
             (?P<rotate>(?:normal|left|right|inverted))\s+                               # Rotation
             (?:(?P<reflect>X\ and\ Y|X|Y)\ axis)?                                       # Reflection
-            )?                                                                          # .. but everything of the above only if the screen is in use.
-        ).*
+        )?                                                                              # .. but everything of the above only if the screen is in use.
+        (?:[\ \t]*\([^\)]+\))(?:\s*[0-9]+mm\sx\s[0-9]+mm)?
+        (?:[\ \t]*panning\ (?P<panning>[0-9]+x[0-9]+\+[0-9]+\+[0-9]+))?                 # Panning information
+        (?:[\ \t]*tracking\ (?P<tracking>[0-9]+x[0-9]+\+[0-9]+\+[0-9]+))?               # Tracking information
+        (?:[\ \t]*border\ (?P<border>(?:[0-9]+/){3}[0-9]+))?                            # Border information
         (?:\s*(?:                                                                       # Properties of the output
-            Gamma: (?P<gamma>[0-9\.:\s]+) |                                             # Gamma value
-            Transform: (?P<transform>[0-9\.\s]+) |                                      # Transformation matrix
-            EDID: (?P<edid>[0-9a-f\s]+) |                                               # EDID of the output
+            Gamma: (?P<gamma>(?:inf|[0-9\.: e])+) |                                     # Gamma value
+            Transform: (?P<transform>(?:[\-0-9\. ]+\s+){3}) |                           # Transformation matrix
+            EDID: (?P<edid>\s*?(?:\\n\\t\\t[0-9a-f]+)+) |                               # EDID of the output
             (?![0-9])[^:\s][^:\n]+:.*(?:\s\\t[\\t ].+)*                                 # Other properties
         ))+
         \s*
         (?P<modes>(?:
-            (?P<mode_width>[0-9]+)x(?P<mode_height>[0-9]+).+?\*current.+\s+
-                h:.+\s+v:.+clock\s+(?P<rate>[0-9\.]+)Hz\s* |                            # Interesting (current) resolution: Extract rate
-            [0-9]+x[0-9]+.+\s+h:.+\s+v:.+\s*                                            # Other resolutions
+            (?P<mode_name>\S+).+?\*current.*\s+                                         # Interesting (current) resolution: Extract rate
+             h:\s+width\s+(?P<mode_width>[0-9]+).+\s+
+             v:\s+height\s+(?P<mode_height>[0-9]+).+clock\s+(?P<rate>[0-9\.]+)Hz\s* |
+            \S+(?:(?!\*current).)+\s+h:.+\s+v:.+\s*                                     # Other resolutions
         )*)
     """
 
     XRANDR_OUTPUT_MODES_REGEXP = """(?x)
-        (?P<width>[0-9]+)x(?P<height>[0-9]+)
-        .*?(?P<preferred>\+preferred)?
-        \s+h:.+
-        \s+v:.+clock\s+(?P<rate>[0-9\.]+)Hz
+        (?P<name>\S+).+?(?P<preferred>\+preferred)?\s+
+         h:\s+width\s+(?P<width>[0-9]+).+\s+
+         v:\s+height\s+(?P<height>[0-9]+).+clock\s+(?P<rate>[0-9\.]+)Hz\s* |
     """
 
+    XRANDR_13_DEFAULTS = {
+        "transform": "1,0,0,0,1,0,0,0,1",
+        "panning": "0x0",
+    }
+
+    XRANDR_12_DEFAULTS = {
+        "reflect": "normal",
+        "rotate": "normal",
+        "gamma": "1.0:1.0:1.0",
+    }
+
+    XRANDR_DEFAULTS = dict(list(XRANDR_13_DEFAULTS.items()) + list(XRANDR_12_DEFAULTS.items()))
+
+    EDID_UNAVAILABLE = "--CONNECTED-BUT-EDID-UNAVAILABLE-"
+
     def __repr__(self):
-        return "<%s%s %s>" % (self.output, (" %s..%s" % (self.edid[:5], self.edid[-5:])) if self.edid else "", " ".join(self.option_vector))
+        return "<%s%s %s>" % (self.output, self.short_edid, " ".join(self.option_vector))
+
+    @property
+    def short_edid(self):
+        return ("%s..%s" % (self.edid[:5], self.edid[-5:])) if self.edid else ""
 
     @property
     def options_with_defaults(self):
@@ -123,32 +185,33 @@ class XrandrOutput(object):
             return self.options
         options = {}
         if xrandr_version() >= Version("1.3"):
-            options.update({
-                "transform": "1,0,0,0,1,0,0,0,1",
-            })
+            options.update(self.XRANDR_13_DEFAULTS)
         if xrandr_version() >= Version("1.2"):
-            options.update({
-                "reflect": "normal",
-                "rotate": "normal",
-                "gamma": "1:1:1",
-            })
+            options.update(self.XRANDR_12_DEFAULTS)
         options.update(self.options)
-        return options
+        return { a: b for a, b in options.items() if a not in self.ignored_options }
+
+    @property
+    def filtered_options(self):
+        "Return a dictionary of options without ignored options"
+        return { a: b for a, b in self.options.items() if a not in self.ignored_options }
 
     @property
     def option_vector(self):
         "Return the command line parameters for XRandR for this instance"
-        return sum([["--%s" % option[0], option[1]] if option[1] else ["--%s" % option[0]] for option in chain((("output", self.output),), self.options_with_defaults.items())], [])
+        return sum([["--%s" % option[0], option[1]] if option[1] else ["--%s" % option[0]] for option in chain((("output", self.output),), sorted(self.options_with_defaults.items()))], [])
 
     @property
     def option_string(self):
         "Return the command line parameters in the configuration file format"
-        return "\n".join([ " ".join(option) if option[1] else option[0] for option in chain((("output", self.output),), self.options.items())])
+        return "\n".join([ " ".join(option) if option[1] else option[0] for option in chain((("output", self.output),), sorted(self.filtered_options.items()))])
 
     @property
     def sort_key(self):
         "Return a key to sort the outputs for xrandr invocation"
         if not self.edid:
+            return -2
+        if "off" in self.options:
             return -1
         if "pos" in self.options:
             x, y = map(float, self.options["pos"].split("x"))
@@ -161,6 +224,21 @@ class XrandrOutput(object):
         self.output = output
         self.edid = edid
         self.options = options
+        self.ignored_options = []
+        self.remove_default_option_values()
+
+    def set_ignored_options(self, options):
+        "Set a list of xrandr options that are never used (neither when comparing configurations nor when applying them)"
+        self.ignored_options = list(options)
+
+    def remove_default_option_values(self):
+        "Remove values from the options dictionary that are superflous"
+        if "off" in self.options and len(self.options.keys()) > 1:
+            self.options = { "off": None }
+            return
+        for option, default_value in self.XRANDR_DEFAULTS.items():
+            if option in self.options and self.options[option] == default_value:
+                del self.options[option]
 
     @classmethod
     def from_xrandr_output(cls, xrandr_output):
@@ -169,68 +247,78 @@ class XrandrOutput(object):
         This method also returns a list of modes supported by the output.
         """
         try:
+            xrandr_output = xrandr_output.replace("\r\n", "\n")
             match_object = re.search(XrandrOutput.XRANDR_OUTPUT_REGEXP, xrandr_output)
         except:
-            raise RuntimeError("Parsing XRandR output failed, there is an error in the regular expression.")
+            raise AutorandrException("Parsing XRandR output failed, there is an error in the regular expression.", report_bug = True)
         if not match_object:
             debug = debug_regexp(XrandrOutput.XRANDR_OUTPUT_REGEXP, xrandr_output)
-            raise RuntimeError("Parsing XRandR output failed, the regular expression did not match: %s" % debug)
+            raise AutorandrException("Parsing XRandR output failed, the regular expression did not match: %s" % debug, report_bug = True)
         remainder = xrandr_output[len(match_object.group(0)):]
         if remainder:
-            raise RuntimeError(("Parsing XRandR output failed, %d bytes left unmatched after regular expression,"
-                                "starting with ..'%s'.") % (len(remainder), remainder[:10]))
-
+            raise AutorandrException(("Parsing XRandR output failed, %d bytes left unmatched after regular expression, "
+                                "starting at byte %d with ..'%s'.") % (len(remainder), len(match_object.group(0)), remainder[:10]), report_bug=True)
 
         match = match_object.groupdict()
 
         modes = []
         if match["modes"]:
-            modes = [ x.groupdict() for x in re.finditer(XrandrOutput.XRANDR_OUTPUT_MODES_REGEXP, match["modes"]) ]
+            modes = [ x.groupdict() for x in re.finditer(XrandrOutput.XRANDR_OUTPUT_MODES_REGEXP, match["modes"]) if x.group("name") ]
             if not modes:
-                raise RuntimeError("Parsing XRandR output failed, couldn't find any display modes")
+                raise AutorandrException("Parsing XRandR output failed, couldn't find any display modes", report_bug=True)
 
         options = {}
         if not match["connected"]:
-            options["off"] = None
             edid = None
-        elif not match["width"]:
+        else:
+            edid = "".join(match["edid"].strip().split()) if match["edid"] else "%s-%s" % (XrandrOutput.EDID_UNAVAILABLE, match["output"])
+
+        if not match["width"]:
             options["off"] = None
-            edid = "".join(match["edid"].strip().split())
         else:
-            if "mode_width" in match:
+            if match["mode_name"]:
+                options["mode"] = match["mode_name"]
+            elif match["mode_width"]:
                 options["mode"] = "%sx%s" % (match["mode_width"], match["mode_height"])
             else:
                 if match["rotate"] not in ("left", "right"):
                     options["mode"] = "%sx%s" % (match["width"], match["height"])
                 else:
                     options["mode"] = "%sx%s" % (match["height"], match["width"])
-            if match["rotate"] != "normal":
-                options["rotate"] = match["rotate"]
-            if "primary" in match and match["primary"]:
+            options["rotate"] = match["rotate"]
+            if match["primary"]:
                 options["primary"] = None
-            if "reflect" in match:
-                if match["reflect"] == "X":
-                    options["reflect"] = "x"
-                elif match["reflect"] == "Y":
-                    options["reflect"] = "y"
-                elif match["reflect"] == "X and Y":
-                    options["reflect"] = "xy"
+            if match["reflect"] == "X":
+                options["reflect"] = "x"
+            elif match["reflect"] == "Y":
+                options["reflect"] = "y"
+            elif match["reflect"] == "X and Y":
+                options["reflect"] = "xy"
             options["pos"] = "%sx%s" % (match["x"], match["y"])
+            if match["panning"]:
+                panning = [ match["panning"] ]
+                if match["tracking"]:
+                    panning += [ "/", match["tracking"] ]
+                    if match["border"]:
+                        panning += [ "/", match["border"] ]
+                options["panning"] = "".join(panning)
             if match["transform"]:
                 transformation = ",".join(match["transform"].strip().split())
                 if transformation != "1.000000,0.000000,0.000000,0.000000,1.000000,0.000000,0.000000,0.000000,1.000000":
                     options["transform"] = transformation
-                    if "mode_width" not in match:
+                    if not match["mode_name"]:
                         # TODO We'd need to apply the reverse transformation here. Let's see if someone complains, I doubt that this
                         # special case is actually required.
-                        print("Warning: Output %s has a transformation applied. Could not determine correct mode!", file=sys.stderr)
+                        print("Warning: Output %s has a transformation applied. Could not determine correct mode! Using `%s'." % (match["output"], options["mode"]), file=sys.stderr)
             if match["gamma"]:
                 gamma = match["gamma"].strip()
-                if gamma != "1.0:1.0:1.0":
-                    options["gamma"] = gamma
+                # xrandr prints different values in --verbose than it accepts as a parameter value for --gamma
+                # Also, it is not able to work with non-standard gamma ramps. Finally, it auto-corrects 0 to 1,
+                # so we approximate by 1e-10.
+                gamma = ":".join([ str(max(1e-10, round(1./float(x), 3))) for x in gamma.split(":") ])
+                options["gamma"] = gamma
             if match["rate"]:
                 options["rate"] = match["rate"]
-            edid = "".join(match["edid"].strip().split())
 
         return XrandrOutput(match["output"], edid, options), modes
 
@@ -254,8 +342,7 @@ class XrandrOutput(object):
             if fuzzy_output in fuzzy_edid_map:
                 edid = edid_map[list(edid_map.keys())[fuzzy_edid_map.index(fuzzy_output)]]
             elif "off" not in options:
-                raise RuntimeError("Failed to find an EDID for output `%s' in setup file, required as `%s' is not off in config file."
-                                   % (options["output"], options["output"]))
+                raise AutorandrException("Failed to find an EDID for output `%s' in setup file, required as `%s' is not off in config file." % (options["output"], options["output"]))
         output = options["output"]
         del options["output"]
 
@@ -264,21 +351,49 @@ class XrandrOutput(object):
     def edid_equals(self, other):
         "Compare to another XrandrOutput's edid and on/off-state, taking legacy autorandr behaviour (md5sum'ing) into account"
         if self.edid and other.edid:
-            if len(self.edid) == 32 and len(other.edid) != 32:
+            if len(self.edid) == 32 and len(other.edid) != 32 and not other.edid.startswith(XrandrOutput.EDID_UNAVAILABLE):
                 return hashlib.md5(binascii.unhexlify(other.edid)).hexdigest() == self.edid
-            if len(self.edid) != 32 and len(other.edid) == 32:
+            if len(self.edid) != 32 and len(other.edid) == 32 and not self.edid.startswith(XrandrOutput.EDID_UNAVAILABLE):
                 return hashlib.md5(binascii.unhexlify(self.edid)).hexdigest() == other.edid
         return self.edid == other.edid
 
+    def __ne__(self, other):
+        return not (self == other)
+
     def __eq__(self, other):
-        return self.edid == other.edid and self.output == other.output and self.options == other.options
+        return self.edid_equals(other) and self.output == other.output and self.filtered_options == other.filtered_options
+
+    def verbose_diff(self, other):
+        "Compare to another XrandrOutput and return a list of human readable differences"
+        diffs = []
+        if not self.edid_equals(other):
+            diffs.append("EDID `%s' differs from `%s'" % (self.short_edid, other.short_edid))
+        if self.output != other.output:
+            diffs.append("Output name `%s' differs from `%s'" % (self.output, other.output))
+        if "off" in self.options and "off" not in other.options:
+            diffs.append("The output is disabled currently, but active in the new configuration")
+        elif "off" in other.options and "off" not in self.options:
+            diffs.append("The output is currently enabled, but inactive in the new configuration")
+        else:
+            for name in set(chain.from_iterable((self.options.keys(), other.options.keys()))):
+                if name not in other.options:
+                    diffs.append("Option --%s %sis not present in the new configuration" % (name, "(= `%s') " % self.options[name] if self.options[name] else ""))
+                elif name not in self.options:
+                    diffs.append("Option --%s (`%s' in the new configuration) is not present currently" % (name, other.options[name]))
+                elif self.options[name] != other.options[name]:
+                    diffs.append("Option --%s %sis `%s' in the new configuration" % (name, "(= `%s') " % self.options[name] if self.options[name] else "", other.options[name]))
+        return diffs
 
 def xrandr_version():
     "Return the version of XRandR that this system uses"
     if getattr(xrandr_version, "version", False) is False:
         version_string = os.popen("xrandr -v").read()
-        version = re.search("xrandr program version\s+([0-9\.]+)", version_string).group(1)
-        xrandr_version.version = Version(version)
+        try:
+            version = re.search("xrandr program version\s+([0-9\.]+)", version_string).group(1)
+            xrandr_version.version = Version(version)
+        except AttributeError:
+            xrandr_version.version = Version("1.3.0")
+
     return xrandr_version.version
 
 def debug_regexp(pattern, string):
@@ -297,19 +412,21 @@ def debug_regexp(pattern, string):
                                                              string[partial_length:partial_length+10]))
     except ImportError:
         pass
-    return "Debug information available if `regex' module is installed."
+    return "Debug information would be available if the `regex' module was installed."
 
 def parse_xrandr_output():
     "Parse the output of `xrandr --verbose' into a list of outputs"
     xrandr_output = os.popen("xrandr -q --verbose").read()
     if not xrandr_output:
-        raise RuntimeError("Failed to run xrandr")
+        raise AutorandrException("Failed to run xrandr")
 
     # We are not interested in screens
     xrandr_output = re.sub("(?m)^Screen [0-9].+", "", xrandr_output).strip()
 
     # Split at output boundaries and instanciate an XrandrOutput per output
     split_xrandr_output = re.split("(?m)^([^ ]+ (?:(?:dis)?connected|unknown connection).*)$", xrandr_output)
+    if len(split_xrandr_output) < 2:
+        raise AutorandrException("No output boundaries found", report_bug=True)
     outputs = OrderedDict()
     modes = OrderedDict()
     for i in range(1, len(split_xrandr_output), 2):
@@ -331,7 +448,7 @@ def load_profiles(profile_path):
         if not os.path.isfile(config_name) or not os.path.isfile(setup_name):
             continue
 
-        edids = dict([ x.strip().split() for x in open(setup_name).readlines() ])
+        edids = dict([ x.strip().split() for x in open(setup_name).readlines() if x.strip() ])
 
         config = {}
         buffer = []
@@ -346,28 +463,31 @@ def load_profiles(profile_path):
             if config[output_name].edid is None:
                 del config[output_name]
 
-        profiles[profile] = config
+        profiles[profile] = { "config": config, "path": os.path.join(profile_path, profile), "config-mtime": os.stat(config_name).st_mtime }
 
     return profiles
 
-def find_profile(current_config, profiles):
-    "Find a profile matching the currently connected outputs"
+def find_profiles(current_config, profiles):
+    "Find profiles matching the currently connected outputs"
+    detected_profiles = []
     for profile_name, profile in profiles.items():
+        config = profile["config"]
         matches = True
-        for name, output in profile.items():
+        for name, output in config.items():
             if not output.edid:
                 continue
             if name not in current_config or not output.edid_equals(current_config[name]):
                 matches = False
                 break
-        if not matches or any(( name not in profile.keys() for name in current_config.keys() if current_config[name].edid )):
+        if not matches or any(( name not in config.keys() for name in current_config.keys() if current_config[name].edid )):
             continue
         if matches:
-            return profile_name
+            detected_profiles.append(profile_name)
+    return detected_profiles
 
 def profile_blocked(profile_path):
     "Check if a profile is blocked"
-    script = os.path.join(profile_path, "blocked")
+    script = os.path.join(profile_path, "block")
     if not os.access(script, os.X_OK | os.F_OK):
         return False
     return subprocess.call(script) == 0
@@ -394,28 +514,88 @@ def save_configuration(profile_path, configuration):
     with open(os.path.join(profile_path, "setup"), "w") as setup:
         output_setup(configuration, setup)
 
-def apply_configuration(configuration, dry_run=False):
+def update_mtime(filename):
+    "Update a file's mtime"
+    try:
+        os.utime(filename, None)
+        return True
+    except:
+        return False
+
+def apply_configuration(new_configuration, current_configuration, dry_run=False):
     "Apply a configuration"
-    outputs = sorted(configuration.keys(), key=lambda x: configuration[x].sort_key)
+    outputs = sorted(new_configuration.keys(), key=lambda x: new_configuration[x].sort_key)
     if dry_run:
         base_argv = [ "echo", "xrandr" ]
     else:
         base_argv = [ "xrandr" ]
 
-    # Disable all unused outputs
-    argv = base_argv[:]
+    # There are several xrandr / driver bugs we need to take care of here:
+    # - We cannot enable more than two screens at the same time
+    #   See https://github.com/phillipberndt/autorandr/pull/6
+    #   and commits f4cce4d and 8429886.
+    # - We cannot disable all screens
+    #   See https://github.com/phillipberndt/autorandr/pull/20
+    # - We should disable screens before enabling others, because there's
+    #   a limit on the number of enabled screens
+    # - We must make sure that the screen at 0x0 is activated first,
+    #   or the other (first) screen to be activated would be moved there.
+    # - If an active screen already has a transformation and remains active,
+    #   the xrandr call fails with an invalid RRSetScreenSize parameter error.
+    #   Update the configuration in 3 passes in that case.  (On Haswell graphics,
+    #   at least.)
+
+    auxiliary_changes_pre = []
+    disable_outputs = []
+    enable_outputs = []
+    remain_active_count = 0
     for output in outputs:
-        if not configuration[output].edid:
-            argv += configuration[output].option_vector
-    if argv != base_argv:
+        if not new_configuration[output].edid or "off" in new_configuration[output].options:
+            disable_outputs.append(new_configuration[output].option_vector)
+        else:
+            if "off" not in current_configuration[output].options:
+                remain_active_count += 1
+            enable_outputs.append(new_configuration[output].option_vector)
+            if xrandr_version() >= Version("1.3.0") and "transform" in current_configuration[output].options:
+                auxiliary_changes_pre.append(["--output", output, "--transform", "none"])
+
+    # Perform pe-change auxiliary changes
+    if auxiliary_changes_pre:
+        argv = base_argv + list(chain.from_iterable(auxiliary_changes_pre))
         if subprocess.call(argv) != 0:
-            return False
+            raise AutorandrException("Command failed: %s" % " ".join(argv))
+
+    # Disable unused outputs, but make sure that there always is at least one active screen
+    disable_keep = 0 if remain_active_count else 1
+    if len(disable_outputs) > disable_keep:
+        if subprocess.call(base_argv + list(chain.from_iterable(disable_outputs[:-1] if disable_keep else disable_outputs))) != 0:
+            # Disabling the outputs failed. Retry with the next command:
+            # Sometimes disabling of outputs fails due to an invalid RRSetScreenSize.
+            # This does not occur if simultaneously the primary screen is reset.
+            pass
+        else:
+            disable_outputs = disable_outputs[-1:] if disable_keep else []
+
+    # If disable_outputs still has more than one output in it, one of the xrandr-calls below would
+    # disable the last two screens. This is a problem, so if this would happen, instead disable only
+    # one screen in the first call below.
+    if len(disable_outputs) > 0 and len(disable_outputs) % 2 == 0:
+        # In the context of a xrandr call that changes the display state, `--query' should do nothing
+        disable_outputs.insert(0, ['--query'])
+
+    # Enable the remaining outputs in pairs of two operations
+    operations = disable_outputs + enable_outputs
+    for index in range(0, len(operations), 2):
+        argv = base_argv + list(chain.from_iterable(operations[index:index+2]))
+        if subprocess.call(argv) != 0:
+            raise AutorandrException("Command failed: %s" % " ".join(argv))
 
-    # Enable remaining outputs in pairs of two
-    remaining_outputs = [ x for x in outputs if configuration[x].edid ]
-    for index in range(0, len(remaining_outputs), 2):
-        if subprocess.call((base_argv[:] + configuration[remaining_outputs[index]].option_vector + (configuration[remaining_outputs[index + 1]].option_vector if index < len(remaining_outputs) - 1 else []))) != 0:
+def is_equal_configuration(source_configuration, target_configuration):
+    "Check if all outputs from target are already configured correctly in source"
+    for output in target_configuration.keys():
+        if (output not in source_configuration) or (source_configuration[output] != target_configuration[output]):
             return False
+    return True
 
 def add_unused_outputs(source_configuration, target_configuration):
     "Add outputs that are missing in target to target, in 'off' state"
@@ -423,18 +603,24 @@ def add_unused_outputs(source_configuration, target_configuration):
         if output_name not in target_configuration:
             target_configuration[output_name] = XrandrOutput(output_name, output.edid, { "off": None })
 
+def remove_irrelevant_outputs(source_configuration, target_configuration):
+    "Remove outputs from target that ought to be 'off' and already are"
+    for output_name, output in source_configuration.items():
+        if "off" in output.options and output_name in target_configuration and "off" in target_configuration[output_name].options:
+            del target_configuration[output_name]
+
 def generate_virtual_profile(configuration, modes, profile_name):
     "Generate one of the virtual profiles"
     configuration = copy.deepcopy(configuration)
     if profile_name == "common":
-        common_resolution = [ set(( ( mode["width"], mode["height"] ) for mode in output )) for output in modes.values() ]
+        common_resolution = [ set(( ( mode["width"], mode["height"] ) for mode in output_modes )) for output, output_modes in modes.items() if configuration[output].edid ]
         common_resolution = reduce(lambda a, b: a & b, common_resolution[1:], common_resolution[0])
         common_resolution = sorted(common_resolution, key=lambda a: int(a[0])*int(a[1]))
         if common_resolution:
             for output in configuration:
                 configuration[output].options = {}
-                if output in modes:
-                    configuration[output].options["mode"] = "%sx%s" % common_resolution[-1]
+                if output in modes and configuration[output].edid:
+                    configuration[output].options["mode"] = [ x["name"] for x in sorted(modes[output], key=lambda x: 0 if x["preferred"] else 1) if x["width"] == common_resolution[-1][0] and x["height"] == common_resolution[-1][1] ][0]
                     configuration[output].options["pos"] = "0x0"
                 else:
                     configuration[output].options["off"] = None
@@ -449,9 +635,9 @@ def generate_virtual_profile(configuration, modes, profile_name):
 
         for output in configuration:
             configuration[output].options = {}
-            if output in modes:
+            if output in modes and configuration[output].edid:
                 mode = sorted(modes[output], key=lambda a: int(a["width"])*int(a["height"]) + (10**6 if a["preferred"] else 0))[-1]
-                configuration[output].options["mode"] = "%sx%s" % (mode["width"], mode["height"])
+                configuration[output].options["mode"] = mode["name"]
                 configuration[output].options["rate"] = mode["rate"]
                 configuration[output].options["pos"] = pos_specifier % shift
                 shift += int(mode[shift_index])
@@ -459,6 +645,23 @@ def generate_virtual_profile(configuration, modes, profile_name):
                 configuration[output].options["off"] = None
     return configuration
 
+def print_profile_differences(one, another):
+    "Print the differences between two profiles for debugging"
+    if one == another:
+        return
+    print("| Differences between the two profiles:", file=sys.stderr)
+    for output in set(chain.from_iterable((one.keys(), another.keys()))):
+        if output not in one:
+            if "off" not in another[output].options:
+                print("| Output `%s' is missing from the active configuration" % output, file=sys.stderr)
+        elif output not in another:
+            if "off" not in one[output].options:
+                print("| Output `%s' is missing from the new configuration" % output, file=sys.stderr)
+        else:
+            for line in one[output].verbose_diff(another[output]):
+                print("| [Output %s] %s" % (output, line), file=sys.stderr)
+    print ("\\-", file=sys.stderr)
+
 def exit_help():
     "Print help and exit"
     print(help_text)
@@ -474,24 +677,34 @@ def exec_scripts(profile_path, script_name):
 
 def main(argv):
     try:
-       options = dict(getopt.getopt(argv[1:], "s:l:d:cfh", [ "dry-run", "change", "default=", "save=", "load=", "force", "fingerprint", "config", "help" ])[0])
+       options = dict(getopt.getopt(argv[1:], "s:l:d:cfh", [ "dry-run", "change", "default=", "save=", "load=", "force", "fingerprint", "config", "debug", "skip-options=", "help" ])[0])
     except getopt.GetoptError as e:
-        print(str(e))
-        options = { "--help": True }
-
-    profile_path = os.path.expanduser("~/.autorandr")
+        print("Failed to parse options: {0}.\n"
+              "Use --help to get usage information.".format(str(e)),
+              file=sys.stderr)
+        sys.exit(posix.EX_USAGE)
 
+    profiles = {}
     try:
-        profiles = load_profiles(profile_path)
+        # Load profiles from each XDG config directory
+        for directory in os.environ.get("XDG_CONFIG_DIRS", "").split(":"):
+            system_profile_path = os.path.join(directory, "autorandr")
+            if os.path.isdir(system_profile_path):
+                profiles.update(load_profiles(system_profile_path))
+        # For the user's profiles, prefer the legacy ~/.autorandr if it already exists
+        # profile_path is also used later on to store configurations
+        profile_path = os.path.expanduser("~/.autorandr")
+        if not os.path.isdir(profile_path):
+            # Elsewise, follow the XDG specification
+            profile_path = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
+        if os.path.isdir(profile_path):
+            profiles.update(load_profiles(profile_path))
+        # Sort by descending mtime
+        profiles = OrderedDict(sorted(profiles.items(), key=lambda x: -x[1]["config-mtime"]))
     except Exception as e:
-        print("Failed to load profiles:\n%s" % str(e), file=sys.stderr)
-        sys.exit(1)
+        raise AutorandrException("Failed to load profiles", e)
 
-    try:
-        config, modes = parse_xrandr_output()
-    except Exception as e:
-        print("Failed to parse current configuration from XRandR:\n%s" % str(e), file=sys.stderr)
-        sys.exit(1)
+    config, modes = parse_xrandr_output()
 
     if "--fingerprint" in options:
         output_setup(config, sys.stdout)
@@ -501,24 +714,30 @@ def main(argv):
         output_configuration(config, sys.stdout)
         sys.exit(0)
 
+    if "--skip-options" in options:
+        skip_options = [ y[2:] if y[:2] == "--" else y for y in ( x.strip() for x in options["--skip-options"].split(",") ) ]
+        for profile in profiles.values():
+            for output in profile["config"].values():
+                output.set_ignored_options(skip_options)
+        for output in config.values():
+            output.set_ignored_options(skip_options)
+
     if "-s" in options:
         options["--save"] = options["-s"]
     if "--save" in options:
         if options["--save"] in ( x[0] for x in virtual_profiles ):
-            print("Cannot save current configuration as profile '%s':\nThis configuration name is a reserved virtual configuration." % options["--save"])
-            sys.exit(1)
+            raise AutorandrException("Cannot save current configuration as profile '%s':\nThis configuration name is a reserved virtual configuration." % options["--save"])
         try:
             save_configuration(os.path.join(profile_path, options["--save"]), config)
         except Exception as e:
-            print("Failed to save current configuration as profile '%s':\n%s" % (options["--save"], str(e)), file=sys.stderr)
-            sys.exit(1)
+            raise AutorandrException("Failed to save current configuration as profile '%s'" % (options["--save"],), e)
         print("Saved current configuration as profile '%s'" % options["--save"])
         sys.exit(0)
 
     if "-h" in options or "--help" in options:
         exit_help()
 
-    detected_profile = find_profile(config, profiles)
+    detected_profiles = find_profiles(config, profiles)
     load_profile = False
 
     if "-l" in options:
@@ -528,14 +747,19 @@ def main(argv):
     else:
         for profile_name in profiles.keys():
             if profile_blocked(os.path.join(profile_path, profile_name)):
-                print("%s (blocked)" % profile_name)
+                print("%s (blocked)" % profile_name, file=sys.stderr)
                 continue
-            if detected_profile == profile_name:
-                print("%s (detected)" % profile_name)
-                if "-c" in options or "--change" in options:
-                    load_profile = detected_profile
-            else:
-                print(profile_name)
+            props = []
+            if profile_name in detected_profiles:
+                props.append("(detected)")
+                if ("-c" in options or "--change" in options) and not load_profile:
+                    load_profile = profile_name
+            configs_are_equal = is_equal_configuration(config, profiles[profile_name]["config"])
+            if configs_are_equal:
+                props.append("(current)")
+            print("%s%s%s" % (profile_name, " " if props else "", " ".join(props)), file=sys.stderr)
+            if not configs_are_equal and "--debug" in options and profile_name in detected_profiles:
+                print_profile_differences(config, profiles[profile_name]["config"])
 
     if "-d" in options:
         options["--default"] = options["-d"]
@@ -544,34 +768,55 @@ def main(argv):
 
     if load_profile:
         if load_profile in ( x[0] for x in virtual_profiles ):
-            profile = generate_virtual_profile(config, modes, load_profile)
+            load_config = generate_virtual_profile(config, modes, load_profile)
+            scripts_path = os.path.join(profile_path, load_profile)
         else:
             try:
                 profile = profiles[load_profile]
+                load_config = profile["config"]
+                scripts_path = profile["path"]
             except KeyError:
-                print("Failed to load profile '%s':\nProfile not found" % load_profile, file=sys.stderr)
-                sys.exit(1)
-        add_unused_outputs(config, profile)
-        if profile == config and not "-f" in options and not "--force" in options:
-            print("Config already loaded")
+                raise AutorandrException("Failed to load profile '%s': Profile not found" % load_profile)
+            if load_profile in detected_profiles and detected_profiles[0] != load_profile:
+                update_mtime(os.path.join(scripts_path, "config"))
+        add_unused_outputs(config, load_config)
+        if load_config == dict(config) and not "-f" in options and not "--force" in options:
+            print("Config already loaded", file=sys.stderr)
             sys.exit(0)
+        if "--debug" in options and load_config != dict(config):
+            print("Loading profile '%s'" % load_profile)
+            print_profile_differences(config, load_config)
+
+        remove_irrelevant_outputs(config, load_config)
 
         try:
             if "--dry-run" in options:
-                apply_configuration(profile, True)
+                apply_configuration(load_config, config, True)
             else:
-                exec_scripts(os.path.join(profile_path, load_profile), "preswitch")
-                apply_configuration(profile, False)
-                exec_scripts(os.path.join(profile_path, load_profile), "postswitch")
+                exec_scripts(scripts_path, "preswitch")
+                apply_configuration(load_config, config, False)
+                exec_scripts(scripts_path, "postswitch")
         except Exception as e:
-            print("Failed to apply profile '%s':\n%s" % (load_profile, str(e)), file=sys.stderr)
-            sys.exit(1)
+            raise AutorandrException("Failed to apply profile '%s'" % load_profile, e, True)
+
+        if "--dry-run" not in options and "--debug" in options:
+            new_config, _ = parse_xrandr_output()
+            if not is_equal_configuration(new_config, load_config):
+                print("The configuration change did not go as expected:")
+                print_profile_differences(new_config, load_config)
 
     sys.exit(0)
 
 if __name__ == '__main__':
     try:
         main(sys.argv)
-    except Exception as e:
-        print("General failure. Please report this as a bug:\n%s" % (str(e),), file=sys.stderr)
+    except AutorandrException as e:
+        print(e, file=sys.stderr)
         sys.exit(1)
+    except Exception as e:
+        if not len(str(e)):  # BdbQuit
+            print("Exception: {0}".format(e.__class__.__name__))
+            sys.exit(2)
+
+        print("Unhandled exception ({0}). Please report this as a bug.".format(e), file=sys.stderr)
+        raise