]> git.donarmstrong.com Git - deb_pkgs/autorandr.git/blob - autorandr.py
Only count a closed lid as disconnected if there are other connected outputs
[deb_pkgs/autorandr.git] / 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"]:
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     # consider a closed lid as disconnected if other outputs are connected
522     if sum(o.edid != None for o in outputs.values()) > 1:
523         for output_name in outputs.keys():
524             if is_closed_lid(output_name):
525                 outputs[output_name].edid = None
526
527     return outputs, modes
528
529
530 def load_profiles(profile_path):
531     "Load the stored profiles"
532
533     profiles = {}
534     for profile in os.listdir(profile_path):
535         config_name = os.path.join(profile_path, profile, "config")
536         setup_name = os.path.join(profile_path, profile, "setup")
537         if not os.path.isfile(config_name) or not os.path.isfile(setup_name):
538             continue
539
540         edids = dict([x.split() for x in (y.strip() for y in open(setup_name).readlines()) if x and x[0] != "#"])
541
542         config = {}
543         buffer = []
544         for line in chain(open(config_name).readlines(), ["output"]):
545             if line[:6] == "output" and buffer:
546                 config[buffer[0].strip().split()[-1]] = XrandrOutput.from_config_file(edids, "".join(buffer))
547                 buffer = [line]
548             else:
549                 buffer.append(line)
550
551         for output_name in list(config.keys()):
552             if config[output_name].edid is None:
553                 del config[output_name]
554
555         profiles[profile] = {
556             "config": config,
557             "path": os.path.join(profile_path, profile),
558             "config-mtime": os.stat(config_name).st_mtime,
559         }
560
561     return profiles
562
563
564 def get_symlinks(profile_path):
565     "Load all symlinks from a directory"
566
567     symlinks = {}
568     for link in os.listdir(profile_path):
569         file_name = os.path.join(profile_path, link)
570         if os.path.islink(file_name):
571             symlinks[link] = os.readlink(file_name)
572
573     return symlinks
574
575
576 def find_profiles(current_config, profiles):
577     "Find profiles matching the currently connected outputs"
578     detected_profiles = []
579     for profile_name, profile in profiles.items():
580         config = profile["config"]
581         matches = True
582         for name, output in config.items():
583             if not output.edid:
584                 continue
585             if name not in current_config or not output.edid_equals(current_config[name]):
586                 matches = False
587                 break
588         if not matches or any((name not in config.keys() for name in current_config.keys() if current_config[name].edid)):
589             continue
590         if matches:
591             detected_profiles.append(profile_name)
592     return detected_profiles
593
594
595 def profile_blocked(profile_path, meta_information=None):
596     """Check if a profile is blocked.
597
598     meta_information is expected to be an dictionary. It will be passed to the block scripts
599     in the environment, as variables called AUTORANDR_<CAPITALIZED_KEY_HERE>.
600     """
601     return not exec_scripts(profile_path, "block", meta_information)
602
603
604 def check_configuration_pre_save(configuration):
605     "Check that a configuration is safe for saving."
606     outputs = sorted(configuration.keys(), key=lambda x: configuration[x].sort_key)
607     for output in outputs:
608         if "off" not in configuration[output].options and not configuration[output].edid:
609             return ("`%(o)s' is not off (has a mode configured) but is disconnected (does not have an EDID).\n"
610                     "This typically means that it has been recently unplugged and then not properly disabled\n"
611                     "by the user. Please disable it (e.g. using `xrandr --output %(o)s --off`) and then rerun\n"
612                     "this command.") % {"o": output}
613
614
615 def output_configuration(configuration, config):
616     "Write a configuration file"
617     outputs = sorted(configuration.keys(), key=lambda x: configuration[x].sort_key)
618     for output in outputs:
619         print(configuration[output].option_string, file=config)
620
621
622 def output_setup(configuration, setup):
623     "Write a setup (fingerprint) file"
624     outputs = sorted(configuration.keys())
625     for output in outputs:
626         if configuration[output].edid:
627             print(output, configuration[output].edid, file=setup)
628
629
630 def save_configuration(profile_path, profile_name, configuration, forced=False):
631     "Save a configuration into a profile"
632     if not os.path.isdir(profile_path):
633         os.makedirs(profile_path)
634     config_path = os.path.join(profile_path, "config")
635     setup_path = os.path.join(profile_path, "setup")
636     if os.path.isfile(config_path) and not forced:
637         raise AutorandrException('Refusing to overwrite config "{}" without passing "--force"!'.format(profile_name))
638     if os.path.isfile(setup_path) and not forced:
639         raise AutorandrException('Refusing to overwrite config "{}" without passing "--force"!'.format(profile_name))
640
641     with open(config_path, "w") as config:
642         output_configuration(configuration, config)
643     with open(setup_path, "w") as setup:
644         output_setup(configuration, setup)
645
646
647 def update_mtime(filename):
648     "Update a file's mtime"
649     try:
650         os.utime(filename, None)
651         return True
652     except:
653         return False
654
655
656 def call_and_retry(*args, **kwargs):
657     """Wrapper around subprocess.call that retries failed calls.
658
659     This function calls subprocess.call and on non-zero exit states,
660     waits a second and then retries once. This mitigates #47,
661     a timing issue with some drivers.
662     """
663     if "dry_run" in kwargs:
664         dry_run = kwargs["dry_run"]
665         del kwargs["dry_run"]
666     else:
667         dry_run = False
668     kwargs_redirected = dict(kwargs)
669     if not dry_run:
670         if hasattr(subprocess, "DEVNULL"):
671             kwargs_redirected["stdout"] = getattr(subprocess, "DEVNULL")
672         else:
673             kwargs_redirected["stdout"] = open(os.devnull, "w")
674         kwargs_redirected["stderr"] = kwargs_redirected["stdout"]
675     retval = subprocess.call(*args, **kwargs_redirected)
676     if retval != 0:
677         time.sleep(1)
678         retval = subprocess.call(*args, **kwargs)
679     return retval
680
681
682 def get_fb_dimensions(configuration):
683     width = 0
684     height = 0
685     for output in configuration.values():
686         if "off" in output.options or not output.edid:
687             continue
688         # This won't work with all modes -- but it's a best effort.
689         match = re.search("[0-9]{3,}x[0-9]{3,}", output.options["mode"])
690         if not match:
691             return None
692         o_mode = match.group(0)
693         o_width, o_height = map(int, o_mode.split("x"))
694         if "transform" in output.options:
695             a, b, c, d, e, f, g, h, i = map(float, output.options["transform"].split(","))
696             w = (g * o_width + h * o_height + i)
697             x = (a * o_width + b * o_height + c) / w
698             y = (d * o_width + e * o_height + f) / w
699             o_width, o_height = x, y
700         if "rotate" in output.options:
701             if output.options["rotate"] in ("left", "right"):
702                 o_width, o_height = o_height, o_width
703         if "pos" in output.options:
704             o_left, o_top = map(int, output.options["pos"].split("x"))
705             o_width += o_left
706             o_height += o_top
707         if "panning" in output.options:
708             match = re.match("(?P<w>[0-9]+)x(?P<h>[0-9]+)(?:\+(?P<x>[0-9]+))?(?:\+(?P<y>[0-9]+))?.*", output.options["panning"])
709             if match:
710                 detail = match.groupdict(default="0")
711                 o_width = int(detail.get("w")) + int(detail.get("x"))
712                 o_height = int(detail.get("h")) + int(detail.get("y"))
713         width = max(width, o_width)
714         height = max(height, o_height)
715     return int(width), int(height)
716
717
718 def apply_configuration(new_configuration, current_configuration, dry_run=False):
719     "Apply a configuration"
720     outputs = sorted(new_configuration.keys(), key=lambda x: new_configuration[x].sort_key)
721     if dry_run:
722         base_argv = ["echo", "xrandr"]
723     else:
724         base_argv = ["xrandr"]
725
726     # There are several xrandr / driver bugs we need to take care of here:
727     # - We cannot enable more than two screens at the same time
728     #   See https://github.com/phillipberndt/autorandr/pull/6
729     #   and commits f4cce4d and 8429886.
730     # - We cannot disable all screens
731     #   See https://github.com/phillipberndt/autorandr/pull/20
732     # - We should disable screens before enabling others, because there's
733     #   a limit on the number of enabled screens
734     # - We must make sure that the screen at 0x0 is activated first,
735     #   or the other (first) screen to be activated would be moved there.
736     # - If an active screen already has a transformation and remains active,
737     #   the xrandr call fails with an invalid RRSetScreenSize parameter error.
738     #   Update the configuration in 3 passes in that case.  (On Haswell graphics,
739     #   at least.)
740     # - Some implementations can not handle --transform at all, so avoid it unless
741     #   necessary. (See https://github.com/phillipberndt/autorandr/issues/37)
742     # - Some implementations can not handle --panning without specifying --fb
743     #   explicitly, so avoid it unless necessary.
744     #   (See https://github.com/phillipberndt/autorandr/issues/72)
745
746     fb_dimensions = get_fb_dimensions(new_configuration)
747     try:
748         base_argv += ["--fb", "%dx%d" % fb_dimensions]
749     except:
750         # Failed to obtain frame-buffer size. Doesn't matter, xrandr will choose for the user.
751         pass
752
753     auxiliary_changes_pre = []
754     disable_outputs = []
755     enable_outputs = []
756     remain_active_count = 0
757     for output in outputs:
758         if not new_configuration[output].edid or "off" in new_configuration[output].options:
759             disable_outputs.append(new_configuration[output].option_vector)
760         else:
761             if output not in current_configuration:
762                 raise AutorandrException("New profile configures output %s which does not exist in current xrandr --verbose output. "
763                                          "Don't know how to proceed." % output)
764             if "off" not in current_configuration[output].options:
765                 remain_active_count += 1
766
767             option_vector = new_configuration[output].option_vector
768             if xrandr_version() >= Version("1.3.0"):
769                 for option, off_value in (("transform", "none"), ("panning", "0x0")):
770                     if option in current_configuration[output].options:
771                         auxiliary_changes_pre.append(["--output", output, "--%s" % option, off_value])
772                     else:
773                         try:
774                             option_index = option_vector.index("--%s" % option)
775                             if option_vector[option_index + 1] == XrandrOutput.XRANDR_DEFAULTS[option]:
776                                 option_vector = option_vector[:option_index] + option_vector[option_index + 2:]
777                         except ValueError:
778                             pass
779
780             enable_outputs.append(option_vector)
781
782     # Perform pe-change auxiliary changes
783     if auxiliary_changes_pre:
784         argv = base_argv + list(chain.from_iterable(auxiliary_changes_pre))
785         if call_and_retry(argv, dry_run=dry_run) != 0:
786             raise AutorandrException("Command failed: %s" % " ".join(argv))
787
788     # Disable unused outputs, but make sure that there always is at least one active screen
789     disable_keep = 0 if remain_active_count else 1
790     if len(disable_outputs) > disable_keep:
791         argv = base_argv + list(chain.from_iterable(disable_outputs[:-1] if disable_keep else disable_outputs))
792         if call_and_retry(argv, dry_run=dry_run) != 0:
793             # Disabling the outputs failed. Retry with the next command:
794             # Sometimes disabling of outputs fails due to an invalid RRSetScreenSize.
795             # This does not occur if simultaneously the primary screen is reset.
796             pass
797         else:
798             disable_outputs = disable_outputs[-1:] if disable_keep else []
799
800     # If disable_outputs still has more than one output in it, one of the xrandr-calls below would
801     # disable the last two screens. This is a problem, so if this would happen, instead disable only
802     # one screen in the first call below.
803     if len(disable_outputs) > 0 and len(disable_outputs) % 2 == 0:
804         # In the context of a xrandr call that changes the display state, `--query' should do nothing
805         disable_outputs.insert(0, ['--query'])
806
807     # Enable the remaining outputs in pairs of two operations
808     operations = disable_outputs + enable_outputs
809     for index in range(0, len(operations), 2):
810         argv = base_argv + list(chain.from_iterable(operations[index:index + 2]))
811         if call_and_retry(argv, dry_run=dry_run) != 0:
812             raise AutorandrException("Command failed: %s" % " ".join(argv))
813
814
815 def is_equal_configuration(source_configuration, target_configuration):
816     """
817         Check if all outputs from target are already configured correctly in source and
818         that no other outputs are active.
819     """
820     for output in target_configuration.keys():
821         if "off" in target_configuration[output].options:
822             if (output in source_configuration and "off" not in source_configuration[output].options):
823                 return False
824         else:
825             if (output not in source_configuration) or (source_configuration[output] != target_configuration[output]):
826                 return False
827     for output in source_configuration.keys():
828         if "off" in source_configuration[output].options:
829             if output in target_configuration and "off" not in target_configuration[output].options:
830                 return False
831         else:
832             if output not in target_configuration:
833                 return False
834     return True
835
836
837 def add_unused_outputs(source_configuration, target_configuration):
838     "Add outputs that are missing in target to target, in 'off' state"
839     for output_name, output in source_configuration.items():
840         if output_name not in target_configuration:
841             target_configuration[output_name] = XrandrOutput(output_name, output.edid, {"off": None})
842
843
844 def remove_irrelevant_outputs(source_configuration, target_configuration):
845     "Remove outputs from target that ought to be 'off' and already are"
846     for output_name, output in source_configuration.items():
847         if "off" in output.options:
848             if output_name in target_configuration:
849                 if "off" in target_configuration[output_name].options:
850                     del target_configuration[output_name]
851
852
853 def generate_virtual_profile(configuration, modes, profile_name):
854     "Generate one of the virtual profiles"
855     configuration = copy.deepcopy(configuration)
856     if profile_name == "common":
857         mode_sets = []
858         for output, output_modes in modes.items():
859             mode_set = set()
860             if configuration[output].edid:
861                 for mode in output_modes:
862                     mode_set.add((mode["width"], mode["height"]))
863             mode_sets.append(mode_set)
864         common_resolution = reduce(lambda a, b: a & b, mode_sets[1:], mode_sets[0])
865         common_resolution = sorted(common_resolution, key=lambda a: int(a[0]) * int(a[1]))
866         if common_resolution:
867             for output in configuration:
868                 configuration[output].options = {}
869                 if output in modes and configuration[output].edid:
870                     modes_sorted = sorted(modes[output], key=lambda x: 0 if x["preferred"] else 1)
871                     modes_filtered = [x for x in modes_sorted if (x["width"], x["height"]) == common_resolution[-1]]
872                     mode = modes_filtered[0]
873                     configuration[output].options["mode"] = mode['name']
874                     configuration[output].options["pos"] = "0x0"
875                 else:
876                     configuration[output].options["off"] = None
877     elif profile_name in ("horizontal", "vertical"):
878         shift = 0
879         if profile_name == "horizontal":
880             shift_index = "width"
881             pos_specifier = "%sx0"
882         else:
883             shift_index = "height"
884             pos_specifier = "0x%s"
885
886         for output in configuration:
887             configuration[output].options = {}
888             if output in modes and configuration[output].edid:
889                 def key(a):
890                     score = int(a["width"]) * int(a["height"])
891                     if a["preferred"]:
892                         score += 10**6
893                     return score
894                 output_modes = sorted(modes[output], key=key)
895                 mode = output_modes[-1]
896                 configuration[output].options["mode"] = mode["name"]
897                 configuration[output].options["rate"] = mode["rate"]
898                 configuration[output].options["pos"] = pos_specifier % shift
899                 shift += int(mode[shift_index])
900             else:
901                 configuration[output].options["off"] = None
902     elif profile_name == "clone-largest":
903         modes_unsorted = [output_modes[0] for output, output_modes in modes.items()]
904         modes_sorted = sorted(modes_unsorted, key=lambda x: int(x["width"]) * int(x["height"]), reverse=True)
905         biggest_resolution = modes_sorted[0]
906         for output in configuration:
907             configuration[output].options = {}
908             if output in modes and configuration[output].edid:
909                 def key(a):
910                     score = int(a["width"]) * int(a["height"])
911                     if a["preferred"]:
912                         score += 10**6
913                     return score
914                 output_modes = sorted(modes[output], key=key)
915                 mode = output_modes[-1]
916                 configuration[output].options["mode"] = mode["name"]
917                 configuration[output].options["rate"] = mode["rate"]
918                 configuration[output].options["pos"] = "0x0"
919                 scale = max(float(biggest_resolution["width"]) / float(mode["width"]),
920                             float(biggest_resolution["height"]) / float(mode["height"]))
921                 mov_x = (float(mode["width"]) * scale - float(biggest_resolution["width"])) / -2
922                 mov_y = (float(mode["height"]) * scale - float(biggest_resolution["height"])) / -2
923                 configuration[output].options["transform"] = "{},0,{},0,{},{},0,0,1".format(scale, mov_x, scale, mov_y)
924             else:
925                 configuration[output].options["off"] = None
926     elif profile_name == "off":
927         for output in configuration:
928             for key in list(configuration[output].options.keys()):
929                 del configuration[output].options[key]
930             configuration[output].options["off"] = None
931     return configuration
932
933
934 def print_profile_differences(one, another):
935     "Print the differences between two profiles for debugging"
936     if one == another:
937         return
938     print("| Differences between the two profiles:")
939     for output in set(chain.from_iterable((one.keys(), another.keys()))):
940         if output not in one:
941             if "off" not in another[output].options:
942                 print("| Output `%s' is missing from the active configuration" % output)
943         elif output not in another:
944             if "off" not in one[output].options:
945                 print("| Output `%s' is missing from the new configuration" % output)
946         else:
947             for line in one[output].verbose_diff(another[output]):
948                 print("| [Output %s] %s" % (output, line))
949     print("\\-")
950
951
952 def exit_help():
953     "Print help and exit"
954     print(help_text)
955     for profile in virtual_profiles:
956         name, description = profile[:2]
957         description = [description]
958         max_width = 78 - 18
959         while len(description[0]) > max_width + 1:
960             left_over = description[0][max_width:]
961             description[0] = description[0][:max_width] + "-"
962             description.insert(1, "  %-15s %s" % ("", left_over))
963         description = "\n".join(description)
964         print("  %-15s %s" % (name, description))
965     sys.exit(0)
966
967
968 def exec_scripts(profile_path, script_name, meta_information=None):
969     """"Run userscripts
970
971     This will run all executables from the profile folder, and global per-user
972     and system-wide configuration folders, named script_name or residing in
973     subdirectories named script_name.d.
974
975     If profile_path is None, only global scripts will be invoked.
976
977     meta_information is expected to be an dictionary. It will be passed to the block scripts
978     in the environment, as variables called AUTORANDR_<CAPITALIZED_KEY_HERE>.
979
980     Returns True unless any of the scripts exited with non-zero exit status.
981     """
982     all_ok = True
983     env = os.environ.copy()
984     if meta_information:
985         for key, value in meta_information.items():
986             env["AUTORANDR_{}".format(key.upper())] = str(value)
987
988     # If there are multiple candidates, the XDG spec tells to only use the first one.
989     ran_scripts = set()
990
991     user_profile_path = os.path.expanduser("~/.autorandr")
992     if not os.path.isdir(user_profile_path):
993         user_profile_path = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
994
995     candidate_directories = [user_profile_path]
996     for config_dir in os.environ.get("XDG_CONFIG_DIRS", "/etc/xdg").split(":"):
997         candidate_directories.append(os.path.join(config_dir, "autorandr"))
998     if profile_path:
999         candidate_directories.append(profile_path)
1000
1001     for folder in candidate_directories:
1002         if script_name not in ran_scripts:
1003             script = os.path.join(folder, script_name)
1004             if os.access(script, os.X_OK | os.F_OK):
1005                 try:
1006                     all_ok &= subprocess.call(script, env=env) != 0
1007                 except:
1008                     raise AutorandrException("Failed to execute user command: %s" % (script,))
1009                 ran_scripts.add(script_name)
1010
1011         script_folder = os.path.join(folder, "%s.d" % script_name)
1012         if os.access(script_folder, os.R_OK | os.X_OK) and os.path.isdir(script_folder):
1013             for file_name in os.listdir(script_folder):
1014                 check_name = "d/%s" % (file_name,)
1015                 if check_name not in ran_scripts:
1016                     script = os.path.join(script_folder, file_name)
1017                     if os.access(script, os.X_OK | os.F_OK):
1018                         try:
1019                             all_ok &= subprocess.call(script, env=env) != 0
1020                         except:
1021                             raise AutorandrException("Failed to execute user command: %s" % (script,))
1022                         ran_scripts.add(check_name)
1023
1024     return all_ok
1025
1026
1027 def dispatch_call_to_sessions(argv):
1028     """Invoke autorandr for each open local X11 session with the given options.
1029
1030     The function iterates over all processes not owned by root and checks
1031     whether they have DISPLAY and XAUTHORITY variables set. It strips the
1032     screen from any variable it finds (i.e. :0.0 becomes :0) and checks whether
1033     this display has been handled already. If it has not, it forks, changes
1034     uid/gid to the user owning the process, reuses the process's environment
1035     and runs autorandr with the parameters from argv.
1036
1037     This function requires root permissions. It only works for X11 servers that
1038     have at least one non-root process running. It is susceptible for attacks
1039     where one user runs a process with another user's DISPLAY variable - in
1040     this case, it might happen that autorandr is invoked for the other user,
1041     which won't work. Since no other harm than prevention of automated
1042     execution of autorandr can be done this way, the assumption is that in this
1043     situation, the local administrator will handle the situation."""
1044
1045     X11_displays_done = set()
1046
1047     autorandr_binary = os.path.abspath(argv[0])
1048     backup_candidates = {}
1049
1050     def fork_child_autorandr(pwent, process_environ):
1051         print("Running autorandr as %s for display %s" % (pwent.pw_name, process_environ["DISPLAY"]))
1052         child_pid = os.fork()
1053         if child_pid == 0:
1054             # This will throw an exception if any of the privilege changes fails,
1055             # so it should be safe. Also, note that since the environment
1056             # is taken from a process owned by the user, reusing it should
1057             # not leak any information.
1058             os.setgroups([])
1059             os.setresgid(pwent.pw_gid, pwent.pw_gid, pwent.pw_gid)
1060             os.setresuid(pwent.pw_uid, pwent.pw_uid, pwent.pw_uid)
1061             os.chdir(pwent.pw_dir)
1062             os.environ.clear()
1063             os.environ.update(process_environ)
1064             os.execl(autorandr_binary, autorandr_binary, *argv[1:])
1065             os.exit(1)
1066         os.waitpid(child_pid, 0)
1067
1068     for directory in os.listdir("/proc"):
1069         directory = os.path.join("/proc/", directory)
1070         if not os.path.isdir(directory):
1071             continue
1072         environ_file = os.path.join(directory, "environ")
1073         if not os.path.isfile(environ_file):
1074             continue
1075         uid = os.stat(environ_file).st_uid
1076
1077         # The following line assumes that user accounts start at 1000 and that
1078         # no one works using the root or another system account. This is rather
1079         # restrictive, but de facto default. Alternatives would be to use the
1080         # UID_MIN from /etc/login.defs or FIRST_UID from /etc/adduser.conf;
1081         # but effectively, both values aren't binding in any way.
1082         # If this breaks your use case, please file a bug on Github.
1083         if uid < 1000:
1084             continue
1085
1086         process_environ = {}
1087         for environ_entry in open(environ_file).read().split("\0"):
1088             name, sep, value = environ_entry.partition("=")
1089             if name and sep:
1090                 if name == "DISPLAY" and "." in value:
1091                     value = value[:value.find(".")]
1092                 process_environ[name] = value
1093
1094         if "DISPLAY" not in process_environ:
1095             # Cannot work with this environment, skip.
1096             continue
1097
1098         # To allow scripts to detect batch invocation (especially useful for predetect)
1099         process_environ["AUTORANDR_BATCH_PID"] = str(os.getpid())
1100         process_environ["UID"] = str(uid)
1101
1102         display = process_environ["DISPLAY"]
1103
1104         if "XAUTHORITY" not in process_environ:
1105             # It's very likely that we cannot work with this environment either,
1106             # but keep it as a backup just in case we don't find anything else.
1107             backup_candidates[display] = process_environ
1108             continue
1109
1110         if display not in X11_displays_done:
1111             try:
1112                 pwent = pwd.getpwuid(uid)
1113             except KeyError:
1114                 # User has no pwd entry
1115                 continue
1116
1117             fork_child_autorandr(pwent, process_environ)
1118             X11_displays_done.add(display)
1119
1120     # Run autorandr for any users/displays which didn't have a process with
1121     # XAUTHORITY set.
1122     for display, process_environ in backup_candidates.items():
1123         if display not in X11_displays_done:
1124             try:
1125                 pwent = pwd.getpwuid(int(process_environ["UID"]))
1126             except KeyError:
1127                 # User has no pwd entry
1128                 continue
1129
1130             fork_child_autorandr(pwent, process_environ)
1131             X11_displays_done.add(display)
1132
1133
1134 def enabled_monitors(config):
1135     monitors = []
1136     for monitor in config:
1137         if "--off" in config[monitor].option_vector:
1138             continue
1139         monitors.append(monitor)
1140     return monitors
1141
1142
1143 def read_config(options, directory):
1144     """Parse a configuration config.ini from directory and merge it into
1145     the options dictionary"""
1146     config = configparser.ConfigParser()
1147     config.read(os.path.join(directory, "settings.ini"))
1148     if config.has_section("config"):
1149         for key, value in config.items("config"):
1150             options.setdefault("--%s" % key, value)
1151
1152 def main(argv):
1153     try:
1154         opts, args = getopt.getopt(argv[1:], "s:r:l:d:cfh",
1155                                    ["batch", "dry-run", "change", "default=", "save=", "remove=", "load=",
1156                                     "force", "fingerprint", "config", "debug", "skip-options=", "help",
1157                                     "current", "detected", "version"])
1158     except getopt.GetoptError as e:
1159         print("Failed to parse options: {0}.\n"
1160               "Use --help to get usage information.".format(str(e)),
1161               file=sys.stderr)
1162         sys.exit(posix.EX_USAGE)
1163
1164     options = dict(opts)
1165
1166     if "-h" in options or "--help" in options:
1167         exit_help()
1168
1169     if "--version" in options:
1170         print("autorandr " + __version__)
1171         sys.exit(0)
1172
1173     if "--current" in options and "--detected" in options:
1174         print("--current and --detected are mutually exclusive.", file=sys.stderr)
1175         sys.exit(posix.EX_USAGE)
1176
1177     # Batch mode
1178     if "--batch" in options:
1179         if ("DISPLAY" not in os.environ or not os.environ["DISPLAY"]) and os.getuid() == 0:
1180             dispatch_call_to_sessions([x for x in argv if x != "--batch"])
1181         else:
1182             print("--batch mode can only be used by root and if $DISPLAY is unset")
1183         return
1184     if "AUTORANDR_BATCH_PID" in os.environ:
1185         user = pwd.getpwuid(os.getuid())
1186         user = user.pw_name if user else "#%d" % os.getuid()
1187         print("autorandr running as user %s (started from batch instance)" % user)
1188
1189     profiles = {}
1190     profile_symlinks = {}
1191     try:
1192         # Load profiles from each XDG config directory
1193         # The XDG spec says that earlier entries should take precedence, so reverse the order
1194         for directory in reversed(os.environ.get("XDG_CONFIG_DIRS", "/etc/xdg").split(":")):
1195             system_profile_path = os.path.join(directory, "autorandr")
1196             if os.path.isdir(system_profile_path):
1197                 profiles.update(load_profiles(system_profile_path))
1198                 profile_symlinks.update(get_symlinks(system_profile_path))
1199                 read_config(options, system_profile_path)
1200         # For the user's profiles, prefer the legacy ~/.autorandr if it already exists
1201         # profile_path is also used later on to store configurations
1202         profile_path = os.path.expanduser("~/.autorandr")
1203         if not os.path.isdir(profile_path):
1204             # Elsewise, follow the XDG specification
1205             profile_path = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
1206         if os.path.isdir(profile_path):
1207             profiles.update(load_profiles(profile_path))
1208             profile_symlinks.update(get_symlinks(profile_path))
1209             read_config(options, profile_path)
1210         # Sort by descending mtime
1211         profiles = OrderedDict(sorted(profiles.items(), key=lambda x: -x[1]["config-mtime"]))
1212     except Exception as e:
1213         raise AutorandrException("Failed to load profiles", e)
1214
1215     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}
1216
1217     exec_scripts(None, "predetect")
1218     config, modes = parse_xrandr_output()
1219
1220     if "--fingerprint" in options:
1221         output_setup(config, sys.stdout)
1222         sys.exit(0)
1223
1224     if "--config" in options:
1225         output_configuration(config, sys.stdout)
1226         sys.exit(0)
1227
1228     if "--skip-options" in options:
1229         skip_options = [y[2:] if y[:2] == "--" else y for y in (x.strip() for x in options["--skip-options"].split(","))]
1230         for profile in profiles.values():
1231             for output in profile["config"].values():
1232                 output.set_ignored_options(skip_options)
1233         for output in config.values():
1234             output.set_ignored_options(skip_options)
1235
1236     if "-s" in options:
1237         options["--save"] = options["-s"]
1238     if "--save" in options:
1239         if options["--save"] in (x[0] for x in virtual_profiles):
1240             raise AutorandrException("Cannot save current configuration as profile '%s':\n"
1241                                      "This configuration name is a reserved virtual configuration." % options["--save"])
1242         error = check_configuration_pre_save(config)
1243         if error:
1244             print("Cannot save current configuration as profile '%s':" % options["--save"])
1245             print(error)
1246             sys.exit(1)
1247         try:
1248             profile_folder = os.path.join(profile_path, options["--save"])
1249             save_configuration(profile_folder, options['--save'], config, forced="--force" in options)
1250             exec_scripts(profile_folder, "postsave", {
1251                 "CURRENT_PROFILE": options["--save"],
1252                 "PROFILE_FOLDER": profile_folder,
1253                 "MONITORS": ":".join(enabled_monitors(config)),
1254             })
1255         except AutorandrException as e:
1256             raise e
1257         except Exception as e:
1258             raise AutorandrException("Failed to save current configuration as profile '%s'" % (options["--save"],), e)
1259         print("Saved current configuration as profile '%s'" % options["--save"])
1260         sys.exit(0)
1261
1262     if "-r" in options:
1263         options["--remove"] = options["-r"]
1264     if "--remove" in options:
1265         if options["--remove"] in (x[0] for x in virtual_profiles):
1266             raise AutorandrException("Cannot remove profile '%s':\n"
1267                                      "This configuration name is a reserved virtual configuration." % options["--remove"])
1268         if options["--remove"] not in profiles.keys():
1269             raise AutorandrException("Cannot remove profile '%s':\n"
1270                                      "This profile does not exist." % options["--remove"])
1271         try:
1272             remove = True
1273             profile_folder = os.path.join(profile_path, options["--remove"])
1274             profile_dirlist = os.listdir(profile_folder)
1275             profile_dirlist.remove("config")
1276             profile_dirlist.remove("setup")
1277             if profile_dirlist:
1278                 print("Profile folder '%s' contains the following additional files:\n"
1279                       "---\n%s\n---" % (options["--remove"], "\n".join(profile_dirlist)))
1280                 response = input("Do you really want to remove profile '%s'? If so, type 'yes': " % options["--remove"]).strip()
1281                 if response != "yes":
1282                     remove = False
1283             if remove is True:
1284                 shutil.rmtree(profile_folder)
1285                 print("Removed profile '%s'" % options["--remove"])
1286             else:
1287                 print("Profile '%s' was not removed" % options["--remove"])
1288         except Exception as e:
1289             raise AutorandrException("Failed to remove profile '%s'" % (options["--remove"],), e)
1290         sys.exit(0)
1291
1292     detected_profiles = find_profiles(config, profiles)
1293     load_profile = False
1294
1295     if "-l" in options:
1296         options["--load"] = options["-l"]
1297     if "--load" in options:
1298         load_profile = options["--load"]
1299     elif len(args) == 1:
1300         load_profile = args[0]
1301     else:
1302         # Find the active profile(s) first, for the block script (See #42)
1303         current_profiles = []
1304         for profile_name in profiles.keys():
1305             configs_are_equal = is_equal_configuration(config, profiles[profile_name]["config"])
1306             if configs_are_equal:
1307                 current_profiles.append(profile_name)
1308         block_script_metadata = {
1309             "CURRENT_PROFILE": "".join(current_profiles[:1]),
1310             "CURRENT_PROFILES": ":".join(current_profiles)
1311         }
1312
1313         for profile_name in profiles.keys():
1314             if profile_blocked(os.path.join(profile_path, profile_name), block_script_metadata):
1315                 if "--current" not in options and "--detected" not in options:
1316                     print("%s (blocked)" % profile_name)
1317                 continue
1318             props = []
1319             if profile_name in detected_profiles:
1320                 props.append("(detected)")
1321                 if ("-c" in options or "--change" in options) and not load_profile:
1322                     load_profile = profile_name
1323             elif "--detected" in options:
1324                 continue
1325             if profile_name in current_profiles:
1326                 props.append("(current)")
1327             elif "--current" in options:
1328                 continue
1329             if "--current" in options or "--detected" in options:
1330                 print("%s" % (profile_name, ))
1331             else:
1332                 print("%s%s%s" % (profile_name, " " if props else "", " ".join(props)))
1333             if not configs_are_equal and "--debug" in options and profile_name in detected_profiles:
1334                 print_profile_differences(config, profiles[profile_name]["config"])
1335
1336     if "-d" in options:
1337         options["--default"] = options["-d"]
1338     if not load_profile and "--default" in options and ("-c" in options or "--change" in options):
1339         load_profile = options["--default"]
1340
1341     if load_profile:
1342         if load_profile in profile_symlinks:
1343             if "--debug" in options:
1344                 print("'%s' symlinked to '%s'" % (load_profile, profile_symlinks[load_profile]))
1345             load_profile = profile_symlinks[load_profile]
1346
1347         if load_profile in (x[0] for x in virtual_profiles):
1348             load_config = generate_virtual_profile(config, modes, load_profile)
1349             scripts_path = os.path.join(profile_path, load_profile)
1350         else:
1351             try:
1352                 profile = profiles[load_profile]
1353                 load_config = profile["config"]
1354                 scripts_path = profile["path"]
1355             except KeyError:
1356                 raise AutorandrException("Failed to load profile '%s': Profile not found" % load_profile)
1357             if load_profile in detected_profiles and detected_profiles[0] != load_profile:
1358                 update_mtime(os.path.join(scripts_path, "config"))
1359         add_unused_outputs(config, load_config)
1360         if load_config == dict(config) and "-f" not in options and "--force" not in options:
1361             print("Config already loaded", file=sys.stderr)
1362             sys.exit(0)
1363         if "--debug" in options and load_config != dict(config):
1364             print("Loading profile '%s'" % load_profile)
1365             print_profile_differences(config, load_config)
1366
1367         remove_irrelevant_outputs(config, load_config)
1368
1369         try:
1370             if "--dry-run" in options:
1371                 apply_configuration(load_config, config, True)
1372             else:
1373                 script_metadata = {
1374                     "CURRENT_PROFILE": load_profile,
1375                     "PROFILE_FOLDER": scripts_path,
1376                     "MONITORS": ":".join(enabled_monitors(load_config)),
1377                 }
1378                 exec_scripts(scripts_path, "preswitch", script_metadata)
1379                 if "--debug" in options:
1380                     print("Going to run:")
1381                     apply_configuration(load_config, config, True)
1382                 apply_configuration(load_config, config, False)
1383                 exec_scripts(scripts_path, "postswitch", script_metadata)
1384         except AutorandrException as e:
1385             raise AutorandrException("Failed to apply profile '%s'" % load_profile, e, e.report_bug)
1386         except Exception as e:
1387             raise AutorandrException("Failed to apply profile '%s'" % load_profile, e, True)
1388
1389         if "--dry-run" not in options and "--debug" in options:
1390             new_config, _ = parse_xrandr_output()
1391             if not is_equal_configuration(new_config, load_config):
1392                 print("The configuration change did not go as expected:")
1393                 print_profile_differences(new_config, load_config)
1394
1395     sys.exit(0)
1396
1397
1398 def exception_handled_main(argv=sys.argv):
1399     try:
1400         main(sys.argv)
1401     except AutorandrException as e:
1402         print(e, file=sys.stderr)
1403         sys.exit(1)
1404     except Exception as e:
1405         if not len(str(e)):  # BdbQuit
1406             print("Exception: {0}".format(e.__class__.__name__))
1407             sys.exit(2)
1408
1409         print("Unhandled exception ({0}). Please report this as a bug at "
1410               "https://github.com/phillipberndt/autorandr/issues.".format(e),
1411               file=sys.stderr)
1412         raise
1413
1414
1415 if __name__ == '__main__':
1416     exception_handled_main()