)? # .. but everything of the above only if the screen is in use.
).*
(?:\s*(?: # Properties of the output
- Gamma: (?P<gamma>[0-9\.:\s]+) | # Gamma value
- Transform: (?P<transform>[0-9\.\s]+) | # Transformation matrix
- EDID: (?P<edid>[0-9a-f\s]+) | # EDID of the output
+ Gamma: (?P<gamma>[0-9\.: ]+) | # Gamma value
+ Transform: (?P<transform>(?:[\-0-9\. ]+\s+){3}) | # Transformation matrix
+ EDID: (?P<edid>\s*?(?:\\n\\t\\t[0-9a-f]+)+) | # EDID of the output
(?![0-9])[^:\s][^:\n]+:.*(?:\s\\t[\\t ].+)* # Other properties
))+
\s*
@property
def option_vector(self):
"Return the command line parameters for XRandR for this instance"
- return sum([["--%s" % option[0], option[1]] if option[1] else ["--%s" % option[0]] for option in chain((("output", self.output),), self.options_with_defaults.items())], [])
+ return sum([["--%s" % option[0], option[1]] if option[1] else ["--%s" % option[0]] for option in chain((("output", self.output),), sorted(self.options_with_defaults.items()))], [])
@property
def option_string(self):
"Return the command line parameters in the configuration file format"
- return "\n".join([ " ".join(option) if option[1] else option[0] for option in chain((("output", self.output),), self.options.items())])
+ return "\n".join([ " ".join(option) if option[1] else option[0] for option in chain((("output", self.output),), sorted(self.options.items()))])
@property
def sort_key(self):
This method also returns a list of modes supported by the output.
"""
try:
+ xrandr_output = xrandr_output.replace("\r\n", "\n")
match_object = re.search(XrandrOutput.XRANDR_OUTPUT_REGEXP, xrandr_output)
except:
raise RuntimeError("Parsing XRandR output failed, there is an error in the regular expression.")
raise RuntimeError("Parsing XRandR output failed, the regular expression did not match: %s" % debug)
remainder = xrandr_output[len(match_object.group(0)):]
if remainder:
- raise RuntimeError(("Parsing XRandR output failed, %d bytes left unmatched after regular expression,"
- "starting with ..'%s'.") % (len(remainder), remainder[:10]))
-
+ raise RuntimeError(("Parsing XRandR output failed, %d bytes left unmatched after regular expression, "
+ "starting at byte %d with ..'%s'.") % (len(remainder), len(len(match_object.group(0))), remainder[:10]))
match = match_object.groupdict()
# Split at output boundaries and instanciate an XrandrOutput per output
split_xrandr_output = re.split("(?m)^([^ ]+ (?:(?:dis)?connected|unknown connection).*)$", xrandr_output)
+ if len(split_xrandr_output) < 2:
+ raise RuntimeError("No output boundaries found")
outputs = OrderedDict()
modes = OrderedDict()
for i in range(1, len(split_xrandr_output), 2):
if not os.path.isfile(config_name) or not os.path.isfile(setup_name):
continue
- edids = dict([ x.strip().split() for x in open(setup_name).readlines() ])
+ edids = dict([ x.strip().split() for x in open(setup_name).readlines() if x.strip() ])
config = {}
buffer = []
if config[output_name].edid is None:
del config[output_name]
- profiles[profile] = config
+ profiles[profile] = { "config": config, "path": os.path.join(profile_path, profile), "config-mtime": os.stat(config_name).st_mtime }
return profiles
-def find_profile(current_config, profiles):
- "Find a profile matching the currently connected outputs"
+def find_profiles(current_config, profiles):
+ "Find profiles matching the currently connected outputs"
+ detected_profiles = []
for profile_name, profile in profiles.items():
+ config = profile["config"]
matches = True
- for name, output in profile.items():
+ for name, output in config.items():
if not output.edid:
continue
if name not in current_config or not output.edid_equals(current_config[name]):
matches = False
break
- if not matches or any(( name not in profile.keys() for name in current_config.keys() if current_config[name].edid )):
+ if not matches or any(( name not in config.keys() for name in current_config.keys() if current_config[name].edid )):
continue
if matches:
- return profile_name
+ detected_profiles.append(profile_name)
+ return detected_profiles
def profile_blocked(profile_path):
"Check if a profile is blocked"
with open(os.path.join(profile_path, "setup"), "w") as setup:
output_setup(configuration, setup)
+def update_mtime(filename):
+ "Update a file's mtime"
+ try:
+ os.utime(filename, None)
+ return True
+ except:
+ return False
+
def apply_configuration(configuration, dry_run=False):
"Apply a configuration"
outputs = sorted(configuration.keys(), key=lambda x: configuration[x].sort_key)
else:
base_argv = [ "xrandr" ]
- # Disable all unused outputs
- argv = base_argv[:]
+ # There are several xrandr / driver bugs we need to take care of here:
+ # - We cannot enable more than two screens at the same time
+ # See https://github.com/phillipberndt/autorandr/pull/6
+ # and commits f4cce4d and 8429886.
+ # - We cannot disable all screens
+ # See https://github.com/phillipberndt/autorandr/pull/20
+ # - We should disable screens before enabling others, because there's
+ # a limit on the number of enabled screens
+ # - We must make sure that the screen at 0x0 is activated first,
+ # or the other (first) screen to be activated would be moved there.
+
+ disable_outputs = []
+ enable_outputs = []
for output in outputs:
if not configuration[output].edid or "off" in configuration[output].options:
- argv += configuration[output].option_vector
- if argv != base_argv:
+ disable_outputs.append(configuration[output].option_vector)
+ else:
+ enable_outputs.append(configuration[output].option_vector)
+
+ # Disable all but the last of the outputs to be disabled
+ if len(disable_outputs) > 1:
+ if subprocess.call(base_argv + list(chain.from_iterable(disable_outputs[:-1]))) != 0:
+ # Disabling the outputs failed. Retry with the next command:
+ # Sometimes disabling of outputs fails due to an invalid RRSetScreenSize.
+ # This does not occur if simultaneously the primary screen is reset.
+ pass
+ else:
+ disable_outputs = disable_outputs[-1:]
+
+ # If disable_outputs still has more than one output in it, one of the xrandr-calls below would
+ # disable the last two screens. This is a problem, so if this would happen, instead disable only
+ # one screen in the first call below.
+ if len(disable_outputs) > 0 and len(disable_outputs) % 2 == 0:
+ # In the context of a xrandr call that changes the display change, `--query' should do nothing
+ disable_outputs.insert(0, ['--query'])
+
+ # Enable the remaining outputs in pairs of two operations
+ operations = disable_outputs + enable_outputs
+ for index in range(0, len(operations), 2):
+ argv = base_argv + list(chain.from_iterable(operations[index:index+2]))
if subprocess.call(argv) != 0:
- return False
-
- # Enable remaining outputs in pairs of two
- remaining_outputs = [ x for x in outputs if configuration[x].edid ]
- for index in range(0, len(remaining_outputs), 2):
- if subprocess.call((base_argv[:] + configuration[remaining_outputs[index]].option_vector + (configuration[remaining_outputs[index + 1]].option_vector if index < len(remaining_outputs) - 1 else []))) != 0:
- return False
+ raise RuntimeError("Command failed: %s" % " ".join(argv))
def add_unused_outputs(source_configuration, target_configuration):
"Add outputs that are missing in target to target, in 'off' state"
if output_name not in target_configuration:
target_configuration[output_name] = XrandrOutput(output_name, output.edid, { "off": None })
+def remove_irrelevant_outputs(source_configuration, target_configuration):
+ "Remove outputs from target that ought to be 'off' and already are"
+ for output_name, output in source_configuration.items():
+ if "off" in output.options and output_name in target_configuration and "off" in target_configuration[output_name].options:
+ del target_configuration[output_name]
+
def generate_virtual_profile(configuration, modes, profile_name):
"Generate one of the virtual profiles"
configuration = copy.deepcopy(configuration)
print(str(e))
options = { "--help": True }
- profile_dir = os.path.expanduser("~/.autorandr")
- if not os.path.isdir(profile_dir):
- profile_dir = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
-
- profile_path = os.path.join(profile_dir, "profiles")
-
+ profiles = {}
try:
- profiles = load_profiles(profile_path)
- except OSError as e:
- if e.errno == 2: # No such file or directory
- profiles = {}
- else:
- raise e
+ # Load profiles from each XDG config directory
+ for directory in os.environ.get("XDG_CONFIG_DIRS", "").split(":"):
+ system_profile_path = os.path.join(directory, "autorandr")
+ if os.path.isdir(system_profile_path):
+ profiles.update(load_profiles(system_profile_path))
+ # For the user's profiles, prefer the legacy ~/.autorandr if it already exists
+ # profile_path is also used later on to store configurations
+ profile_path = os.path.expanduser("~/.autorandr")
+ if not os.path.isdir(profile_path):
+ # Elsewise, follow the XDG specification
+ profile_path = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
+ if os.path.isdir(profile_path):
+ profiles.update(load_profiles(profile_path))
+ # Sort by descending mtime
+ profiles = OrderedDict(sorted(profiles.items(), key=lambda x: -x[1]["config-mtime"]))
except Exception as e:
print("Failed to load profiles:\n%s" % str(e), file=sys.stderr)
sys.exit(1)
if "-h" in options or "--help" in options:
exit_help()
- detected_profile = find_profile(config, profiles)
+ detected_profiles = find_profiles(config, profiles)
load_profile = False
if "-l" in options:
if profile_blocked(os.path.join(profile_path, profile_name)):
print("%s (blocked)" % profile_name, file=sys.stderr)
continue
- if detected_profile == profile_name:
+ if profile_name in detected_profiles:
print("%s (detected)" % profile_name, file=sys.stderr)
- if "-c" in options or "--change" in options:
- load_profile = detected_profile
+ if ("-c" in options or "--change" in options) and not load_profile:
+ load_profile = profile_name
else:
print(profile_name, file=sys.stderr)
if load_profile:
if load_profile in ( x[0] for x in virtual_profiles ):
- profile = generate_virtual_profile(config, modes, load_profile)
+ load_config = generate_virtual_profile(config, modes, load_profile)
+ scripts_path = os.path.join(profile_path, load_profile)
else:
try:
profile = profiles[load_profile]
+ load_config = profile["config"]
+ scripts_path = profile["path"]
except KeyError:
print("Failed to load profile '%s':\nProfile not found" % load_profile, file=sys.stderr)
sys.exit(1)
- add_unused_outputs(config, profile)
- if profile == dict(config) and not "-f" in options and not "--force" in options:
+ if load_profile in detected_profiles and detected_profiles[0] != load_profile:
+ update_mtime(os.path.join(scripts_path, "config"))
+ add_unused_outputs(config, load_config)
+ if load_config == dict(config) and not "-f" in options and not "--force" in options:
print("Config already loaded", file=sys.stderr)
sys.exit(0)
+ remove_irrelevant_outputs(config, load_config)
try:
if "--dry-run" in options:
- apply_configuration(profile, True)
+ apply_configuration(load_config, True)
else:
- exec_scripts(os.path.join(profile_path, load_profile), "preswitch")
- apply_configuration(profile, False)
- exec_scripts(os.path.join(profile_path, load_profile), "postswitch")
+ exec_scripts(scripts_path, "preswitch")
+ apply_configuration(load_config, False)
+ exec_scripts(scripts_path, "postswitch")
except Exception as e:
print("Failed to apply profile '%s':\n%s" % (load_profile, str(e)), file=sys.stderr)
sys.exit(1)