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