alexion
8d6ec10b74
Dispatches kglobalshortcutsrc identifiers through the kglobalaccel D-Bus service instead of the schema-backed or freeform rc-file paths. Verified manually against the live session (per the spec's testing decision, this mechanism is excluded from the automated suite); switched to the shortcutKeys/defaultShortcutKeys/setShortcutKeys D-Bus methods after the spec's originally-named shortcut/defaultShortcut/setShortcut proved to return stale data on the live system. Moves Lock Session off Meta+L to Meta+X as the real-world validation, tracked in the manifest and recorded in keybindings.md.
427 lines
14 KiB
Python
427 lines
14 KiB
Python
#!/usr/bin/env python3
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
import xml.etree.ElementTree as ET
|
|
from collections import defaultdict, namedtuple
|
|
from pathlib import Path
|
|
|
|
KCFG_NS = "{http://www.kde.org/standards/kcfg/1.0}"
|
|
DEFAULT_SCHEMA_DIR = "/usr/share/config.kcfg"
|
|
|
|
KGLOBALACCEL_SERVICE = "org.kde.kglobalaccel"
|
|
KGLOBALACCEL_PATH = "/kglobalaccel"
|
|
KGLOBALACCEL_IFACE = "org.kde.KGlobalAccel"
|
|
# KGlobalAccel::GlobalShortcutLoading::NoAutoloading, per KF6/KGlobalAccel/kglobalaccel.h --
|
|
# makes a write always win over whatever shortcut was previously saved, rather than being
|
|
# ignored in favor of it (the Autoloading=0x0 default).
|
|
SHORTCUT_NO_AUTOLOADING = 0x4
|
|
|
|
# .kcfg files that only declare their target rc file at runtime
|
|
# (<kcfgfile arg="true">), so it can't be discovered by scanning.
|
|
ARG_TRUE_RCFILES = {
|
|
"kwin.kcfg": "kwinrc",
|
|
}
|
|
|
|
SAVE_USAGE = """usage: dot kde save [identifier]
|
|
|
|
identifier declare a new manifest entry, seeded from its current live value
|
|
(no args) refresh every already-declared manifest entry from the live system
|
|
help show this message"""
|
|
|
|
APPLY_USAGE = """usage: dot kde apply
|
|
|
|
Pushes every manifest entry's declared value onto the live system.
|
|
help show this message"""
|
|
|
|
DIFF_USAGE = """usage: dot kde diff
|
|
|
|
Scans every schema-backed setting reachable through the kcfg mapping
|
|
table and reports each one whose live value differs from its
|
|
schema-declared default, tagged declared (present in the manifest)
|
|
or undeclared. Also reports already-declared freeform and shortcut
|
|
settings whose live value differs from their default (neither has a
|
|
schema/mapping table to broad-scan, so both are only checked when
|
|
already declared). Read-only -- never writes the manifest or the
|
|
live system.
|
|
help show this message"""
|
|
|
|
Setting = namedtuple("Setting", ["file", "group", "key"])
|
|
|
|
|
|
def parse_identifier(identifier):
|
|
parts = identifier.split(".", 2)
|
|
if len(parts) != 3:
|
|
raise ValueError(f"invalid identifier {identifier!r} (expected file.group.key)")
|
|
return Setting(*parts)
|
|
|
|
|
|
def load_manifest(path):
|
|
entries = {}
|
|
if not path.exists():
|
|
return entries
|
|
for line in path.read_text().splitlines():
|
|
if not line.strip():
|
|
continue
|
|
identifier, _, value = line.partition("=")
|
|
entries[identifier] = value
|
|
return entries
|
|
|
|
|
|
def write_manifest(path, entries):
|
|
lines = [f"{identifier}={value}" for identifier, value in entries.items()]
|
|
path.write_text("".join(f"{line}\n" for line in lines))
|
|
|
|
|
|
def _parse_kcfg(path):
|
|
try:
|
|
return ET.parse(path).getroot()
|
|
except ET.ParseError:
|
|
return None
|
|
|
|
|
|
def _kcfgfile_name(root):
|
|
elem = root.find(f"{KCFG_NS}kcfgfile")
|
|
if elem is None:
|
|
return None
|
|
return elem.get("name")
|
|
|
|
|
|
def build_kcfg_map(schema_dir):
|
|
mapping = defaultdict(list)
|
|
if not schema_dir.is_dir():
|
|
return mapping
|
|
|
|
for path in sorted(schema_dir.glob("*.kcfg")):
|
|
root = _parse_kcfg(path)
|
|
if root is None:
|
|
continue
|
|
|
|
rcfile = _kcfgfile_name(root) or ARG_TRUE_RCFILES.get(path.name)
|
|
if rcfile:
|
|
mapping[rcfile].append(path)
|
|
|
|
return mapping
|
|
|
|
|
|
def find_schema_default(kcfg_paths, setting):
|
|
for path in kcfg_paths:
|
|
root = _parse_kcfg(path)
|
|
if root is None:
|
|
continue
|
|
|
|
for group_elem in root.iter(f"{KCFG_NS}group"):
|
|
if group_elem.get("name") != setting.group:
|
|
continue
|
|
for entry in group_elem.findall(f"{KCFG_NS}entry"):
|
|
if (entry.get("key") or entry.get("name")) != setting.key:
|
|
continue
|
|
default_elem = entry.find(f"{KCFG_NS}default")
|
|
return default_elem.text if default_elem is not None and default_elem.text else ""
|
|
|
|
return None
|
|
|
|
|
|
def iter_schema_identifiers(kcfg_map):
|
|
for rcfile, paths in kcfg_map.items():
|
|
for path in paths:
|
|
root = _parse_kcfg(path)
|
|
if root is None:
|
|
continue
|
|
|
|
for group_elem in root.iter(f"{KCFG_NS}group"):
|
|
group = group_elem.get("name")
|
|
if not group:
|
|
continue
|
|
for entry in group_elem.findall(f"{KCFG_NS}entry"):
|
|
key = entry.get("key") or entry.get("name")
|
|
if key:
|
|
yield f"{rcfile}.{group}.{key}"
|
|
|
|
|
|
def resolve_mechanism(setting, kcfg_map):
|
|
if setting.file == "kglobalshortcutsrc":
|
|
return "shortcuts", None
|
|
|
|
default = find_schema_default(kcfg_map.get(setting.file, []), setting)
|
|
if default is not None:
|
|
return "schema", default
|
|
|
|
return "freeform", None
|
|
|
|
|
|
def read_live_value(setting, default):
|
|
cmd = ["kreadconfig6", "--file", setting.file, "--group", setting.group, "--key", setting.key]
|
|
if default is not None:
|
|
cmd += ["--default", default]
|
|
|
|
result = subprocess.run(cmd, capture_output=True, text=True)
|
|
if result.returncode != 0:
|
|
raise RuntimeError(
|
|
f"kreadconfig6 failed for {setting.file}/{setting.group}/{setting.key}: {result.stderr.strip()}"
|
|
)
|
|
return result.stdout.rstrip("\n")
|
|
|
|
|
|
def write_live_value(setting, value):
|
|
cmd = [
|
|
"kwriteconfig6",
|
|
"--file", setting.file,
|
|
"--group", setting.group,
|
|
"--key", setting.key,
|
|
"--",
|
|
value,
|
|
]
|
|
result = subprocess.run(cmd, capture_output=True, text=True)
|
|
if result.returncode != 0:
|
|
raise RuntimeError(
|
|
f"kwriteconfig6 failed for {setting.file}/{setting.group}/{setting.key}: {result.stderr.strip()}"
|
|
)
|
|
|
|
|
|
def _key_sequence_class():
|
|
try:
|
|
from PyQt6.QtGui import QKeySequence
|
|
except ImportError as e:
|
|
raise RuntimeError(
|
|
"the shortcuts mechanism requires PyQt6 (install python-pyqt6) to translate key names"
|
|
) from e
|
|
return QKeySequence
|
|
|
|
|
|
def _keys_to_string(key_ints):
|
|
QKeySequence = _key_sequence_class()
|
|
return "\t".join(QKeySequence(key).toString() for key in key_ints)
|
|
|
|
|
|
def _string_to_keys(value):
|
|
if not value:
|
|
return []
|
|
|
|
QKeySequence = _key_sequence_class()
|
|
keys = []
|
|
for part in value.split("\t"):
|
|
part = part.strip()
|
|
if not part or part.lower() == "none":
|
|
continue
|
|
sequence = QKeySequence(part)
|
|
if sequence.count() != 1:
|
|
raise RuntimeError(f"invalid key sequence {part!r} (expected exactly one key combination)")
|
|
keys.append(int(sequence[0].toCombined()))
|
|
return keys
|
|
|
|
|
|
def _kglobalaccel_call(method, signature, *tokens):
|
|
cmd = ["busctl", "--user", "--json=short", "call",
|
|
KGLOBALACCEL_SERVICE, KGLOBALACCEL_PATH, KGLOBALACCEL_IFACE, method]
|
|
if signature:
|
|
cmd += [signature, *(str(token) for token in tokens)]
|
|
|
|
result = subprocess.run(cmd, capture_output=True, text=True)
|
|
if result.returncode != 0:
|
|
raise RuntimeError(f"kglobalaccel {method} failed: {result.stderr.strip()}")
|
|
return json.loads(result.stdout)["data"]
|
|
|
|
|
|
def _resolve_shortcut_action_id(component_unique, action_unique):
|
|
(actions,) = _kglobalaccel_call("allActionsForComponent", "as", 1, component_unique)
|
|
for action in actions:
|
|
if action[0] == component_unique and action[1] == action_unique:
|
|
return action
|
|
|
|
raise RuntimeError(
|
|
f"no shortcut action {action_unique!r} in component {component_unique!r} "
|
|
"(the owning application may need to run once to register its shortcuts with kglobalaccel)"
|
|
)
|
|
|
|
|
|
# The plural *Keys methods (a(ai), one 4-int QKeyCombination chord slot per bound
|
|
# key sequence) are used instead of the singular shortcut()/defaultShortcut()/
|
|
# setShortcut() methods the flat ai signature suggests: on this KF6 build,
|
|
# defaultShortcut() was empirically found to just mirror shortcut() -- returning
|
|
# whatever the *current* value is rather than the true packaged default -- while
|
|
# defaultShortcutKeys() correctly returns the untouched default even after
|
|
# setShortcutKeys() has changed the current value. Only single, non-chorded key
|
|
# combinations are supported (see _string_to_keys), so only the first of each
|
|
# chord's 4 int slots is ever meaningful here; the rest are always 0.
|
|
def _keys_from_chords(chords):
|
|
return [chord[0][0] for chord in chords]
|
|
|
|
|
|
def read_shortcut_value(component_unique, action_unique, method="shortcutKeys"):
|
|
action_id = _resolve_shortcut_action_id(component_unique, action_unique)
|
|
(chords,) = _kglobalaccel_call(method, "as", len(action_id), *action_id)
|
|
return _keys_to_string(_keys_from_chords(chords))
|
|
|
|
|
|
def write_shortcut_value(component_unique, action_unique, value):
|
|
action_id = _resolve_shortcut_action_id(component_unique, action_unique)
|
|
keys = _string_to_keys(value)
|
|
|
|
tokens = [len(action_id), *action_id, len(keys)]
|
|
for key in keys:
|
|
tokens += [4, key, 0, 0, 0]
|
|
tokens.append(SHORTCUT_NO_AUTOLOADING)
|
|
|
|
_kglobalaccel_call("setShortcutKeys", "asa(ai)u", *tokens)
|
|
|
|
|
|
def save_one(identifier, kcfg_map):
|
|
setting = parse_identifier(identifier)
|
|
mechanism, default = resolve_mechanism(setting, kcfg_map)
|
|
if mechanism == "shortcuts":
|
|
return read_shortcut_value(setting.group, setting.key)
|
|
return read_live_value(setting, default)
|
|
|
|
|
|
def apply_one(identifier, value, kcfg_map):
|
|
setting = parse_identifier(identifier)
|
|
mechanism, _default = resolve_mechanism(setting, kcfg_map)
|
|
if mechanism == "shortcuts":
|
|
write_shortcut_value(setting.group, setting.key, value)
|
|
return
|
|
write_live_value(setting, value)
|
|
|
|
|
|
def cmd_save(args, manifest_path, schema_dir):
|
|
if args and args[0] == "help":
|
|
print(SAVE_USAGE)
|
|
return 0
|
|
|
|
if len(args) > 1:
|
|
print("dot kde save: too many arguments", file=sys.stderr)
|
|
return 1
|
|
|
|
kcfg_map = build_kcfg_map(schema_dir)
|
|
manifest = load_manifest(manifest_path)
|
|
|
|
try:
|
|
if args:
|
|
manifest[args[0]] = save_one(args[0], kcfg_map)
|
|
else:
|
|
for identifier in manifest:
|
|
manifest[identifier] = save_one(identifier, kcfg_map)
|
|
except (ValueError, RuntimeError) as e:
|
|
print(f"dot kde save: {e}", file=sys.stderr)
|
|
return 1
|
|
|
|
write_manifest(manifest_path, manifest)
|
|
return 0
|
|
|
|
|
|
def cmd_apply(args, manifest_path, schema_dir):
|
|
if args and args[0] == "help":
|
|
print(APPLY_USAGE)
|
|
return 0
|
|
|
|
if args:
|
|
print("dot kde apply: too many arguments", file=sys.stderr)
|
|
return 1
|
|
|
|
kcfg_map = build_kcfg_map(schema_dir)
|
|
manifest = load_manifest(manifest_path)
|
|
|
|
try:
|
|
for identifier, value in manifest.items():
|
|
apply_one(identifier, value, kcfg_map)
|
|
except (ValueError, RuntimeError) as e:
|
|
print(f"dot kde apply: {e}", file=sys.stderr)
|
|
return 1
|
|
|
|
return 0
|
|
|
|
|
|
def cmd_diff(args, manifest_path, schema_dir):
|
|
if args and args[0] == "help":
|
|
print(DIFF_USAGE)
|
|
return 0
|
|
|
|
if args:
|
|
print("dot kde diff: too many arguments", file=sys.stderr)
|
|
return 1
|
|
|
|
kcfg_map = build_kcfg_map(schema_dir)
|
|
manifest = load_manifest(manifest_path)
|
|
|
|
for identifier in sorted(set(iter_schema_identifiers(kcfg_map))):
|
|
setting = parse_identifier(identifier)
|
|
default = find_schema_default(kcfg_map.get(setting.file, []), setting)
|
|
try:
|
|
live = read_live_value(setting, default)
|
|
except RuntimeError as e:
|
|
print(f"dot kde diff: {e}", file=sys.stderr)
|
|
continue
|
|
|
|
if live == default:
|
|
continue
|
|
|
|
tag = "declared" if identifier in manifest else "undeclared"
|
|
print(f"{tag} {identifier} = {live} (default: {default})")
|
|
|
|
# Freeform and shortcuts settings have no schema/mapping table to enumerate,
|
|
# so unlike the schema-backed loop above, they can only be checked by walking
|
|
# identifiers already in the manifest -- neither ever surfaces an undeclared
|
|
# setting via broad scan.
|
|
for identifier in manifest:
|
|
try:
|
|
setting = parse_identifier(identifier)
|
|
mechanism, default = resolve_mechanism(setting, kcfg_map)
|
|
if mechanism == "shortcuts":
|
|
live = read_shortcut_value(setting.group, setting.key)
|
|
default = read_shortcut_value(setting.group, setting.key, method="defaultShortcutKeys")
|
|
if live == default:
|
|
continue
|
|
elif mechanism == "freeform":
|
|
live = read_live_value(setting, default)
|
|
if live == "":
|
|
continue
|
|
else:
|
|
continue
|
|
except (ValueError, RuntimeError) as e:
|
|
print(f"dot kde diff: {e}", file=sys.stderr)
|
|
continue
|
|
|
|
print(f"declared {identifier} = {live} (default: {default or ''})")
|
|
|
|
return 0
|
|
|
|
|
|
def cmd_complete(schema_dir):
|
|
kcfg_map = build_kcfg_map(schema_dir)
|
|
for identifier in sorted(set(iter_schema_identifiers(kcfg_map))):
|
|
print(identifier)
|
|
return 0
|
|
|
|
|
|
def main(argv):
|
|
if not argv:
|
|
print("dot kde: no command given", file=sys.stderr)
|
|
return 1
|
|
|
|
command, rest = argv[0], argv[1:]
|
|
schema_dir = Path(os.environ.get("DOT_KDE_KCFG_DIR", DEFAULT_SCHEMA_DIR))
|
|
manifest_path = Path(os.environ["HOME"]) / ".config" / "dot" / "kde-manifest"
|
|
|
|
if command == "save":
|
|
return cmd_save(rest, manifest_path, schema_dir)
|
|
|
|
if command == "apply":
|
|
return cmd_apply(rest, manifest_path, schema_dir)
|
|
|
|
if command == "diff":
|
|
return cmd_diff(rest, manifest_path, schema_dir)
|
|
|
|
# Internal, not a user-facing `dot kde` subcommand -- called directly by
|
|
# completions/dot.fish to source candidates from the live schema, never
|
|
# dispatched to via kde.fish.
|
|
if command == "complete":
|
|
return cmd_complete(schema_dir)
|
|
|
|
print(f"dot kde: unknown command {command!r}", file=sys.stderr)
|
|
return 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main(sys.argv[1:]))
|