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