X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=autorandr.py;h=596d3ffb504d20f04d3cbad2dba2956efe660ddf;hb=ac540ffafada68dfee5a992ae92f5926bc5d6849;hp=c33246f4ddb9c7b0a2052dc645299a36fe9976a7;hpb=89bf1ac166e2c124c2b0bd687138b8fddbe74c47;p=deb_pkgs%2Fautorandr.git

diff --git a/autorandr.py b/autorandr.py
index c33246f..596d3ff 100755
--- a/autorandr.py
+++ b/autorandr.py
@@ -23,19 +23,22 @@
 #
 
 from __future__ import print_function
-import copy
-import getopt
 
 import binascii
+import copy
+import getopt
 import hashlib
 import os
+import posix
 import re
 import subprocess
 import sys
-from distutils.version import LooseVersion as Version
 
-from itertools import chain
 from collections import OrderedDict
+from distutils.version import LooseVersion as Version
+from functools import reduce
+from itertools import chain
+
 
 virtual_profiles = [
     # (name, description, callback)
@@ -52,10 +55,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
@@ -74,6 +80,36 @@ Usage: autorandr [options]
  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"
 
@@ -99,24 +135,24 @@ class XrandrOutput(object):
         (?:[\ \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\.: ]+) |                                              # Gamma value
+            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]+(?:(?!\*current).)+\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 = {
@@ -135,7 +171,11 @@ class XrandrOutput(object):
     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):
@@ -148,7 +188,12 @@ class XrandrOutput(object):
         if xrandr_version() >= Version("1.2"):
             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):
@@ -158,7 +203,7 @@ class XrandrOutput(object):
     @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),), sorted(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):
@@ -178,8 +223,13 @@ 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:
@@ -199,22 +249,22 @@ class XrandrOutput(object):
             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 at byte %d with ..'%s'.") % (len(remainder), len(match_object.group(0)), 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"]:
@@ -225,7 +275,9 @@ class XrandrOutput(object):
         if not match["width"]:
             options["off"] = None
         else:
-            if match["mode_width"]:
+            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"):
@@ -253,12 +305,16 @@ class XrandrOutput(object):
                 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 not match["mode_width"]:
+                    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! Using `%s'." % (match["output"], options["mode"]), file=sys.stderr)
             if match["gamma"]:
                 gamma = match["gamma"].strip()
+                # 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"]
@@ -285,8 +341,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"]
 
@@ -301,8 +356,32 @@ class XrandrOutput(object):
                 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_equals(other) 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"
@@ -332,13 +411,13 @@ 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()
@@ -346,7 +425,7 @@ def parse_xrandr_output():
     # 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 RuntimeError("No output boundaries found")
+        raise AutorandrException("No output boundaries found", report_bug=True)
     outputs = OrderedDict()
     modes = OrderedDict()
     for i in range(1, len(split_xrandr_output), 2):
@@ -405,12 +484,13 @@ def find_profiles(current_config, profiles):
             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, "block")
-    if not os.access(script, os.X_OK | os.F_OK):
-        return False
-    return subprocess.call(script) == 0
+def profile_blocked(profile_path, meta_information=None):
+    """Check if a profile is blocked.
+
+    meta_information is expected to be an dictionary. It will be passed to the block scripts
+    in the environment, as variables called AUTORANDR_<CAPITALIZED_KEY_HERE>.
+    """
+    return not exec_scripts(profile_path, "block", meta_information)
 
 def output_configuration(configuration, config):
     "Write a configuration file"
@@ -464,6 +544,8 @@ def apply_configuration(new_configuration, current_configuration, dry_run=False)
     #   the xrandr call fails with an invalid RRSetScreenSize parameter error.
     #   Update the configuration in 3 passes in that case.  (On Haswell graphics,
     #   at least.)
+    # - Some implementations can not handle --transform at all, so avoid it unless
+    #   necessary. (See https://github.com/phillipberndt/autorandr/issues/37)
 
     auxiliary_changes_pre = []
     disable_outputs = []
@@ -475,15 +557,26 @@ def apply_configuration(new_configuration, current_configuration, dry_run=False)
         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"])
+
+            option_vector = new_configuration[output].option_vector
+            if xrandr_version() >= Version("1.3.0"):
+                if "transform" in current_configuration[output].options:
+                    auxiliary_changes_pre.append(["--output", output, "--transform", "none"])
+                else:
+                    try:
+                        transform_index = option_vector.index("--transform")
+                        if option_vector[transform_index+1] == XrandrOutput.XRANDR_DEFAULTS["transform"]:
+                            option_vector = option_vector[:transform_index] + option_vector[transform_index+2:]
+                    except ValueError:
+                        pass
+
+            enable_outputs.append(option_vector)
 
     # Perform pe-change auxiliary changes
     if auxiliary_changes_pre:
         argv = base_argv + list(chain.from_iterable(auxiliary_changes_pre))
         if subprocess.call(argv) != 0:
-            raise RuntimeError("Command failed: %s" % " ".join(argv))
+            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
@@ -508,7 +601,14 @@ def apply_configuration(new_configuration, current_configuration, dry_run=False)
     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 RuntimeError("Command failed: %s" % " ".join(argv))
+            raise AutorandrException("Command failed: %s" % " ".join(argv))
+
+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"
@@ -526,14 +626,14 @@ 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
@@ -548,9 +648,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])
@@ -558,6 +658,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)
@@ -565,23 +682,67 @@ def exit_help():
         print("  %-10s %s" % profile[:2])
     sys.exit(0)
 
-def exec_scripts(profile_path, script_name):
-    "Run userscripts"
-    for script in (os.path.join(profile_path, script_name), os.path.join(os.path.dirname(profile_path), script_name)):
-        if os.access(script, os.X_OK | os.F_OK):
-            subprocess.call(script)
+def exec_scripts(profile_path, script_name, meta_information=None):
+    """"Run userscripts
+
+    This will run all executables from the profile folder, and global per-user
+    and system-wide configuration folders, named script_name or residing in
+    subdirectories named script_name.d.
+
+    meta_information is expected to be an dictionary. It will be passed to the block scripts
+    in the environment, as variables called AUTORANDR_<CAPITALIZED_KEY_HERE>.
+
+    Returns True unless any of the scripts exited with non-zero exit status.
+    """
+    all_ok = True
+    if meta_information:
+        env = os.environ.copy()
+        env.update({ "AUTORANDR_%s" % str(key).upper(): str(value) for (key, value) in meta_information.items() })
+    else:
+        env = os.environ.copy()
+
+    # If there are multiple candidates, the XDG spec tells to only use the first one.
+    ran_scripts = set()
+
+    user_profile_path = os.path.expanduser("~/.autorandr")
+    if not os.path.isdir(user_profile_path):
+        user_profile_path = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
+
+    for folder in chain((profile_path, os.path.dirname(profile_path), user_profile_path),
+                        (os.path.join(x, "autorandr") for x in os.environ.get("XDG_CONFIG_DIRS", "").split(":"))):
+
+        if script_name not in ran_scripts:
+            script = os.path.join(folder, script_name)
+            if os.access(script, os.X_OK | os.F_OK):
+                all_ok &= subprocess.call(script, env=env) != 0
+                ran_scripts.add(script_name)
+
+        script_folder = os.path.join(folder, "%s.d" % script_name)
+        if os.access(script_folder, os.R_OK | os.X_OK) and os.path.isdir(script_folder):
+            for file_name in os.listdir(script_folder):
+                check_name = "d/%s" % (file_name,)
+                if check_name not in ran_scripts:
+                    script = os.path.join(script_folder, file_name)
+                    if os.access(script, os.X_OK | os.F_OK):
+                        all_ok &= subprocess.call(script, env=env) != 0
+                        ran_scripts.add(check_name)
+
+    return all_ok
 
 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 }
+        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:
         # Load profiles from each XDG config directory
-        for directory in os.environ.get("XDG_CONFIG_DIRS", "").split(":"):
+        # The XDG spec says that earlier entries should take precedence, so reverse the order
+        for directory in reversed(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))
@@ -596,14 +757,9 @@ def main(argv):
         # 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)
@@ -613,17 +769,25 @@ 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)
+            profile_folder = os.path.join(profile_path, options["--save"])
+            save_configuration(profile_folder, config)
+            exec_scripts(profile_folder, "postsave", {"CURRENT_PROFILE": options["--save"], "PROFILE_FOLDER": profile_folder})
         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)
 
@@ -638,16 +802,31 @@ def main(argv):
     if "--load" in options:
         load_profile = options["--load"]
     else:
+        # Find the active profile(s) first, for the block script (See #42)
+        current_profiles = []
+        for profile_name in profiles.keys():
+            configs_are_equal = is_equal_configuration(config, profiles[profile_name]["config"])
+            if configs_are_equal:
+                current_profiles.append(profile_name)
+        block_script_metadata = {
+            "CURRENT_PROFILE":  "".join(current_profiles[:1]),
+            "CURRENT_PROFILES": ":".join(current_profiles)
+        }
+
         for profile_name in profiles.keys():
-            if profile_blocked(os.path.join(profile_path, profile_name)):
+            if profile_blocked(os.path.join(profile_path, profile_name), block_script_metadata):
                 print("%s (blocked)" % profile_name, file=sys.stderr)
                 continue
+            props = []
             if profile_name in detected_profiles:
-                print("%s (detected)" % profile_name, file=sys.stderr)
+                props.append("(detected)")
                 if ("-c" in options or "--change" in options) and not load_profile:
                     load_profile = profile_name
-            else:
-                print(profile_name, file=sys.stderr)
+            if profile_name in current_profiles:
+                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"]
@@ -664,32 +843,51 @@ def main(argv):
                 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)
+                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(load_config, config, True)
             else:
-                exec_scripts(scripts_path, "preswitch")
+                script_metadata = {
+                    "CURRENT_PROFILE": load_profile,
+                    "PROFILE_FOLDER": scripts_path,
+                }
+                exec_scripts(scripts_path, "preswitch", script_metadata)
                 apply_configuration(load_config, config, False)
-                exec_scripts(scripts_path, "postswitch")
+                exec_scripts(scripts_path, "postswitch", script_metadata)
         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