autorandr.py

   1 #!/usr/bin/env python
   2 # encoding: utf-8
   3 #
   4 # autorandr.py
   5 # Copyright (c) 2015, Phillip Berndt
   6 #
   7 # Autorandr rewrite in Python
   8 #
   9 # This script aims to be fully compatible with the original autorandr.
  10 #
  11 # This program is free software: you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation, either version 3 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # This program is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19 # GNU General Public License for more details.
  20 #
  21 # You should have received a copy of the GNU General Public License
  22 # along with this program. If not, see <http://www.gnu.org/licenses/>.
  23 #
  24
  25 from __future__ import print_function
  26
  27 import binascii
  28 import copy
  29 import getopt
  30 import hashlib
  31 import os
  32 import posix
  33 import pwd
  34 import re
  35 import subprocess
  36 import sys
  37 import shutil
  38 import time
  39
  40 from collections import OrderedDict
  41 from distutils.version import LooseVersion as Version
  42 from functools import reduce
  43 from itertools import chain
  44
  45 try:
  46     input = raw_input
  47 except NameError:
  48     pass
  49
  50 virtual_profiles = [
  51     # (name, description, callback)
  52     ("common", "Clone all connected outputs at the largest common resolution", None),
  53     ("clone-largest", "Clone all connected outputs with the largest resolution (scaled down if necessary)", None),
  54     ("horizontal", "Stack all connected outputs horizontally at their largest resolution", None),
  55     ("vertical", "Stack all connected outputs vertically at their largest resolution", None),
  56 ]
  57
  58 help_text = """
  59 Usage: autorandr [options]
  60
  61 -h, --help              get this small help
  62 -c, --change            reload current setup
  63 -s, --save <profile>    save your current setup to profile <profile>
  64 -r, --remove <profile>  remove profile <profile>
  65 -l, --load <profile>    load profile <profile>
  66 -d, --default <profile> make profile <profile> the default profile
  67 --skip-options <option> comma separated list of xrandr arguments (e.g. "gamma")
  68                         to skip both in detecting changes and applying a profile
  69 --force                 force (re)loading of a profile
  70 --fingerprint           fingerprint your current hardware setup
  71 --config                dump your current xrandr setup
  72 --dry-run               don't change anything, only print the xrandr commands
  73 --debug                 enable verbose output
  74 --batch                 run autorandr for all users with active X11 sessions
  75
  76  To prevent a profile from being loaded, place a script called "block" in its
  77  directory. The script is evaluated before the screen setup is inspected, and
  78  in case of it returning a value of 0 the profile is skipped. This can be used
  79  to query the status of a docking station you are about to leave.
  80
  81  If no suitable profile can be identified, the current configuration is kept.
  82  To change this behaviour and switch to a fallback configuration, specify
  83  --default <profile>.
  84
  85  Another script called "postswitch" can be placed in the directory
  86  ~/.config/autorandr (or ~/.autorandr if you have an old installation) as well
  87  as in any profile directories: The scripts are executed after a mode switch
  88  has taken place and can notify window managers.
  89
  90  The following virtual configurations are available:
  91 """.strip()
  92
  93
  94 class AutorandrException(Exception):
  95     def __init__(self, message, original_exception=None, report_bug=False):
  96         self.message = message
  97         self.report_bug = report_bug
  98         if original_exception:
  99             self.original_exception = original_exception
 100             trace = sys.exc_info()[2]
 101             while trace.tb_next:
 102                 trace = trace.tb_next
 103             self.line = trace.tb_lineno
 104             self.file_name = trace.tb_frame.f_code.co_filename
 105         else:
 106             try:
 107                 import inspect
 108                 frame = inspect.currentframe().f_back
 109                 self.line = frame.f_lineno
 110                 self.file_name = frame.f_code.co_filename
 111             except:
 112                 self.line = None
 113                 self.file_name = None
 114             self.original_exception = None
 115
 116         if os.path.abspath(self.file_name) == os.path.abspath(sys.argv[0]):
 117             self.file_name = None
 118
 119     def __str__(self):
 120         retval = [self.message]
 121         if self.line:
 122             retval.append(" (line %d%s)" % (self.line, ("; %s" % self.file_name) if self.file_name else ""))
 123         if self.original_exception:
 124             retval.append(":\n  ")
 125             retval.append(str(self.original_exception).replace("\n", "\n  "))
 126         if self.report_bug:
 127             retval.append("\nThis appears to be a bug. Please help improving autorandr by reporting it upstream:"
 128                           "\nhttps://github.com/phillipberndt/autorandr/issues"
 129                           "\nPlease attach the output of `xrandr --verbose` to your bug report if appropriate.")
 130         return "".join(retval)
 131
 132
 133 class XrandrOutput(object):
 134     "Represents an XRandR output"
 135
 136     # This regular expression is used to parse an output in `xrandr --verbose'
 137     XRANDR_OUTPUT_REGEXP = """(?x)
 138         ^(?P<output>[^ ]+)\s+                                                           # Line starts with output name
 139         (?:                                                                             # Differentiate disconnected and connected
 140             disconnected |                                                              # in first line
 141             unknown\ connection |
 142             (?P<connected>connected)
 143         )
 144         \s*
 145         (?P<primary>primary\ )?                                                         # Might be primary screen
 146         (?:\s*
 147             (?P<width>[0-9]+)x(?P<height>[0-9]+)                                        # Resolution (might be overridden below!)
 148             \+(?P<x>-?[0-9]+)\+(?P<y>-?[0-9]+)\s+                                       # Position
 149             (?:\(0x[0-9a-fA-F]+\)\s+)?                                                  # XID
 150             (?P<rotate>(?:normal|left|right|inverted))\s+                               # Rotation
 151             (?:(?P<reflect>X\ and\ Y|X|Y)\ axis)?                                       # Reflection
 152         )?                                                                              # .. but only if the screen is in use.
 153         (?:[\ \t]*\([^\)]+\))(?:\s*[0-9]+mm\sx\s[0-9]+mm)?
 154         (?:[\ \t]*panning\ (?P<panning>[0-9]+x[0-9]+\+[0-9]+\+[0-9]+))?                 # Panning information
 155         (?:[\ \t]*tracking\ (?P<tracking>[0-9]+x[0-9]+\+[0-9]+\+[0-9]+))?               # Tracking information
 156         (?:[\ \t]*border\ (?P<border>(?:[0-9]+/){3}[0-9]+))?                            # Border information
 157         (?:\s*(?:                                                                       # Properties of the output
 158             Gamma: (?P<gamma>(?:inf|[0-9\.: e])+) |                                     # Gamma value
 159             Transform: (?P<transform>(?:[\-0-9\. ]+\s+){3}) |                           # Transformation matrix
 160             EDID: (?P<edid>\s*?(?:\\n\\t\\t[0-9a-f]+)+) |                               # EDID of the output
 161             (?![0-9])[^:\s][^:\n]+:.*(?:\s\\t[\\t ].+)*                                 # Other properties
 162         ))+
 163         \s*
 164         (?P<modes>(?:
 165             (?P<mode_name>\S+).+?\*current.*\s+                                         # Interesting (current) resolution:
 166              h:\s+width\s+(?P<mode_width>[0-9]+).+\s+                                   # Extract rate
 167              v:\s+height\s+(?P<mode_height>[0-9]+).+clock\s+(?P<rate>[0-9\.]+)Hz\s* |
 168             \S+(?:(?!\*current).)+\s+h:.+\s+v:.+\s*                                     # Other resolutions
 169         )*)
 170     """
 171
 172     XRANDR_OUTPUT_MODES_REGEXP = """(?x)
 173         (?P<name>\S+).+?(?P<preferred>\+preferred)?\s+
 174          h:\s+width\s+(?P<width>[0-9]+).+\s+
 175          v:\s+height\s+(?P<height>[0-9]+).+clock\s+(?P<rate>[0-9\.]+)Hz\s* |
 176     """
 177
 178     XRANDR_13_DEFAULTS = {
 179         "transform": "1,0,0,0,1,0,0,0,1",
 180         "panning": "0x0",
 181     }
 182
 183     XRANDR_12_DEFAULTS = {
 184         "reflect": "normal",
 185         "rotate": "normal",
 186         "gamma": "1.0:1.0:1.0",
 187     }
 188
 189     XRANDR_DEFAULTS = dict(list(XRANDR_13_DEFAULTS.items()) + list(XRANDR_12_DEFAULTS.items()))
 190
 191     EDID_UNAVAILABLE = "--CONNECTED-BUT-EDID-UNAVAILABLE-"
 192
 193     def __repr__(self):
 194         return "<%s%s %s>" % (self.output, self.short_edid, " ".join(self.option_vector))
 195
 196     @property
 197     def short_edid(self):
 198         return ("%s..%s" % (self.edid[:5], self.edid[-5:])) if self.edid else ""
 199
 200     @property
 201     def options_with_defaults(self):
 202         "Return the options dictionary, augmented with the default values that weren't set"
 203         if "off" in self.options:
 204             return self.options
 205         options = {}
 206         if xrandr_version() >= Version("1.3"):
 207             options.update(self.XRANDR_13_DEFAULTS)
 208         if xrandr_version() >= Version("1.2"):
 209             options.update(self.XRANDR_12_DEFAULTS)
 210         options.update(self.options)
 211         return {a: b for a, b in options.items() if a not in self.ignored_options}
 212
 213     @property
 214     def filtered_options(self):
 215         "Return a dictionary of options without ignored options"
 216         return {a: b for a, b in self.options.items() if a not in self.ignored_options}
 217
 218     @property
 219     def option_vector(self):
 220         "Return the command line parameters for XRandR for this instance"
 221         args = ["--output", self.output]
 222         for option, arg in sorted(self.options_with_defaults.items()):
 223             args.append("--%s" % option)
 224             if arg:
 225                 args.append(arg)
 226         return args
 227
 228     @property
 229     def option_string(self):
 230         "Return the command line parameters in the configuration file format"
 231         options = ["output %s" % self.output]
 232         for option, arg in sorted(self.filtered_options.items()):
 233             if arg:
 234                 options.append("%s %s" % (option, arg))
 235             else:
 236                 options.append(option)
 237         return "\n".join(options)
 238
 239     @property
 240     def sort_key(self):
 241         "Return a key to sort the outputs for xrandr invocation"
 242         if not self.edid:
 243             return -2
 244         if "off" in self.options:
 245             return -1
 246         if "pos" in self.options:
 247             x, y = map(float, self.options["pos"].split("x"))
 248         else:
 249             x, y = 0, 0
 250         return x + 10000 * y
 251
 252     def __init__(self, output, edid, options):
 253         "Instanciate using output name, edid and a dictionary of XRandR command line parameters"
 254         self.output = output
 255         self.edid = edid
 256         self.options = options
 257         self.ignored_options = []
 258         self.remove_default_option_values()
 259
 260     def set_ignored_options(self, options):
 261         "Set a list of xrandr options that are never used (neither when comparing configurations nor when applying them)"
 262         self.ignored_options = list(options)
 263
 264     def remove_default_option_values(self):
 265         "Remove values from the options dictionary that are superflous"
 266         if "off" in self.options and len(self.options.keys()) > 1:
 267             self.options = {"off": None}
 268             return
 269         for option, default_value in self.XRANDR_DEFAULTS.items():
 270             if option in self.options and self.options[option] == default_value:
 271                 del self.options[option]
 272
 273     @classmethod
 274     def from_xrandr_output(cls, xrandr_output):
 275         """Instanciate an XrandrOutput from the output of `xrandr --verbose'
 276
 277         This method also returns a list of modes supported by the output.
 278         """
 279         try:
 280             xrandr_output = xrandr_output.replace("\r\n", "\n")
 281             match_object = re.search(XrandrOutput.XRANDR_OUTPUT_REGEXP, xrandr_output)
 282         except:
 283             raise AutorandrException("Parsing XRandR output failed, there is an error in the regular expression.",
 284                                      report_bug=True)
 285         if not match_object:
 286             debug = debug_regexp(XrandrOutput.XRANDR_OUTPUT_REGEXP, xrandr_output)
 287             raise AutorandrException("Parsing XRandR output failed, the regular expression did not match: %s" % debug,
 288                                      report_bug=True)
 289         remainder = xrandr_output[len(match_object.group(0)):]
 290         if remainder:
 291             raise AutorandrException("Parsing XRandR output failed, %d bytes left unmatched after "
 292                                      "regular expression, starting at byte %d with ..'%s'." %
 293                                      (len(remainder), len(match_object.group(0)), remainder[:10]),
 294                                      report_bug=True)
 295
 296         match = match_object.groupdict()
 297
 298         modes = []
 299         if match["modes"]:
 300             modes = []
 301             for mode_match in re.finditer(XrandrOutput.XRANDR_OUTPUT_MODES_REGEXP, match["modes"]):
 302                 if mode_match.group("name"):
 303                     modes.append(mode_match.groupdict())
 304             if not modes:
 305                 raise AutorandrException("Parsing XRandR output failed, couldn't find any display modes", report_bug=True)
 306
 307         options = {}
 308         if not match["connected"]:
 309             edid = None
 310         elif match["edid"]:
 311             edid = "".join(match["edid"].strip().split())
 312         else:
 313             edid = "%s-%s" % (XrandrOutput.EDID_UNAVAILABLE, match["output"])
 314
 315         if not match["width"]:
 316             options["off"] = None
 317         else:
 318             if match["mode_name"]:
 319                 options["mode"] = match["mode_name"]
 320             elif match["mode_width"]:
 321                 options["mode"] = "%sx%s" % (match["mode_width"], match["mode_height"])
 322             else:
 323                 if match["rotate"] not in ("left", "right"):
 324                     options["mode"] = "%sx%s" % (match["width"], match["height"])
 325                 else:
 326                     options["mode"] = "%sx%s" % (match["height"], match["width"])
 327             options["rotate"] = match["rotate"]
 328             if match["primary"]:
 329                 options["primary"] = None
 330             if match["reflect"] == "X":
 331                 options["reflect"] = "x"
 332             elif match["reflect"] == "Y":
 333                 options["reflect"] = "y"
 334             elif match["reflect"] == "X and Y":
 335                 options["reflect"] = "xy"
 336             options["pos"] = "%sx%s" % (match["x"], match["y"])
 337             if match["panning"]:
 338                 panning = [match["panning"]]
 339                 if match["tracking"]:
 340                     panning += ["/", match["tracking"]]
 341                     if match["border"]:
 342                         panning += ["/", match["border"]]
 343                 options["panning"] = "".join(panning)
 344             if match["transform"]:
 345                 transformation = ",".join(match["transform"].strip().split())
 346                 if transformation != "1.000000,0.000000,0.000000,0.000000,1.000000,0.000000,0.000000,0.000000,1.000000":
 347                     options["transform"] = transformation
 348                     if not match["mode_name"]:
 349                         # TODO We'd need to apply the reverse transformation here. Let's see if someone complains,
 350                         # I doubt that this special case is actually required.
 351                         print("Warning: Output %s has a transformation applied. Could not determine correct mode! "
 352                               "Using `%s'." % (match["output"], options["mode"]), file=sys.stderr)
 353             if match["gamma"]:
 354                 gamma = match["gamma"].strip()
 355                 # xrandr prints different values in --verbose than it accepts as a parameter value for --gamma
 356                 # Also, it is not able to work with non-standard gamma ramps. Finally, it auto-corrects 0 to 1,
 357                 # so we approximate by 1e-10.
 358                 gamma = ":".join([str(max(1e-10, round(1. / float(x), 3))) for x in gamma.split(":")])
 359                 options["gamma"] = gamma
 360             if match["rate"]:
 361                 options["rate"] = match["rate"]
 362
 363         return XrandrOutput(match["output"], edid, options), modes
 364
 365     @classmethod
 366     def from_config_file(cls, edid_map, configuration):
 367         "Instanciate an XrandrOutput from the contents of a configuration file"
 368         options = {}
 369         for line in configuration.split("\n"):
 370             if line:
 371                 line = line.split(None, 1)
 372                 if line and line[0].startswith("#"):
 373                     continue
 374                 options[line[0]] = line[1] if len(line) > 1 else None
 375
 376         edid = None
 377
 378         if options["output"] in edid_map:
 379             edid = edid_map[options["output"]]
 380         else:
 381             # This fuzzy matching is for legacy autorandr that used sysfs output names
 382             fuzzy_edid_map = [re.sub("(card[0-9]+|-)", "", x) for x in edid_map.keys()]
 383             fuzzy_output = re.sub("(card[0-9]+|-)", "", options["output"])
 384             if fuzzy_output in fuzzy_edid_map:
 385                 edid = edid_map[list(edid_map.keys())[fuzzy_edid_map.index(fuzzy_output)]]
 386             elif "off" not in options:
 387                 raise AutorandrException("Failed to find an EDID for output `%s' in setup file, required as `%s' "
 388                                          "is not off in config file." % (options["output"], options["output"]))
 389         output = options["output"]
 390         del options["output"]
 391
 392         return XrandrOutput(output, edid, options)
 393
 394     def edid_equals(self, other):
 395         "Compare to another XrandrOutput's edid and on/off-state, taking legacy autorandr behaviour (md5sum'ing) into account"
 396         if self.edid and other.edid:
 397             if len(self.edid) == 32 and len(other.edid) != 32 and not other.edid.startswith(XrandrOutput.EDID_UNAVAILABLE):
 398                 return hashlib.md5(binascii.unhexlify(other.edid)).hexdigest() == self.edid
 399             if len(self.edid) != 32 and len(other.edid) == 32 and not self.edid.startswith(XrandrOutput.EDID_UNAVAILABLE):
 400                 return hashlib.md5(binascii.unhexlify(self.edid)).hexdigest() == other.edid
 401         return self.edid == other.edid
 402
 403     def __ne__(self, other):
 404         return not (self == other)
 405
 406     def __eq__(self, other):
 407         return self.edid_equals(other) and self.output == other.output and self.filtered_options == other.filtered_options
 408
 409     def verbose_diff(self, other):
 410         "Compare to another XrandrOutput and return a list of human readable differences"
 411         diffs = []
 412         if not self.edid_equals(other):
 413             diffs.append("EDID `%s' differs from `%s'" % (self.short_edid, other.short_edid))
 414         if self.output != other.output:
 415             diffs.append("Output name `%s' differs from `%s'" % (self.output, other.output))
 416         if "off" in self.options and "off" not in other.options:
 417             diffs.append("The output is disabled currently, but active in the new configuration")
 418         elif "off" in other.options and "off" not in self.options:
 419             diffs.append("The output is currently enabled, but inactive in the new configuration")
 420         else:
 421             for name in set(chain.from_iterable((self.options.keys(), other.options.keys()))):
 422                 if name not in other.options:
 423                     diffs.append("Option --%s %sis not present in the new configuration" %
 424                                  (name, "(= `%s') " % self.options[name] if self.options[name] else ""))
 425                 elif name not in self.options:
 426                     diffs.append("Option --%s (`%s' in the new configuration) is not present currently" %
 427                                  (name, other.options[name]))
 428                 elif self.options[name] != other.options[name]:
 429                     diffs.append("Option --%s %sis `%s' in the new configuration" %
 430                                  (name, "(= `%s') " % self.options[name] if self.options[name] else "", other.options[name]))
 431         return diffs
 432
 433
 434 def xrandr_version():
 435     "Return the version of XRandR that this system uses"
 436     if getattr(xrandr_version, "version", False) is False:
 437         version_string = os.popen("xrandr -v").read()
 438         try:
 439             version = re.search("xrandr program version\s+([0-9\.]+)", version_string).group(1)
 440             xrandr_version.version = Version(version)
 441         except AttributeError:
 442             xrandr_version.version = Version("1.3.0")
 443
 444     return xrandr_version.version
 445
 446
 447 def debug_regexp(pattern, string):
 448     "Use the partial matching functionality of the regex module to display debug info on a non-matching regular expression"
 449     try:
 450         import regex
 451         bounds = (0, len(string))
 452         while bounds[0] != bounds[1]:
 453             half = int((bounds[0] + bounds[1]) / 2)
 454             if half == bounds[0]:
 455                 break
 456             bounds = (half, bounds[1]) if regex.search(pattern, string[:half], partial=True) else (bounds[0], half - 1)
 457         partial_length = bounds[0]
 458         return ("Regular expression matched until position %d, ..'%s', and did not match from '%s'.." %
 459                 (partial_length, string[max(0, partial_length - 20):partial_length],
 460                  string[partial_length:partial_length + 10]))
 461     except ImportError:
 462         pass
 463     return "Debug information would be available if the `regex' module was installed."
 464
 465
 466 def parse_xrandr_output():
 467     "Parse the output of `xrandr --verbose' into a list of outputs"
 468     xrandr_output = os.popen("xrandr -q --verbose").read()
 469     if not xrandr_output:
 470         raise AutorandrException("Failed to run xrandr")
 471
 472     # We are not interested in screens
 473     xrandr_output = re.sub("(?m)^Screen [0-9].+", "", xrandr_output).strip()
 474
 475     # Split at output boundaries and instanciate an XrandrOutput per output
 476     split_xrandr_output = re.split("(?m)^([^ ]+ (?:(?:dis)?connected|unknown connection).*)$", xrandr_output)
 477     if len(split_xrandr_output) < 2:
 478         raise AutorandrException("No output boundaries found", report_bug=True)
 479     outputs = OrderedDict()
 480     modes = OrderedDict()
 481     for i in range(1, len(split_xrandr_output), 2):
 482         output_name = split_xrandr_output[i].split()[0]
 483         output, output_modes = XrandrOutput.from_xrandr_output("".join(split_xrandr_output[i:i + 2]))
 484         outputs[output_name] = output
 485         if output_modes:
 486             modes[output_name] = output_modes
 487
 488     return outputs, modes
 489
 490
 491 def load_profiles(profile_path):
 492     "Load the stored profiles"
 493
 494     profiles = {}
 495     for profile in os.listdir(profile_path):
 496         config_name = os.path.join(profile_path, profile, "config")
 497         setup_name = os.path.join(profile_path, profile, "setup")
 498         if not os.path.isfile(config_name) or not os.path.isfile(setup_name):
 499             continue
 500
 501         edids = dict([x.split() for x in (y.strip() for y in open(setup_name).readlines()) if x and x[0] != "#"])
 502
 503         config = {}
 504         buffer = []
 505         for line in chain(open(config_name).readlines(), ["output"]):
 506             if line[:6] == "output" and buffer:
 507                 config[buffer[0].strip().split()[-1]] = XrandrOutput.from_config_file(edids, "".join(buffer))
 508                 buffer = [line]
 509             else:
 510                 buffer.append(line)
 511
 512         for output_name in list(config.keys()):
 513             if config[output_name].edid is None:
 514                 del config[output_name]
 515
 516         profiles[profile] = {
 517             "config": config,
 518             "path": os.path.join(profile_path, profile),
 519             "config-mtime": os.stat(config_name).st_mtime,
 520         }
 521
 522     return profiles
 523
 524
 525 def get_symlinks(profile_path):
 526     "Load all symlinks from a directory"
 527
 528     symlinks = {}
 529     for link in os.listdir(profile_path):
 530         file_name = os.path.join(profile_path, link)
 531         if os.path.islink(file_name):
 532             symlinks[link] = os.readlink(file_name)
 533
 534     return symlinks
 535
 536
 537 def find_profiles(current_config, profiles):
 538     "Find profiles matching the currently connected outputs"
 539     detected_profiles = []
 540     for profile_name, profile in profiles.items():
 541         config = profile["config"]
 542         matches = True
 543         for name, output in config.items():
 544             if not output.edid:
 545                 continue
 546             if name not in current_config or not output.edid_equals(current_config[name]):
 547                 matches = False
 548                 break
 549         if not matches or any((name not in config.keys() for name in current_config.keys() if current_config[name].edid)):
 550             continue
 551         if matches:
 552             detected_profiles.append(profile_name)
 553     return detected_profiles
 554
 555
 556 def profile_blocked(profile_path, meta_information=None):
 557     """Check if a profile is blocked.
 558
 559     meta_information is expected to be an dictionary. It will be passed to the block scripts
 560     in the environment, as variables called AUTORANDR_<CAPITALIZED_KEY_HERE>.
 561     """
 562     return not exec_scripts(profile_path, "block", meta_information)
 563
 564
 565 def output_configuration(configuration, config):
 566     "Write a configuration file"
 567     outputs = sorted(configuration.keys(), key=lambda x: configuration[x].sort_key)
 568     for output in outputs:
 569         print(configuration[output].option_string, file=config)
 570
 571
 572 def output_setup(configuration, setup):
 573     "Write a setup (fingerprint) file"
 574     outputs = sorted(configuration.keys())
 575     for output in outputs:
 576         if configuration[output].edid:
 577             print(output, configuration[output].edid, file=setup)
 578
 579
 580 def save_configuration(profile_path, configuration):
 581     "Save a configuration into a profile"
 582     if not os.path.isdir(profile_path):
 583         os.makedirs(profile_path)
 584     with open(os.path.join(profile_path, "config"), "w") as config:
 585         output_configuration(configuration, config)
 586     with open(os.path.join(profile_path, "setup"), "w") as setup:
 587         output_setup(configuration, setup)
 588
 589
 590 def update_mtime(filename):
 591     "Update a file's mtime"
 592     try:
 593         os.utime(filename, None)
 594         return True
 595     except:
 596         return False
 597
 598
 599 def call_and_retry(*args, **kwargs):
 600     """Wrapper around subprocess.call that retries failed calls.
 601
 602     This function calls subprocess.call and on non-zero exit states,
 603     waits a second and then retries once. This mitigates #47,
 604     a timing issue with some drivers.
 605     """
 606     if "dry_run" in kwargs:
 607         dry_run = kwargs["dry_run"]
 608         del kwargs["dry_run"]
 609     else:
 610         dry_run = False
 611     kwargs_redirected = dict(kwargs)
 612     if not dry_run:
 613         if hasattr(subprocess, "DEVNULL"):
 614             kwargs_redirected["stdout"] = getattr(subprocess, "DEVNULL")
 615         else:
 616             kwargs_redirected["stdout"] = open(os.devnull, "w")
 617         kwargs_redirected["stderr"] = kwargs_redirected["stdout"]
 618     retval = subprocess.call(*args, **kwargs_redirected)
 619     if retval != 0:
 620         time.sleep(1)
 621         retval = subprocess.call(*args, **kwargs)
 622     return retval
 623
 624
 625 def apply_configuration(new_configuration, current_configuration, dry_run=False):
 626     "Apply a configuration"
 627     outputs = sorted(new_configuration.keys(), key=lambda x: new_configuration[x].sort_key)
 628     if dry_run:
 629         base_argv = ["echo", "xrandr"]
 630     else:
 631         base_argv = ["xrandr"]
 632
 633     # There are several xrandr / driver bugs we need to take care of here:
 634     # - We cannot enable more than two screens at the same time
 635     #   See https://github.com/phillipberndt/autorandr/pull/6
 636     #   and commits f4cce4d and 8429886.
 637     # - We cannot disable all screens
 638     #   See https://github.com/phillipberndt/autorandr/pull/20
 639     # - We should disable screens before enabling others, because there's
 640     #   a limit on the number of enabled screens
 641     # - We must make sure that the screen at 0x0 is activated first,
 642     #   or the other (first) screen to be activated would be moved there.
 643     # - If an active screen already has a transformation and remains active,
 644     #   the xrandr call fails with an invalid RRSetScreenSize parameter error.
 645     #   Update the configuration in 3 passes in that case.  (On Haswell graphics,
 646     #   at least.)
 647     # - Some implementations can not handle --transform at all, so avoid it unless
 648     #   necessary. (See https://github.com/phillipberndt/autorandr/issues/37)
 649     # - Some implementations can not handle --panning without specifying --fb
 650     #   explicitly, so avoid it unless necessary.
 651     #   (See https://github.com/phillipberndt/autorandr/issues/72)
 652
 653     auxiliary_changes_pre = []
 654     disable_outputs = []
 655     enable_outputs = []
 656     remain_active_count = 0
 657     for output in outputs:
 658         if not new_configuration[output].edid or "off" in new_configuration[output].options:
 659             disable_outputs.append(new_configuration[output].option_vector)
 660         else:
 661             if "off" not in current_configuration[output].options:
 662                 remain_active_count += 1
 663
 664             option_vector = new_configuration[output].option_vector
 665             if xrandr_version() >= Version("1.3.0"):
 666                 for option in ("transform", "panning"):
 667                     if option in current_configuration[output].options:
 668                         auxiliary_changes_pre.append(["--output", output, "--%s" % option, "none"])
 669                     else:
 670                         try:
 671                             option_index = option_vector.index("--%s" % option)
 672                             if option_vector[option_index + 1] == XrandrOutput.XRANDR_DEFAULTS[option]:
 673                                 option_vector = option_vector[:option_index] + option_vector[option_index + 2:]
 674                         except ValueError:
 675                             pass
 676
 677             enable_outputs.append(option_vector)
 678
 679     # Perform pe-change auxiliary changes
 680     if auxiliary_changes_pre:
 681         argv = base_argv + list(chain.from_iterable(auxiliary_changes_pre))
 682         if call_and_retry(argv, dry_run=dry_run) != 0:
 683             raise AutorandrException("Command failed: %s" % " ".join(argv))
 684
 685     # Disable unused outputs, but make sure that there always is at least one active screen
 686     disable_keep = 0 if remain_active_count else 1
 687     if len(disable_outputs) > disable_keep:
 688         argv = base_argv + list(chain.from_iterable(disable_outputs[:-1] if disable_keep else disable_outputs))
 689         if call_and_retry(argv, dry_run=dry_run) != 0:
 690             # Disabling the outputs failed. Retry with the next command:
 691             # Sometimes disabling of outputs fails due to an invalid RRSetScreenSize.
 692             # This does not occur if simultaneously the primary screen is reset.
 693             pass
 694         else:
 695             disable_outputs = disable_outputs[-1:] if disable_keep else []
 696
 697     # If disable_outputs still has more than one output in it, one of the xrandr-calls below would
 698     # disable the last two screens. This is a problem, so if this would happen, instead disable only
 699     # one screen in the first call below.
 700     if len(disable_outputs) > 0 and len(disable_outputs) % 2 == 0:
 701         # In the context of a xrandr call that changes the display state, `--query' should do nothing
 702         disable_outputs.insert(0, ['--query'])
 703
 704     # Enable the remaining outputs in pairs of two operations
 705     operations = disable_outputs + enable_outputs
 706     for index in range(0, len(operations), 2):
 707         argv = base_argv + list(chain.from_iterable(operations[index:index + 2]))
 708         if call_and_retry(argv, dry_run=dry_run) != 0:
 709             raise AutorandrException("Command failed: %s" % " ".join(argv))
 710
 711
 712 def is_equal_configuration(source_configuration, target_configuration):
 713     "Check if all outputs from target are already configured correctly in source"
 714     for output in target_configuration.keys():
 715         if (output not in source_configuration) or (source_configuration[output] != target_configuration[output]):
 716             return False
 717     return True
 718
 719
 720 def add_unused_outputs(source_configuration, target_configuration):
 721     "Add outputs that are missing in target to target, in 'off' state"
 722     for output_name, output in source_configuration.items():
 723         if output_name not in target_configuration:
 724             target_configuration[output_name] = XrandrOutput(output_name, output.edid, {"off": None})
 725
 726
 727 def remove_irrelevant_outputs(source_configuration, target_configuration):
 728     "Remove outputs from target that ought to be 'off' and already are"
 729     for output_name, output in source_configuration.items():
 730         if "off" in output.options:
 731             if output_name in target_configuration:
 732                 if "off" in target_configuration[output_name].options:
 733                     del target_configuration[output_name]
 734
 735
 736 def generate_virtual_profile(configuration, modes, profile_name):
 737     "Generate one of the virtual profiles"
 738     configuration = copy.deepcopy(configuration)
 739     if profile_name == "common":
 740         mode_sets = []
 741         for output, output_modes in modes.items():
 742             mode_set = set()
 743             if configuration[output].edid:
 744                 for mode in output_modes:
 745                     mode_set.add((mode["width"], mode["height"]))
 746             mode_sets.append(mode_set)
 747         common_resolution = reduce(lambda a, b: a & b, mode_sets[1:], mode_sets[0])
 748         common_resolution = sorted(common_resolution, key=lambda a: int(a[0]) * int(a[1]))
 749         if common_resolution:
 750             for output in configuration:
 751                 configuration[output].options = {}
 752                 if output in modes and configuration[output].edid:
 753                     modes_sorted = sorted(modes[output], key=lambda x: 0 if x["preferred"] else 1)
 754                     modes_filtered = [x for x in modes_sorted if (x["width"], x["height"]) == common_resolution[-1]]
 755                     mode = modes_filtered[0]
 756                     configuration[output].options["mode"] = mode['name']
 757                     configuration[output].options["pos"] = "0x0"
 758                 else:
 759                     configuration[output].options["off"] = None
 760     elif profile_name in ("horizontal", "vertical"):
 761         shift = 0
 762         if profile_name == "horizontal":
 763             shift_index = "width"
 764             pos_specifier = "%sx0"
 765         else:
 766             shift_index = "height"
 767             pos_specifier = "0x%s"
 768
 769         for output in configuration:
 770             configuration[output].options = {}
 771             if output in modes and configuration[output].edid:
 772                 def key(a, b):
 773                     score = int(a["width"]) * int(a["height"])
 774                     if a["preferred"]:
 775                         score += 10**6
 776                     return score
 777                 modes = sorted(modes[output], key=key)
 778                 mode = modes[-1]
 779                 configuration[output].options["mode"] = mode["name"]
 780                 configuration[output].options["rate"] = mode["rate"]
 781                 configuration[output].options["pos"] = pos_specifier % shift
 782                 shift += int(mode[shift_index])
 783             else:
 784                 configuration[output].options["off"] = None
 785     elif profile_name == "clone-largest":
 786         modes_unsorted = [output_modes[0] for output, output_modes in modes.items()]
 787         modes_sorted = sorted(modes_unsorted, key=lambda x: int(x["width"]) * int(x["height"]), reverse=True)
 788         biggest_resolution = modes_sorted[0]
 789         for output in configuration:
 790             configuration[output].options = {}
 791             if output in modes and configuration[output].edid:
 792                 def key(a, b):
 793                     score = int(a["width"]) * int(a["height"])
 794                     if a["preferred"]:
 795                         score += 10**6
 796                     return score
 797                 modes = sorted(modes[output], key=key)
 798                 mode = modes[-1]
 799                 configuration[output].options["mode"] = mode["name"]
 800                 configuration[output].options["rate"] = mode["rate"]
 801                 configuration[output].options["pos"] = "0x0"
 802                 scale = max(float(biggest_resolution["width"]) / float(mode["width"]),
 803                             float(biggest_resolution["height"]) / float(mode["height"]))
 804                 mov_x = (float(mode["width"]) * scale - float(biggest_resolution["width"])) / -2
 805                 mov_y = (float(mode["height"]) * scale - float(biggest_resolution["height"])) / -2
 806                 configuration[output].options["transform"] = "{},0,{},0,{},{},0,0,1".format(scale, mov_x, scale, mov_y)
 807             else:
 808                 configuration[output].options["off"] = None
 809     return configuration
 810
 811
 812 def print_profile_differences(one, another):
 813     "Print the differences between two profiles for debugging"
 814     if one == another:
 815         return
 816     print("| Differences between the two profiles:", file=sys.stderr)
 817     for output in set(chain.from_iterable((one.keys(), another.keys()))):
 818         if output not in one:
 819             if "off" not in another[output].options:
 820                 print("| Output `%s' is missing from the active configuration" % output, file=sys.stderr)
 821         elif output not in another:
 822             if "off" not in one[output].options:
 823                 print("| Output `%s' is missing from the new configuration" % output, file=sys.stderr)
 824         else:
 825             for line in one[output].verbose_diff(another[output]):
 826                 print("| [Output %s] %s" % (output, line), file=sys.stderr)
 827     print("\\-", file=sys.stderr)
 828
 829
 830 def exit_help():
 831     "Print help and exit"
 832     print(help_text)
 833     for profile in virtual_profiles:
 834         name, description = profile[:2]
 835         description = [description]
 836         max_width = 78 - 18
 837         while len(description[0]) > max_width + 1:
 838             left_over = description[0][max_width:]
 839             description[0] = description[0][:max_width] + "-"
 840             description.insert(1, "  %-15s %s" % ("", left_over))
 841         description = "\n".join(description)
 842         print("  %-15s %s" % (name, description))
 843     sys.exit(0)
 844
 845
 846 def exec_scripts(profile_path, script_name, meta_information=None):
 847     """"Run userscripts
 848
 849     This will run all executables from the profile folder, and global per-user
 850     and system-wide configuration folders, named script_name or residing in
 851     subdirectories named script_name.d.
 852
 853     If profile_path is None, only global scripts will be invoked.
 854
 855     meta_information is expected to be an dictionary. It will be passed to the block scripts
 856     in the environment, as variables called AUTORANDR_<CAPITALIZED_KEY_HERE>.
 857
 858     Returns True unless any of the scripts exited with non-zero exit status.
 859     """
 860     all_ok = True
 861     env = os.environ.copy()
 862     if meta_information:
 863         for key, value in meta_information.items():
 864             env["AUTORANDR_{}".format(key.upper())] = str(value)
 865
 866     # If there are multiple candidates, the XDG spec tells to only use the first one.
 867     ran_scripts = set()
 868
 869     user_profile_path = os.path.expanduser("~/.autorandr")
 870     if not os.path.isdir(user_profile_path):
 871         user_profile_path = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
 872
 873     candidate_directories = [user_profile_path]
 874     for config_dir in os.environ.get("XDG_CONFIG_DIRS", "/etc/xdg").split(":"):
 875         candidate_directories += os.path.join(config_dir, "autorandr")
 876     if profile_path:
 877         candidate_directories += profile_path
 878
 879     for folder in candidate_directories:
 880
 881         if script_name not in ran_scripts:
 882             script = os.path.join(folder, script_name)
 883             if os.access(script, os.X_OK | os.F_OK):
 884                 try:
 885                     all_ok &= subprocess.call(script, env=env) != 0
 886                 except:
 887                     raise AutorandrException("Failed to execute user command: %s" % (script,))
 888                 ran_scripts.add(script_name)
 889
 890         script_folder = os.path.join(folder, "%s.d" % script_name)
 891         if os.access(script_folder, os.R_OK | os.X_OK) and os.path.isdir(script_folder):
 892             for file_name in os.listdir(script_folder):
 893                 check_name = "d/%s" % (file_name,)
 894                 if check_name not in ran_scripts:
 895                     script = os.path.join(script_folder, file_name)
 896                     if os.access(script, os.X_OK | os.F_OK):
 897                         try:
 898                             all_ok &= subprocess.call(script, env=env) != 0
 899                         except:
 900                             raise AutorandrException("Failed to execute user command: %s" % (script,))
 901                         ran_scripts.add(check_name)
 902
 903     return all_ok
 904
 905
 906 def dispatch_call_to_sessions(argv):
 907     """Invoke autorandr for each open local X11 session with the given options.
 908
 909     The function iterates over all processes not owned by root and checks
 910     whether they have DISPLAY and XAUTHORITY variables set. It strips the
 911     screen from any variable it finds (i.e. :0.0 becomes :0) and checks whether
 912     this display has been handled already. If it has not, it forks, changes
 913     uid/gid to the user owning the process, reuses the process's environment
 914     and runs autorandr with the parameters from argv.
 915
 916     This function requires root permissions. It only works for X11 servers that
 917     have at least one non-root process running. It is susceptible for attacks
 918     where one user runs a process with another user's DISPLAY variable - in
 919     this case, it might happen that autorandr is invoked for the other user,
 920     which won't work. Since no other harm than prevention of automated
 921     execution of autorandr can be done this way, the assumption is that in this
 922     situation, the local administrator will handle the situation."""
 923
 924     X11_displays_done = set()
 925
 926     autorandr_binary = os.path.abspath(argv[0])
 927     backup_candidates = {}
 928
 929     def fork_child_autorandr(pwent, process_environ):
 930         print("Running autorandr as %s for display %s" % (pwent.pw_name, process_environ["DISPLAY"]))
 931         child_pid = os.fork()
 932         if child_pid == 0:
 933             # This will throw an exception if any of the privilege changes fails,
 934             # so it should be safe. Also, note that since the environment
 935             # is taken from a process owned by the user, reusing it should
 936             # not leak any information.
 937             os.setgroups([])
 938             os.setresgid(pwent.pw_gid, pwent.pw_gid, pwent.pw_gid)
 939             os.setresuid(pwent.pw_uid, pwent.pw_uid, pwent.pw_uid)
 940             os.chdir(pwent.pw_dir)
 941             os.environ.clear()
 942             os.environ.update(process_environ)
 943             os.execl(autorandr_binary, autorandr_binary, *argv[1:])
 944             os.exit(1)
 945         os.waitpid(child_pid, 0)
 946
 947     for directory in os.listdir("/proc"):
 948         directory = os.path.join("/proc/", directory)
 949         if not os.path.isdir(directory):
 950             continue
 951         environ_file = os.path.join(directory, "environ")
 952         if not os.path.isfile(environ_file):
 953             continue
 954         uid = os.stat(environ_file).st_uid
 955
 956         # The following line assumes that user accounts start at 1000 and that
 957         # no one works using the root or another system account. This is rather
 958         # restrictive, but de facto default. Alternatives would be to use the
 959         # UID_MIN from /etc/login.defs or FIRST_UID from /etc/adduser.conf;
 960         # but effectively, both values aren't binding in any way.
 961         # If this breaks your use case, please file a bug on Github.
 962         if uid < 1000:
 963             continue
 964
 965         process_environ = {}
 966         for environ_entry in open(environ_file).read().split("\0"):
 967             if "=" in environ_entry:
 968                 name, value = environ_entry.split("=", 1)
 969                 if name == "DISPLAY" and "." in value:
 970                     value = value[:value.find(".")]
 971                 process_environ[name] = value
 972
 973         if "DISPLAY" not in process_environ:
 974             # Cannot work with this environment, skip.
 975             continue
 976
 977         # To allow scripts to detect batch invocation (especially useful for predetect)
 978         process_environ["AUTORANDR_BATCH_PID"] = str(os.getpid())
 979         process_environ["UID"] = str(uid)
 980
 981         display = process_environ["DISPLAY"]
 982
 983         if "XAUTHORITY" not in process_environ:
 984             # It's very likely that we cannot work with this environment either,
 985             # but keep it as a backup just in case we don't find anything else.
 986             backup_candidates[display] = process_environ
 987             continue
 988
 989         if display not in X11_displays_done:
 990             try:
 991                 pwent = pwd.getpwuid(uid)
 992             except KeyError:
 993                 # User has no pwd entry
 994                 continue
 995
 996             fork_child_autorandr(pwent, process_environ)
 997             X11_displays_done.add(display)
 998
 999     # Run autorandr for any users/displays which didn't have a process with
1000     # XAUTHORITY set.
1001     for display, process_environ in backup_candidates.items():
1002         if display not in X11_displays_done:
1003             try:
1004                 pwent = pwd.getpwuid(int(process_environ["UID"]))
1005             except KeyError:
1006                 # User has no pwd entry
1007                 continue
1008
1009             fork_child_autorandr(pwent, process_environ)
1010             X11_displays_done.add(display)
1011
1012
1013 def main(argv):
1014     try:
1015         opts, args = getopt.getopt(argv[1:], "s:r:l:d:cfh",
1016                                    ["batch", "dry-run", "change", "default=", "save=", "remove=", "load=",
1017                                     "force", "fingerprint", "config", "debug", "skip-options=", "help"])
1018     except getopt.GetoptError as e:
1019         print("Failed to parse options: {0}.\n"
1020               "Use --help to get usage information.".format(str(e)),
1021               file=sys.stderr)
1022         sys.exit(posix.EX_USAGE)
1023
1024     options = dict(opts)
1025
1026     if "-h" in options or "--help" in options:
1027         exit_help()
1028
1029     # Batch mode
1030     if "--batch" in options:
1031         if ("DISPLAY" not in os.environ or not os.environ["DISPLAY"]) and os.getuid() == 0:
1032             dispatch_call_to_sessions([x for x in argv if x != "--batch"])
1033         else:
1034             print("--batch mode can only be used by root and if $DISPLAY is unset")
1035         return
1036     if "AUTORANDR_BATCH_PID" in os.environ:
1037         user = pwd.getpwuid(os.getuid())
1038         user = user.pw_name if user else "#%d" % os.getuid()
1039         print("autorandr running as user %s (started from batch instance)" % user)
1040
1041     profiles = {}
1042     profile_symlinks = {}
1043     try:
1044         # Load profiles from each XDG config directory
1045         # The XDG spec says that earlier entries should take precedence, so reverse the order
1046         for directory in reversed(os.environ.get("XDG_CONFIG_DIRS", "/etc/xdg").split(":")):
1047             system_profile_path = os.path.join(directory, "autorandr")
1048             if os.path.isdir(system_profile_path):
1049                 profiles.update(load_profiles(system_profile_path))
1050                 profile_symlinks.update(get_symlinks(system_profile_path))
1051         # For the user's profiles, prefer the legacy ~/.autorandr if it already exists
1052         # profile_path is also used later on to store configurations
1053         profile_path = os.path.expanduser("~/.autorandr")
1054         if not os.path.isdir(profile_path):
1055             # Elsewise, follow the XDG specification
1056             profile_path = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
1057         if os.path.isdir(profile_path):
1058             profiles.update(load_profiles(profile_path))
1059             profile_symlinks.update(get_symlinks(profile_path))
1060         # Sort by descending mtime
1061         profiles = OrderedDict(sorted(profiles.items(), key=lambda x: -x[1]["config-mtime"]))
1062     except Exception as e:
1063         raise AutorandrException("Failed to load profiles", e)
1064
1065     profile_symlinks = {k: v for k, v in profile_symlinks.items() if v in (x[0] for x in virtual_profiles) or v in profiles}
1066
1067     exec_scripts(None, "predetect")
1068     config, modes = parse_xrandr_output()
1069
1070     if "--fingerprint" in options:
1071         output_setup(config, sys.stdout)
1072         sys.exit(0)
1073
1074     if "--config" in options:
1075         output_configuration(config, sys.stdout)
1076         sys.exit(0)
1077
1078     if "--skip-options" in options:
1079         skip_options = [y[2:] if y[:2] == "--" else y for y in (x.strip() for x in options["--skip-options"].split(","))]
1080         for profile in profiles.values():
1081             for output in profile["config"].values():
1082                 output.set_ignored_options(skip_options)
1083         for output in config.values():
1084             output.set_ignored_options(skip_options)
1085
1086     if "-s" in options:
1087         options["--save"] = options["-s"]
1088     if "--save" in options:
1089         if options["--save"] in (x[0] for x in virtual_profiles):
1090             raise AutorandrException("Cannot save current configuration as profile '%s':\n"
1091                                      "This configuration name is a reserved virtual configuration." % options["--save"])
1092         try:
1093             profile_folder = os.path.join(profile_path, options["--save"])
1094             save_configuration(profile_folder, config)
1095             exec_scripts(profile_folder, "postsave", {"CURRENT_PROFILE": options["--save"], "PROFILE_FOLDER": profile_folder})
1096         except Exception as e:
1097             raise AutorandrException("Failed to save current configuration as profile '%s'" % (options["--save"],), e)
1098         print("Saved current configuration as profile '%s'" % options["--save"])
1099         sys.exit(0)
1100
1101     if "-r" in options:
1102         options["--remove"] = options["-r"]
1103     if "--remove" in options:
1104         if options["--remove"] in (x[0] for x in virtual_profiles):
1105             raise AutorandrException("Cannot remove profile '%s':\n"
1106                                      "This configuration name is a reserved virtual configuration." % options["--remove"])
1107         if options["--remove"] not in profiles.keys():
1108             raise AutorandrException("Cannot remove profile '%s':\n"
1109                                      "This profile does not exist." % options["--remove"])
1110         try:
1111             remove = True
1112             profile_folder = os.path.join(profile_path, options["--remove"])
1113             profile_dirlist = os.listdir(profile_folder)
1114             profile_dirlist.remove("config")
1115             profile_dirlist.remove("setup")
1116             if profile_dirlist:
1117                 print("Profile folder '%s' contains the following additional files:\n"
1118                       "---\n%s\n---" % (options["--remove"], "\n".join(profile_dirlist)))
1119                 response = input("Do you really want to remove profile '%s'? If so, type 'yes': " % options["--remove"]).strip()
1120                 if response != "yes":
1121                     remove = False
1122             if remove is True:
1123                 shutil.rmtree(profile_folder)
1124                 print("Removed profile '%s'" % options["--remove"])
1125             else:
1126                 print("Profile '%s' was not removed" % options["--remove"])
1127         except Exception as e:
1128             raise AutorandrException("Failed to remove profile '%s'" % (options["--remove"],), e)
1129         sys.exit(0)
1130
1131     detected_profiles = find_profiles(config, profiles)
1132     load_profile = False
1133
1134     if "-l" in options:
1135         options["--load"] = options["-l"]
1136     if "--load" in options:
1137         load_profile = options["--load"]
1138     elif len(args) == 1:
1139         load_profile = args[0]
1140     else:
1141         # Find the active profile(s) first, for the block script (See #42)
1142         current_profiles = []
1143         for profile_name in profiles.keys():
1144             configs_are_equal = is_equal_configuration(config, profiles[profile_name]["config"])
1145             if configs_are_equal:
1146                 current_profiles.append(profile_name)
1147         block_script_metadata = {
1148             "CURRENT_PROFILE": "".join(current_profiles[:1]),
1149             "CURRENT_PROFILES": ":".join(current_profiles)
1150         }
1151
1152         for profile_name in profiles.keys():
1153             if profile_blocked(os.path.join(profile_path, profile_name), block_script_metadata):
1154                 print("%s (blocked)" % profile_name, file=sys.stderr)
1155                 continue
1156             props = []
1157             if profile_name in detected_profiles:
1158                 props.append("(detected)")
1159                 if ("-c" in options or "--change" in options) and not load_profile:
1160                     load_profile = profile_name
1161             if profile_name in current_profiles:
1162                 props.append("(current)")
1163             print("%s%s%s" % (profile_name, " " if props else "", " ".join(props)), file=sys.stderr)
1164             if not configs_are_equal and "--debug" in options and profile_name in detected_profiles:
1165                 print_profile_differences(config, profiles[profile_name]["config"])
1166
1167     if "-d" in options:
1168         options["--default"] = options["-d"]
1169     if not load_profile and "--default" in options:
1170         load_profile = options["--default"]
1171
1172     if load_profile:
1173         if load_profile in profile_symlinks:
1174             if "--debug" in options:
1175                 print("'%s' symlinked to '%s'" % (load_profile, profile_symlinks[load_profile]))
1176             load_profile = profile_symlinks[load_profile]
1177
1178         if load_profile in (x[0] for x in virtual_profiles):
1179             load_config = generate_virtual_profile(config, modes, load_profile)
1180             scripts_path = os.path.join(profile_path, load_profile)
1181         else:
1182             try:
1183                 profile = profiles[load_profile]
1184                 load_config = profile["config"]
1185                 scripts_path = profile["path"]
1186             except KeyError:
1187                 raise AutorandrException("Failed to load profile '%s': Profile not found" % load_profile)
1188             if load_profile in detected_profiles and detected_profiles[0] != load_profile:
1189                 update_mtime(os.path.join(scripts_path, "config"))
1190         add_unused_outputs(config, load_config)
1191         if load_config == dict(config) and "-f" not in options and "--force" not in options:
1192             print("Config already loaded", file=sys.stderr)
1193             sys.exit(0)
1194         if "--debug" in options and load_config != dict(config):
1195             print("Loading profile '%s'" % load_profile)
1196             print_profile_differences(config, load_config)
1197
1198         remove_irrelevant_outputs(config, load_config)
1199
1200         try:
1201             if "--dry-run" in options:
1202                 apply_configuration(load_config, config, True)
1203             else:
1204                 script_metadata = {
1205                     "CURRENT_PROFILE": load_profile,
1206                     "PROFILE_FOLDER": scripts_path,
1207                 }
1208                 exec_scripts(scripts_path, "preswitch", script_metadata)
1209                 if "--debug" in options:
1210                     print("Going to run:")
1211                     apply_configuration(load_config, config, True)
1212                 apply_configuration(load_config, config, False)
1213                 exec_scripts(scripts_path, "postswitch", script_metadata)
1214         except AutorandrException as e:
1215             raise AutorandrException("Failed to apply profile '%s'" % load_profile, e, e.report_bug)
1216         except Exception as e:
1217             raise AutorandrException("Failed to apply profile '%s'" % load_profile, e, True)
1218
1219         if "--dry-run" not in options and "--debug" in options:
1220             new_config, _ = parse_xrandr_output()
1221             if not is_equal_configuration(new_config, load_config):
1222                 print("The configuration change did not go as expected:")
1223                 print_profile_differences(new_config, load_config)
1224
1225     sys.exit(0)
1226
1227
1228 def exception_handled_main(argv=sys.argv):
1229     try:
1230         main(sys.argv)
1231     except AutorandrException as e:
1232         print(e, file=sys.stderr)
1233         sys.exit(1)
1234     except Exception as e:
1235         if not len(str(e)):  # BdbQuit
1236             print("Exception: {0}".format(e.__class__.__name__))
1237             sys.exit(2)
1238
1239         print("Unhandled exception ({0}). Please report this as a bug at "
1240               "https://github.com/phillipberndt/autorandr/issues.".format(e),
1241               file=sys.stderr)
1242         raise
1243
1244
1245 if __name__ == '__main__':
1246     exception_handled_main()