mirror of
https://codeberg.org/privacy1st/rotate-screen
synced 2024-11-23 21:49:32 +01:00
221 lines
7.2 KiB
Python
221 lines
7.2 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
import json
|
|
import subprocess
|
|
import re
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import NamedTuple
|
|
|
|
orientations = ['normal', 'right', 'inverted', 'left']
|
|
|
|
|
|
class Device(NamedTuple):
|
|
name: str
|
|
id: int
|
|
fail_ok: bool = False
|
|
|
|
|
|
class Screen(NamedTuple):
|
|
"""
|
|
The xrandr-name of a screen and a list of xinput-device-names that shall be mapped to the screen.
|
|
"""
|
|
name: str
|
|
devices: list[Device]
|
|
|
|
|
|
def main():
|
|
rotate_clockwise()
|
|
|
|
|
|
def rotate_clockwise():
|
|
# Screens from configuration that are connected.
|
|
screens = [screen for screen in Config().get_screens()
|
|
if Xrandr.is_connected(screen.name)]
|
|
|
|
if len(screens) == 0:
|
|
raise Exception('None of the configured screens are connected.')
|
|
|
|
current_orientation = Xrandr.get_orientation(screens[0].name)
|
|
next_orientation = orientations[(orientations.index(current_orientation) + 1) % len(orientations)]
|
|
|
|
for screen in screens:
|
|
rotate(screen, next_orientation)
|
|
|
|
|
|
def rotate(screen: Screen, orientation):
|
|
Xrandr.rotate(screen.name, orientation)
|
|
for device in screen.devices:
|
|
try:
|
|
Xinput.map_to_output(device.name, screen.name)
|
|
except Exception as e:
|
|
if device.fail_ok:
|
|
print(f"Mapping of {device.name} to {screen.name} failed", file=sys.stderr)
|
|
else:
|
|
raise e
|
|
|
|
|
|
class Config:
|
|
"""
|
|
Json structure:
|
|
|
|
{
|
|
# List of screen names from xrandr:
|
|
"screens": ["eDP", "HDMI-A-0", "eDP-1"]
|
|
|
|
# List of devices from xinput that shall be mapped to a screen.
|
|
"devices": [
|
|
# A device can be identified by its exact name through `name` ...
|
|
{"screen": "eDP-1", "name": "ELAN9038:00"},
|
|
# ... or by `name_contains`.
|
|
{"screen": "eDP-1", "name_contains": "ELAN9038"}
|
|
# If `fail_ok` is set to true, errors during mapping of device to screen are ignored.
|
|
{"screen": "eDP-1", "name_contains": "ELAN9038", "fail_ok": true}
|
|
]
|
|
}
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.screens, self.devices = self.load_json()
|
|
|
|
def get_screens(self) -> list[Screen]:
|
|
return [Screen(name=screen, devices=self.get_devices_for(screen)) for screen in self.screens]
|
|
|
|
def get_devices_for(self, screen: str) -> list[Device]:
|
|
x_devs = Xinput.get_devices()
|
|
matches = []
|
|
|
|
for device in self.devices:
|
|
if device["screen"] != screen:
|
|
continue
|
|
fail_ok = device["fail_ok"] if "fail_ok" in device else False
|
|
|
|
if "name" in device:
|
|
match = None
|
|
for x_dev in x_devs:
|
|
if x_dev.name == device["name"]:
|
|
match = x_dev
|
|
break
|
|
if match is None:
|
|
raise Exception(f"Device {device['name']} not found.")
|
|
matches.append(Device(match.name, match.id, fail_ok))
|
|
if "name_contains" in device:
|
|
matched = False
|
|
for x_dev in x_devs:
|
|
if device["name_contains"] in x_dev.name:
|
|
matches.append(Device(x_dev.name, x_dev.id, fail_ok))
|
|
matched = True
|
|
if not matched:
|
|
raise Exception(f"No device found containing {device['name_contains']}.")
|
|
|
|
return matches
|
|
|
|
def load_json(self) -> tuple[list[str], list]:
|
|
j = json.loads(self.get_cfg_path().read_text())
|
|
if "screens" not in j:
|
|
raise Exception("'screens' array missing in cfg.")
|
|
screens = j["screens"]
|
|
|
|
if "devices" not in j:
|
|
raise Exception("'devices' array missing in cfg.")
|
|
devices = j["devices"]
|
|
for device in devices:
|
|
if "name" not in device and "name_contains" not in device:
|
|
raise Exception("Device must have 'name' or 'name_contains'.")
|
|
|
|
return screens, devices
|
|
|
|
@classmethod
|
|
def get_cfg_path(cls) -> Path:
|
|
global_path = Path('/etc/rotate-screen.json')
|
|
if global_path.exists():
|
|
return global_path
|
|
|
|
local_path = Path('example.json')
|
|
if local_path.exists():
|
|
return local_path
|
|
|
|
raise Exception('No configuration file found.')
|
|
|
|
|
|
class Xrandr:
|
|
@classmethod
|
|
def rotate(cls, screen: str, orientation: str):
|
|
execute(['xrandr', '--output', screen, '--rotate', orientation])
|
|
|
|
@classmethod
|
|
def get_orientation(cls, screen: str):
|
|
"""
|
|
@precond: is_connected(screen) = True
|
|
|
|
Example:
|
|
- stdout includes line: eDP connected primary 2880x1620+0+0 (0x55) normal (normal left inverted right x axis y axis) 344mm x 194mm
|
|
- screen: eDP
|
|
- returns: normal
|
|
|
|
Example:
|
|
- stdout includes line: eDP-1 connected 1920x1280+0+0 (0x46) normal (normal left inverted right x axis y axis) 222mm x 148mm
|
|
- screen: eDP-1
|
|
- returns: normal
|
|
"""
|
|
stdout = execute(['xrandr', '--query', '--verbose'])
|
|
# pattern = re.compile(rf'^{re.escape(screen)} .* \([^\)]+\) (\S+) \([^\)]+\) .*$', flags=re.MULTILINE)
|
|
pattern = re.compile(rf'^{re.escape(screen)} connected [^\(]+ \([^\)]+\) (\S+) \([^\)]+\) [^\(]+$',
|
|
flags=re.MULTILINE)
|
|
match = pattern.search(stdout)
|
|
if match is None: raise Exception(f'Did not find screen {screen} in stdout:\n{stdout}')
|
|
return match.group(1)
|
|
|
|
@classmethod
|
|
def is_connected(cls, screen: str):
|
|
"""
|
|
Example:
|
|
- stdout includes line: eDP connected primary 2880x1620+0+0 (normal left inverted right x axis y axis) 344mm x 194mm
|
|
- returns: True
|
|
"""
|
|
stdout = execute(['xrandr'])
|
|
pattern = re.compile(rf'^({re.escape(screen)} connected .*)$', flags=re.MULTILINE)
|
|
match = pattern.search(stdout)
|
|
return match is not None
|
|
|
|
|
|
class Xinput:
|
|
@classmethod
|
|
def map_to_output(cls, device_name_or_id: str | int, screen: str):
|
|
execute(['xinput', '--map-to-output', str(device_name_or_id), screen])
|
|
|
|
@classmethod
|
|
def get_devices(cls) -> list[Device]:
|
|
ids = cls.get_device_ids()
|
|
names = [execute(['xinput', 'list', '--name-only', str(id_)]).strip() for id_ in ids]
|
|
return [Device(name, id_) for id_, name in zip(ids, names)]
|
|
|
|
@classmethod
|
|
def get_device_names(cls) -> list[str]:
|
|
return execute(['xinput', 'list', '--name-only']).strip().splitlines()
|
|
|
|
@classmethod
|
|
def get_device_ids(cls) -> list[int]:
|
|
return [int(id_) for id_ in execute(['xinput', 'list', '--id-only']).strip().splitlines()]
|
|
|
|
|
|
def execute(command: list[str]) -> str:
|
|
"""
|
|
:return: stdout of command execution
|
|
"""
|
|
completed: subprocess.CompletedProcess = subprocess.run(
|
|
command,
|
|
capture_output=True,
|
|
text=True,
|
|
)
|
|
if completed.returncode != 0:
|
|
raise Exception(f'Command: {command}\n'
|
|
f'Exit Code: {completed.returncode}\n'
|
|
f'Stdout:\n{completed.stdout}\n'
|
|
f'Stderr:\n{completed.stderr}')
|
|
return completed.stdout
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|