autorandr.py

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