You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
308 lines
10 KiB
Python
308 lines
10 KiB
Python
#!/usr/bin/python3
|
|
# -*- coding: utf-8 -*-
|
|
# input-remapper - GUI for device specific keyboard mappings
|
|
# Copyright (C) 2022 sezanzeb <proxima@sezanzeb.de>
|
|
#
|
|
# This file is part of input-remapper.
|
|
#
|
|
# input-remapper is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# input-remapper is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with input-remapper. If not, see <https://www.gnu.org/licenses/>.
|
|
from __future__ import annotations
|
|
|
|
import enum
|
|
from dataclasses import dataclass
|
|
from typing import Tuple, Union, Sequence, Callable, Optional
|
|
|
|
import evdev
|
|
from evdev import ecodes
|
|
|
|
from inputremapper.configs.system_mapping import system_mapping
|
|
from inputremapper.exceptions import InputEventCreationError
|
|
from inputremapper.gui.message_broker import MessageType
|
|
from inputremapper.logger import logger
|
|
|
|
InputEventValidationType = Union[
|
|
str,
|
|
Tuple[int, int, int],
|
|
evdev.InputEvent,
|
|
]
|
|
|
|
|
|
class EventActions(enum.Enum):
|
|
"""Additional information a InputEvent can send through the event pipeline"""
|
|
|
|
as_key = enum.auto() # treat this event as a key event
|
|
recenter = enum.auto() # recenter the axis when receiving this
|
|
none = enum.auto()
|
|
|
|
# used in combination with as_key, for originally abs or rel events
|
|
positive_trigger = enum.auto() # original event was positive direction
|
|
negative_trigger = enum.auto() # original event was negative direction
|
|
|
|
|
|
# Todo: add slots=True as soon as python 3.10 is in common distros
|
|
@dataclass(frozen=True)
|
|
class InputEvent:
|
|
"""The evnet used by inputremapper
|
|
|
|
as a drop in replacement for evdev.InputEvent
|
|
"""
|
|
|
|
message_type = MessageType.selected_event
|
|
|
|
sec: int
|
|
usec: int
|
|
type: int
|
|
code: int
|
|
value: int
|
|
actions: Tuple[EventActions, ...] = ()
|
|
|
|
def __hash__(self):
|
|
return hash((self.type, self.code, self.value))
|
|
|
|
def __eq__(self, other):
|
|
if isinstance(other, InputEvent) or isinstance(other, evdev.InputEvent):
|
|
return self.event_tuple == (other.type, other.code, other.value)
|
|
if isinstance(other, tuple):
|
|
return self.event_tuple == other
|
|
return False
|
|
|
|
@classmethod
|
|
def __get_validators__(cls):
|
|
"""Used by pydantic and EventCombination to create InputEvent objects."""
|
|
yield cls.validate
|
|
|
|
@classmethod
|
|
def validate(cls, init_arg: InputEventValidationType) -> InputEvent:
|
|
"""Try all the different methods, and raise an error if none succeed."""
|
|
if isinstance(init_arg, InputEvent):
|
|
return init_arg
|
|
|
|
event = None
|
|
validators: Sequence[Callable[..., InputEvent]] = (
|
|
cls.from_event,
|
|
cls.from_string,
|
|
cls.from_tuple,
|
|
)
|
|
for validator in validators:
|
|
try:
|
|
event = validator(init_arg)
|
|
break
|
|
except InputEventCreationError:
|
|
pass
|
|
|
|
if event:
|
|
return event
|
|
|
|
raise ValueError(f"failed to create InputEvent with {init_arg = }")
|
|
|
|
@classmethod
|
|
def from_event(cls, event: evdev.InputEvent) -> InputEvent:
|
|
"""Create a InputEvent from another InputEvent or evdev.InputEvent."""
|
|
try:
|
|
return cls(event.sec, event.usec, event.type, event.code, event.value)
|
|
except AttributeError:
|
|
raise InputEventCreationError(
|
|
f"failed to create InputEvent from {event = }"
|
|
)
|
|
|
|
@classmethod
|
|
def from_string(cls, string: str) -> InputEvent:
|
|
"""Create a InputEvent from a string like 'type, code, value'."""
|
|
try:
|
|
t, c, v = string.split(",")
|
|
return cls(0, 0, int(t), int(c), int(v))
|
|
except (ValueError, AttributeError):
|
|
raise InputEventCreationError(
|
|
f"failed to create InputEvent from {string = !r}"
|
|
)
|
|
|
|
@classmethod
|
|
def from_tuple(cls, event_tuple: Tuple[int, int, int]) -> InputEvent:
|
|
"""Create a InputEvent from a (type, code, value) tuple."""
|
|
try:
|
|
if len(event_tuple) != 3:
|
|
raise InputEventCreationError(
|
|
f"failed to create InputEvent {event_tuple = }"
|
|
f" must have length 3"
|
|
)
|
|
return cls(
|
|
0,
|
|
0,
|
|
int(event_tuple[0]),
|
|
int(event_tuple[1]),
|
|
int(event_tuple[2]),
|
|
)
|
|
except ValueError:
|
|
raise InputEventCreationError(
|
|
f"failed to create InputEvent from {event_tuple = }"
|
|
)
|
|
except TypeError:
|
|
raise InputEventCreationError(
|
|
f"failed to create InputEvent from {type(event_tuple) = }"
|
|
)
|
|
|
|
@classmethod
|
|
def btn_left(cls):
|
|
return cls(0, 0, evdev.ecodes.EV_KEY, evdev.ecodes.BTN_LEFT, 1)
|
|
|
|
@property
|
|
def type_and_code(self) -> Tuple[int, int]:
|
|
"""Event type, code."""
|
|
return self.type, self.code
|
|
|
|
@property
|
|
def event_tuple(self) -> Tuple[int, int, int]:
|
|
"""Event type, code, value."""
|
|
return self.type, self.code, self.value
|
|
|
|
@property
|
|
def is_key_event(self) -> bool:
|
|
"""Whether this is interpreted as a key event."""
|
|
return self.type == evdev.ecodes.EV_KEY or EventActions.as_key in self.actions
|
|
|
|
def __str__(self):
|
|
return f"InputEvent{self.event_tuple}"
|
|
|
|
def description(self, exclude_threshold=False, exclude_direction=False) -> str:
|
|
"""get a human-readable description of the event"""
|
|
return (
|
|
f"{self.get_name()} "
|
|
f"{self.get_direction() if not exclude_direction else ''} "
|
|
f"{self.get_threshold() if not exclude_threshold else ''}".strip()
|
|
)
|
|
|
|
def timestamp(self):
|
|
"""Return the unix timestamp of when the event was seen."""
|
|
return self.sec + self.usec / 1000000
|
|
|
|
def modify(
|
|
self,
|
|
sec: int = None,
|
|
usec: int = None,
|
|
type: int = None,
|
|
code: int = None,
|
|
value: int = None,
|
|
actions: Tuple[EventActions, ...] = None,
|
|
) -> InputEvent:
|
|
"""Return a new modified event."""
|
|
return InputEvent(
|
|
sec if sec is not None else self.sec,
|
|
usec if usec is not None else self.usec,
|
|
type if type is not None else self.type,
|
|
code if code is not None else self.code,
|
|
value if value is not None else self.value,
|
|
actions if actions is not None else self.actions,
|
|
)
|
|
|
|
def json_str(self) -> str:
|
|
return ",".join([str(self.type), str(self.code), str(self.value)])
|
|
|
|
def get_name(self) -> Optional[str]:
|
|
"""human-readable name"""
|
|
if self.type not in ecodes.bytype:
|
|
logger.error("Unknown type for %s", self)
|
|
return "unknown"
|
|
|
|
if self.code not in ecodes.bytype[self.type]:
|
|
logger.error("Unknown code for %s", self)
|
|
return "unknown"
|
|
|
|
key_name = None
|
|
|
|
# first try to find the name in xmodmap to not display wrong
|
|
# names due to the keyboard layout
|
|
if self.type == ecodes.EV_KEY:
|
|
key_name = system_mapping.get_name(self.code)
|
|
|
|
if key_name is None:
|
|
# if no result, look in the linux combination constants. On a german
|
|
# keyboard for example z and y are switched, which will therefore
|
|
# cause the wrong letter to be displayed.
|
|
key_name = ecodes.bytype[self.type][self.code]
|
|
if isinstance(key_name, list):
|
|
key_name = key_name[0]
|
|
|
|
key_name = key_name.replace("ABS_Z", "Trigger Left")
|
|
key_name = key_name.replace("ABS_RZ", "Trigger Right")
|
|
|
|
key_name = key_name.replace("ABS_HAT0X", "DPad-X")
|
|
key_name = key_name.replace("ABS_HAT0Y", "DPad-Y")
|
|
key_name = key_name.replace("ABS_HAT1X", "DPad-2-X")
|
|
key_name = key_name.replace("ABS_HAT1Y", "DPad-2-Y")
|
|
key_name = key_name.replace("ABS_HAT2X", "DPad-3-X")
|
|
key_name = key_name.replace("ABS_HAT2Y", "DPad-3-Y")
|
|
|
|
key_name = key_name.replace("ABS_X", "Joystick-X")
|
|
key_name = key_name.replace("ABS_Y", "Joystick-Y")
|
|
key_name = key_name.replace("ABS_RX", "Joystick-RX")
|
|
key_name = key_name.replace("ABS_RY", "Joystick-RY")
|
|
|
|
key_name = key_name.replace("BTN_", "Button ")
|
|
key_name = key_name.replace("KEY_", "")
|
|
|
|
key_name = key_name.replace("REL_", "")
|
|
key_name = key_name.replace("HWHEEL", "Wheel")
|
|
key_name = key_name.replace("WHEEL", "Wheel")
|
|
|
|
key_name = key_name.replace("_", " ")
|
|
key_name = key_name.replace(" ", " ")
|
|
return key_name
|
|
|
|
def get_direction(self) -> str:
|
|
if self.type == ecodes.EV_KEY:
|
|
return ""
|
|
|
|
try:
|
|
event = self.modify(value=self.value // abs(self.value))
|
|
except ZeroDivisionError:
|
|
return ""
|
|
|
|
return {
|
|
# D-Pad
|
|
(ecodes.ABS_HAT0X, -1): "Left",
|
|
(ecodes.ABS_HAT0X, 1): "Right",
|
|
(ecodes.ABS_HAT0Y, -1): "Up",
|
|
(ecodes.ABS_HAT0Y, 1): "Down",
|
|
(ecodes.ABS_HAT1X, -1): "Left",
|
|
(ecodes.ABS_HAT1X, 1): "Right",
|
|
(ecodes.ABS_HAT1Y, -1): "Up",
|
|
(ecodes.ABS_HAT1Y, 1): "Down",
|
|
(ecodes.ABS_HAT2X, -1): "Left",
|
|
(ecodes.ABS_HAT2X, 1): "Right",
|
|
(ecodes.ABS_HAT2Y, -1): "Up",
|
|
(ecodes.ABS_HAT2Y, 1): "Down",
|
|
# joystick
|
|
(ecodes.ABS_X, 1): "Right",
|
|
(ecodes.ABS_X, -1): "Left",
|
|
(ecodes.ABS_Y, 1): "Down",
|
|
(ecodes.ABS_Y, -1): "Up",
|
|
(ecodes.ABS_RX, 1): "Right",
|
|
(ecodes.ABS_RX, -1): "Left",
|
|
(ecodes.ABS_RY, 1): "Down",
|
|
(ecodes.ABS_RY, -1): "Up",
|
|
# wheel
|
|
(ecodes.REL_WHEEL, -1): "Down",
|
|
(ecodes.REL_WHEEL, 1): "Up",
|
|
(ecodes.REL_HWHEEL, -1): "Left",
|
|
(ecodes.REL_HWHEEL, 1): "Right",
|
|
}.get((event.code, event.value)) or ("+" if event.value > 0 else "-")
|
|
|
|
def get_threshold(self) -> str:
|
|
if self.value == 0:
|
|
return ""
|
|
return {
|
|
ecodes.EV_REL: f"{abs(self.value)}",
|
|
ecodes.EV_ABS: f"{abs(self.value)}%",
|
|
}.get(self.type) or ""
|