Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
932a6d41a6
|
No files matched your search
+1
-1
@@ -8,7 +8,7 @@ arch=('x86_64')
|
||||
url="https://git.linux-gaming.ru/Linux-Gaming/PortProtonQt"
|
||||
license=('GPL-3.0')
|
||||
depends=('python-requests' 'python-babel' 'python-evdev' 'python-orjson'
|
||||
'python-psutil' 'python-tqdm' 'python-vdf' 'python-libarchive-c' 'pyside6' 'python-rapidfuzz' 'python-pefile' 'python-pillow' 'perl-image-exiftool' 'python-websocket-client' 'cabextract' 'unzip' 'curl' 'file' 'findutils' 'gawk' 'grep' 'tar' 'xz' 'zstd' 'gzip' 'unrar' 'qt6-svg' 'qt6-imageformats' 'qt6-multimedia' 'pciutils' 'mesa-utils' 'vulkan-icd-loader' 'procps-ng' 'psmisc' '7zip' 'python-dbus-fast' 'sdl3' 'desktop-file-utils')
|
||||
'python-psutil' 'python-tqdm' 'python-vdf' 'python-libarchive-c' 'pyside6' 'python-rapidfuzz' 'python-pefile' 'python-pillow' 'perl-image-exiftool' 'python-websocket-client' 'cabextract' 'unzip' 'curl' 'file' 'findutils' 'gawk' 'grep' 'tar' 'xz' 'zstd' 'gzip' 'unrar' 'qt6-svg' 'qt6-imageformats' 'qt6-multimedia' 'pciutils' 'mesa-utils' 'vulkan-icd-loader' 'procps-ng' 'psmisc' '7zip' 'python-dbus-fast' 'sdl3' 'desktop-file-utils' 'wayland' 'libxkbcommon' 'libx11' 'xkeyboard-config')
|
||||
makedepends=('meson' 'ninja' 'vulkan-headers' 'gettext' 'sdl3')
|
||||
conflicts=("portprotonqt-steam-compat")
|
||||
provides=('portprotonqt-steam-compat')
|
||||
|
||||
@@ -8,7 +8,7 @@ arch=('x86_64')
|
||||
url="https://git.linux-gaming.ru/Linux-Gaming/PortProtonQt"
|
||||
license=('GPL-3.0')
|
||||
depends=('python-requests' 'python-babel' 'python-evdev' 'python-orjson'
|
||||
'python-psutil' 'python-tqdm' 'python-vdf' 'python-libarchive-c' 'pyside6' 'python-rapidfuzz' 'python-pefile' 'python-pillow' 'perl-image-exiftool' 'python-websocket-client' 'cabextract' 'unzip' 'curl' 'file' 'findutils' 'gawk' 'grep' 'tar' 'xz' 'zstd' 'gzip' 'unrar' 'qt6-svg' 'qt6-imageformats' 'qt6-multimedia' 'pciutils' 'mesa-utils' 'vulkan-icd-loader' 'procps-ng' 'psmisc' '7zip' 'python-dbus-fast' 'sdl3' 'desktop-file-utils')
|
||||
'python-psutil' 'python-tqdm' 'python-vdf' 'python-libarchive-c' 'pyside6' 'python-rapidfuzz' 'python-pefile' 'python-pillow' 'perl-image-exiftool' 'python-websocket-client' 'cabextract' 'unzip' 'curl' 'file' 'findutils' 'gawk' 'grep' 'tar' 'xz' 'zstd' 'gzip' 'unrar' 'qt6-svg' 'qt6-imageformats' 'qt6-multimedia' 'pciutils' 'mesa-utils' 'vulkan-icd-loader' 'procps-ng' 'psmisc' '7zip' 'python-dbus-fast' 'sdl3' 'desktop-file-utils' 'wayland' 'libxkbcommon' 'libx11' 'xkeyboard-config')
|
||||
makedepends=('meson' 'ninja' 'vulkan-headers' 'gettext' 'sdl3')
|
||||
conflicts=("portprotonqt-steam-compat")
|
||||
provides=('portprotonqt-steam-compat')
|
||||
|
||||
@@ -23,6 +23,9 @@ BuildRequires: gettext
|
||||
BuildRequires: systemd-rpm-macros
|
||||
BuildRequires: vulkan-loader-devel
|
||||
BuildRequires: pkgconfig(sdl3)
|
||||
BuildRequires: pkgconfig(wayland-client)
|
||||
BuildRequires: pkgconfig(xkbcommon)
|
||||
BuildRequires: pkgconfig(x11)
|
||||
BuildRequires: gcc
|
||||
|
||||
Obsoletes: python3-%{pypi_name}-git < %{version}-%{release}
|
||||
@@ -66,6 +69,7 @@ Requires: psmisc
|
||||
Requires: 7zip
|
||||
Requires: python3-dbus-fast
|
||||
Requires: desktop-file-utils
|
||||
Requires: xkeyboard-config
|
||||
|
||||
# System Tab
|
||||
Recommends: NetworkManager
|
||||
|
||||
@@ -20,6 +20,9 @@ BuildRequires: gettext
|
||||
BuildRequires: systemd-rpm-macros
|
||||
BuildRequires: vulkan-loader-devel
|
||||
BuildRequires: pkgconfig(sdl3)
|
||||
BuildRequires: pkgconfig(wayland-client)
|
||||
BuildRequires: pkgconfig(xkbcommon)
|
||||
BuildRequires: pkgconfig(x11)
|
||||
BuildRequires: gcc
|
||||
|
||||
Obsoletes: python3-%{pypi_name} < %{version}-%{release}
|
||||
@@ -63,6 +66,7 @@ Requires: psmisc
|
||||
Requires: 7zip
|
||||
Requires: python3-dbus-fast
|
||||
Requires: desktop-file-utils
|
||||
Requires: xkeyboard-config
|
||||
|
||||
# System Tab
|
||||
Recommends: NetworkManager
|
||||
|
||||
Executable
BIN
Binary file not shown.
@@ -0,0 +1,60 @@
|
||||
/* Assisted-by: Codex:GPT-6 */
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/Xatom.h>
|
||||
#include <string.h>
|
||||
#include <wayland-client.h>
|
||||
#include <xkbcommon/xkbcommon.h>
|
||||
|
||||
struct wl_display *portproton_keyboard_wayland_connect(const char *name)
|
||||
{
|
||||
return wl_display_connect(name);
|
||||
}
|
||||
|
||||
struct xkb_context *portproton_keyboard_xkb_context_new(enum xkb_context_flags flags)
|
||||
{
|
||||
return xkb_context_new(flags);
|
||||
}
|
||||
|
||||
Display *portproton_keyboard_x11_open_display(const char *name)
|
||||
{
|
||||
return XOpenDisplay(name);
|
||||
}
|
||||
|
||||
int portproton_keyboard_x11_layout_name(Display *display, unsigned int group,
|
||||
char *buffer, size_t size)
|
||||
{
|
||||
const long property_length = 1024;
|
||||
Atom property = XInternAtom(display, "_XKB_RULES_NAMES", True);
|
||||
Atom type;
|
||||
int format;
|
||||
unsigned long length, remaining;
|
||||
unsigned char *data = NULL;
|
||||
if (!property || !buffer || size == 0)
|
||||
return 0;
|
||||
if (XGetWindowProperty(display, DefaultRootWindow(display), property, 0,
|
||||
property_length, False, XA_STRING, &type, &format,
|
||||
&length, &remaining, &data) != Success || !data)
|
||||
return 0;
|
||||
char *start = (char *)data;
|
||||
char *end = start + length;
|
||||
for (unsigned int field = 0; field < 2 && start < end; ++field) {
|
||||
char *separator = memchr(start, '\0', (size_t)(end - start));
|
||||
start = separator ? separator + 1 : end;
|
||||
}
|
||||
char *layouts_end = memchr(start, '\0', (size_t)(end - start));
|
||||
if (!layouts_end)
|
||||
layouts_end = end;
|
||||
for (unsigned int index = 0; index < group && start < layouts_end; ++index) {
|
||||
char *separator = memchr(start, ',', (size_t)(layouts_end - start));
|
||||
start = separator ? separator + 1 : layouts_end;
|
||||
}
|
||||
char *separator = memchr(start, ',', (size_t)(layouts_end - start));
|
||||
size_t count = (size_t)((separator ? separator : layouts_end) - start);
|
||||
int found = format == 8 && count > 0 && count < size;
|
||||
if (found) {
|
||||
memcpy(buffer, start, count);
|
||||
buffer[count] = '\0';
|
||||
}
|
||||
XFree(data);
|
||||
return found;
|
||||
}
|
||||
@@ -40,6 +40,8 @@ pkgdatadir = pythondir / meson.project_name()
|
||||
cc = meson.get_compiler('c')
|
||||
sdl3_dep = dependency('sdl3', required: true)
|
||||
gamepad_sources = files('build-aux/src/gamepad_backend.c')
|
||||
keyboard_deps = [dependency('wayland-client'), dependency('xkbcommon'), dependency('x11')]
|
||||
keyboard_sources = files('build-aux/src/keyboard_backend.c')
|
||||
|
||||
# Install Python package
|
||||
subdir('portprotonqt')
|
||||
|
||||
@@ -311,6 +311,17 @@ class DpadInputMixin(InputMixin):
|
||||
|
||||
@Slot(int, int, float)
|
||||
def handle_dpad_slot(self, code: int, value: int, current_time: float) -> None:
|
||||
keyboard = getattr(self._parent, 'system_keyboard', None)
|
||||
if keyboard is not None and keyboard.isVisible():
|
||||
if value == 0:
|
||||
self._reset_dpad_repeat()
|
||||
return
|
||||
directions = {PAD_DPAD_X: ('left', 'right'), PAD_AXIS_LEFT_X: ('left', 'right'),
|
||||
PAD_DPAD_Y: ('up', 'down'), PAD_AXIS_LEFT_Y: ('up', 'down')}
|
||||
if code in directions:
|
||||
self._start_dpad_repeat(code, value, current_time)
|
||||
keyboard.send('direction', directions[code][value > 0])
|
||||
return
|
||||
if self._route_surface_dpad(code, value, current_time):
|
||||
return
|
||||
self._handle_default_dpad(code, value, current_time)
|
||||
|
||||
@@ -57,8 +57,6 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
|
||||
def _on_gamepad_hotplug(self, action: str) -> None:
|
||||
try:
|
||||
if self._gamepad_polling_suspended:
|
||||
return
|
||||
if action == 'add':
|
||||
self.check_gamepad()
|
||||
elif action == 'remove':
|
||||
@@ -80,8 +78,6 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
|
||||
def check_gamepad(self) -> None:
|
||||
try:
|
||||
if self._gamepad_polling_suspended:
|
||||
return
|
||||
new_gamepad = self.find_gamepad()
|
||||
|
||||
if new_gamepad:
|
||||
@@ -128,6 +124,7 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
self.lt_pressed = False
|
||||
self.rt_pressed = False
|
||||
self.start_held = False
|
||||
self._start_consumed = False
|
||||
self.select_held = False
|
||||
self.pending_menu_fullscreen_time = 0.0
|
||||
self.guide_held = False
|
||||
@@ -173,6 +170,9 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
keyboard = getattr(self._parent, "keyboard", None)
|
||||
if keyboard and hasattr(keyboard, "update_keyboard"):
|
||||
keyboard.update_keyboard()
|
||||
system_keyboard = getattr(self._parent, 'system_keyboard', None)
|
||||
if system_keyboard is not None:
|
||||
system_keyboard.send('gamepad', self.gamepad_type.value)
|
||||
|
||||
def find_gamepad(self) -> SDLGamepad | None:
|
||||
"""Open the SDL3 handle that combines all connected gamepads."""
|
||||
@@ -206,6 +206,9 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
logger.info("Gamepad axes configured for SDL backend: %s", device.name)
|
||||
|
||||
def _handle_pending_menu_fullscreen(self, current_time: float) -> None:
|
||||
if getattr(self, '_gamepad_polling_suspended', False):
|
||||
self.pending_menu_fullscreen_time = 0.0
|
||||
return
|
||||
if not self.pending_menu_fullscreen_time:
|
||||
return
|
||||
if current_time < self.pending_menu_fullscreen_time:
|
||||
@@ -217,10 +220,10 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
|
||||
def _poll_button_events(self, gamepad: SDLGamepad, current_time: float) -> None:
|
||||
"""Emit button changes using SDL's standardized controller mapping."""
|
||||
# Deliver Guide before Select when both change in the same SDL snapshot.
|
||||
# Deliver modifier buttons before their combinations in the same snapshot.
|
||||
buttons = sorted(
|
||||
SDL_CONTROLLER_BUTTON_TO_PAD.items(),
|
||||
key=lambda item: item[1] not in BUTTONS['guide'],
|
||||
key=lambda item: (item[1] not in BUTTONS['guide'], item[1] != PAD_BUTTON_START),
|
||||
)
|
||||
for button_index, button_code in buttons:
|
||||
value = gamepad.get_button(button_index)
|
||||
@@ -242,6 +245,8 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
if button_code == PAD_BUTTON_START:
|
||||
self.start_held = value == 1
|
||||
emulation_combo = self._handle_emulation_combo(button_code, value)
|
||||
if self._handle_system_keyboard_input(button_code, value, emulation_combo):
|
||||
return
|
||||
if self._is_mouse_emulation_active() and value == 1:
|
||||
if button_code in BUTTONS['confirm']:
|
||||
self.click_left()
|
||||
@@ -265,6 +270,41 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
self.pending_menu_fullscreen_time = 0.0
|
||||
return emulation_combo
|
||||
|
||||
def _handle_system_keyboard_input(self, button_code: int, value: int, combo: bool) -> bool:
|
||||
keyboard = getattr(getattr(self, '_parent', None), 'system_keyboard', None)
|
||||
if keyboard is None:
|
||||
return False
|
||||
if combo:
|
||||
self._start_consumed = True
|
||||
return True
|
||||
if button_code == PAD_BUTTON_START:
|
||||
if value:
|
||||
self._start_consumed = False
|
||||
return True
|
||||
if getattr(self, '_start_consumed', False):
|
||||
return True
|
||||
if value and button_code in BUTTONS['prev_dir'] and self.start_held:
|
||||
self._start_consumed = True
|
||||
keyboard.toggle()
|
||||
return True
|
||||
if keyboard.isVisible():
|
||||
actions = {'confirm': 'confirm', 'back': 'back', 'menu': 'back',
|
||||
'prev_tab': 'language', 'next_tab': 'shift', 'add_game': 'backspace'}
|
||||
if button_code == PAD_BUTTON_START and not value:
|
||||
keyboard.send('button', 'confirm')
|
||||
else:
|
||||
for name, action in actions.items():
|
||||
if button_code in BUTTONS[name]:
|
||||
if value:
|
||||
keyboard.send('button', action)
|
||||
elif name == 'add_game':
|
||||
keyboard.send('button', 'backspace_release')
|
||||
break
|
||||
return True
|
||||
if button_code == PAD_BUTTON_START and not value:
|
||||
self.button_event.emit(PAD_BUTTON_START, 1)
|
||||
return False
|
||||
|
||||
def _should_schedule_menu_fullscreen(self, button_code: int, value: int, emulation_combo: bool) -> bool:
|
||||
return (
|
||||
value == 1 and button_code in BUTTONS['menu'] and
|
||||
@@ -347,14 +387,22 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
|
||||
def _is_mouse_emulation_active(self) -> bool:
|
||||
"""Return True when the gamepad currently drives mouse emulation."""
|
||||
keyboard = getattr(getattr(self, '_parent', None), 'system_keyboard', None)
|
||||
if keyboard is not None and keyboard.isVisible():
|
||||
return False
|
||||
return self.mouse_emulation_enabled and self.emulation_active and self.emulation_triggered
|
||||
|
||||
def _should_skip_regular_events(self) -> bool:
|
||||
"""Skip regular UI events while mouse emulation owns the controller."""
|
||||
keyboard = getattr(getattr(self, '_parent', None), 'system_keyboard', None)
|
||||
if keyboard is not None and keyboard.isVisible():
|
||||
return False
|
||||
if getattr(self, '_gamepad_polling_suspended', False):
|
||||
return True
|
||||
return self._is_mouse_emulation_active() and QApplication.activeWindow() is not None
|
||||
|
||||
def _poll_gamepad(self) -> None:
|
||||
if not self.running or self._gamepad_polling_suspended:
|
||||
if not self.running:
|
||||
return
|
||||
current_time = time.time()
|
||||
active_gamepad = self.gamepad
|
||||
@@ -382,7 +430,7 @@ class GamepadRuntimeMixin(InputMixin):
|
||||
self._poll_axis_events(active_gamepad, current_time)
|
||||
if (
|
||||
current_time - self.last_update >= self.update_interval and
|
||||
self.mouse_emulation_enabled and self.emulation_active and self.emulation_triggered
|
||||
self._is_mouse_emulation_active()
|
||||
):
|
||||
self.update_mouse_position()
|
||||
self.last_update = current_time
|
||||
|
||||
@@ -579,6 +579,8 @@ class MainWindow(
|
||||
self.restore_state()
|
||||
|
||||
self.keyboard = VirtualKeyboard(self, self.theme)
|
||||
from portprotonqt.system_keyboard import SystemKeyboard
|
||||
self.system_keyboard = SystemKeyboard(self)
|
||||
|
||||
self.detail_animations = DetailPageAnimations(self, self.theme)
|
||||
self._animations = {}
|
||||
@@ -3529,6 +3531,9 @@ class MainWindow(
|
||||
|
||||
# Full application close
|
||||
event.accept()
|
||||
system_keyboard = getattr(self, 'system_keyboard', None)
|
||||
if system_keyboard is not None:
|
||||
system_keyboard.shutdown()
|
||||
|
||||
watcher = getattr(self, "system_theme_watcher", None)
|
||||
if watcher is not None:
|
||||
|
||||
@@ -77,6 +77,14 @@ shared_library(
|
||||
install_dir: pkgdatadir,
|
||||
)
|
||||
|
||||
shared_library(
|
||||
'portprotonqt_keyboard',
|
||||
keyboard_sources,
|
||||
dependencies: keyboard_deps,
|
||||
install: true,
|
||||
install_dir: pkgdatadir,
|
||||
)
|
||||
|
||||
install_data(
|
||||
['compatibility_rules.json',
|
||||
'keyboard_layouts.json',
|
||||
@@ -85,6 +93,24 @@ install_data(
|
||||
)
|
||||
|
||||
# Install animations package
|
||||
install_data(
|
||||
['system_keyboard/__init__.py',
|
||||
'system_keyboard/__main__.py',
|
||||
'system_keyboard/input.py',
|
||||
'system_keyboard/keys.py',
|
||||
'system_keyboard/layouts.py',
|
||||
'system_keyboard/detection.py',
|
||||
'system_keyboard/gsettings_detection.py',
|
||||
'system_keyboard/wayland_detection.py',
|
||||
'system_keyboard/cosmic_detection.py',
|
||||
'system_keyboard/manual_layout.py',
|
||||
'system_keyboard/native.py',
|
||||
'system_keyboard/window.py',
|
||||
'system_keyboard/wayland_window.py',
|
||||
],
|
||||
install_dir: pythondir / meson.project_name() / 'system_keyboard',
|
||||
)
|
||||
|
||||
install_data(
|
||||
['animations/__init__.py',
|
||||
'animations/detail_background.py',
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
"""Launch and control the system keyboard independently of application focus.
|
||||
|
||||
Assisted-by: Codex:GPT-6
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
import orjson
|
||||
from PySide6.QtCore import QObject, QProcess, QProcessEnvironment
|
||||
from PySide6.QtWidgets import QApplication, QMessageBox, QWidget
|
||||
|
||||
from portprotonqt.config import ui_config
|
||||
from portprotonqt.localization import _
|
||||
from portprotonqt.logger import get_logger
|
||||
|
||||
from .wayland_detection import compositor
|
||||
|
||||
logger = get_logger(__name__)
|
||||
SHUTDOWN_TIMEOUT_MS = 3000
|
||||
ERROR_OUTPUT_LIMIT = 8192
|
||||
|
||||
|
||||
class SystemKeyboard(QObject):
|
||||
"""Retain the child process and forward gamepad commands over its stdin."""
|
||||
|
||||
def __init__(self, parent: QWidget) -> None:
|
||||
super().__init__(parent)
|
||||
self.owner = parent
|
||||
self.process = QProcess(self)
|
||||
self.process.started.connect(self._started)
|
||||
self.process.readyReadStandardOutput.connect(self._read_state)
|
||||
self.process.readyReadStandardError.connect(self._read_errors)
|
||||
self.process.errorOccurred.connect(self._process_error)
|
||||
self.process.finished.connect(self._finished)
|
||||
self.visible = False
|
||||
self.shift_pressed = False
|
||||
self.output = bytearray()
|
||||
self.errors = ''
|
||||
self.closing = False
|
||||
app = QApplication.instance()
|
||||
if app is not None:
|
||||
app.aboutToQuit.connect(self.shutdown)
|
||||
|
||||
def isVisible(self) -> bool:
|
||||
return self.visible
|
||||
|
||||
def toggle(self) -> None:
|
||||
if self.visible:
|
||||
self.hide()
|
||||
return
|
||||
self.visible = True
|
||||
if self.process.state() != QProcess.ProcessState.NotRunning:
|
||||
self.send('show')
|
||||
return
|
||||
self.errors = ''
|
||||
self.output.clear()
|
||||
environment = QProcessEnvironment.systemEnvironment()
|
||||
platform = 'offscreen' if compositor(os.environ) else 'xcb'
|
||||
environment.insert('QT_QPA_PLATFORM', platform)
|
||||
self.process.setProcessEnvironment(environment)
|
||||
self.process.start(sys.executable, ['-m', 'portprotonqt.system_keyboard'])
|
||||
|
||||
def _started(self) -> None:
|
||||
self.send('theme', ui_config.get_theme())
|
||||
self.send('show' if self.visible else 'hide')
|
||||
|
||||
def send(self, action: str, value: object = None) -> None:
|
||||
if self.process.state() == QProcess.ProcessState.Running:
|
||||
self.process.write(orjson.dumps({'action': action, 'value': value}) + b'\n')
|
||||
|
||||
def hide(self) -> None:
|
||||
self.visible = False
|
||||
self.send('hide')
|
||||
|
||||
def _read_state(self) -> None:
|
||||
self.output.extend(bytes(self.process.readAllStandardOutput().data()))
|
||||
while b'\n' in self.output:
|
||||
line, _, remainder = self.output.partition(b'\n')
|
||||
self.output = bytearray(remainder)
|
||||
try:
|
||||
data = orjson.loads(line)
|
||||
except orjson.JSONDecodeError:
|
||||
logger.warning('Invalid system keyboard response: %r', line)
|
||||
continue
|
||||
if isinstance(data, dict) and data.get('event') == 'hidden':
|
||||
self.visible = False
|
||||
self.shift_pressed = False
|
||||
elif isinstance(data, dict) and data.get('event') == 'shift':
|
||||
self.shift_pressed = bool(data.get('value'))
|
||||
|
||||
def _read_errors(self) -> None:
|
||||
output = bytes(self.process.readAllStandardError().data()).decode(errors='replace')
|
||||
self.errors = (self.errors + output)[-ERROR_OUTPUT_LIMIT:]
|
||||
if output.strip():
|
||||
logger.warning('System keyboard: %s', output.strip())
|
||||
|
||||
def _process_error(self, error: QProcess.ProcessError) -> None:
|
||||
if error == QProcess.ProcessError.FailedToStart:
|
||||
self.visible = False
|
||||
self._show_error(self.process.errorString())
|
||||
|
||||
def _finished(self, code: int, status: QProcess.ExitStatus) -> None:
|
||||
self.visible = False
|
||||
self.shift_pressed = False
|
||||
self._read_errors()
|
||||
if not self.closing and (code or status == QProcess.ExitStatus.CrashExit):
|
||||
self._show_error(self.errors.strip() or self.process.errorString())
|
||||
|
||||
def _show_error(self, message: str) -> None:
|
||||
logger.error('Cannot open system keyboard: %s', message)
|
||||
if not self.closing:
|
||||
QMessageBox.warning(self.owner, _('Error'), message)
|
||||
|
||||
def shutdown(self) -> None:
|
||||
self.closing = True
|
||||
self.visible = False
|
||||
self.send('quit')
|
||||
if self.process.state() == QProcess.ProcessState.NotRunning:
|
||||
return
|
||||
if self.process.waitForFinished(SHUTDOWN_TIMEOUT_MS):
|
||||
return
|
||||
self.process.terminate()
|
||||
if not self.process.waitForFinished(SHUTDOWN_TIMEOUT_MS):
|
||||
self.process.kill()
|
||||
self.process.waitForFinished(SHUTDOWN_TIMEOUT_MS)
|
||||
@@ -0,0 +1,73 @@
|
||||
"""Isolated Qt frontend: X11/XWayland or a native Wayland layer surface."""
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
import orjson
|
||||
from typing import Any
|
||||
from PySide6.QtCore import QSocketNotifier
|
||||
from PySide6.QtWidgets import QApplication
|
||||
|
||||
from portprotonqt.logger import get_logger, setup_logger
|
||||
|
||||
logger = get_logger(__name__)
|
||||
COMMAND_READ_SIZE = 8192
|
||||
|
||||
|
||||
class CommandReader:
|
||||
def __init__(self, window: Any) -> None:
|
||||
self.window = window
|
||||
self.buffer = bytearray()
|
||||
os.set_blocking(sys.stdin.fileno(), False)
|
||||
self.notifier = QSocketNotifier(sys.stdin.fileno(), QSocketNotifier.Type.Read)
|
||||
self.notifier.activated.connect(self.read)
|
||||
|
||||
def read(self) -> None:
|
||||
try:
|
||||
data = os.read(sys.stdin.fileno(), COMMAND_READ_SIZE)
|
||||
except BlockingIOError:
|
||||
return
|
||||
if not data:
|
||||
self.notifier.setEnabled(False)
|
||||
self.window.command('quit')
|
||||
return
|
||||
self.buffer.extend(data)
|
||||
while b'\n' in self.buffer:
|
||||
line, _, remaining = self.buffer.partition(b'\n')
|
||||
self.buffer = bytearray(remaining)
|
||||
try:
|
||||
command = orjson.loads(line)
|
||||
if isinstance(command, dict) and isinstance(command.get('action'), str):
|
||||
self.window.command(command['action'], command.get('value'))
|
||||
except Exception:
|
||||
logger.exception('Invalid system keyboard command')
|
||||
|
||||
|
||||
def main() -> int:
|
||||
setup_logger('WARNING')
|
||||
from .wayland_detection import compositor
|
||||
layer_shell = compositor(os.environ) is not None
|
||||
os.environ['QT_QPA_PLATFORM'] = 'offscreen' if layer_shell else 'xcb'
|
||||
app = QApplication([sys.argv[0]])
|
||||
app.setQuitOnLastWindowClosed(False)
|
||||
from .window import SystemKeyboardWindow
|
||||
window = SystemKeyboardWindow()
|
||||
try:
|
||||
if layer_shell:
|
||||
from .wayland_window import WaylandWindow
|
||||
window.native_layer = WaylandWindow(window)
|
||||
reader = CommandReader(window)
|
||||
app.aboutToQuit.connect(window.shutdown)
|
||||
window.worker.start()
|
||||
result = app.exec()
|
||||
window.shutdown()
|
||||
del reader
|
||||
return result
|
||||
except Exception:
|
||||
logger.exception('Failed to start system keyboard')
|
||||
window.shutdown()
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,187 @@
|
||||
"""COSMIC layout notifications over Wayland, without focus or OSK ownership."""
|
||||
from typing import Any
|
||||
|
||||
import ctypes as C
|
||||
import os
|
||||
import select
|
||||
|
||||
from .layouts import Layout
|
||||
from .native import load_library
|
||||
|
||||
|
||||
class Message(C.Structure):
|
||||
_fields_ = [('name', C.c_char_p), ('signature', C.c_char_p),
|
||||
('types', C.c_void_p)]
|
||||
|
||||
|
||||
class Interface(C.Structure):
|
||||
_fields_ = [('name', C.c_char_p), ('version', C.c_int),
|
||||
('method_count', C.c_int), ('methods', C.POINTER(Message)),
|
||||
('event_count', C.c_int), ('events', C.POINTER(Message))]
|
||||
|
||||
|
||||
class CosmicLayout:
|
||||
def __init__(self) -> None:
|
||||
self.display = self.layout = None
|
||||
self.group = None
|
||||
self.error = None
|
||||
self.callbacks, self.proxies = [], []
|
||||
self.keyboard = self.manager = self.tracker = None
|
||||
self.lib = load_library()
|
||||
self._configure_library()
|
||||
self._configure_protocol()
|
||||
try:
|
||||
self.display = self.lib.portproton_keyboard_wayland_connect(None)
|
||||
if not self.display:
|
||||
raise RuntimeError('Failed to connect to Wayland')
|
||||
self.registry = self._new(self.display, (1, self._interface('wl_registry')), C.c_void_p())
|
||||
self._listen(self.registry, [
|
||||
(self._global, [C.c_uint32, C.c_char_p, C.c_uint32]),
|
||||
(lambda *args: None, [C.c_uint32])])
|
||||
for _ in range(4):
|
||||
self._check(self.lib.wl_display_roundtrip(self.display))
|
||||
if self.layout is None or self.group is None:
|
||||
raise RuntimeError('COSMIC keyboard layout protocol or keymap unavailable')
|
||||
except Exception:
|
||||
self.close()
|
||||
raise
|
||||
|
||||
def _configure_library(self) -> None:
|
||||
p = C.c_void_p
|
||||
for name, args, result in (
|
||||
('portproton_keyboard_wayland_connect', [C.c_char_p], p),
|
||||
('wl_display_disconnect', [p], None),
|
||||
('wl_display_roundtrip', [p], C.c_int),
|
||||
('wl_display_dispatch', [p], C.c_int),
|
||||
('wl_display_dispatch_pending', [p], C.c_int),
|
||||
('wl_display_get_fd', [p], C.c_int),
|
||||
('wl_display_flush', [p], C.c_int),
|
||||
('wl_proxy_destroy', [p], None),
|
||||
('wl_proxy_add_listener', [p, p, p], C.c_int),
|
||||
('wl_proxy_marshal_flags', [p, C.c_uint32, C.POINTER(Interface),
|
||||
C.c_uint32, C.c_uint32], p),
|
||||
):
|
||||
fn = getattr(self.lib, name)
|
||||
fn.argtypes, fn.restype = args, result
|
||||
|
||||
def _configure_protocol(self) -> None:
|
||||
p = C.c_void_p
|
||||
# Keep protocol metadata alive for the entire connection.
|
||||
self.group_requests = (Message * 2)(Message(b'set_group', b'u', None),
|
||||
Message(b'destroy', b'', None))
|
||||
self.group_events = (Message * 1)(Message(b'group', b'u', None))
|
||||
self.group_interface = Interface(b'zcosmic_keyboard_layout_v1', 1, 2,
|
||||
self.group_requests, 1, self.group_events)
|
||||
self.manager_types = (C.c_void_p * 2)(C.addressof(self.group_interface),
|
||||
C.addressof(self._interface('wl_keyboard')))
|
||||
self.manager_requests = (Message * 2)(
|
||||
Message(b'get_keyboard_layout', b'no', C.cast(self.manager_types, p)),
|
||||
Message(b'destroy', b'', None))
|
||||
self.manager_interface = Interface(b'zcosmic_keyboard_layout_manager_v1', 1,
|
||||
2, self.manager_requests, 0, None)
|
||||
|
||||
def _interface(self, name: Any) -> Any:
|
||||
return Interface.in_dll(self.lib, name + '_interface')
|
||||
|
||||
def _new(self, proxy: Any, request: tuple[Any, Any], *args: Any) -> Any:
|
||||
opcode, interface = request
|
||||
result = self.lib.wl_proxy_marshal_flags(proxy, opcode, C.byref(interface),
|
||||
1, 0, *args)
|
||||
if not result:
|
||||
raise RuntimeError('COSMIC: не удалось создать объект Wayland')
|
||||
self.proxies.append(result)
|
||||
return result
|
||||
|
||||
def _listen(self, proxy: Any, handlers: Any) -> None:
|
||||
callbacks = []
|
||||
for handler, types in handlers:
|
||||
def guarded(data: Any, obj: Any, *args: Any, handler: Any = handler) -> None:
|
||||
try:
|
||||
handler(*args)
|
||||
except Exception as exc:
|
||||
self.error = exc
|
||||
callbacks.append(C.CFUNCTYPE(None, C.c_void_p, C.c_void_p, *types)(guarded))
|
||||
table = (C.c_void_p * len(callbacks))(*[C.cast(fn, C.c_void_p) for fn in callbacks])
|
||||
self.callbacks.append((callbacks, table))
|
||||
if self.lib.wl_proxy_add_listener(proxy, table, None) != 0:
|
||||
raise RuntimeError('COSMIC: не удалось подписаться на события Wayland')
|
||||
|
||||
def _global(self, name: Any, interface: Any, version: Any) -> None:
|
||||
if interface == b'wl_seat' and not hasattr(self, 'seat'):
|
||||
self.seat = self._new(self.registry, (0, self._interface('wl_seat')),
|
||||
C.c_uint32(name), interface, C.c_uint32(1), C.c_void_p())
|
||||
self._listen(self.seat, [(self._capabilities, [C.c_uint32])])
|
||||
elif interface == self.manager_interface.name and self.manager is None:
|
||||
self.manager = self._new(self.registry, (0, self.manager_interface),
|
||||
C.c_uint32(name), interface, C.c_uint32(1), C.c_void_p())
|
||||
self._track()
|
||||
|
||||
def _capabilities(self, capabilities: Any) -> None:
|
||||
if capabilities & 2 and self.keyboard is None:
|
||||
self.keyboard = self._new(self.seat, (1, self._interface('wl_keyboard')), C.c_void_p())
|
||||
u, p = C.c_uint32, C.c_void_p
|
||||
self._listen(self.keyboard, [
|
||||
(self._keymap, [u, C.c_int, u]),
|
||||
(lambda *args: None, [u, p, p]),
|
||||
(lambda *args: None, [u, p]),
|
||||
(lambda *args: None, [u, u, u, u]),
|
||||
(lambda *args: None, [u, u, u, u, u])])
|
||||
self._track()
|
||||
elif not capabilities & 2 and self.keyboard is not None:
|
||||
self.error = RuntimeError('COSMIC: клавиатура отключена')
|
||||
|
||||
def _track(self) -> None:
|
||||
if self.keyboard and self.manager and self.tracker is None:
|
||||
self.tracker = self._new(self.manager, (0, self.group_interface),
|
||||
C.c_void_p(), C.c_void_p(self.keyboard))
|
||||
self._listen(self.tracker, [(self._group, [C.c_uint32])])
|
||||
|
||||
def _group(self, group: Any) -> None:
|
||||
self.group = group
|
||||
|
||||
def layout_identifier(self) -> str:
|
||||
if self.layout is None or self.group is None:
|
||||
return 'System'
|
||||
return self.layout.layout_identifier(self.group)
|
||||
|
||||
def _keymap(self, format: Any, fd: Any, size: Any) -> None:
|
||||
try:
|
||||
if format != 1 or not 0 < size <= 16 * 1024 * 1024:
|
||||
raise RuntimeError('COSMIC: неверная карта Wayland')
|
||||
text = os.pread(fd, size, 0)
|
||||
if len(text) != size:
|
||||
raise RuntimeError('COSMIC: неполная карта Wayland')
|
||||
replacement = Layout(keymap_text=text)
|
||||
finally:
|
||||
os.close(fd)
|
||||
if self.layout is not None:
|
||||
self.layout.close()
|
||||
self.layout = replacement
|
||||
|
||||
def _check(self, result: Any) -> None:
|
||||
if result < 0:
|
||||
raise RuntimeError('COSMIC: соединение Wayland закрыто')
|
||||
if self.error is not None:
|
||||
raise self.error
|
||||
|
||||
def labels(self, modifiers: Any=()) -> Any:
|
||||
self._check(self.lib.wl_display_dispatch_pending(self.display))
|
||||
fd = self.lib.wl_display_get_fd(self.display)
|
||||
for _ in range(32):
|
||||
if not select.select([fd], [], [], 0)[0]:
|
||||
break
|
||||
self._check(self.lib.wl_display_dispatch(self.display))
|
||||
if self.layout is None or self.group is None:
|
||||
raise RuntimeError('COSMIC: раскладка недоступна')
|
||||
return self.layout.labels(modifiers, mask=(0, 0, 0, self.group))
|
||||
|
||||
def close(self) -> None:
|
||||
if self.layout is not None:
|
||||
self.layout.close()
|
||||
self.layout = None
|
||||
if self.display:
|
||||
for proxy in reversed(self.proxies):
|
||||
self.lib.wl_proxy_destroy(proxy)
|
||||
self.proxies.clear()
|
||||
self.lib.wl_display_disconnect(self.display)
|
||||
self.display = None
|
||||
@@ -0,0 +1,130 @@
|
||||
"""Read the X11/XWayland keymap without capturing keyboard focus."""
|
||||
|
||||
import ctypes as C
|
||||
import os
|
||||
from collections.abc import Mapping
|
||||
|
||||
from .keys import (ROWS, MODIFIERS, XKB_KEYCODE_OFFSET, XKB_CORE_KEYBOARD,
|
||||
XKB_SHIFT_MASK, XKB_LOCK_MASK, XKB_ALTGR_MASK, XKB_GROUP_COUNT, XKB_GROUP_SHIFT)
|
||||
from evdev import ecodes
|
||||
from .native import load_library
|
||||
|
||||
LAYOUT_NAME_BUFFER_BYTES = 256
|
||||
|
||||
|
||||
def is_x11_session(environment: Mapping[str, str]) -> bool:
|
||||
if environment.get('XDG_SESSION_TYPE'):
|
||||
return environment['XDG_SESSION_TYPE'] == 'x11'
|
||||
return bool(environment.get('DISPLAY')) and not environment.get('WAYLAND_DISPLAY')
|
||||
|
||||
|
||||
class XkbState(C.Structure):
|
||||
_fields_ = [('group', C.c_ubyte), ('locked_group', C.c_ubyte),
|
||||
('base_group', C.c_ushort), ('latched_group', C.c_ushort),
|
||||
*[(name, C.c_ubyte) for name in (
|
||||
'mods', 'base_mods', 'latched_mods', 'locked_mods',
|
||||
'compat_state', 'grab_mods', 'compat_grab_mods',
|
||||
'lookup_mods', 'compat_lookup_mods')],
|
||||
('ptr_buttons', C.c_ushort)]
|
||||
|
||||
|
||||
class X11Layout:
|
||||
def __init__(self) -> None:
|
||||
self.display = None
|
||||
self.lib = load_library()
|
||||
functions = {
|
||||
'portproton_keyboard_x11_open_display': ([C.c_char_p], C.c_void_p),
|
||||
'XCloseDisplay': ([C.c_void_p], C.c_int),
|
||||
'XkbGetState': ([C.c_void_p, C.c_uint, C.POINTER(XkbState)], C.c_int),
|
||||
'XkbLockGroup': ([C.c_void_p, C.c_uint, C.c_uint], C.c_int),
|
||||
'XkbLockModifiers': ([C.c_void_p, C.c_uint, C.c_uint, C.c_uint], C.c_int),
|
||||
'XkbLookupKeySym': ([C.c_void_p, C.c_ubyte, C.c_uint,
|
||||
C.POINTER(C.c_uint), C.POINTER(C.c_ulong)], C.c_int),
|
||||
'XKeysymToString': ([C.c_ulong], C.c_char_p),
|
||||
'XStringToKeysym': ([C.c_char_p], C.c_ulong),
|
||||
'XKeysymToKeycode': ([C.c_void_p, C.c_ulong], C.c_ubyte),
|
||||
'XSync': ([C.c_void_p, C.c_int], C.c_int),
|
||||
'portproton_keyboard_x11_layout_name': ([C.c_void_p, C.c_uint, C.c_void_p, C.c_size_t], C.c_int),
|
||||
}
|
||||
for name, (args, result) in functions.items():
|
||||
function = getattr(self.lib, name)
|
||||
function.argtypes, function.restype = args, result
|
||||
self.xkb = self.lib
|
||||
self.xkb.xkb_keysym_to_utf32.argtypes = [C.c_uint]
|
||||
self.xkb.xkb_keysym_to_utf32.restype = C.c_uint
|
||||
self.display = self.lib.portproton_keyboard_x11_open_display(None)
|
||||
if not self.display:
|
||||
raise RuntimeError('Cannot read the X11 keyboard layout')
|
||||
|
||||
def state(self) -> XkbState:
|
||||
state = XkbState()
|
||||
if self.lib.XkbGetState(self.display, XKB_CORE_KEYBOARD, C.byref(state)) != 0:
|
||||
raise RuntimeError('Cannot read XKB state')
|
||||
return state
|
||||
|
||||
def switch(self) -> None:
|
||||
group = (self.state().group + 1) % XKB_GROUP_COUNT
|
||||
if not self.lib.XkbLockGroup(self.display, XKB_CORE_KEYBOARD, group):
|
||||
raise RuntimeError('Cannot switch XKB layout')
|
||||
self.lib.XSync(self.display, False)
|
||||
|
||||
def caps_lock(self) -> bool:
|
||||
return bool(self.state().locked_mods & XKB_LOCK_MASK)
|
||||
|
||||
def layout_identifier(self) -> str:
|
||||
name = C.create_string_buffer(LAYOUT_NAME_BUFFER_BYTES)
|
||||
if self.lib.portproton_keyboard_x11_layout_name(self.display, self.state().group, name, len(name)):
|
||||
return name.value.decode()
|
||||
return 'System'
|
||||
|
||||
def toggle_caps_lock(self) -> None:
|
||||
value = 0 if self.caps_lock() else XKB_LOCK_MASK
|
||||
if not self.lib.XkbLockModifiers(self.display, XKB_CORE_KEYBOARD, XKB_LOCK_MASK, value):
|
||||
raise RuntimeError('Cannot switch XKB Caps Lock')
|
||||
self.lib.XSync(self.display, False)
|
||||
|
||||
def keycode(self, name: str) -> int:
|
||||
symbol = self.lib.XStringToKeysym(name.encode())
|
||||
code = self.lib.XKeysymToKeycode(self.display, symbol) if symbol else 0
|
||||
if code < XKB_KEYCODE_OFFSET:
|
||||
raise ValueError(f'Unknown shortcut key: {name}')
|
||||
return code - XKB_KEYCODE_OFFSET
|
||||
|
||||
def labels(self, modifiers: set[int] | tuple[int, ...] = ()) -> dict[str, str]:
|
||||
state = self.state()
|
||||
mask = state.mods & (XKB_SHIFT_MASK | XKB_LOCK_MASK | XKB_ALTGR_MASK)
|
||||
for code, bit in ((ecodes.KEY_LEFTSHIFT, XKB_SHIFT_MASK),
|
||||
(ecodes.KEY_CAPSLOCK, XKB_LOCK_MASK),
|
||||
(ecodes.KEY_RIGHTALT, XKB_ALTGR_MASK)):
|
||||
if code in modifiers:
|
||||
mask |= bit
|
||||
# Match XkbBuildCoreState from X11/extensions/XKB.h.
|
||||
mask |= state.group << XKB_GROUP_SHIFT
|
||||
result = {}
|
||||
for row in ROWS:
|
||||
for fallback, code in row:
|
||||
if code in MODIFIERS or code in {ecodes.KEY_TAB, ecodes.KEY_CAPSLOCK}:
|
||||
continue
|
||||
symbol, consumed = C.c_ulong(), C.c_uint()
|
||||
if self.lib.XkbLookupKeySym(self.display, code + XKB_KEYCODE_OFFSET,
|
||||
mask, C.byref(consumed), C.byref(symbol)):
|
||||
value = self.xkb.xkb_keysym_to_utf32(symbol.value)
|
||||
character = chr(value) if value else ''
|
||||
result[str(code)] = character if character.isprintable() else fallback
|
||||
return result
|
||||
|
||||
def close(self) -> None:
|
||||
if self.display:
|
||||
self.lib.XCloseDisplay(self.display)
|
||||
self.display = None
|
||||
|
||||
|
||||
def detect_layout() -> object:
|
||||
desktop = os.environ.get('XDG_CURRENT_DESKTOP', '').lower().split(':')
|
||||
if 'gnome' in desktop:
|
||||
from .gsettings_detection import GSettingsLayout
|
||||
return GSettingsLayout()
|
||||
from .wayland_detection import compositor, detect_layout as detect_wayland_layout
|
||||
if compositor(os.environ):
|
||||
return detect_wayland_layout(os.environ)
|
||||
return X11Layout()
|
||||
@@ -0,0 +1,98 @@
|
||||
"""GNOME source-history labels and the configured switching shortcut."""
|
||||
|
||||
import ast
|
||||
import re
|
||||
|
||||
from evdev import ecodes
|
||||
|
||||
from .detection import X11Layout
|
||||
from .layouts import Layout
|
||||
from .wayland_detection import command
|
||||
|
||||
SOURCE_SCHEMA = 'org.gnome.desktop.input-sources'
|
||||
BINDINGS_SCHEMA = 'org.gnome.desktop.wm.keybindings'
|
||||
SHORTCUT_MODIFIERS = {
|
||||
'Control': ecodes.KEY_LEFTCTRL, 'Ctrl': ecodes.KEY_LEFTCTRL,
|
||||
'Primary': ecodes.KEY_LEFTCTRL, 'Alt': ecodes.KEY_LEFTALT,
|
||||
'Shift': ecodes.KEY_LEFTSHIFT, 'Super': ecodes.KEY_LEFTMETA,
|
||||
}
|
||||
|
||||
|
||||
class GSettingsLayout:
|
||||
def __init__(self) -> None:
|
||||
self.layout: Layout | None = None
|
||||
self.current: tuple[str, str] | None = None
|
||||
description = command(['gsettings', 'describe', SOURCE_SCHEMA, 'current']).lower()
|
||||
self.legacy_current = 'zero-based index' in description and 'deprecated' not in description
|
||||
self._update()
|
||||
|
||||
def _read(self, key: str) -> object:
|
||||
text = command(['gsettings', 'get', SOURCE_SCHEMA, key]).strip()
|
||||
text = re.sub(r'^@[a-z()]+\s+|^uint32\s+', '', text)
|
||||
if text in ('true', 'false'):
|
||||
return text == 'true'
|
||||
return ast.literal_eval(text)
|
||||
|
||||
def _source(self) -> tuple[str, str]:
|
||||
sources = self._read('sources')
|
||||
if self._read('per-window'):
|
||||
raise ValueError('GSettings cannot track per-window input sources')
|
||||
if not isinstance(sources, list) or not sources:
|
||||
raise ValueError('GSettings has no input sources')
|
||||
if self.legacy_current:
|
||||
index = self._read('current')
|
||||
if type(index) is not int or not 0 <= index < len(sources):
|
||||
raise ValueError('Invalid GSettings current input-source index')
|
||||
selected = sources[index]
|
||||
elif len(sources) == 1:
|
||||
selected = sources[0]
|
||||
else:
|
||||
recent = self._read('mru-sources')
|
||||
if not isinstance(recent, list) or not recent or recent[0] not in sources:
|
||||
raise ValueError('GSettings input-source history is unavailable')
|
||||
selected = recent[0]
|
||||
kind, name = selected
|
||||
if kind != 'xkb' or not isinstance(name, str) or not name:
|
||||
raise ValueError('GSettings input source is not an XKB layout')
|
||||
layout, _, variant = name.partition('+')
|
||||
return layout, variant
|
||||
|
||||
def _update(self) -> None:
|
||||
choice = self._source()
|
||||
if choice == self.current:
|
||||
return
|
||||
replacement = Layout(*choice)
|
||||
if self.layout is not None:
|
||||
self.layout.close()
|
||||
self.layout, self.current = replacement, choice
|
||||
|
||||
def labels(self, modifiers: set[int] | tuple[int, ...] = ()) -> dict[str, str]:
|
||||
self._update()
|
||||
assert self.layout is not None
|
||||
return self.layout.labels(modifiers)
|
||||
|
||||
def switch_codes(self) -> tuple[int, ...]:
|
||||
text = command(['gsettings', 'get', BINDINGS_SCHEMA, 'switch-input-source']).strip()
|
||||
bindings = ast.literal_eval(re.sub(r'^@as\s+', '', text))
|
||||
if not isinstance(bindings, list):
|
||||
raise ValueError('Invalid GSettings input-source shortcuts')
|
||||
keymap = X11Layout()
|
||||
try:
|
||||
for accelerator in bindings:
|
||||
modifiers = re.findall(r'<([^>]+)>', accelerator)
|
||||
name = re.sub(r'<[^>]+>', '', accelerator)
|
||||
if not name or any(item not in SHORTCUT_MODIFIERS for item in modifiers):
|
||||
continue
|
||||
try:
|
||||
code = keymap.keycode(name)
|
||||
except ValueError:
|
||||
continue
|
||||
return tuple(SHORTCUT_MODIFIERS[item] for item in modifiers) + (code,)
|
||||
finally:
|
||||
keymap.close()
|
||||
raise RuntimeError('No supported GSettings switch-input-source shortcut')
|
||||
|
||||
def close(self) -> None:
|
||||
if self.layout is not None:
|
||||
self.layout.close()
|
||||
self.layout = None
|
||||
@@ -0,0 +1,197 @@
|
||||
"""System input for the themed on-screen keyboard.
|
||||
|
||||
Assisted-by: Codex:GPT-6
|
||||
"""
|
||||
|
||||
from queue import Empty, Queue
|
||||
from threading import Event
|
||||
import time
|
||||
from typing import Any
|
||||
|
||||
from evdev import UInput, ecodes
|
||||
from PySide6.QtCore import QThread, Signal
|
||||
|
||||
from portprotonqt.logger import get_logger
|
||||
|
||||
logger = get_logger(__name__)
|
||||
|
||||
INPUT_POLL_SECONDS = 0.15
|
||||
KEY_ROWS = (
|
||||
(ecodes.KEY_GRAVE, *range(ecodes.KEY_1, ecodes.KEY_EQUAL + 1)),
|
||||
(ecodes.KEY_TAB, *range(ecodes.KEY_Q, ecodes.KEY_RIGHTBRACE + 1), ecodes.KEY_BACKSLASH),
|
||||
(ecodes.KEY_CAPSLOCK, *range(ecodes.KEY_A, ecodes.KEY_APOSTROPHE + 1)),
|
||||
(ecodes.KEY_LEFTSHIFT, ecodes.KEY_102ND, *range(ecodes.KEY_Z, ecodes.KEY_SLASH + 1)),
|
||||
)
|
||||
SPECIAL_KEYS = (
|
||||
ecodes.KEY_BACKSPACE, ecodes.KEY_ENTER, ecodes.KEY_SPACE,
|
||||
ecodes.KEY_HOME, ecodes.KEY_END, ecodes.KEY_LEFT, ecodes.KEY_RIGHT,
|
||||
ecodes.KEY_UP, ecodes.KEY_DOWN,
|
||||
ecodes.KEY_LEFTCTRL, ecodes.KEY_KBD_LAYOUT_NEXT, ecodes.KEY_DELETE,
|
||||
ecodes.KEY_LEFTALT, ecodes.KEY_RIGHTALT, ecodes.KEY_LEFTMETA,
|
||||
)
|
||||
|
||||
|
||||
class SystemInputWorker(QThread):
|
||||
"""Own the uinput device and serialize all key events off the UI thread."""
|
||||
|
||||
ready = Signal()
|
||||
failed = Signal(str)
|
||||
state_changed = Signal(dict)
|
||||
warning = Signal(str)
|
||||
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
self.commands: Queue[tuple[str, tuple[int, ...]]] = Queue()
|
||||
self.stopping = Event()
|
||||
self.enabled = Event()
|
||||
self.modifiers: set[int] = set()
|
||||
self.caps_lock = False
|
||||
self.layout: Any = None
|
||||
self.manual_layout = False
|
||||
|
||||
def run(self) -> None:
|
||||
device = None
|
||||
try:
|
||||
keys = {code for row in KEY_ROWS for code in row} | set(SPECIAL_KEYS)
|
||||
device = UInput({ecodes.EV_KEY: sorted(keys), ecodes.EV_LED: [ecodes.LED_CAPSL]},
|
||||
name="PortProtonQt Keyboard", bustype=ecodes.BUS_USB)
|
||||
self._load_layout()
|
||||
self.ready.emit()
|
||||
self._run_commands(device)
|
||||
except OSError as error:
|
||||
logger.warning("System keyboard input unavailable: %s", error)
|
||||
self.failed.emit(str(error))
|
||||
except Exception as error:
|
||||
logger.exception("System keyboard input failed")
|
||||
self.failed.emit(str(error))
|
||||
finally:
|
||||
if self.layout is not None:
|
||||
self.layout.close()
|
||||
if device is not None:
|
||||
device.close()
|
||||
|
||||
def _run_commands(self, device: UInput) -> None:
|
||||
next_poll = 0.0
|
||||
while not self.stopping.is_set():
|
||||
try:
|
||||
action, codes = self.commands.get(timeout=INPUT_POLL_SECONDS)
|
||||
except Empty:
|
||||
action, codes = '', ()
|
||||
if self.stopping.is_set():
|
||||
break
|
||||
try:
|
||||
if action:
|
||||
self._execute(device, action, codes)
|
||||
except RuntimeError as error:
|
||||
logger.warning('System keyboard command failed: %s', error)
|
||||
self.warning.emit(str(error))
|
||||
except ValueError as error:
|
||||
logger.warning('Invalid system keyboard command: %s', error)
|
||||
self.warning.emit(str(error))
|
||||
if action or time.monotonic() >= next_poll:
|
||||
self._refresh_state(device)
|
||||
next_poll = time.monotonic() + INPUT_POLL_SECONDS
|
||||
|
||||
def _load_layout(self) -> None:
|
||||
import os
|
||||
from .detection import detect_layout
|
||||
from .manual_layout import ManualLayout
|
||||
from .wayland_detection import compositor
|
||||
try:
|
||||
self.layout = detect_layout()
|
||||
except Exception as error:
|
||||
if not compositor(os.environ):
|
||||
raise
|
||||
logger.warning("System layout detection unavailable: %s", error)
|
||||
self.layout = ManualLayout()
|
||||
self.manual_layout = True
|
||||
self.warning.emit(f'{error}. Manual US/RU labels; external layout changes are not tracked.')
|
||||
|
||||
def _execute(self, device: UInput, action: str, codes: tuple[int, ...]) -> None:
|
||||
from .detection import X11Layout, is_x11_session
|
||||
from .gsettings_detection import GSettingsLayout
|
||||
import os
|
||||
if action in {'tap', 'caps', 'language'} and not self.enabled.is_set():
|
||||
return
|
||||
if action == 'modifiers':
|
||||
self.modifiers = set(codes)
|
||||
elif action == 'release':
|
||||
self.modifiers.clear()
|
||||
elif action == 'caps':
|
||||
if isinstance(self.layout, X11Layout) and is_x11_session(os.environ):
|
||||
self.layout.toggle_caps_lock()
|
||||
else:
|
||||
self.send_keys(device, (ecodes.KEY_CAPSLOCK,))
|
||||
elif action == 'language':
|
||||
if isinstance(self.layout, X11Layout) and is_x11_session(os.environ):
|
||||
self.layout.switch()
|
||||
elif isinstance(self.layout, GSettingsLayout):
|
||||
self.send_keys(device, self.layout.switch_codes())
|
||||
elif self.manual_layout:
|
||||
self.send_keys(device, (ecodes.KEY_KBD_LAYOUT_NEXT,))
|
||||
self.layout.switch()
|
||||
elif hasattr(self.layout, 'switch') and not isinstance(self.layout, X11Layout):
|
||||
self.layout.switch()
|
||||
else:
|
||||
self.send_keys(device, (ecodes.KEY_KBD_LAYOUT_NEXT,))
|
||||
self.modifiers.clear()
|
||||
elif action == 'tap':
|
||||
self.send_keys(device, tuple(sorted(self.modifiers)) + codes)
|
||||
self.modifiers.clear()
|
||||
|
||||
def _refresh_state(self, device: UInput) -> None:
|
||||
from .detection import X11Layout, is_x11_session
|
||||
import os
|
||||
try:
|
||||
for event in device.read():
|
||||
if event.type == ecodes.EV_LED and event.code == ecodes.LED_CAPSL:
|
||||
self.caps_lock = bool(event.value)
|
||||
except BlockingIOError:
|
||||
pass
|
||||
try:
|
||||
caps = (self.layout.caps_lock() if isinstance(self.layout, X11Layout)
|
||||
and is_x11_session(os.environ) else self.caps_lock)
|
||||
modifiers = self.modifiers & {ecodes.KEY_LEFTSHIFT, ecodes.KEY_RIGHTALT}
|
||||
if caps:
|
||||
modifiers.add(ecodes.KEY_CAPSLOCK)
|
||||
labels = self.layout.labels(modifiers)
|
||||
current = getattr(self.layout, 'current', None)
|
||||
name = current[0] if isinstance(current, tuple) else getattr(self.layout, 'language', 'System')
|
||||
if hasattr(self.layout, 'layout_identifier'):
|
||||
name = self.layout.layout_identifier()
|
||||
self.state_changed.emit({'labels': labels, 'caps': caps,
|
||||
'shift': ecodes.KEY_LEFTSHIFT in self.modifiers,
|
||||
'modifiers': tuple(sorted(self.modifiers)), 'layout': name})
|
||||
except Exception as error:
|
||||
logger.warning("Cannot update system keyboard labels: %s", error)
|
||||
self.warning.emit(str(error))
|
||||
|
||||
def send_keys(self, device: UInput, codes: tuple[int, ...]) -> None:
|
||||
pressed = []
|
||||
try:
|
||||
for code in codes:
|
||||
pressed.append(code)
|
||||
device.write(ecodes.EV_KEY, code, 1)
|
||||
device.syn()
|
||||
finally:
|
||||
for code in reversed(pressed):
|
||||
try:
|
||||
device.write(ecodes.EV_KEY, code, 0)
|
||||
device.syn()
|
||||
except OSError:
|
||||
logger.exception("Failed to release system keyboard key %s", code)
|
||||
|
||||
def stop(self) -> None:
|
||||
self.enabled.clear()
|
||||
self.stopping.set()
|
||||
self.commands.put(('', ()))
|
||||
self.wait()
|
||||
|
||||
def cancel_pending(self) -> None:
|
||||
self.enabled.clear()
|
||||
while True:
|
||||
try:
|
||||
self.commands.get_nowait()
|
||||
except Empty:
|
||||
break
|
||||
self.commands.put(('release', ()))
|
||||
@@ -0,0 +1,17 @@
|
||||
"""Physical keys shared by uinput and XKB label readers."""
|
||||
|
||||
from evdev import ecodes
|
||||
|
||||
from .input import KEY_ROWS
|
||||
|
||||
ROWS = [[("", code) for code in row] for row in KEY_ROWS]
|
||||
MODIFIERS = {ecodes.KEY_LEFTSHIFT, ecodes.KEY_LEFTCTRL, ecodes.KEY_LEFTMETA,
|
||||
ecodes.KEY_LEFTALT, ecodes.KEY_RIGHTALT}
|
||||
KEY_KBD_LAYOUT_NEXT = ecodes.KEY_KBD_LAYOUT_NEXT
|
||||
XKB_KEYCODE_OFFSET = 8
|
||||
XKB_CORE_KEYBOARD = 0x0100
|
||||
XKB_SHIFT_MASK = 1
|
||||
XKB_LOCK_MASK = 2
|
||||
XKB_ALTGR_MASK = 128
|
||||
XKB_GROUP_COUNT = 4
|
||||
XKB_GROUP_SHIFT = 13
|
||||
@@ -0,0 +1,108 @@
|
||||
"""Generate labels from the installed XKB database, not a hand-written language list."""
|
||||
from typing import Any
|
||||
|
||||
import ctypes as C
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
from .keys import ROWS, MODIFIERS
|
||||
from .native import load_library
|
||||
|
||||
|
||||
class Names(C.Structure):
|
||||
_fields_ = [(name, C.c_char_p) for name in ('rules', 'model', 'layout', 'variant', 'options')]
|
||||
|
||||
|
||||
def available_layouts(registry: Any='/usr/share/X11/xkb/rules/evdev.xml') -> Any:
|
||||
result = []
|
||||
for layout in ET.parse(registry).findall('./layoutList/layout'):
|
||||
name = layout.findtext('./configItem/name')
|
||||
result.append((name, ''))
|
||||
for variant in layout.findall('./variantList/variant'):
|
||||
result.append((name, variant.findtext('./configItem/name')))
|
||||
return result
|
||||
|
||||
|
||||
class Layout:
|
||||
def __init__(self, layout: Any='us', variant: Any='', *, keymap_text: Any=None) -> None:
|
||||
self.context = self.keymap = None
|
||||
self.lib = load_library()
|
||||
self._configure_library()
|
||||
self.context = self.lib.portproton_keyboard_xkb_context_new(0)
|
||||
if not self.context:
|
||||
raise RuntimeError('Failed to create XKB context')
|
||||
names = Names(None, b'pc105', layout.encode(), variant.encode(), b'')
|
||||
if keymap_text is None:
|
||||
self.keymap = self.lib.xkb_keymap_new_from_names(self.context, C.byref(names), 0)
|
||||
else:
|
||||
self.keymap = self.lib.xkb_keymap_new_from_string(self.context, keymap_text, 1, 0)
|
||||
if not self.keymap:
|
||||
self.close()
|
||||
raise ValueError(f'Unknown XKB layout: {layout}+{variant}')
|
||||
|
||||
def _configure_library(self) -> None:
|
||||
functions = {
|
||||
'portproton_keyboard_xkb_context_new': ([C.c_int], C.c_void_p),
|
||||
'xkb_keymap_num_layouts': ([C.c_void_p], C.c_uint),
|
||||
'xkb_keymap_layout_get_name': ([C.c_void_p, C.c_uint], C.c_char_p),
|
||||
'xkb_context_unref': ([C.c_void_p], None),
|
||||
'xkb_keymap_new_from_names': ([C.c_void_p, C.POINTER(Names), C.c_int], C.c_void_p),
|
||||
'xkb_keymap_new_from_string': ([C.c_void_p, C.c_char_p, C.c_int, C.c_int], C.c_void_p),
|
||||
'xkb_state_update_mask': ([C.c_void_p] + [C.c_uint] * 6, C.c_uint),
|
||||
'xkb_keymap_unref': ([C.c_void_p], None),
|
||||
'xkb_state_new': ([C.c_void_p], C.c_void_p),
|
||||
'xkb_state_unref': ([C.c_void_p], None),
|
||||
'xkb_state_update_key': ([C.c_void_p, C.c_uint, C.c_int], C.c_uint),
|
||||
'xkb_state_key_get_utf8': ([C.c_void_p, C.c_uint, C.c_void_p, C.c_size_t], C.c_int),
|
||||
'xkb_state_key_get_one_sym': ([C.c_void_p, C.c_uint], C.c_uint),
|
||||
'xkb_keysym_get_name': ([C.c_uint, C.c_void_p, C.c_size_t], C.c_int),
|
||||
}
|
||||
for name, (args, result) in functions.items():
|
||||
function = getattr(self.lib, name)
|
||||
function.argtypes, function.restype = args, result
|
||||
|
||||
def labels(self, modifiers: Any=(), *, mask: Any=None) -> Any:
|
||||
state = self.lib.xkb_state_new(self.keymap)
|
||||
if not state:
|
||||
raise RuntimeError('Не удалось создать состояние XKB')
|
||||
try:
|
||||
if mask is not None:
|
||||
depressed, latched, locked, group = mask
|
||||
self.lib.xkb_state_update_mask(state, depressed, latched, locked, 0, 0, group)
|
||||
for code in modifiers:
|
||||
self.lib.xkb_state_update_key(state, code + 8, 1)
|
||||
labels = {}
|
||||
for row in ROWS:
|
||||
for fallback, code in row:
|
||||
if code in MODIFIERS or code in {1, 14, 15, 28, 58, 57, 103, 105, 106, 108, 111}:
|
||||
labels[str(code)] = fallback
|
||||
continue
|
||||
buffer = C.create_string_buffer(128)
|
||||
length = self.lib.xkb_state_key_get_utf8(state, code + 8, buffer, len(buffer))
|
||||
label = buffer.value.decode() if 0 < length < len(buffer) else ''
|
||||
if not label or not label.isprintable():
|
||||
sym = self.lib.xkb_state_key_get_one_sym(state, code + 8)
|
||||
self.lib.xkb_keysym_get_name(sym, buffer, len(buffer))
|
||||
label = buffer.value.decode() or fallback
|
||||
labels[str(code)] = label
|
||||
return labels
|
||||
finally:
|
||||
self.lib.xkb_state_unref(state)
|
||||
|
||||
def export(self) -> Any:
|
||||
return {name: self.labels(mods) for name, mods in
|
||||
[('normal', ()), ('shift', (42,)), ('altgr', (100,)), ('shift-altgr', (42, 100))]}
|
||||
|
||||
def layout_count(self) -> int:
|
||||
return self.lib.xkb_keymap_num_layouts(self.keymap)
|
||||
|
||||
def layout_identifier(self, group: int) -> str:
|
||||
name = self.lib.xkb_keymap_layout_get_name(self.keymap, group)
|
||||
return name.decode() if name else 'System'
|
||||
|
||||
def close(self) -> None:
|
||||
if self.keymap:
|
||||
self.lib.xkb_keymap_unref(self.keymap)
|
||||
self.keymap = None
|
||||
if self.context:
|
||||
self.lib.xkb_context_unref(self.context)
|
||||
self.context = None
|
||||
@@ -0,0 +1,23 @@
|
||||
"""Manual label fallback for compositors without layout detection."""
|
||||
from typing import Any
|
||||
|
||||
from .layouts import Layout
|
||||
|
||||
|
||||
class ManualLayout:
|
||||
def __init__(self) -> None:
|
||||
self.layout = Layout('us')
|
||||
self.language = 'us'
|
||||
|
||||
def switch(self) -> Any:
|
||||
language = 'ru' if self.language == 'us' else 'us'
|
||||
replacement = Layout(language)
|
||||
self.layout.close()
|
||||
self.layout = replacement
|
||||
self.language = language
|
||||
|
||||
def labels(self, modifiers: Any=()) -> Any:
|
||||
return self.layout.labels(modifiers)
|
||||
|
||||
def close(self) -> None:
|
||||
self.layout.close()
|
||||
@@ -0,0 +1,14 @@
|
||||
"""Load the linked keyboard backend using the same paths as the SDL backend."""
|
||||
|
||||
import ctypes
|
||||
from pathlib import Path
|
||||
|
||||
KEYBOARD_LIBRARY_NAME = 'libportprotonqt_keyboard.so'
|
||||
SYSTEM_KEYBOARD_LIBRARY = Path(__file__).parent.parent / KEYBOARD_LIBRARY_NAME
|
||||
DEV_KEYBOARD_LIBRARY = Path(__file__).parent.parent.parent / 'build-aux' / 'lib' / KEYBOARD_LIBRARY_NAME
|
||||
KEYBOARD_LIBRARY_PATH = (SYSTEM_KEYBOARD_LIBRARY if SYSTEM_KEYBOARD_LIBRARY.is_file()
|
||||
else DEV_KEYBOARD_LIBRARY)
|
||||
|
||||
|
||||
def load_library() -> ctypes.CDLL:
|
||||
return ctypes.CDLL(str(KEYBOARD_LIBRARY_PATH))
|
||||
@@ -0,0 +1,123 @@
|
||||
"""Compositor IPC adapters for layer-shell layout labels."""
|
||||
from typing import Any
|
||||
|
||||
import orjson
|
||||
import subprocess
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
from .layouts import Layout
|
||||
|
||||
|
||||
def compositor(environment: Any) -> Any:
|
||||
desktop = environment.get('XDG_CURRENT_DESKTOP', '').lower().split(':')
|
||||
for name, variable in [('hyprland', 'HYPRLAND_INSTANCE_SIGNATURE'),
|
||||
('sway', 'SWAYSOCK'), ('niri', 'NIRI_SOCKET')]:
|
||||
if environment.get(variable):
|
||||
return name
|
||||
return next((name for name in ('hyprland', 'sway', 'niri', 'cosmic') if name in desktop), None)
|
||||
|
||||
|
||||
def command(args: Any) -> Any:
|
||||
try:
|
||||
return subprocess.run(args, capture_output=True, text=True,
|
||||
timeout=1, check=True).stdout
|
||||
except (OSError, subprocess.SubprocessError) as exc:
|
||||
raise RuntimeError(f'Ошибка IPC ({args[0]}): {exc}') from exc
|
||||
|
||||
|
||||
class NiriLayout:
|
||||
def __init__(self, registry: Any='/usr/share/X11/xkb/rules/evdev.xml') -> None:
|
||||
self.names = {}
|
||||
for entry in ET.parse(registry).findall('./layoutList/layout'):
|
||||
code = entry.findtext('./configItem/name')
|
||||
self.names[entry.findtext('./configItem/description')] = (code, '')
|
||||
for variant in entry.findall('./variantList/variant'):
|
||||
self.names[variant.findtext('./configItem/description')] = (
|
||||
code, variant.findtext('./configItem/name'))
|
||||
self.layout = None
|
||||
self.current = None
|
||||
self._update()
|
||||
|
||||
def _query_name(self) -> Any:
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['niri', 'msg', '--json', 'keyboard-layouts'],
|
||||
capture_output=True, text=True, timeout=1, check=True)
|
||||
except (OSError, subprocess.SubprocessError) as exc:
|
||||
raise RuntimeError(f'Не удалось запросить раскладку через niri IPC: {exc}') from exc
|
||||
data = orjson.loads(result.stdout)
|
||||
index = data['current_idx']
|
||||
if type(index) is not int or not 0 <= index < len(data['names']):
|
||||
raise ValueError('Некорректный индекс раскладки niri')
|
||||
return data['names'][index]
|
||||
|
||||
def _update(self) -> None:
|
||||
name = self._query_name()
|
||||
if name not in self.names:
|
||||
raise ValueError(f'Раскладка отсутствует в реестре XKB: {name}')
|
||||
choice = self.names[name]
|
||||
if choice != self.current:
|
||||
replacement = Layout(*choice)
|
||||
if self.layout is not None:
|
||||
self.layout.close()
|
||||
self.layout = replacement
|
||||
self.current = choice
|
||||
|
||||
def labels(self, modifiers: Any=()) -> Any:
|
||||
self._update()
|
||||
assert self.layout is not None
|
||||
return self.layout.labels(modifiers)
|
||||
|
||||
def switch(self) -> None:
|
||||
command(['niri', 'msg', 'action', 'switch-layout', 'next'])
|
||||
|
||||
def close(self) -> None:
|
||||
if self.layout is not None:
|
||||
self.layout.close()
|
||||
self.layout = None
|
||||
|
||||
|
||||
class SwayLayout(NiriLayout):
|
||||
def _query_name(self) -> Any:
|
||||
inputs = orjson.loads(command(['swaymsg', '-t', 'get_inputs', '-r']))
|
||||
keyboards = [item for item in inputs if item.get('type') == 'keyboard'
|
||||
and item.get('xkb_active_layout_name')]
|
||||
if not keyboards:
|
||||
raise RuntimeError('Sway не сообщил раскладку клавиатуры')
|
||||
# Never silently display one of several conflicting device layouts.
|
||||
names = {item['xkb_active_layout_name'] for item in keyboards}
|
||||
if len(names) != 1:
|
||||
raise RuntimeError('У клавиатур Sway разные раскладки; задайте --layout')
|
||||
return keyboards[0]['xkb_active_layout_name']
|
||||
|
||||
def switch(self) -> Any:
|
||||
result = orjson.loads(command(['swaymsg', '-r', 'input type:keyboard xkb_switch_layout next']))
|
||||
if not result or not all(item.get('success') for item in result):
|
||||
raise RuntimeError(f'Sway не переключил раскладку: {result}')
|
||||
|
||||
|
||||
class HyprlandLayout(NiriLayout):
|
||||
def _query_name(self) -> Any:
|
||||
data = orjson.loads(command(['hyprctl', '-j', 'devices']))
|
||||
keyboard = next((item for item in data['keyboards'] if item.get('main')), None)
|
||||
if keyboard is None or not keyboard.get('active_keymap'):
|
||||
raise RuntimeError('Hyprland не сообщил раскладку основной клавиатуры')
|
||||
self.keyboard = keyboard['name']
|
||||
return keyboard['active_keymap']
|
||||
|
||||
def switch(self) -> Any:
|
||||
self._query_name()
|
||||
result = command(['hyprctl', 'switchxkblayout', self.keyboard, 'next'])
|
||||
if result.strip() != 'ok':
|
||||
raise RuntimeError(f'Hyprland не переключил раскладку: {result.strip()}')
|
||||
|
||||
|
||||
def detect_layout(environment: Any) -> Any:
|
||||
if compositor(environment) == 'cosmic':
|
||||
from .cosmic_detection import CosmicLayout
|
||||
return CosmicLayout()
|
||||
adapter = {'niri': NiriLayout, 'sway': SwayLayout,
|
||||
'hyprland': HyprlandLayout}.get(compositor(environment))
|
||||
if adapter is None:
|
||||
raise RuntimeError('Нет адаптера определения раскладки для этого композитора')
|
||||
return adapter()
|
||||
@@ -0,0 +1,378 @@
|
||||
"""Present the Qt keyboard through native layer-shell and shared memory."""
|
||||
|
||||
import ctypes as C
|
||||
from functools import partial
|
||||
import mmap
|
||||
import os
|
||||
import select
|
||||
from typing import Any
|
||||
|
||||
from PySide6.QtCore import QEvent, QObject, QPoint, QPointF, QSocketNotifier, Qt, QTimer
|
||||
from PySide6.QtGui import QImage, QMouseEvent, QRegion
|
||||
from PySide6.QtWidgets import QApplication
|
||||
|
||||
from portprotonqt.logger import get_logger
|
||||
from .cosmic_detection import Interface, Message
|
||||
from .native import load_library
|
||||
|
||||
logger = get_logger(__name__)
|
||||
WL_VERSION = 1
|
||||
WL_DESTROY = 1
|
||||
WL_FIXED_SCALE = 256
|
||||
LAYER_OVERLAY = 3
|
||||
ANCHOR_ALL_EDGES = 15
|
||||
KEYBOARD_INTERACTIVITY_NONE = 0
|
||||
SHM_ARGB8888 = 0
|
||||
PIXEL_BYTES = 4
|
||||
FRAME_INTERVAL_MS = 33
|
||||
MAX_SURFACE_PIXELS = 33_177_600
|
||||
POINTER_BUTTON_LEFT = 272
|
||||
|
||||
|
||||
class WaylandWindow(QObject):
|
||||
"""Keep native surfaces separate from Qt's offscreen platform plugin."""
|
||||
|
||||
def __init__(self, window: Any) -> None:
|
||||
super().__init__(window)
|
||||
self.window = window
|
||||
self.callbacks: list[Any] = []
|
||||
self.proxies: list[int] = []
|
||||
self.buffers: dict[int, dict[str, Any]] = {}
|
||||
self.compositor = self.shm = self.shell = None
|
||||
self.seat: int | None = None
|
||||
self.surface = self.layer = self.pointer = self.touch = None
|
||||
self.display = None
|
||||
self.wanted_visible = self.configured = False
|
||||
self.dirty = True
|
||||
self.position = QPointF()
|
||||
self.pressed_widget: Any = None
|
||||
self.lib = load_library()
|
||||
self._configure_library()
|
||||
self._configure_protocol()
|
||||
self.display = self.lib.portproton_keyboard_wayland_connect(None)
|
||||
if not self.display:
|
||||
raise RuntimeError('Cannot connect to the Wayland compositor')
|
||||
self.registry = self._request(self.display, (1, self._interface('wl_registry')), (C.c_void_p(),))
|
||||
self._listen(self.registry, [(self._global, [C.c_uint32, C.c_char_p, C.c_uint32]),
|
||||
(self._global_removed, [C.c_uint32])])
|
||||
self.sync = self._request(self.display, (0, self._interface('wl_callback')), (C.c_void_p(),))
|
||||
self._listen(self.sync, [(self._registry_ready, [C.c_uint32])])
|
||||
self.notifier = QSocketNotifier(self.lib.wl_display_get_fd(self.display), QSocketNotifier.Type.Read, self)
|
||||
self.notifier.activated.connect(self._dispatch)
|
||||
self.timer = QTimer(self)
|
||||
self.timer.setInterval(FRAME_INTERVAL_MS)
|
||||
self.timer.timeout.connect(self._render)
|
||||
self.timer.start()
|
||||
app = QApplication.instance()
|
||||
if app is not None:
|
||||
app.installEventFilter(self)
|
||||
self.lib.wl_display_flush(self.display)
|
||||
|
||||
def _configure_library(self) -> None:
|
||||
p = C.c_void_p
|
||||
functions = {
|
||||
'portproton_keyboard_wayland_connect': ([C.c_char_p], p),
|
||||
'wl_display_disconnect': ([p], None),
|
||||
'wl_display_dispatch_pending': ([p], C.c_int),
|
||||
'wl_display_prepare_read': ([p], C.c_int),
|
||||
'wl_display_read_events': ([p], C.c_int),
|
||||
'wl_display_cancel_read': ([p], None),
|
||||
'wl_display_get_fd': ([p], C.c_int),
|
||||
'wl_display_flush': ([p], C.c_int),
|
||||
'wl_proxy_destroy': ([p], None),
|
||||
'wl_proxy_add_listener': ([p, p, p], C.c_int),
|
||||
'wl_proxy_marshal_flags': ([p, C.c_uint32, C.POINTER(Interface), C.c_uint32, C.c_uint32], p),
|
||||
}
|
||||
for name, (args, result) in functions.items():
|
||||
function = getattr(self.lib, name)
|
||||
function.argtypes, function.restype = args, result
|
||||
|
||||
def _configure_protocol(self) -> None:
|
||||
self.layer_methods = (Message * 8)(
|
||||
Message(b'set_size', b'uu', None), Message(b'set_anchor', b'u', None),
|
||||
Message(b'set_exclusive_zone', b'i', None), Message(b'set_margin', b'iiii', None),
|
||||
Message(b'set_keyboard_interactivity', b'u', None), Message(b'get_popup', b'o', None),
|
||||
Message(b'ack_configure', b'u', None), Message(b'destroy', b'', None))
|
||||
self.layer_events = (Message * 2)(Message(b'configure', b'uuu', None), Message(b'closed', b'', None))
|
||||
self.layer_interface = Interface(b'zwlr_layer_surface_v1', WL_VERSION, 8,
|
||||
self.layer_methods, 2, self.layer_events)
|
||||
self.shell_types = (C.c_void_p * 5)(C.addressof(self.layer_interface),
|
||||
C.addressof(self._interface('wl_surface')), C.addressof(self._interface('wl_output')), None, None)
|
||||
self.shell_methods = (Message * 1)(Message(b'get_layer_surface', b'no?ous',
|
||||
C.cast(self.shell_types, C.c_void_p)))
|
||||
self.shell_interface = Interface(b'zwlr_layer_shell_v1', WL_VERSION, 1, self.shell_methods, 0, None)
|
||||
|
||||
def _interface(self, name: str) -> Interface:
|
||||
return Interface.in_dll(self.lib, name + '_interface')
|
||||
|
||||
def _request(self, proxy: int | None, request: tuple[int, Any], arguments: tuple[Any, ...] = ()) -> Any:
|
||||
opcode, interface = request
|
||||
pointer = C.byref(interface) if interface is not None else None
|
||||
result = self.lib.wl_proxy_marshal_flags(proxy, opcode, pointer, WL_VERSION, 0, *arguments)
|
||||
if interface is not None:
|
||||
if not result:
|
||||
raise RuntimeError('Cannot create Wayland protocol object')
|
||||
self.proxies.append(result)
|
||||
return result
|
||||
|
||||
def _listen(self, proxy: int, handlers: list[tuple[Any, list[Any]]]) -> None:
|
||||
callbacks = []
|
||||
for handler, types in handlers:
|
||||
def guarded(data: Any, obj: Any, *args: Any, handler: Any = handler) -> None:
|
||||
try:
|
||||
handler(*args)
|
||||
except Exception:
|
||||
logger.exception('System keyboard Wayland event failed')
|
||||
QApplication.exit(1)
|
||||
callbacks.append(C.CFUNCTYPE(None, C.c_void_p, C.c_void_p, *types)(guarded))
|
||||
table = (C.c_void_p * len(callbacks))(*[C.cast(callback, C.c_void_p) for callback in callbacks])
|
||||
self.callbacks.append((callbacks, table))
|
||||
if self.lib.wl_proxy_add_listener(proxy, table, None) != 0:
|
||||
raise RuntimeError('Cannot subscribe to Wayland events')
|
||||
|
||||
def _global(self, name: int, interface: bytes, version: int) -> None:
|
||||
interfaces = {b'wl_compositor': ('compositor', self._interface('wl_compositor')),
|
||||
b'wl_shm': ('shm', self._interface('wl_shm')),
|
||||
b'zwlr_layer_shell_v1': ('shell', self.shell_interface),
|
||||
b'wl_seat': ('seat', self._interface('wl_seat'))}
|
||||
if interface not in interfaces:
|
||||
return
|
||||
attribute, metadata = interfaces[interface]
|
||||
if getattr(self, attribute, None) is not None:
|
||||
return
|
||||
proxy = self._request(self.registry, (0, metadata),
|
||||
(C.c_uint32(name), interface, C.c_uint32(WL_VERSION), C.c_void_p()))
|
||||
setattr(self, attribute, proxy)
|
||||
if interface == b'wl_seat':
|
||||
self._listen(proxy, [(self._seat_capabilities, [C.c_uint32])])
|
||||
self._create_surface()
|
||||
|
||||
def _global_removed(self, name: int) -> None:
|
||||
logger.debug('Wayland global removed: %s', name)
|
||||
|
||||
def _registry_ready(self, serial: int) -> None:
|
||||
self.lib.wl_proxy_destroy(self.sync)
|
||||
self.proxies.remove(self.sync)
|
||||
if not all((self.compositor, self.shm, self.shell)):
|
||||
logger.error('The compositor does not provide layer-shell or shared-memory surfaces')
|
||||
QApplication.exit(1)
|
||||
|
||||
def show_layer(self) -> None:
|
||||
self.wanted_visible = True
|
||||
self._create_surface()
|
||||
|
||||
def _create_surface(self) -> None:
|
||||
if self.surface or not self.wanted_visible or not all((self.compositor, self.shm, self.shell)):
|
||||
return
|
||||
self.surface = self._request(self.compositor, (0, self._interface('wl_surface')), (C.c_void_p(),))
|
||||
self._listen(self.surface, [(self._surface_output, [C.c_void_p]),
|
||||
(self._surface_output, [C.c_void_p])])
|
||||
self.layer = self._request(self.shell, (0, self.layer_interface),
|
||||
(C.c_void_p(), C.c_void_p(self.surface), C.c_void_p(),
|
||||
C.c_uint32(LAYER_OVERLAY), b'portprotonqt-system-keyboard'))
|
||||
self._listen(self.layer, [(self._configured, [C.c_uint32, C.c_uint32, C.c_uint32]),
|
||||
(self.window.hide_keyboard, [])])
|
||||
self._request(self.layer, (0, None), (C.c_uint32(0), C.c_uint32(0)))
|
||||
self._request(self.layer, (1, None), (C.c_uint32(ANCHOR_ALL_EDGES),))
|
||||
self._request(self.layer, (2, None), (C.c_int32(-1),))
|
||||
self._request(self.layer, (4, None), (C.c_uint32(KEYBOARD_INTERACTIVITY_NONE),))
|
||||
self._input_region(False)
|
||||
self._request(self.surface, (6, None))
|
||||
self.lib.wl_display_flush(self.display)
|
||||
|
||||
def _configured(self, serial: int, width: int, height: int) -> None:
|
||||
if not width or not height or width * height > MAX_SURFACE_PIXELS:
|
||||
raise ValueError('Invalid Wayland layer-surface dimensions')
|
||||
self._request(self.layer, (6, None), (C.c_uint32(serial),))
|
||||
self.window.resize(width, height)
|
||||
self.window._position_keyboard()
|
||||
self.configured = self.dirty = True
|
||||
|
||||
def _surface_output(self, output: int) -> None:
|
||||
self.dirty = True
|
||||
|
||||
def _input_region(self, include_panel: bool = True) -> None:
|
||||
region = self._request(self.compositor, (1, self._interface('wl_region')), (C.c_void_p(),))
|
||||
if include_panel:
|
||||
rect = self.window.keyboard.geometry()
|
||||
args = tuple(C.c_int32(value) for value in (rect.x(), rect.y(), rect.width(), rect.height()))
|
||||
self._request(region, (1, None), args)
|
||||
self._request(self.surface, (5, None), (C.c_void_p(region),))
|
||||
self._destroy(region, 0)
|
||||
|
||||
def _destroy(self, proxy: int | None, opcode: int) -> None:
|
||||
if proxy is not None:
|
||||
self.lib.wl_proxy_marshal_flags(proxy, opcode, None, WL_VERSION, WL_DESTROY)
|
||||
self.proxies.remove(proxy)
|
||||
|
||||
def _buffer(self, width: int, height: int) -> int | None:
|
||||
size = width * height * PIXEL_BYTES
|
||||
for proxy, buffer in self.buffers.items():
|
||||
if buffer['size'] == (width, height) and not buffer['busy']:
|
||||
return proxy
|
||||
if sum(buffer['size'] == (width, height) for buffer in self.buffers.values()) >= 2:
|
||||
return None
|
||||
fd = os.memfd_create('portprotonqt-keyboard', os.MFD_CLOEXEC)
|
||||
try:
|
||||
os.ftruncate(fd, size)
|
||||
memory = mmap.mmap(fd, size)
|
||||
pool = self._request(self.shm, (0, self._interface('wl_shm_pool')),
|
||||
(C.c_void_p(), C.c_int(fd), C.c_int32(size)))
|
||||
proxy = self._request(pool, (0, self._interface('wl_buffer')),
|
||||
(C.c_void_p(), C.c_int32(0), C.c_int32(width), C.c_int32(height),
|
||||
C.c_int32(width * PIXEL_BYTES), C.c_uint32(SHM_ARGB8888)))
|
||||
self._destroy(pool, 1)
|
||||
finally:
|
||||
os.close(fd)
|
||||
self.buffers[proxy] = {'memory': memory, 'size': (width, height), 'busy': False}
|
||||
self._listen(proxy, [(partial(self._released, proxy), [])])
|
||||
return proxy
|
||||
|
||||
def _released(self, proxy: int) -> None:
|
||||
buffer = self.buffers.get(proxy)
|
||||
if buffer is not None:
|
||||
buffer['busy'] = False
|
||||
if buffer['size'] != (self.window.width(), self.window.height()):
|
||||
self._destroy(proxy, 0)
|
||||
buffer['memory'].close()
|
||||
del self.buffers[proxy]
|
||||
|
||||
def _render(self) -> None:
|
||||
if not self.surface or not self.configured or not self.dirty:
|
||||
return
|
||||
width, height = self.window.width(), self.window.height()
|
||||
proxy = self._buffer(width, height)
|
||||
if proxy is None:
|
||||
return
|
||||
image = QImage(width, height, QImage.Format.Format_ARGB32_Premultiplied)
|
||||
image.fill(Qt.GlobalColor.transparent)
|
||||
self.dirty = False
|
||||
self.window.render(image, QPoint(), QRegion(), self.window.RenderFlag.DrawChildren)
|
||||
buffer = self.buffers[proxy]
|
||||
buffer['memory'].seek(0)
|
||||
buffer['memory'].write(image.constBits())
|
||||
buffer['busy'] = True
|
||||
self._request(self.surface, (1, None), (C.c_void_p(proxy), C.c_int32(0), C.c_int32(0)))
|
||||
self._request(self.surface, (2, None), tuple(C.c_int32(v) for v in (0, 0, width, height)))
|
||||
self._input_region()
|
||||
self._request(self.surface, (6, None))
|
||||
self.lib.wl_display_flush(self.display)
|
||||
|
||||
def eventFilter(self, obj: QObject, event: QEvent) -> bool:
|
||||
if event.type() == QEvent.Type.UpdateRequest:
|
||||
self.dirty = True
|
||||
return False
|
||||
|
||||
def _dispatch(self) -> None:
|
||||
while self.lib.wl_display_prepare_read(self.display) != 0:
|
||||
if self.lib.wl_display_dispatch_pending(self.display) < 0:
|
||||
QApplication.exit(1)
|
||||
return
|
||||
fd = self.lib.wl_display_get_fd(self.display)
|
||||
if select.select([fd], [], [], 0)[0]:
|
||||
result = self.lib.wl_display_read_events(self.display)
|
||||
else:
|
||||
self.lib.wl_display_cancel_read(self.display)
|
||||
result = 0
|
||||
if result < 0 or self.lib.wl_display_dispatch_pending(self.display) < 0:
|
||||
logger.error('System keyboard Wayland connection closed')
|
||||
QApplication.exit(1)
|
||||
return
|
||||
self.lib.wl_display_flush(self.display)
|
||||
|
||||
def _seat_capabilities(self, capabilities: int) -> None:
|
||||
if capabilities & 1 and self.pointer is None:
|
||||
self.pointer = self._request(self.seat, (0, self._interface('wl_pointer')), (C.c_void_p(),))
|
||||
u, i, p = C.c_uint32, C.c_int32, C.c_void_p
|
||||
self._listen(self.pointer, [(self._pointer_enter, [u, p, i, i]),
|
||||
(self._pointer_leave, [u, p]),
|
||||
(self._pointer_motion, [u, i, i]),
|
||||
(self._pointer_button, [u, u, u, u]),
|
||||
(self._pointer_axis, [u, u, i])])
|
||||
if capabilities & 4 and self.touch is None:
|
||||
self.touch = self._request(self.seat, (2, self._interface('wl_touch')), (C.c_void_p(),))
|
||||
u, i, p = C.c_uint32, C.c_int32, C.c_void_p
|
||||
self._listen(self.touch, [(self._touch_down, [u, u, p, i, i, i]),
|
||||
(self._touch_up, [u, u, i]), (self._touch_motion, [u, i, i, i]),
|
||||
(self._touch_frame, []), (self._touch_cancel, [])])
|
||||
|
||||
def _pointer_enter(self, *event: int) -> None:
|
||||
serial, surface, x, y = event
|
||||
self.position = QPointF(x / WL_FIXED_SCALE, y / WL_FIXED_SCALE)
|
||||
|
||||
def _pointer_leave(self, serial: int, surface: int) -> None:
|
||||
self.dirty = True
|
||||
|
||||
def _pointer_motion(self, timestamp: int, x: int, y: int) -> None:
|
||||
self.position = QPointF(x / WL_FIXED_SCALE, y / WL_FIXED_SCALE)
|
||||
self._mouse_event(QEvent.Type.MouseMove)
|
||||
|
||||
def _pointer_button(self, *event: int) -> None:
|
||||
serial, timestamp, button, state = event
|
||||
if button == POINTER_BUTTON_LEFT:
|
||||
kind = QEvent.Type.MouseButtonPress if state else QEvent.Type.MouseButtonRelease
|
||||
self._mouse_event(kind)
|
||||
|
||||
def _pointer_axis(self, timestamp: int, axis: int, value: int) -> None:
|
||||
logger.debug('System keyboard pointer axis: %s', axis)
|
||||
|
||||
def _touch_down(self, *event: int) -> None:
|
||||
serial, timestamp, surface, touch_id, x, y = event
|
||||
if self.pressed_widget is None:
|
||||
self.touch_id = touch_id
|
||||
self.position = QPointF(x / WL_FIXED_SCALE, y / WL_FIXED_SCALE)
|
||||
self._mouse_event(QEvent.Type.MouseButtonPress)
|
||||
|
||||
def _touch_up(self, serial: int, timestamp: int, touch_id: int) -> None:
|
||||
if touch_id == getattr(self, 'touch_id', None):
|
||||
self._mouse_event(QEvent.Type.MouseButtonRelease)
|
||||
self.touch_id = None
|
||||
|
||||
def _touch_motion(self, *event: int) -> None:
|
||||
timestamp, touch_id, x, y = event
|
||||
if touch_id == getattr(self, 'touch_id', None):
|
||||
self._pointer_motion(timestamp, x, y)
|
||||
|
||||
def _touch_frame(self) -> None:
|
||||
self.dirty = True
|
||||
|
||||
def _touch_cancel(self) -> None:
|
||||
self.touch_id = None
|
||||
self.pressed_widget = None
|
||||
self.window.keyboard.stop_backspace_repeat()
|
||||
|
||||
def _mouse_event(self, kind: QEvent.Type) -> None:
|
||||
point = self.position.toPoint()
|
||||
target = self.pressed_widget or self.window.childAt(point) or self.window.keyboard
|
||||
if kind == QEvent.Type.MouseButtonPress:
|
||||
self.pressed_widget = target
|
||||
local = QPointF(target.mapFrom(self.window, point))
|
||||
button = Qt.MouseButton.NoButton if kind == QEvent.Type.MouseMove else Qt.MouseButton.LeftButton
|
||||
held = self.pressed_widget is not None and kind != QEvent.Type.MouseButtonRelease
|
||||
buttons = Qt.MouseButton.LeftButton if held else Qt.MouseButton.NoButton
|
||||
event = QMouseEvent(kind, local, self.position, button, buttons, Qt.KeyboardModifier.NoModifier)
|
||||
QApplication.sendEvent(target, event)
|
||||
if kind == QEvent.Type.MouseButtonRelease:
|
||||
self.pressed_widget = None
|
||||
self.dirty = True
|
||||
|
||||
def hide_layer(self) -> None:
|
||||
self.wanted_visible = self.configured = False
|
||||
self.pressed_widget = None
|
||||
self._destroy(self.layer, 7)
|
||||
self._destroy(self.surface, 0)
|
||||
self.layer = self.surface = None
|
||||
self.lib.wl_display_flush(self.display)
|
||||
|
||||
def shutdown(self) -> None:
|
||||
self.timer.stop()
|
||||
self.notifier.setEnabled(False)
|
||||
if self.display:
|
||||
for proxy in reversed(self.proxies):
|
||||
self.lib.wl_proxy_destroy(proxy)
|
||||
self.proxies.clear()
|
||||
self.lib.wl_display_disconnect(self.display)
|
||||
self.display = None
|
||||
for buffer in self.buffers.values():
|
||||
buffer['memory'].close()
|
||||
self.buffers.clear()
|
||||
@@ -0,0 +1,336 @@
|
||||
"""Reuse the embedded keyboard's buttons and theme for system input."""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from types import SimpleNamespace
|
||||
from typing import Any, cast
|
||||
|
||||
import orjson
|
||||
from evdev import ecodes
|
||||
from PySide6.QtCore import QEvent, QObject, QPoint, Qt
|
||||
from PySide6.QtGui import QCloseEvent, QMouseEvent
|
||||
from PySide6.QtWidgets import QApplication, QFrame, QLabel, QPushButton, QWidget
|
||||
|
||||
from portprotonqt.config import gamepad_config, ui_config
|
||||
from portprotonqt.input_manager.constants import GamepadType
|
||||
from portprotonqt.keyboard_layouts import keyboard_layouts
|
||||
from portprotonqt.logger import get_logger
|
||||
from portprotonqt.tabs.control_hints import MainWindowControlHintsMixin
|
||||
from portprotonqt.theme_manager import ThemeManager
|
||||
from portprotonqt.virtual_keyboard import VirtualKeyboard, LAYOUT_DISPLAY_NAMES
|
||||
|
||||
from .input import KEY_ROWS, SystemInputWorker
|
||||
from .wayland_detection import compositor
|
||||
|
||||
logger = get_logger(__name__)
|
||||
|
||||
|
||||
def report(event: str, value: object = None) -> None:
|
||||
sys.stdout.buffer.write(orjson.dumps({'event': event, 'value': value}) + b'\n')
|
||||
sys.stdout.buffer.flush()
|
||||
|
||||
|
||||
class SystemKeyboardPanel(VirtualKeyboard):
|
||||
def __init__(self, owner: 'SystemKeyboardWindow', theme: Any) -> None:
|
||||
self.owner = owner
|
||||
self.keycodes: dict[str, int] = {}
|
||||
self.labels: dict[str, str] = {}
|
||||
self.modifiers: set[int] = set()
|
||||
self.layout_name = 'System'
|
||||
self.drag_origin: QPoint | None = None
|
||||
super().__init__(owner, theme)
|
||||
self.set_slide_animation_enabled(False)
|
||||
self.setObjectName('systemKeyboard')
|
||||
self.keyboard_container.setObjectName('systemKeyboardContainer')
|
||||
self.refresh_theme(theme)
|
||||
|
||||
def refresh_theme(self, theme: Any) -> None:
|
||||
super().refresh_theme(theme)
|
||||
self.setStyleSheet(theme.VIRTUAL_KEYBOARD_STYLE + theme.SYSTEM_KEYBOARD_BACKGROUND_STYLE)
|
||||
|
||||
def get_layouts_setxkbmap(self) -> list[str]:
|
||||
return ['us']
|
||||
|
||||
def _space_button_text(self) -> str:
|
||||
return f'Space · {LAYOUT_DISPLAY_NAMES.get(self.layout_name, self.layout_name)}'
|
||||
|
||||
def _save_focused_coords(self) -> tuple[int, int] | None:
|
||||
current = self.selected_button
|
||||
if current is None:
|
||||
return None
|
||||
index = self.keyboard_layout.indexOf(current)
|
||||
if index < 0:
|
||||
return None
|
||||
row, column, _, _ = cast(tuple[int, int, int, int], self.keyboard_layout.getItemPosition(index))
|
||||
return row, column
|
||||
|
||||
def _apply_responsive_metrics(self) -> None:
|
||||
metrics = self.theme.SYSTEM_KEYBOARD
|
||||
width = min(self.owner.width(), metrics['width'])
|
||||
available = width - self.margins * 2 - self.spacing * (self.num_cols - 1)
|
||||
self.button_width = min(self.max_button_width,
|
||||
max(metrics['minimum_key_width'], available // self.num_cols))
|
||||
|
||||
def update_keyboard(self) -> None:
|
||||
shifted = self.shift_pressed
|
||||
self.shift_pressed = False
|
||||
super().update_keyboard()
|
||||
self.shift_pressed = shifted
|
||||
self.keycodes.clear()
|
||||
for row, codes in zip(keyboard_layouts['us']['normal'], KEY_ROWS, strict=True):
|
||||
self.keycodes.update(zip(row, codes, strict=True))
|
||||
self.apply_key_state()
|
||||
if self.owner.warning_message:
|
||||
warning = QLabel(self.owner.warning_message)
|
||||
warning.setStyleSheet(self.theme.SETTINGS_TITLE_STYLE)
|
||||
warning.setWordWrap(True)
|
||||
self.keyboard_layout.addWidget(warning, 5, 0, 1, self.num_cols)
|
||||
for button in self.findChildren(QPushButton):
|
||||
button.setFocusPolicy(Qt.FocusPolicy.NoFocus)
|
||||
|
||||
def apply_key_state(self) -> None:
|
||||
for key, button in self.buttons.items():
|
||||
code = self.keycodes.get(key)
|
||||
if code not in {None, ecodes.KEY_TAB, ecodes.KEY_CAPSLOCK, ecodes.KEY_LEFTSHIFT} and str(code) in self.labels:
|
||||
text = self.labels[str(code)].replace('&', '&&')
|
||||
if button.text() != text:
|
||||
button.setText(text)
|
||||
for button in self.findChildren(QPushButton):
|
||||
checked = None
|
||||
if button.text() == 'CAPS':
|
||||
checked = self.caps_lock
|
||||
elif button.text() == '⬆':
|
||||
checked = self.shift_pressed
|
||||
elif button.text().startswith('Space · '):
|
||||
button.setText(self._space_button_text())
|
||||
if checked is not None and button.isChecked() != checked:
|
||||
button.setChecked(checked)
|
||||
button.style().unpolish(button)
|
||||
button.style().polish(button)
|
||||
button.update()
|
||||
|
||||
def _release_modifiers(self) -> None:
|
||||
self.modifiers.clear()
|
||||
self.shift_pressed = False
|
||||
self.owner.worker.commands.put(('release', ()))
|
||||
self.apply_key_state()
|
||||
|
||||
def on_button_click(self, key: str) -> None:
|
||||
code = ecodes.KEY_SPACE if key == ' ' else self.keycodes.get(key)
|
||||
if code is not None:
|
||||
self.owner.worker.commands.put(('tap', (code,)))
|
||||
|
||||
def on_backspace_click(self) -> None:
|
||||
self.owner.worker.commands.put(('tap', (ecodes.KEY_BACKSPACE,)))
|
||||
|
||||
def on_enter_click(self) -> None:
|
||||
self.owner.worker.commands.put(('tap', (ecodes.KEY_ENTER,)))
|
||||
|
||||
def on_clear_click(self) -> None:
|
||||
self.owner.worker.commands.put(('tap', (ecodes.KEY_LEFTCTRL, ecodes.KEY_A)))
|
||||
self.owner.worker.commands.put(('tap', (ecodes.KEY_BACKSPACE,)))
|
||||
|
||||
def on_caps_click(self) -> None:
|
||||
self.apply_key_state()
|
||||
self.owner.worker.commands.put(('caps', ()))
|
||||
|
||||
def on_shift_click(self, checked: bool) -> None:
|
||||
self.shift_pressed = checked
|
||||
if checked:
|
||||
self.modifiers.add(ecodes.KEY_LEFTSHIFT)
|
||||
else:
|
||||
self.modifiers.discard(ecodes.KEY_LEFTSHIFT)
|
||||
self.owner.worker.commands.put(('modifiers', tuple(sorted(self.modifiers))))
|
||||
self.apply_key_state()
|
||||
|
||||
def on_lang_click(self) -> None:
|
||||
self.owner.worker.commands.put(('language', ()))
|
||||
|
||||
def up_key(self) -> None:
|
||||
self.owner.worker.commands.put(('tap', (ecodes.KEY_UP,)))
|
||||
|
||||
def down_key(self) -> None:
|
||||
self.owner.worker.commands.put(('tap', (ecodes.KEY_DOWN,)))
|
||||
|
||||
def left_key(self) -> None:
|
||||
self.owner.worker.commands.put(('tap', (ecodes.KEY_LEFT,)))
|
||||
|
||||
def right_key(self) -> None:
|
||||
self.owner.worker.commands.put(('tap', (ecodes.KEY_RIGHT,)))
|
||||
|
||||
def hide(self) -> None:
|
||||
self.stop_backspace_repeat()
|
||||
QFrame.hide(self)
|
||||
if getattr(self.owner, 'keyboard', None) is self:
|
||||
self.owner.hide_keyboard()
|
||||
|
||||
def eventFilter(self, obj: QObject, event: QEvent) -> bool:
|
||||
return QFrame.eventFilter(self, obj, event)
|
||||
|
||||
def mousePressEvent(self, event: QMouseEvent) -> None:
|
||||
if event.button() == Qt.MouseButton.LeftButton:
|
||||
self.drag_origin = event.globalPosition().toPoint()
|
||||
event.accept()
|
||||
return
|
||||
super().mousePressEvent(event)
|
||||
|
||||
def mouseMoveEvent(self, event: QMouseEvent) -> None:
|
||||
if self.drag_origin is not None:
|
||||
position = event.globalPosition().toPoint()
|
||||
delta = position - self.drag_origin
|
||||
self.drag_origin = position
|
||||
if self.owner.layer_shell:
|
||||
position = self.pos() + delta
|
||||
self.move(max(0, min(position.x(), self.owner.width() - self.width())),
|
||||
max(0, min(position.y(), self.owner.height() - self.height())))
|
||||
else:
|
||||
self.owner.move(self.owner.pos() + delta)
|
||||
event.accept()
|
||||
return
|
||||
super().mouseMoveEvent(event)
|
||||
|
||||
def mouseReleaseEvent(self, event: QMouseEvent) -> None:
|
||||
self.drag_origin = None
|
||||
super().mouseReleaseEvent(event)
|
||||
|
||||
|
||||
class SystemKeyboardWindow(QWidget, MainWindowControlHintsMixin):
|
||||
def __init__(self) -> None:
|
||||
super().__init__(None, Qt.WindowType.Tool | Qt.WindowType.FramelessWindowHint
|
||||
| Qt.WindowType.WindowStaysOnTopHint | Qt.WindowType.WindowDoesNotAcceptFocus)
|
||||
self.setWindowTitle('PortProtonQt System Keyboard')
|
||||
self.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating)
|
||||
self.setAttribute(Qt.WidgetAttribute.WA_X11NetWmWindowTypeDock)
|
||||
self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||||
self.layer_shell = compositor(os.environ) is not None
|
||||
self.native_layer: Any = None
|
||||
self.theme_manager = ThemeManager()
|
||||
self.theme = self.theme_manager.apply_theme(ui_config.get_theme())
|
||||
gtype = GamepadType.PLAYSTATION if gamepad_config.get_gamepad_type() == 'playstation' else GamepadType.XBOX
|
||||
self.input_manager = SimpleNamespace(gamepad_type=gtype)
|
||||
self.worker = SystemInputWorker()
|
||||
self.ready = False
|
||||
self.wanted_visible = False
|
||||
self.warning_message = ''
|
||||
self.resize(self.theme.SYSTEM_KEYBOARD['width'], self.theme.SYSTEM_KEYBOARD['height'])
|
||||
self.keyboard = SystemKeyboardPanel(self, self.theme)
|
||||
self.worker.ready.connect(self._ready)
|
||||
self.worker.failed.connect(self._failed)
|
||||
self.worker.state_changed.connect(self._state_changed)
|
||||
self.worker.warning.connect(self._warning)
|
||||
self._position_keyboard()
|
||||
screen = self.screen()
|
||||
if screen is not None:
|
||||
screen.availableGeometryChanged.connect(self._position_keyboard)
|
||||
screen.geometryChanged.connect(self._position_keyboard)
|
||||
|
||||
def _position_keyboard(self) -> None:
|
||||
screen = self.screen()
|
||||
if screen is None:
|
||||
return
|
||||
metrics = self.theme.SYSTEM_KEYBOARD
|
||||
area = screen.geometry() if self.layer_shell else screen.availableGeometry()
|
||||
available_width = self.width() if self.layer_shell else area.width()
|
||||
width, height = min(available_width, metrics['width']), metrics['height']
|
||||
if self.warning_message:
|
||||
height += metrics['warning_height']
|
||||
if self.layer_shell:
|
||||
self.keyboard.setFixedSize(width, height)
|
||||
self.keyboard.move((self.width() - width) // 2, max(0, self.height() - height))
|
||||
else:
|
||||
self.resize(width, height)
|
||||
self.move(area.x() + (area.width() - width) // 2, area.bottom() - height + 1)
|
||||
self.keyboard.setFixedSize(width, height)
|
||||
self.keyboard.move(0, 0)
|
||||
self.keyboard.update_keyboard()
|
||||
|
||||
def show_keyboard(self) -> None:
|
||||
self.wanted_visible = True
|
||||
if not self.ready:
|
||||
return
|
||||
self.worker.enabled.set()
|
||||
self._position_keyboard()
|
||||
self.keyboard.show()
|
||||
self.show()
|
||||
self.keyboard.raise_()
|
||||
if self.native_layer is not None:
|
||||
self.native_layer.show_layer()
|
||||
|
||||
def hide_keyboard(self) -> None:
|
||||
self.wanted_visible = False
|
||||
self.worker.cancel_pending()
|
||||
self.keyboard.stop_backspace_repeat()
|
||||
self.keyboard._release_modifiers()
|
||||
if self.native_layer is not None:
|
||||
self.native_layer.hide_layer()
|
||||
self.hide()
|
||||
report('hidden')
|
||||
|
||||
def _ready(self) -> None:
|
||||
self.ready = True
|
||||
if self.wanted_visible:
|
||||
self.show_keyboard()
|
||||
|
||||
def _failed(self, message: str) -> None:
|
||||
logger.error('System keyboard: %s. Requires evdev and access to /dev/uinput.', message)
|
||||
app = QApplication.instance()
|
||||
if app is not None:
|
||||
app.exit(1)
|
||||
|
||||
def _warning(self, message: str) -> None:
|
||||
logger.warning('System keyboard: %s', message)
|
||||
if self.warning_message != message:
|
||||
self.warning_message = message
|
||||
self._position_keyboard()
|
||||
|
||||
def _state_changed(self, state: dict[str, Any]) -> None:
|
||||
changed = self.keyboard.labels != state['labels'] or self.keyboard.caps_lock != state['caps']
|
||||
changed |= self.keyboard.shift_pressed != state['shift']
|
||||
changed |= self.keyboard.modifiers != set(state['modifiers'])
|
||||
changed |= self.keyboard.layout_name != state['layout']
|
||||
self.keyboard.labels = state['labels']
|
||||
self.keyboard.caps_lock = state['caps']
|
||||
self.keyboard.shift_pressed = state['shift']
|
||||
self.keyboard.modifiers = set(state['modifiers'])
|
||||
self.keyboard.layout_name = state['layout']
|
||||
self.keyboard.apply_key_state()
|
||||
if changed:
|
||||
report('shift', state['shift'])
|
||||
|
||||
def command(self, action: str, value: Any = None) -> None:
|
||||
if action == 'show':
|
||||
self.show_keyboard()
|
||||
elif action == 'hide':
|
||||
self.hide_keyboard()
|
||||
elif action == 'theme' and isinstance(value, str):
|
||||
self.theme = self.theme_manager.apply_theme(value)
|
||||
self.keyboard.refresh_theme(self.theme)
|
||||
self.keyboard.current_theme_name = value
|
||||
self._position_keyboard()
|
||||
elif action == 'gamepad' and isinstance(value, str):
|
||||
self.input_manager.gamepad_type = GamepadType(value)
|
||||
self.keyboard.update_keyboard()
|
||||
elif action == 'direction' and value in ('up', 'down', 'left', 'right'):
|
||||
self.keyboard.focusNextKey(value)
|
||||
elif action == 'button' and self.ready and self.wanted_visible:
|
||||
handlers = {'confirm': self.keyboard.activateFocusedKey, 'back': self.hide_keyboard,
|
||||
'language': self.keyboard.on_lang_click, 'backspace': self.keyboard.on_backspace_pressed,
|
||||
'backspace_release': self.keyboard.stop_backspace_repeat}
|
||||
if value == 'shift':
|
||||
self.keyboard.on_shift_click(not self.keyboard.shift_pressed)
|
||||
elif value in handlers:
|
||||
handlers[value]()
|
||||
elif action == 'quit':
|
||||
app = QApplication.instance()
|
||||
if app is not None:
|
||||
app.quit()
|
||||
|
||||
def closeEvent(self, event: QCloseEvent) -> None:
|
||||
event.ignore()
|
||||
self.hide_keyboard()
|
||||
|
||||
def shutdown(self) -> None:
|
||||
self.keyboard.stop_backspace_repeat()
|
||||
self.worker.stop()
|
||||
if self.native_layer is not None:
|
||||
self.native_layer.shutdown()
|
||||
@@ -313,6 +313,12 @@ virtual_keyboard_fade_animation_duration = 140
|
||||
virtual_keyboard_slide_fade_animation_duration = 180
|
||||
virtual_keyboard_slide_bounce_animation_duration = 220
|
||||
virtual_keyboard_animation_type = "slide"
|
||||
SYSTEM_KEYBOARD = {
|
||||
"width": 1000,
|
||||
"height": 220,
|
||||
"minimum_key_width": 18,
|
||||
"warning_height": 36,
|
||||
}
|
||||
DETAIL_PAGE_LAYOUT_MODE = "full"
|
||||
|
||||
COMPATIBILITY_REPORT_DIALOG = {
|
||||
|
||||
@@ -44,6 +44,16 @@ CONTEXT_MENU_STYLE = f"""
|
||||
}}
|
||||
"""
|
||||
|
||||
SYSTEM_KEYBOARD_BACKGROUND_STYLE = f"""
|
||||
QFrame#systemKeyboard {{
|
||||
background: {color_bg};
|
||||
border-radius: {border_radius_small};
|
||||
}}
|
||||
QWidget#systemKeyboardContainer {{
|
||||
background: {color_transparent};
|
||||
}}
|
||||
"""
|
||||
|
||||
VIRTUAL_KEYBOARD_STYLE = f"""
|
||||
QWidget {{
|
||||
background: {color_overlay};
|
||||
|
||||
@@ -104,6 +104,10 @@ class TrayManager:
|
||||
self.tray_menu.addAction(self.pause_game_action)
|
||||
self.tray_menu.addAction(self.stop_game_action)
|
||||
self.update_game_actions()
|
||||
system_keyboard = getattr(getattr(self, 'main_window', None), 'system_keyboard', None)
|
||||
if system_keyboard is not None:
|
||||
keyboard_action = self.tray_menu.addAction('System Keyboard · Start + Y')
|
||||
keyboard_action.triggered.connect(system_keyboard.toggle)
|
||||
if self.minimal_mode:
|
||||
return
|
||||
self.tray_menu.addSeparator()
|
||||
|
||||
@@ -0,0 +1,292 @@
|
||||
"""System keyboard input, focus-independent routing and native lifecycle."""
|
||||
|
||||
from collections.abc import Generator
|
||||
from threading import Event
|
||||
from types import SimpleNamespace
|
||||
from typing import Any, cast
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
import pytest
|
||||
from evdev import ecodes
|
||||
from PySide6.QtCore import QObject, QPoint, Qt
|
||||
from PySide6.QtGui import QImage, QRegion
|
||||
from PySide6.QtWidgets import QApplication, QPushButton, QWidget
|
||||
|
||||
from portprotonqt.input_manager import InputManager
|
||||
from portprotonqt.input_manager.constants import (PAD_BUTTON_START, PAD_BUTTON_NORTH,
|
||||
PAD_BUTTON_SOUTH, SDL_CONTROLLER_BUTTON_TO_PAD)
|
||||
from portprotonqt.native_gamepad import SDLGamepad
|
||||
from portprotonqt.system_keyboard import SystemKeyboard
|
||||
from portprotonqt.system_keyboard.input import SystemInputWorker
|
||||
from portprotonqt.system_keyboard.window import SystemKeyboardWindow
|
||||
from portprotonqt.system_keyboard import input as system_input
|
||||
from portprotonqt.system_keyboard import window as system_window
|
||||
from portprotonqt.system_keyboard import wayland_detection
|
||||
from portprotonqt.system_keyboard.cosmic_detection import CosmicLayout
|
||||
from portprotonqt.system_keyboard.detection import X11Layout, XkbState
|
||||
from portprotonqt.system_keyboard.keys import XKB_GROUP_SHIFT
|
||||
from portprotonqt.theme_manager import load_theme
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def application() -> QApplication:
|
||||
return cast(QApplication, QApplication.instance() or QApplication([]))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def keyboard_window(monkeypatch: pytest.MonkeyPatch, application: QApplication) -> Generator[SystemKeyboardWindow]:
|
||||
theme = load_theme('standart')
|
||||
monkeypatch.setattr(system_window.ThemeManager, 'apply_theme', lambda self, name: theme)
|
||||
monkeypatch.setattr(system_window, 'compositor', lambda env: None)
|
||||
monkeypatch.setattr(system_window, 'report', MagicMock())
|
||||
window = SystemKeyboardWindow()
|
||||
yield window
|
||||
window.shutdown()
|
||||
window.hide()
|
||||
|
||||
|
||||
def test_panel_matches_embedded_layout_without_extra_rows(keyboard_window: SystemKeyboardWindow) -> None:
|
||||
keyboard = keyboard_window.keyboard
|
||||
assert keyboard.current_layout == 'us'
|
||||
assert keyboard.keyboard_layout.rowCount() == 5
|
||||
item = keyboard.keyboard_layout.itemAtPosition(3, 1)
|
||||
assert item is not None
|
||||
extra_iso_key = item.widget()
|
||||
assert isinstance(extra_iso_key, QPushButton)
|
||||
assert extra_iso_key.text() == '<'
|
||||
assert keyboard.keycodes['<'] == ecodes.KEY_102ND
|
||||
assert keyboard.height() == keyboard_window.theme.SYSTEM_KEYBOARD['height']
|
||||
assert keyboard_window.windowFlags() & Qt.WindowType.WindowDoesNotAcceptFocus
|
||||
|
||||
|
||||
def test_panel_sends_physical_keys_without_editing_target(keyboard_window: SystemKeyboardWindow) -> None:
|
||||
keyboard = keyboard_window.keyboard
|
||||
keyboard.on_button_click('q')
|
||||
keyboard.on_enter_click()
|
||||
keyboard.on_lang_click()
|
||||
commands = keyboard_window.worker.commands
|
||||
assert commands.get_nowait() == ('tap', (ecodes.KEY_Q,))
|
||||
assert commands.get_nowait() == ('tap', (ecodes.KEY_ENTER,))
|
||||
assert commands.get_nowait() == ('language', ())
|
||||
keyboard.on_shift_click(True)
|
||||
assert commands.get_nowait() == ('modifiers', (ecodes.KEY_LEFTSHIFT,))
|
||||
keyboard.buttons['q'].click()
|
||||
assert commands.get_nowait() == ('tap', (ecodes.KEY_Q,))
|
||||
|
||||
|
||||
def test_hide_cancels_pending_input_and_repeat(keyboard_window: SystemKeyboardWindow) -> None:
|
||||
keyboard_window.ready = True
|
||||
keyboard_window.show_keyboard()
|
||||
keyboard_window.keyboard.on_backspace_pressed()
|
||||
keyboard_window.hide_keyboard()
|
||||
assert not keyboard_window.worker.enabled.is_set()
|
||||
assert keyboard_window.keyboard.backspace_timer is None
|
||||
assert keyboard_window.worker.commands.get_nowait() == ('release', ())
|
||||
assert not keyboard_window.isVisible()
|
||||
|
||||
|
||||
def test_refresh_preserves_selected_key(keyboard_window: SystemKeyboardWindow) -> None:
|
||||
keyboard = keyboard_window.keyboard
|
||||
keyboard._set_selected_button(keyboard.buttons['q'])
|
||||
original_button = keyboard.buttons['q']
|
||||
original_button.setDown(True)
|
||||
keyboard_window._state_changed({'labels': {str(ecodes.KEY_Q): 'й'}, 'caps': False,
|
||||
'shift': False, 'modifiers': (), 'layout': 'ru'})
|
||||
assert keyboard.selected_button is keyboard.buttons['q']
|
||||
assert keyboard.buttons['q'].text() == 'й'
|
||||
assert keyboard.buttons['q'] is original_button
|
||||
assert original_button.isDown()
|
||||
|
||||
|
||||
def test_caps_highlight_and_space_follow_system_state(keyboard_window: SystemKeyboardWindow) -> None:
|
||||
keyboard = keyboard_window.keyboard
|
||||
button = keyboard.buttons['CAPS']
|
||||
keyboard_window._state_changed({'labels': {str(ecodes.KEY_CAPSLOCK): '', str(ecodes.KEY_Q): 'Й'},
|
||||
'caps': True, 'shift': False, 'modifiers': (), 'layout': 'ru'})
|
||||
assert button.text() == 'CAPS'
|
||||
assert button.isChecked()
|
||||
assert keyboard.buttons['q'].text() == 'Й'
|
||||
item = keyboard.keyboard_layout.itemAtPosition(4, 1)
|
||||
assert item is not None
|
||||
space = item.widget()
|
||||
assert isinstance(space, QPushButton)
|
||||
assert space.text() == f'Space · {system_window.LAYOUT_DISPLAY_NAMES["ru"]}'
|
||||
keyboard_window._state_changed({'labels': {str(ecodes.KEY_Q): 'q'}, 'caps': False,
|
||||
'shift': False, 'modifiers': (), 'layout': 'us'})
|
||||
assert not button.isChecked()
|
||||
assert space.text() == f'Space · {system_window.LAYOUT_DISPLAY_NAMES["us"]}'
|
||||
|
||||
|
||||
def test_panel_has_themed_background(keyboard_window: SystemKeyboardWindow) -> None:
|
||||
keyboard_window.ready = True
|
||||
keyboard_window.show_keyboard()
|
||||
QApplication.processEvents()
|
||||
image = QImage(keyboard_window.size(), QImage.Format.Format_ARGB32_Premultiplied)
|
||||
image.fill(Qt.GlobalColor.transparent)
|
||||
keyboard_window.render(image, QPoint(), QRegion(), QWidget.RenderFlag.DrawChildren)
|
||||
assert image.pixelColor(0, 0).alpha() == 0
|
||||
assert image.pixelColor(1, keyboard_window.height() // 2).alpha() > 0
|
||||
|
||||
|
||||
def test_caps_button_does_not_keep_unconfirmed_local_toggle(keyboard_window: SystemKeyboardWindow) -> None:
|
||||
button = keyboard_window.keyboard.buttons['CAPS']
|
||||
button.click()
|
||||
assert not button.isChecked()
|
||||
assert keyboard_window.worker.commands.get_nowait() == ('caps', ())
|
||||
button.setChecked(True)
|
||||
keyboard_window._state_changed({'labels': {}, 'caps': False, 'shift': False,
|
||||
'modifiers': (), 'layout': 'System'})
|
||||
assert not button.isChecked()
|
||||
|
||||
|
||||
def test_x11_labels_use_xkb_group_bits(application: QApplication) -> None:
|
||||
layout: Any = X11Layout.__new__(X11Layout)
|
||||
state = XkbState()
|
||||
state.group = 1
|
||||
layout.state = lambda: state
|
||||
layout.display = 123
|
||||
layout.lib = MagicMock()
|
||||
layout.xkb = MagicMock()
|
||||
layout.lib.XkbLookupKeySym.return_value = False
|
||||
layout.labels()
|
||||
assert layout.lib.XkbLookupKeySym.call_args_list
|
||||
for call in layout.lib.XkbLookupKeySym.call_args_list:
|
||||
assert call.args[2] == 1 << XKB_GROUP_SHIFT
|
||||
|
||||
|
||||
def test_key_failure_releases_all_pressed_keys(application: QApplication) -> None:
|
||||
worker = SystemInputWorker()
|
||||
device = MagicMock()
|
||||
device.write.side_effect = [None, OSError('injection failed'), None, None]
|
||||
with pytest.raises(OSError, match='injection failed'):
|
||||
worker.send_keys(device, (ecodes.KEY_LEFTSHIFT, ecodes.KEY_Q))
|
||||
assert [call.args for call in device.write.call_args_list] == [
|
||||
(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 1), (ecodes.EV_KEY, ecodes.KEY_Q, 1),
|
||||
(ecodes.EV_KEY, ecodes.KEY_Q, 0), (ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 0)]
|
||||
|
||||
|
||||
def test_hidden_keyboard_cannot_inject(application: QApplication) -> None:
|
||||
worker = SystemInputWorker()
|
||||
device = MagicMock()
|
||||
worker._execute(device, 'tap', (ecodes.KEY_Q,))
|
||||
worker._execute(device, 'language', ())
|
||||
worker._execute(device, 'caps', ())
|
||||
device.write.assert_not_called()
|
||||
|
||||
|
||||
def test_worker_shutdown_closes_device_once(monkeypatch: pytest.MonkeyPatch, application: QApplication) -> None:
|
||||
worker = SystemInputWorker()
|
||||
device = MagicMock()
|
||||
opened = Event()
|
||||
def open_device(*args: Any, **kwargs: Any) -> Any:
|
||||
opened.set()
|
||||
return device
|
||||
monkeypatch.setattr(system_input, 'UInput', open_device)
|
||||
monkeypatch.setattr(worker, '_load_layout', MagicMock())
|
||||
monkeypatch.setattr(worker, '_refresh_state', MagicMock())
|
||||
worker.start()
|
||||
assert opened.wait(2)
|
||||
worker.stop()
|
||||
worker.stop()
|
||||
assert not worker.isRunning()
|
||||
device.close.assert_called_once()
|
||||
|
||||
|
||||
def test_worker_failure_reports_and_finishes(monkeypatch: pytest.MonkeyPatch, application: QApplication) -> None:
|
||||
worker = SystemInputWorker()
|
||||
monkeypatch.setattr(system_input, 'UInput', MagicMock(side_effect=PermissionError('uinput denied')))
|
||||
failures = []
|
||||
worker.failed.connect(failures.append)
|
||||
worker.start()
|
||||
assert worker.wait(2000)
|
||||
application.processEvents()
|
||||
assert failures == ['uinput denied']
|
||||
|
||||
|
||||
@pytest.mark.parametrize('session', ['wayland', 'x11'])
|
||||
def test_xwayland_switch_uses_uinput_instead_of_xkb(
|
||||
monkeypatch: pytest.MonkeyPatch, application: QApplication, session: str,
|
||||
) -> None:
|
||||
monkeypatch.setenv('XDG_SESSION_TYPE', session)
|
||||
worker = SystemInputWorker()
|
||||
worker.enabled.set()
|
||||
layout: Any = X11Layout.__new__(X11Layout)
|
||||
layout.switch = MagicMock()
|
||||
worker.layout = layout
|
||||
device = MagicMock()
|
||||
worker._execute(device, 'language', ())
|
||||
if session == 'x11':
|
||||
layout.switch.assert_called_once()
|
||||
device.write.assert_not_called()
|
||||
else:
|
||||
layout.switch.assert_not_called()
|
||||
assert [call.args for call in device.write.call_args_list] == [
|
||||
(ecodes.EV_KEY, ecodes.KEY_KBD_LAYOUT_NEXT, 1),
|
||||
(ecodes.EV_KEY, ecodes.KEY_KBD_LAYOUT_NEXT, 0)]
|
||||
|
||||
|
||||
def test_cosmic_switch_matches_prototype_uinput_path(application: QApplication) -> None:
|
||||
worker = SystemInputWorker()
|
||||
worker.enabled.set()
|
||||
worker.layout = CosmicLayout.__new__(CosmicLayout)
|
||||
device = MagicMock()
|
||||
worker._execute(device, 'language', ())
|
||||
assert [call.args for call in device.write.call_args_list] == [
|
||||
(ecodes.EV_KEY, ecodes.KEY_KBD_LAYOUT_NEXT, 1),
|
||||
(ecodes.EV_KEY, ecodes.KEY_KBD_LAYOUT_NEXT, 0)]
|
||||
|
||||
|
||||
def test_niri_switch_uses_ipc(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
command = MagicMock()
|
||||
monkeypatch.setattr(wayland_detection, 'command', command)
|
||||
layout = wayland_detection.NiriLayout.__new__(wayland_detection.NiriLayout)
|
||||
layout.switch()
|
||||
command.assert_called_once_with(['niri', 'msg', 'action', 'switch-layout', 'next'])
|
||||
|
||||
|
||||
def test_start_y_is_consumed_before_internal_search(application: QApplication) -> None:
|
||||
manager: Any = InputManager.__new__(InputManager)
|
||||
QObject.__init__(manager)
|
||||
keyboard = SimpleNamespace(toggle=MagicMock(), isVisible=lambda: False)
|
||||
manager._parent = SimpleNamespace(system_keyboard=keyboard)
|
||||
manager.start_held = True
|
||||
assert manager._handle_system_keyboard_input(PAD_BUTTON_START, 1, False)
|
||||
assert manager._handle_system_keyboard_input(PAD_BUTTON_NORTH, 1, False)
|
||||
assert manager._handle_system_keyboard_input(PAD_BUTTON_START, 0, False)
|
||||
keyboard.toggle.assert_called_once()
|
||||
manager.start_held = False
|
||||
assert not manager._handle_system_keyboard_input(PAD_BUTTON_NORTH, 1, False)
|
||||
|
||||
|
||||
def test_system_keyboard_routes_buttons_without_application_focus(application: QApplication) -> None:
|
||||
manager: Any = InputManager.__new__(InputManager)
|
||||
QObject.__init__(manager)
|
||||
keyboard = SimpleNamespace(send=MagicMock(), isVisible=lambda: True)
|
||||
manager._parent = SimpleNamespace(system_keyboard=keyboard)
|
||||
manager.start_held = False
|
||||
assert manager._handle_system_keyboard_input(PAD_BUTTON_SOUTH, 1, False)
|
||||
keyboard.send.assert_called_once_with('button', 'confirm')
|
||||
|
||||
|
||||
def test_start_is_polled_before_y_in_same_snapshot(application: QApplication) -> None:
|
||||
manager: Any = InputManager.__new__(InputManager)
|
||||
manager._handle_button_value = MagicMock()
|
||||
gamepad = cast(SDLGamepad, SimpleNamespace(get_button=lambda index: 1))
|
||||
manager._poll_button_events(gamepad, 1.0)
|
||||
codes = [call.args[1] for call in manager._handle_button_value.call_args_list]
|
||||
assert codes.index(PAD_BUTTON_START) < codes.index(PAD_BUTTON_NORTH)
|
||||
assert set(codes) == set(SDL_CONTROLLER_BUTTON_TO_PAD.values())
|
||||
|
||||
|
||||
def test_controller_shutdown_waits_for_child(monkeypatch: pytest.MonkeyPatch, application: QApplication) -> None:
|
||||
parent = QWidget()
|
||||
keyboard = SystemKeyboard(parent)
|
||||
process = MagicMock()
|
||||
from PySide6.QtCore import QProcess
|
||||
process.state.return_value = QProcess.ProcessState.Running
|
||||
process.waitForFinished.side_effect = [False, False, True]
|
||||
keyboard.process = process
|
||||
keyboard.shutdown()
|
||||
process.terminate.assert_called_once()
|
||||
process.kill.assert_called_once()
|
||||
assert process.waitForFinished.call_count == 3
|
||||
Reference in new issue
Block a user