Tobi
2 years ago
committed by
GitHub
commit
d5ec0383ab
@ -0,0 +1,7 @@
|
||||
|
||||
[mypy]
|
||||
plugins = pydantic.mypy
|
||||
|
||||
# ignore the missing evdev stubs
|
||||
[mypy-evdev.*]
|
||||
ignore_missing_imports = True
|
||||
@ -0,0 +1,17 @@
|
||||
<component name="ProjectRunConfigurationManager">
|
||||
<configuration default="false" name="Only Integration Tests" type="tests" factoryName="Unittests">
|
||||
<module name="input-remapper" />
|
||||
<option name="INTERPRETER_OPTIONS" value="" />
|
||||
<option name="PARENT_ENVS" value="true" />
|
||||
<option name="SDK_HOME" value="" />
|
||||
<option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/tests" />
|
||||
<option name="IS_MODULE_SDK" value="true" />
|
||||
<option name="ADD_CONTENT_ROOTS" value="true" />
|
||||
<option name="ADD_SOURCE_ROOTS" value="true" />
|
||||
<option name="_new_pattern" value="""" />
|
||||
<option name="_new_additionalArguments" value="""" />
|
||||
<option name="_new_target" value=""$PROJECT_DIR$/tests/integration"" />
|
||||
<option name="_new_targetType" value=""PATH"" />
|
||||
<method v="2" />
|
||||
</configuration>
|
||||
</component>
|
||||
@ -0,0 +1,17 @@
|
||||
<component name="ProjectRunConfigurationManager">
|
||||
<configuration default="false" name="Only Unit Tests" type="tests" factoryName="Unittests">
|
||||
<module name="input-remapper" />
|
||||
<option name="INTERPRETER_OPTIONS" value="" />
|
||||
<option name="PARENT_ENVS" value="true" />
|
||||
<option name="SDK_HOME" value="" />
|
||||
<option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/tests" />
|
||||
<option name="IS_MODULE_SDK" value="true" />
|
||||
<option name="ADD_CONTENT_ROOTS" value="true" />
|
||||
<option name="ADD_SOURCE_ROOTS" value="true" />
|
||||
<option name="_new_pattern" value="""" />
|
||||
<option name="_new_additionalArguments" value="""" />
|
||||
<option name="_new_target" value=""$PROJECT_DIR$/tests/unit"" />
|
||||
<option name="_new_targetType" value=""PATH"" />
|
||||
<method v="2" />
|
||||
</configuration>
|
||||
</component>
|
||||
@ -1,3 +1,3 @@
|
||||
Files: *
|
||||
Copyright: 2021 sezanzeb
|
||||
Copyright: 2023 Sezanzeb
|
||||
License: GPL-3+
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,431 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 itertools
|
||||
from typing import Tuple, Iterable, Union, List, Dict, Optional, Hashable, TypeAlias
|
||||
|
||||
from evdev import ecodes
|
||||
from evdev._ecodes import EV_ABS, EV_KEY, EV_REL
|
||||
|
||||
from inputremapper.input_event import InputEvent
|
||||
from pydantic import BaseModel, root_validator, validator
|
||||
|
||||
from inputremapper.configs.system_mapping import system_mapping
|
||||
from inputremapper.gui.messages.message_types import MessageType
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.utils import get_evdev_constant_name
|
||||
|
||||
# having shift in combinations modifies the configured output,
|
||||
# ctrl might not work at all
|
||||
DIFFICULT_COMBINATIONS = [
|
||||
ecodes.KEY_LEFTSHIFT,
|
||||
ecodes.KEY_RIGHTSHIFT,
|
||||
ecodes.KEY_LEFTCTRL,
|
||||
ecodes.KEY_RIGHTCTRL,
|
||||
ecodes.KEY_LEFTALT,
|
||||
ecodes.KEY_RIGHTALT,
|
||||
]
|
||||
|
||||
DeviceHash: TypeAlias = str
|
||||
|
||||
EMPTY_TYPE = 99
|
||||
|
||||
|
||||
class InputConfig(BaseModel):
|
||||
"""Describes a single input within a combination, to configure mappings."""
|
||||
|
||||
message_type = MessageType.selected_event
|
||||
|
||||
type: int
|
||||
code: int
|
||||
|
||||
# origin_hash is a hash to identify a specific /dev/input/eventXX device.
|
||||
# This solves a number of bugs when multiple devices have overlapping capabilities.
|
||||
# see utils.get_device_hash for the exact hashing function
|
||||
origin_hash: Optional[DeviceHash] = None
|
||||
|
||||
# At which point is an analog input treated as "pressed"
|
||||
analog_threshold: Optional[int] = None
|
||||
|
||||
def __str__(self):
|
||||
return f"InputConfig {get_evdev_constant_name(self.type, self.code)}"
|
||||
|
||||
def __repr__(self):
|
||||
return (
|
||||
f"<InputConfig {self.type_and_code} "
|
||||
f"{get_evdev_constant_name(*self.type_and_code)}, "
|
||||
f"{self.analog_threshold}, "
|
||||
f"{self.origin_hash}, "
|
||||
f"at {hex(id(self))}>"
|
||||
)
|
||||
|
||||
@property
|
||||
def input_match_hash(self) -> Hashable:
|
||||
"""a Hashable object which is intended to match the InputConfig with a
|
||||
InputEvent.
|
||||
|
||||
InputConfig itself is hashable, but can not be used to match InputEvent's
|
||||
because its hash includes the analog_threshold
|
||||
"""
|
||||
return self.type, self.code, self.origin_hash
|
||||
|
||||
@property
|
||||
def is_empty(self) -> bool:
|
||||
return self.type == EMPTY_TYPE
|
||||
|
||||
@property
|
||||
def defines_analog_input(self) -> bool:
|
||||
"""Whether this defines an analog input."""
|
||||
return not self.analog_threshold and self.type != ecodes.EV_KEY
|
||||
|
||||
@property
|
||||
def type_and_code(self) -> Tuple[int, int]:
|
||||
"""Event type, code."""
|
||||
return self.type, self.code
|
||||
|
||||
@classmethod
|
||||
def btn_left(cls):
|
||||
return cls(type=ecodes.EV_KEY, code=ecodes.BTN_LEFT)
|
||||
|
||||
@classmethod
|
||||
def from_input_event(cls, event: InputEvent) -> InputConfig:
|
||||
"""create an input confing from the given InputEvent, uses the value as
|
||||
analog threshold"""
|
||||
return cls(
|
||||
type=event.type,
|
||||
code=event.code,
|
||||
origin_hash=event.origin_hash,
|
||||
analog_threshold=event.value,
|
||||
)
|
||||
|
||||
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_value() if not exclude_threshold else ''}".strip()
|
||||
)
|
||||
|
||||
def _get_name(self) -> Optional[str]:
|
||||
"""Human-readable name (e.g. KEY_A) of the specified input event."""
|
||||
if self.type not in ecodes.bytype:
|
||||
logger.warning("Unknown type for %s", self)
|
||||
return f"unknown {self.type, self.code}"
|
||||
|
||||
if self.code not in ecodes.bytype[self.type]:
|
||||
logger.warning("Unknown code for %s", self)
|
||||
return f"unknown {self.type, self.code}"
|
||||
|
||||
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 = get_evdev_constant_name(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:
|
||||
"""human-readable direction description for the analog_threshold"""
|
||||
if self.type == ecodes.EV_KEY or self.defines_analog_input:
|
||||
return ""
|
||||
|
||||
assert self.analog_threshold
|
||||
threshold_direction = self.analog_threshold // abs(self.analog_threshold)
|
||||
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((self.code, threshold_direction)) or (
|
||||
"+" if threshold_direction > 0 else "-"
|
||||
)
|
||||
|
||||
def _get_threshold_value(self) -> str:
|
||||
"""human-readable value of the analog_threshold e.g. '20%'"""
|
||||
if self.analog_threshold is None:
|
||||
return ""
|
||||
return {
|
||||
ecodes.EV_REL: f"{abs(self.analog_threshold)}",
|
||||
ecodes.EV_ABS: f"{abs(self.analog_threshold)}%",
|
||||
}.get(self.type) or ""
|
||||
|
||||
def modify(
|
||||
self,
|
||||
type_: Optional[int] = None,
|
||||
code: Optional[int] = None,
|
||||
origin_hash: Optional[str] = None,
|
||||
analog_threshold: Optional[int] = None,
|
||||
) -> InputConfig:
|
||||
"""Return a new modified event."""
|
||||
return InputConfig(
|
||||
type=type_ if type_ is not None else self.type,
|
||||
code=code if code is not None else self.code,
|
||||
origin_hash=origin_hash if origin_hash is not None else self.origin_hash,
|
||||
analog_threshold=analog_threshold
|
||||
if analog_threshold is not None
|
||||
else self.analog_threshold,
|
||||
)
|
||||
|
||||
def __hash__(self):
|
||||
return hash((self.type, self.code, self.origin_hash, self.analog_threshold))
|
||||
|
||||
@validator("analog_threshold")
|
||||
def _ensure_analog_threshold_is_none(cls, analog_threshold):
|
||||
"""ensure the analog threshold is none, not zero."""
|
||||
if analog_threshold == 0 or analog_threshold is None:
|
||||
return None
|
||||
|
||||
return analog_threshold
|
||||
|
||||
@root_validator
|
||||
def _remove_analog_threshold_for_key_input(cls, values):
|
||||
"""remove the analog threshold if the type is a EV_KEY"""
|
||||
type_ = values.get("type")
|
||||
if type_ == ecodes.EV_KEY:
|
||||
values["analog_threshold"] = None
|
||||
return values
|
||||
|
||||
@root_validator(pre=True)
|
||||
def validate_origin_hash(cls, values):
|
||||
origin_hash = values.get("origin_hash")
|
||||
if origin_hash is None:
|
||||
# For new presets, origin_hash should be set. For old ones, it can
|
||||
# be still missing. A lot of tests didn't set an origin_hash.
|
||||
if values.get("type") != EMPTY_TYPE:
|
||||
logger.warning("No origin_hash set for %s", values)
|
||||
|
||||
return values
|
||||
|
||||
values["origin_hash"] = origin_hash.lower()
|
||||
return values
|
||||
|
||||
class Config:
|
||||
allow_mutation = False
|
||||
underscore_attrs_are_private = True
|
||||
|
||||
|
||||
InputCombinationInit = Union[
|
||||
Iterable[Dict[str, Union[str, int]]],
|
||||
Iterable[InputConfig],
|
||||
]
|
||||
|
||||
|
||||
class InputCombination(Tuple[InputConfig, ...]):
|
||||
"""One or more InputConfigs used to trigger a mapping."""
|
||||
|
||||
# tuple is immutable, therefore we need to override __new__()
|
||||
# https://jfine-python-classes.readthedocs.io/en/latest/subclass-tuple.html
|
||||
def __new__(cls, configs: InputCombinationInit) -> InputCombination:
|
||||
"""Create a new InputCombination.
|
||||
|
||||
Examples
|
||||
--------
|
||||
InputCombination([InputConfig, ...])
|
||||
InputCombination([{type: ..., code: ..., value: ...}, ...])
|
||||
"""
|
||||
if not isinstance(configs, Iterable):
|
||||
raise TypeError("InputCombination requires a list of InputConfigs.")
|
||||
|
||||
if isinstance(configs, InputConfig):
|
||||
# wrap the argument in square brackets
|
||||
raise TypeError("InputCombination requires a list of InputConfigs.")
|
||||
|
||||
validated_configs = []
|
||||
for config in configs:
|
||||
if isinstance(configs, InputEvent):
|
||||
raise TypeError("InputCombinations require InputConfigs, not Events.")
|
||||
|
||||
if isinstance(config, InputConfig):
|
||||
validated_configs.append(config)
|
||||
elif isinstance(config, dict):
|
||||
validated_configs.append(InputConfig(**config))
|
||||
else:
|
||||
raise TypeError(f'Can\'t handle "{config}"')
|
||||
|
||||
if len(validated_configs) == 0:
|
||||
raise ValueError(f"failed to create InputCombination with {configs = }")
|
||||
|
||||
# mypy bug: https://github.com/python/mypy/issues/8957
|
||||
# https://github.com/python/mypy/issues/8541
|
||||
return super().__new__(cls, validated_configs) # type: ignore
|
||||
|
||||
def __str__(self):
|
||||
return f'Combination ({" + ".join(str(event) for event in self)})'
|
||||
|
||||
def __repr__(self):
|
||||
combination = ", ".join(repr(event) for event in self)
|
||||
return f"<InputCombination ({combination}) at {hex(id(self))}>"
|
||||
|
||||
@classmethod
|
||||
def __get_validators__(cls):
|
||||
"""Used by pydantic to create InputCombination objects."""
|
||||
yield cls.validate
|
||||
|
||||
@classmethod
|
||||
def validate(cls, init_arg) -> InputCombination:
|
||||
"""The only valid option is from_config"""
|
||||
if isinstance(init_arg, InputCombination):
|
||||
return init_arg
|
||||
return cls(init_arg)
|
||||
|
||||
def to_config(self) -> Tuple[Dict[str, int], ...]:
|
||||
"""Turn the object into a tuple of dicts."""
|
||||
return tuple(input_config.dict(exclude_defaults=True) for input_config in self)
|
||||
|
||||
@classmethod
|
||||
def empty_combination(cls) -> InputCombination:
|
||||
"""A combination that has default invalid (to evdev) values.
|
||||
|
||||
Useful for the UI to indicate that this combination is not set
|
||||
"""
|
||||
return cls([{"type": EMPTY_TYPE, "code": 99, "analog_threshold": 99}])
|
||||
|
||||
@classmethod
|
||||
def from_tuples(cls, *tuples):
|
||||
"""Construct an InputCombination from (type, code, analog_threshold) tuples."""
|
||||
dicts = []
|
||||
for tuple_ in tuples:
|
||||
if len(tuple_) == 3:
|
||||
dicts.append(
|
||||
{
|
||||
"type": tuple_[0],
|
||||
"code": tuple_[1],
|
||||
"analog_threshold": tuple_[2],
|
||||
}
|
||||
)
|
||||
elif len(tuple_) == 2:
|
||||
dicts.append(
|
||||
{
|
||||
"type": tuple_[0],
|
||||
"code": tuple_[1],
|
||||
}
|
||||
)
|
||||
else:
|
||||
raise TypeError
|
||||
|
||||
return cls(dicts)
|
||||
|
||||
def is_problematic(self) -> bool:
|
||||
"""Is this combination going to work properly on all systems?"""
|
||||
if len(self) <= 1:
|
||||
return False
|
||||
|
||||
for input_config in self:
|
||||
if input_config.type != ecodes.EV_KEY:
|
||||
continue
|
||||
|
||||
if input_config.code in DIFFICULT_COMBINATIONS:
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
@property
|
||||
def defines_analog_input(self) -> bool:
|
||||
"""Check if there is any analog input in self."""
|
||||
return True in tuple(i.defines_analog_input for i in self)
|
||||
|
||||
def find_analog_input_config(
|
||||
self, type_: Optional[int] = None
|
||||
) -> Optional[InputConfig]:
|
||||
"""Return the first event that defines an analog input."""
|
||||
for input_config in self:
|
||||
if input_config.defines_analog_input and (
|
||||
type_ is None or input_config.type == type_
|
||||
):
|
||||
return input_config
|
||||
return None
|
||||
|
||||
def get_permutations(self) -> List[InputCombination]:
|
||||
"""Get a list of EventCombinations representing all possible permutations.
|
||||
|
||||
combining a + b + c should have the same result as b + a + c.
|
||||
Only the last combination remains the same in the returned result.
|
||||
"""
|
||||
if len(self) <= 2:
|
||||
return [self]
|
||||
|
||||
permutations = []
|
||||
for permutation in itertools.permutations(self[:-1]):
|
||||
permutations.append(InputCombination((*permutation, self[-1])))
|
||||
|
||||
return permutations
|
||||
|
||||
def beautify(self) -> str:
|
||||
"""Get a human-readable string representation."""
|
||||
if self == InputCombination.empty_combination():
|
||||
return "empty_combination"
|
||||
return " + ".join(event.description(exclude_threshold=True) for event in self)
|
||||
@ -0,0 +1,482 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 collections import namedtuple
|
||||
from typing import Optional, Callable, Tuple, TypeVar, Union, Any, Dict
|
||||
|
||||
import pkg_resources
|
||||
from evdev.ecodes import (
|
||||
EV_KEY,
|
||||
EV_ABS,
|
||||
EV_REL,
|
||||
REL_WHEEL,
|
||||
REL_HWHEEL,
|
||||
REL_HWHEEL_HI_RES,
|
||||
REL_WHEEL_HI_RES,
|
||||
)
|
||||
from pydantic import (
|
||||
BaseModel,
|
||||
PositiveInt,
|
||||
confloat,
|
||||
conint,
|
||||
root_validator,
|
||||
validator,
|
||||
ValidationError,
|
||||
PositiveFloat,
|
||||
VERSION,
|
||||
BaseConfig,
|
||||
)
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination
|
||||
from inputremapper.configs.system_mapping import system_mapping, DISABLE_NAME
|
||||
from inputremapper.configs.validation_errors import (
|
||||
OutputSymbolUnknownError,
|
||||
SymbolNotAvailableInTargetError,
|
||||
OnlyOneAnalogInputError,
|
||||
TriggerPointInRangeError,
|
||||
OutputSymbolVariantError,
|
||||
MacroButTypeOrCodeSetError,
|
||||
SymbolAndCodeMismatchError,
|
||||
MissingMacroOrKeyError,
|
||||
MissingOutputAxisError,
|
||||
MacroParsingError,
|
||||
)
|
||||
from inputremapper.gui.gettext import _
|
||||
from inputremapper.gui.messages.message_types import MessageType
|
||||
from inputremapper.injection.global_uinputs import can_default_uinput_emit
|
||||
from inputremapper.injection.macros.parse import is_this_a_macro, parse
|
||||
from inputremapper.utils import get_evdev_constant_name
|
||||
|
||||
# TODO: remove pydantic VERSION check as soon as we no longer support
|
||||
# Ubuntu 20.04 and with it the ancient pydantic 1.2
|
||||
|
||||
needs_workaround = pkg_resources.parse_version(
|
||||
str(VERSION)
|
||||
) < pkg_resources.parse_version("1.7.1")
|
||||
|
||||
|
||||
EMPTY_MAPPING_NAME: str = _("Empty Mapping")
|
||||
|
||||
# If `1` is the default speed for EV_REL, how much does this value needs to be scaled
|
||||
# up to get reasonable speeds for various EV_REL events?
|
||||
# Mouse injection rates vary wildly, and so do the values.
|
||||
REL_XY_SCALING: float = 60
|
||||
WHEEL_SCALING: float = 1
|
||||
# WHEEL_HI_RES always generates events with 120 times higher values than WHEEL
|
||||
# https://www.kernel.org/doc/html/latest/input/event-codes.html?highlight=wheel_hi_res#ev-rel
|
||||
WHEEL_HI_RES_SCALING: float = 120
|
||||
# Those values are assuming a rate of 60hz
|
||||
DEFAULT_REL_RATE: float = 60
|
||||
|
||||
|
||||
class KnownUinput(str, enum.Enum):
|
||||
"""The default targets."""
|
||||
|
||||
KEYBOARD = "keyboard"
|
||||
MOUSE = "mouse"
|
||||
GAMEPAD = "gamepad"
|
||||
KEYBOARD_MOUSE = "keyboard + mouse"
|
||||
|
||||
|
||||
class MappingType(str, enum.Enum):
|
||||
"""What kind of output the mapping produces."""
|
||||
|
||||
KEY_MACRO = "key_macro"
|
||||
ANALOG = "analog"
|
||||
|
||||
|
||||
CombinationChangedCallback = Optional[
|
||||
Callable[[InputCombination, InputCombination], None]
|
||||
]
|
||||
MappingModel = TypeVar("MappingModel", bound="UIMapping")
|
||||
|
||||
|
||||
class Cfg(BaseConfig):
|
||||
validate_assignment = True
|
||||
use_enum_values = True
|
||||
underscore_attrs_are_private = True
|
||||
json_encoders = {InputCombination: lambda v: v.json_key()}
|
||||
|
||||
|
||||
class ImmutableCfg(Cfg):
|
||||
allow_mutation = False
|
||||
|
||||
|
||||
class UIMapping(BaseModel):
|
||||
"""Holds all the data for mapping an input action to an output action.
|
||||
|
||||
The Preset contains multiple UIMappings.
|
||||
|
||||
This mapping does not validate the structure of the mapping or macros, only basic
|
||||
values. It is meant to be used in the GUI where invalid mappings are expected.
|
||||
"""
|
||||
|
||||
if needs_workaround:
|
||||
__slots__ = ("_combination_changed",)
|
||||
|
||||
# Required attributes
|
||||
# The InputEvent or InputEvent combination which is mapped
|
||||
input_combination: InputCombination = InputCombination.empty_combination()
|
||||
# The UInput to which the mapped event will be sent
|
||||
target_uinput: Optional[Union[str, KnownUinput]] = None
|
||||
|
||||
# Either `output_symbol` or `output_type` and `output_code` is required
|
||||
output_symbol: Optional[str] = None # The symbol or macro string if applicable
|
||||
output_type: Optional[int] = None # The event type of the mapped event
|
||||
output_code: Optional[int] = None # The event code of the mapped event
|
||||
|
||||
name: Optional[str] = None
|
||||
mapping_type: Optional[MappingType] = None
|
||||
|
||||
# if release events will be sent to the forwarded device as soon as a combination
|
||||
# triggers see also #229
|
||||
release_combination_keys: bool = True
|
||||
|
||||
# macro settings
|
||||
macro_key_sleep_ms: conint(ge=0) = 0 # type: ignore
|
||||
|
||||
# Optional attributes for mapping Axis to Axis
|
||||
# The deadzone of the input axis
|
||||
deadzone: confloat(ge=0, le=1) = 0.1 # type: ignore
|
||||
gain: float = 1.0 # The scale factor for the transformation
|
||||
# The expo factor for the transformation
|
||||
expo: confloat(ge=-1, le=1) = 0 # type: ignore
|
||||
|
||||
# when mapping to relative axis
|
||||
# The frequency [Hz] at which EV_REL events get generated
|
||||
rel_rate: PositiveInt = 60
|
||||
|
||||
# when mapping from a relative axis:
|
||||
# the relative value at which a EV_REL axis is considered at its maximum. Moving
|
||||
# a mouse at 2x the regular speed would be considered max by default.
|
||||
rel_to_abs_input_cutoff: PositiveInt = 2
|
||||
|
||||
# the time until a relative axis is considered stationary if no new events arrive
|
||||
release_timeout: PositiveFloat = 0.05
|
||||
# don't release immediately when a relative axis drops below the speed threshold
|
||||
# instead wait until it dropped for loger than release_timeout below the threshold
|
||||
force_release_timeout: bool = False
|
||||
|
||||
# callback which gets called if the input_combination is updated
|
||||
if not needs_workaround:
|
||||
_combination_changed: Optional[CombinationChangedCallback] = None
|
||||
|
||||
# use type: ignore, looks like a mypy bug related to:
|
||||
# https://github.com/samuelcolvin/pydantic/issues/2949
|
||||
def __init__(self, **kwargs): # type: ignore
|
||||
super().__init__(**kwargs)
|
||||
if needs_workaround:
|
||||
object.__setattr__(self, "_combination_changed", None)
|
||||
|
||||
def __setattr__(self, key: str, value: Any):
|
||||
"""Call the combination changed callback
|
||||
if we are about to update the input_combination
|
||||
"""
|
||||
if key != "input_combination" or self._combination_changed is None:
|
||||
if key == "_combination_changed" and needs_workaround:
|
||||
object.__setattr__(self, "_combination_changed", value)
|
||||
return
|
||||
super().__setattr__(key, value)
|
||||
return
|
||||
|
||||
# the new combination is not yet validated
|
||||
try:
|
||||
new_combi = InputCombination.validate(value)
|
||||
except (ValueError, TypeError) as exception:
|
||||
raise ValidationError(
|
||||
f"failed to Validate {value} as InputCombination", UIMapping
|
||||
) from exception
|
||||
|
||||
if new_combi == self.input_combination:
|
||||
return
|
||||
|
||||
# raises a keyError if the combination or a permutation is already mapped
|
||||
self._combination_changed(new_combi, self.input_combination)
|
||||
super().__setattr__("input_combination", new_combi)
|
||||
|
||||
def __str__(self):
|
||||
return str(
|
||||
self.dict(
|
||||
exclude_defaults=True, include={"input_combination", "target_uinput"}
|
||||
)
|
||||
)
|
||||
|
||||
if needs_workaround:
|
||||
# https://github.com/samuelcolvin/pydantic/issues/1383
|
||||
def copy(self: MappingModel, *args, **kwargs) -> MappingModel:
|
||||
kwargs["deep"] = True
|
||||
copy = super().copy(*args, **kwargs)
|
||||
object.__setattr__(copy, "_combination_changed", self._combination_changed)
|
||||
return copy
|
||||
|
||||
def format_name(self) -> str:
|
||||
"""Get the custom-name or a readable representation of the combination."""
|
||||
if self.name:
|
||||
return self.name
|
||||
|
||||
if (
|
||||
self.input_combination == InputCombination.empty_combination()
|
||||
or self.input_combination is None
|
||||
):
|
||||
return EMPTY_MAPPING_NAME
|
||||
|
||||
return self.input_combination.beautify()
|
||||
|
||||
def has_input_defined(self) -> bool:
|
||||
"""Whether this mapping defines an event-input."""
|
||||
return self.input_combination != InputCombination.empty_combination()
|
||||
|
||||
def is_axis_mapping(self) -> bool:
|
||||
"""Whether this mapping specifies an output axis."""
|
||||
return self.output_type in [EV_ABS, EV_REL]
|
||||
|
||||
def is_wheel_output(self) -> bool:
|
||||
"""Check if this maps to wheel output."""
|
||||
return self.output_code in (
|
||||
REL_WHEEL,
|
||||
REL_HWHEEL,
|
||||
)
|
||||
|
||||
def is_high_res_wheel_output(self) -> bool:
|
||||
"""Check if this maps to high-res wheel output."""
|
||||
return self.output_code in (
|
||||
REL_WHEEL_HI_RES,
|
||||
REL_HWHEEL_HI_RES,
|
||||
)
|
||||
|
||||
def is_analog_output(self):
|
||||
return self.mapping_type == MappingType.ANALOG
|
||||
|
||||
def set_combination_changed_callback(self, callback: CombinationChangedCallback):
|
||||
self._combination_changed = callback
|
||||
|
||||
def remove_combination_changed_callback(self):
|
||||
self._combination_changed = None
|
||||
|
||||
def get_output_type_code(self) -> Optional[Tuple[int, int]]:
|
||||
"""Returns the output_type and output_code if set,
|
||||
otherwise looks the output_symbol up in the system_mapping
|
||||
return None for unknown symbols and macros
|
||||
"""
|
||||
if self.output_code and self.output_type:
|
||||
return self.output_type, self.output_code
|
||||
if self.output_symbol and not is_this_a_macro(self.output_symbol):
|
||||
return EV_KEY, system_mapping.get(self.output_symbol)
|
||||
return None
|
||||
|
||||
def get_output_name_constant(self) -> str:
|
||||
"""Get the evdev name costant for the output."""
|
||||
return get_evdev_constant_name(self.output_type, self.output_code)
|
||||
|
||||
def is_valid(self) -> bool:
|
||||
"""If the mapping is valid."""
|
||||
return not self.get_error()
|
||||
|
||||
def get_error(self) -> Optional[ValidationError]:
|
||||
"""The validation error or None."""
|
||||
try:
|
||||
Mapping(**self.dict())
|
||||
except ValidationError as exception:
|
||||
return exception
|
||||
return None
|
||||
|
||||
def get_bus_message(self) -> MappingData:
|
||||
"""Return an immutable copy for use in the message broker."""
|
||||
return MappingData(**self.dict())
|
||||
|
||||
@root_validator
|
||||
def validate_mapping_type(cls, values):
|
||||
"""Overrides the mapping type if the output mapping type is obvious."""
|
||||
output_type = values.get("output_type")
|
||||
output_code = values.get("output_code")
|
||||
output_symbol = values.get("output_symbol")
|
||||
|
||||
if output_type is not None and output_code is not None and not output_symbol:
|
||||
values["mapping_type"] = "analog"
|
||||
|
||||
if output_type is None and output_code is None and output_symbol:
|
||||
values["mapping_type"] = "key_macro"
|
||||
|
||||
return values
|
||||
|
||||
Config = Cfg
|
||||
|
||||
|
||||
class Mapping(UIMapping):
|
||||
"""Holds all the data for mapping an input action to an output action.
|
||||
|
||||
This implements the missing validations from UIMapping.
|
||||
"""
|
||||
|
||||
# Override Required attributes to enforce they are set
|
||||
input_combination: InputCombination
|
||||
target_uinput: KnownUinput
|
||||
|
||||
@classmethod
|
||||
def from_combination(
|
||||
cls, input_combination=None, target_uinput="keyboard", output_symbol="a"
|
||||
):
|
||||
"""Convenient function to get a valid mapping."""
|
||||
if not input_combination:
|
||||
input_combination = [{"type": 99, "code": 99, "analog_threshold": 99}]
|
||||
|
||||
return cls(
|
||||
input_combination=input_combination,
|
||||
target_uinput=target_uinput,
|
||||
output_symbol=output_symbol,
|
||||
)
|
||||
|
||||
def is_valid(self) -> bool:
|
||||
"""If the mapping is valid."""
|
||||
return True
|
||||
|
||||
@root_validator(pre=True)
|
||||
def validate_symbol(cls, values):
|
||||
"""Parse a macro to check for syntax errors."""
|
||||
symbol = values.get("output_symbol")
|
||||
|
||||
if symbol == "":
|
||||
values["output_symbol"] = None
|
||||
return values
|
||||
|
||||
if symbol is None:
|
||||
return values
|
||||
|
||||
symbol = symbol.strip()
|
||||
values["output_symbol"] = symbol
|
||||
|
||||
if symbol == DISABLE_NAME:
|
||||
return values
|
||||
|
||||
if is_this_a_macro(symbol):
|
||||
mapping_mock = namedtuple("Mapping", values.keys())(**values)
|
||||
# raises MacroParsingError
|
||||
parse(symbol, mapping=mapping_mock, verbose=False)
|
||||
return values
|
||||
|
||||
code = system_mapping.get(symbol)
|
||||
if code is None:
|
||||
raise OutputSymbolUnknownError(symbol)
|
||||
|
||||
target = values.get("target_uinput")
|
||||
if target is not None and not can_default_uinput_emit(target, EV_KEY, code):
|
||||
raise SymbolNotAvailableInTargetError(symbol, target)
|
||||
|
||||
return values
|
||||
|
||||
@validator("input_combination")
|
||||
def only_one_analog_input(cls, combination) -> InputCombination:
|
||||
"""Check that the input_combination specifies a maximum of one
|
||||
analog to analog mapping
|
||||
"""
|
||||
analog_events = [event for event in combination if event.defines_analog_input]
|
||||
if len(analog_events) > 1:
|
||||
raise OnlyOneAnalogInputError(analog_events)
|
||||
|
||||
return combination
|
||||
|
||||
@validator("input_combination")
|
||||
def trigger_point_in_range(cls, combination: InputCombination) -> InputCombination:
|
||||
"""Check if the trigger point for mapping analog axis to buttons is valid."""
|
||||
for input_config in combination:
|
||||
if (
|
||||
input_config.type == EV_ABS
|
||||
and input_config.analog_threshold
|
||||
and abs(input_config.analog_threshold) >= 100
|
||||
):
|
||||
raise TriggerPointInRangeError(input_config)
|
||||
return combination
|
||||
|
||||
@root_validator
|
||||
def validate_output_symbol_variant(cls, values):
|
||||
"""Validate that either type and code or symbol are set for key output."""
|
||||
o_symbol = values.get("output_symbol")
|
||||
o_type = values.get("output_type")
|
||||
o_code = values.get("output_code")
|
||||
if o_symbol is None and (o_type is None or o_code is None):
|
||||
raise OutputSymbolVariantError()
|
||||
return values
|
||||
|
||||
@root_validator
|
||||
def validate_output_integrity(cls, values):
|
||||
"""Validate the output key configuration."""
|
||||
symbol = values.get("output_symbol")
|
||||
type_ = values.get("output_type")
|
||||
code = values.get("output_code")
|
||||
if symbol is None:
|
||||
# If symbol is "", then validate_symbol changes it to None
|
||||
# type and code can be anything
|
||||
return values
|
||||
|
||||
if type_ is None and code is None:
|
||||
# we have a symbol: no type and code is fine
|
||||
return values
|
||||
|
||||
if is_this_a_macro(symbol):
|
||||
# disallow output type and code for macros
|
||||
if type_ is not None or code is not None:
|
||||
raise MacroButTypeOrCodeSetError()
|
||||
|
||||
if code is not None and code != system_mapping.get(symbol) or type_ != EV_KEY:
|
||||
raise SymbolAndCodeMismatchError(symbol, code)
|
||||
return values
|
||||
|
||||
@root_validator
|
||||
def output_matches_input(cls, values: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Validate that an output type is an axis if we have an input axis.
|
||||
And vice versa."""
|
||||
assert isinstance(values.get("input_combination"), InputCombination)
|
||||
combination: InputCombination = values["input_combination"]
|
||||
analog_input_config = combination.find_analog_input_config()
|
||||
use_as_analog = analog_input_config is not None
|
||||
|
||||
output_type = values.get("output_type")
|
||||
output_symbol = values.get("output_symbol")
|
||||
|
||||
if not use_as_analog and not output_symbol and output_type != EV_KEY:
|
||||
raise MissingMacroOrKeyError()
|
||||
|
||||
if (
|
||||
use_as_analog
|
||||
and output_type not in (EV_ABS, EV_REL)
|
||||
and output_symbol != DISABLE_NAME
|
||||
):
|
||||
raise MissingOutputAxisError(analog_input_config, output_type)
|
||||
|
||||
return values
|
||||
|
||||
|
||||
class MappingData(UIMapping):
|
||||
"""Like UIMapping, but can be sent over the message broker."""
|
||||
|
||||
Config = ImmutableCfg
|
||||
message_type = MessageType.mapping # allow this to be sent over the MessageBroker
|
||||
|
||||
def __str__(self):
|
||||
return str(self.dict(exclude_defaults=True))
|
||||
|
||||
def dict(self, *args, **kwargs):
|
||||
"""Will not include the message_type."""
|
||||
dict_ = super().dict(*args, **kwargs)
|
||||
if "message_type" in dict_:
|
||||
del dict_["message_type"]
|
||||
return dict_
|
||||
@ -0,0 +1,132 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
"""Exceptions that are thrown when configurations are incorrect."""
|
||||
|
||||
# can't merge this with exceptions.py, because I want error constructors here to
|
||||
# be intelligent to avoid redundant code, and they need imports, which would cause
|
||||
# circular imports.
|
||||
|
||||
# pydantic only catches ValueError, TypeError, and AssertionError
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Optional
|
||||
|
||||
from evdev.ecodes import EV_KEY
|
||||
|
||||
from inputremapper.configs.system_mapping import system_mapping
|
||||
from inputremapper.injection.global_uinputs import find_fitting_default_uinputs
|
||||
|
||||
|
||||
class OutputSymbolVariantError(ValueError):
|
||||
def __init__(self):
|
||||
super().__init__(
|
||||
"Missing Argument: Mapping must either contain "
|
||||
"`output_symbol` or `output_type` and `output_code`"
|
||||
)
|
||||
|
||||
|
||||
class TriggerPointInRangeError(ValueError):
|
||||
def __init__(self, input_config):
|
||||
super().__init__(
|
||||
f"{input_config = } maps an absolute axis to a button, but the "
|
||||
"trigger point (event.analog_threshold) is not between -100[%] "
|
||||
"and 100[%]"
|
||||
)
|
||||
|
||||
|
||||
class OnlyOneAnalogInputError(ValueError):
|
||||
def __init__(self, analog_events):
|
||||
super().__init__(
|
||||
f"Cannot map a combination of multiple analog inputs: {analog_events}"
|
||||
"add trigger points (event.value != 0) to map as a button"
|
||||
)
|
||||
|
||||
|
||||
class SymbolNotAvailableInTargetError(ValueError):
|
||||
def __init__(self, symbol, target):
|
||||
code = system_mapping.get(symbol)
|
||||
|
||||
fitting_targets = find_fitting_default_uinputs(EV_KEY, code)
|
||||
fitting_targets_string = '", "'.join(fitting_targets)
|
||||
|
||||
super().__init__(
|
||||
f'The output_symbol "{symbol}" is not available for the "{target}" '
|
||||
+ f'target. Try "{fitting_targets_string}".'
|
||||
)
|
||||
|
||||
|
||||
class OutputSymbolUnknownError(ValueError):
|
||||
def __init__(self, symbol: str):
|
||||
super().__init__(
|
||||
f'The output_symbol "{symbol}" is not a macro and not a valid '
|
||||
+ "keycode-name"
|
||||
)
|
||||
|
||||
|
||||
class MacroButTypeOrCodeSetError(ValueError):
|
||||
def __init__(self):
|
||||
super().__init__(
|
||||
"output_symbol is a macro: output_type " "and output_code must be None"
|
||||
)
|
||||
|
||||
|
||||
class SymbolAndCodeMismatchError(ValueError):
|
||||
def __init__(self, symbol, code):
|
||||
super().__init__(
|
||||
"output_symbol and output_code mismatch: "
|
||||
f"output macro is {symbol} -> {system_mapping.get(symbol)} "
|
||||
f"but output_code is {code} -> {system_mapping.get_name(code)} "
|
||||
)
|
||||
|
||||
|
||||
class MissingMacroOrKeyError(ValueError):
|
||||
def __init__(self):
|
||||
super().__init__("missing macro or key")
|
||||
|
||||
|
||||
class MissingOutputAxisError(ValueError):
|
||||
def __init__(self, analog_input_config, output_type):
|
||||
super().__init__(
|
||||
"Missing output axis: "
|
||||
f'"{analog_input_config}" is used as analog input, '
|
||||
f"but the {output_type = } is not an axis "
|
||||
)
|
||||
|
||||
|
||||
class MacroParsingError(ValueError):
|
||||
"""Macro syntax errors."""
|
||||
|
||||
def __init__(self, symbol: Optional[str] = None, msg="Error while parsing a macro"):
|
||||
self.symbol = symbol
|
||||
super().__init__(msg)
|
||||
|
||||
|
||||
def pydantify(error: type):
|
||||
"""Generate a string as it would appear IN pydantic error types.
|
||||
|
||||
This does not include the base class name, which is transformed to snake case in
|
||||
pydantic. Example pydantic error type: "value_error.foobar" for FooBarError.
|
||||
"""
|
||||
# See https://github.com/pydantic/pydantic/discussions/5112
|
||||
lower_classname = error.__name__.lower()
|
||||
if lower_classname.endswith("error"):
|
||||
return lower_classname[: -len("error")]
|
||||
return lower_classname
|
||||
@ -1,221 +0,0 @@
|
||||
# -*- 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 itertools
|
||||
|
||||
from typing import Tuple, Iterable
|
||||
|
||||
import evdev
|
||||
from evdev import ecodes
|
||||
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.configs.system_mapping import system_mapping
|
||||
from inputremapper.input_event import InputEvent
|
||||
from inputremapper.exceptions import InputEventCreationError
|
||||
|
||||
# having shift in combinations modifies the configured output,
|
||||
# ctrl might not work at all
|
||||
DIFFICULT_COMBINATIONS = [
|
||||
ecodes.KEY_LEFTSHIFT,
|
||||
ecodes.KEY_RIGHTSHIFT,
|
||||
ecodes.KEY_LEFTCTRL,
|
||||
ecodes.KEY_RIGHTCTRL,
|
||||
ecodes.KEY_LEFTALT,
|
||||
ecodes.KEY_RIGHTALT,
|
||||
]
|
||||
|
||||
|
||||
class EventCombination(Tuple[InputEvent]):
|
||||
"""one or multiple InputEvent objects for use as an unique identifier for mappings"""
|
||||
|
||||
# tuple is immutable, therefore we need to override __new__()
|
||||
# https://jfine-python-classes.readthedocs.io/en/latest/subclass-tuple.html
|
||||
def __new__(cls, *init_args) -> EventCombination:
|
||||
events = []
|
||||
for init_arg in init_args:
|
||||
event = None
|
||||
|
||||
for constructor in InputEvent.__get_validators__():
|
||||
try:
|
||||
event = constructor(init_arg)
|
||||
break
|
||||
except InputEventCreationError:
|
||||
pass
|
||||
|
||||
if event:
|
||||
events.append(event)
|
||||
else:
|
||||
raise ValueError(f"failed to create InputEvent with {init_arg = }")
|
||||
|
||||
return super().__new__(cls, events)
|
||||
|
||||
def __str__(self):
|
||||
# only used in tests and logging
|
||||
return f"<EventCombination {', '.join([str(e.event_tuple) for e in self])}>"
|
||||
|
||||
@classmethod
|
||||
def __get_validators__(cls):
|
||||
"""used by pydantic to create EventCombination objects"""
|
||||
yield cls.from_string
|
||||
yield cls.from_events
|
||||
|
||||
@classmethod
|
||||
def from_string(cls, init_string: str) -> EventCombination:
|
||||
init_args = init_string.split("+")
|
||||
return cls(*init_args)
|
||||
|
||||
@classmethod
|
||||
def from_events(
|
||||
cls, init_events: Iterable[InputEvent | evdev.InputEvent]
|
||||
) -> EventCombination:
|
||||
return cls(*init_events)
|
||||
|
||||
def contains_type_and_code(self, type, code) -> bool:
|
||||
"""if a InputEvent contains the type and code"""
|
||||
for event in self:
|
||||
if event.type_and_code == (type, code):
|
||||
return True
|
||||
return False
|
||||
|
||||
def is_problematic(self):
|
||||
"""Is this combination going to work properly on all systems?"""
|
||||
if len(self) <= 1:
|
||||
return False
|
||||
|
||||
for event in self:
|
||||
if event.type != ecodes.EV_KEY:
|
||||
continue
|
||||
|
||||
if event.code in DIFFICULT_COMBINATIONS:
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
def get_permutations(self):
|
||||
"""Get a list of EventCombination objects representing all possible permutations.
|
||||
|
||||
combining a + b + c should have the same result as b + a + c.
|
||||
Only the last combination remains the same in the returned result.
|
||||
"""
|
||||
if len(self) <= 2:
|
||||
return [self]
|
||||
|
||||
permutations = []
|
||||
for permutation in itertools.permutations(self[:-1]):
|
||||
permutations.append(EventCombination(*permutation, self[-1]))
|
||||
|
||||
return permutations
|
||||
|
||||
def json_str(self) -> str:
|
||||
return "+".join([event.json_str() for event in self])
|
||||
|
||||
def beautify(self) -> str:
|
||||
"""Get a human readable string representation."""
|
||||
result = []
|
||||
|
||||
for event in self:
|
||||
|
||||
if event.type not in ecodes.bytype:
|
||||
logger.error("Unknown type for %s", event)
|
||||
result.append(str(event.code))
|
||||
continue
|
||||
|
||||
if event.code not in ecodes.bytype[event.type]:
|
||||
logger.error("Unknown combination code for %s", event)
|
||||
result.append(str(event.code))
|
||||
continue
|
||||
|
||||
key_name = None
|
||||
|
||||
# first try to find the name in xmodmap to not display wrong
|
||||
# names due to the keyboard layout
|
||||
if event.type == ecodes.EV_KEY:
|
||||
key_name = system_mapping.get_name(event.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[event.type][event.code]
|
||||
if isinstance(key_name, list):
|
||||
key_name = key_name[0]
|
||||
|
||||
if event.type != ecodes.EV_KEY:
|
||||
direction = {
|
||||
# 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))
|
||||
if direction is not None:
|
||||
key_name += f" {direction}"
|
||||
|
||||
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")
|
||||
key_name = key_name.replace("ABS_HAT0Y", "DPad")
|
||||
key_name = key_name.replace("ABS_HAT1X", "DPad 2")
|
||||
key_name = key_name.replace("ABS_HAT1Y", "DPad 2")
|
||||
key_name = key_name.replace("ABS_HAT2X", "DPad 3")
|
||||
key_name = key_name.replace("ABS_HAT2Y", "DPad 3")
|
||||
|
||||
key_name = key_name.replace("ABS_X", "Joystick")
|
||||
key_name = key_name.replace("ABS_Y", "Joystick")
|
||||
key_name = key_name.replace("ABS_RX", "Joystick 2")
|
||||
key_name = key_name.replace("ABS_RY", "Joystick 2")
|
||||
|
||||
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(" ", " ")
|
||||
|
||||
result.append(key_name)
|
||||
|
||||
return " + ".join(result)
|
||||
@ -0,0 +1,6 @@
|
||||
import gi
|
||||
|
||||
gi.require_version("Gdk", "3.0")
|
||||
gi.require_version("Gtk", "3.0")
|
||||
gi.require_version("GLib", "2.0")
|
||||
gi.require_version("GtkSource", "4")
|
||||
@ -0,0 +1,175 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
|
||||
"""Components used in multiple places."""
|
||||
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import gi
|
||||
|
||||
from gi.repository import Gtk
|
||||
|
||||
from typing import Optional
|
||||
|
||||
from inputremapper.configs.mapping import MappingData
|
||||
|
||||
from inputremapper.gui.controller import Controller
|
||||
from inputremapper.gui.messages.message_broker import (
|
||||
MessageBroker,
|
||||
MessageType,
|
||||
)
|
||||
from inputremapper.gui.messages.message_data import GroupData, PresetData
|
||||
from inputremapper.gui.utils import HandlerDisabled
|
||||
|
||||
|
||||
class FlowBoxEntry(Gtk.ToggleButton):
|
||||
"""A device that can be selected in the GUI.
|
||||
|
||||
For example a keyboard or a mouse.
|
||||
"""
|
||||
|
||||
__gtype_name__ = "FlowBoxEntry"
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message_broker: MessageBroker,
|
||||
controller: Controller,
|
||||
name: str,
|
||||
icon_name: Optional[str] = None,
|
||||
):
|
||||
super().__init__()
|
||||
self.icon_name = icon_name
|
||||
self.message_broker = message_broker
|
||||
self._controller = controller
|
||||
|
||||
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
|
||||
|
||||
if icon_name:
|
||||
icon = Gtk.Image.new_from_icon_name(icon_name, Gtk.IconSize.DIALOG)
|
||||
box.add(icon)
|
||||
|
||||
label = Gtk.Label()
|
||||
label.set_label(name)
|
||||
self.name = name
|
||||
|
||||
# wrap very long names properly
|
||||
label.set_line_wrap(True)
|
||||
label.set_line_wrap_mode(2)
|
||||
# this affeects how many device entries fit next to each other
|
||||
label.set_width_chars(28)
|
||||
label.set_max_width_chars(28)
|
||||
|
||||
box.add(label)
|
||||
|
||||
box.set_margin_top(18)
|
||||
box.set_margin_bottom(18)
|
||||
box.set_homogeneous(True)
|
||||
box.set_spacing(12)
|
||||
|
||||
# self.set_relief(Gtk.ReliefStyle.NONE)
|
||||
|
||||
self.add(box)
|
||||
|
||||
self.show_all()
|
||||
|
||||
self.connect("toggled", self._on_gtk_toggle)
|
||||
|
||||
def _on_gtk_toggle(self):
|
||||
raise NotImplementedError
|
||||
|
||||
def show_active(self, active):
|
||||
"""Show the active state without triggering anything."""
|
||||
with HandlerDisabled(self, self._on_gtk_toggle):
|
||||
self.set_active(active)
|
||||
|
||||
|
||||
class FlowBoxWrapper:
|
||||
"""A wrapper for a flowbox that contains FlowBoxEntry widgets."""
|
||||
|
||||
def __init__(self, flowbox: Gtk.FlowBox):
|
||||
self._gui = flowbox
|
||||
|
||||
def show_active_entry(self, name: Optional[str]):
|
||||
"""Activate the togglebutton that matches the name."""
|
||||
for child in self._gui.get_children():
|
||||
flow_box_entry: FlowBoxEntry = child.get_children()[0]
|
||||
flow_box_entry.show_active(flow_box_entry.name == name)
|
||||
|
||||
|
||||
class Breadcrumbs:
|
||||
"""Writes a breadcrumbs string into a given label."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message_broker: MessageBroker,
|
||||
label: Gtk.Label,
|
||||
show_device_group: bool = False,
|
||||
show_preset: bool = False,
|
||||
show_mapping: bool = False,
|
||||
):
|
||||
self._message_broker = message_broker
|
||||
self._gui = label
|
||||
self._connect_message_listener()
|
||||
|
||||
self.show_device_group = show_device_group
|
||||
self.show_preset = show_preset
|
||||
self.show_mapping = show_mapping
|
||||
|
||||
self._group_key: str = ""
|
||||
self._preset_name: str = ""
|
||||
self._mapping_name: str = ""
|
||||
|
||||
label.set_max_width_chars(50)
|
||||
label.set_line_wrap(True)
|
||||
label.set_line_wrap_mode(2)
|
||||
|
||||
self._render()
|
||||
|
||||
def _connect_message_listener(self):
|
||||
self._message_broker.subscribe(MessageType.group, self._on_group_changed)
|
||||
self._message_broker.subscribe(MessageType.preset, self._on_preset_changed)
|
||||
self._message_broker.subscribe(MessageType.mapping, self._on_mapping_changed)
|
||||
|
||||
def _on_preset_changed(self, data: PresetData):
|
||||
self._preset_name = data.name or ""
|
||||
self._render()
|
||||
|
||||
def _on_group_changed(self, data: GroupData):
|
||||
self._group_key = data.group_key
|
||||
self._render()
|
||||
|
||||
def _on_mapping_changed(self, mapping_data: MappingData):
|
||||
self._mapping_name = mapping_data.format_name()
|
||||
self._render()
|
||||
|
||||
def _render(self):
|
||||
label = []
|
||||
|
||||
if self.show_device_group:
|
||||
label.append(self._group_key or "?")
|
||||
|
||||
if self.show_preset:
|
||||
label.append(self._preset_name or "?")
|
||||
|
||||
if self.show_mapping:
|
||||
label.append(self._mapping_name or "?")
|
||||
|
||||
self._gui.set_label(" / ".join(label))
|
||||
@ -0,0 +1,115 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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
|
||||
|
||||
from typing import Optional
|
||||
|
||||
from gi.repository import Gtk
|
||||
|
||||
from inputremapper.gui.components.common import FlowBoxEntry, FlowBoxWrapper
|
||||
from inputremapper.gui.components.editor import ICON_PRIORITIES, ICON_NAMES
|
||||
from inputremapper.gui.components.main import Stack
|
||||
from inputremapper.gui.controller import Controller
|
||||
from inputremapper.gui.messages.message_broker import (
|
||||
MessageBroker,
|
||||
MessageType,
|
||||
)
|
||||
from inputremapper.gui.messages.message_data import (
|
||||
GroupsData,
|
||||
GroupData,
|
||||
DoStackSwitch,
|
||||
)
|
||||
from inputremapper.logger import logger
|
||||
|
||||
|
||||
class DeviceGroupEntry(FlowBoxEntry):
|
||||
"""A device that can be selected in the GUI.
|
||||
|
||||
For example a keyboard or a mouse.
|
||||
"""
|
||||
|
||||
__gtype_name__ = "DeviceGroupEntry"
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message_broker: MessageBroker,
|
||||
controller: Controller,
|
||||
icon_name: Optional[str],
|
||||
group_key: str,
|
||||
):
|
||||
super().__init__(
|
||||
message_broker=message_broker,
|
||||
controller=controller,
|
||||
icon_name=icon_name,
|
||||
name=group_key,
|
||||
)
|
||||
self.group_key = group_key
|
||||
|
||||
def _on_gtk_toggle(self, *_, **__):
|
||||
logger.debug('Selecting device "%s"', self.group_key)
|
||||
self._controller.load_group(self.group_key)
|
||||
self.message_broker.publish(DoStackSwitch(Stack.presets_page))
|
||||
|
||||
|
||||
class DeviceGroupSelection(FlowBoxWrapper):
|
||||
"""A wrapper for the container with our groups.
|
||||
|
||||
A group is a collection of devices.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message_broker: MessageBroker,
|
||||
controller: Controller,
|
||||
flowbox: Gtk.FlowBox,
|
||||
):
|
||||
super().__init__(flowbox)
|
||||
|
||||
self._message_broker = message_broker
|
||||
self._controller = controller
|
||||
self._gui = flowbox
|
||||
|
||||
self._message_broker.subscribe(MessageType.groups, self._on_groups_changed)
|
||||
self._message_broker.subscribe(MessageType.group, self._on_group_changed)
|
||||
|
||||
def _on_groups_changed(self, data: GroupsData):
|
||||
self._gui.foreach(self._gui.remove)
|
||||
|
||||
for group_key, types in data.groups.items():
|
||||
if len(types) > 0:
|
||||
device_type = sorted(types, key=ICON_PRIORITIES.index)[0]
|
||||
icon_name = ICON_NAMES[device_type]
|
||||
else:
|
||||
icon_name = None
|
||||
|
||||
logger.debug("adding %s to device selection", group_key)
|
||||
device_group_entry = DeviceGroupEntry(
|
||||
self._message_broker,
|
||||
self._controller,
|
||||
icon_name,
|
||||
group_key,
|
||||
)
|
||||
self._gui.insert(device_group_entry, -1)
|
||||
|
||||
if self._controller.data_manager.active_group:
|
||||
self.show_active_entry(self._controller.data_manager.active_group.key)
|
||||
|
||||
def _on_group_changed(self, data: GroupData):
|
||||
self.show_active_entry(data.group_key)
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,135 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
|
||||
"""Components that wrap everything."""
|
||||
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import gi
|
||||
from gi.repository import Gtk, Pango
|
||||
|
||||
from inputremapper.gui.controller import Controller
|
||||
from inputremapper.gui.messages.message_broker import (
|
||||
MessageBroker,
|
||||
MessageType,
|
||||
)
|
||||
from inputremapper.gui.messages.message_data import StatusData, DoStackSwitch
|
||||
from inputremapper.gui.utils import CTX_ERROR, CTX_MAPPING, CTX_WARNING
|
||||
|
||||
|
||||
class Stack:
|
||||
"""Wraps the Stack, which contains the main menu pages."""
|
||||
|
||||
devices_page = 0
|
||||
presets_page = 1
|
||||
editor_page = 2
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message_broker: MessageBroker,
|
||||
controller: Controller,
|
||||
stack: Gtk.Stack,
|
||||
):
|
||||
self._message_broker = message_broker
|
||||
self._controller = controller
|
||||
self._gui = stack
|
||||
|
||||
self._message_broker.subscribe(
|
||||
MessageType.do_stack_switch, self._do_stack_switch
|
||||
)
|
||||
|
||||
def _do_stack_switch(self, msg: DoStackSwitch):
|
||||
self._gui.set_visible_child(self._gui.get_children()[msg.page_index])
|
||||
|
||||
|
||||
class StatusBar:
|
||||
"""The status bar on the bottom of the main window."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message_broker: MessageBroker,
|
||||
controller: Controller,
|
||||
status_bar: Gtk.Statusbar,
|
||||
error_icon: Gtk.Image,
|
||||
warning_icon: Gtk.Image,
|
||||
):
|
||||
self._message_broker = message_broker
|
||||
self._controller = controller
|
||||
self._gui = status_bar
|
||||
self._error_icon = error_icon
|
||||
self._warning_icon = warning_icon
|
||||
|
||||
label = self._gui.get_message_area().get_children()[0]
|
||||
label.set_ellipsize(Pango.EllipsizeMode.END)
|
||||
label.set_selectable(True)
|
||||
|
||||
self._message_broker.subscribe(MessageType.status_msg, self._on_status_update)
|
||||
|
||||
# keep track if there is an error or warning in the stack of statusbar
|
||||
# unfortunately this is not exposed over the api
|
||||
self._error = False
|
||||
self._warning = False
|
||||
|
||||
def _on_status_update(self, data: StatusData):
|
||||
"""Show a status message and set its tooltip.
|
||||
|
||||
If message is None, it will remove the newest message of the
|
||||
given context_id.
|
||||
"""
|
||||
context_id = data.ctx_id
|
||||
message = data.msg
|
||||
tooltip = data.tooltip
|
||||
status_bar = self._gui
|
||||
|
||||
if message is None:
|
||||
status_bar.remove_all(context_id)
|
||||
|
||||
if context_id in (CTX_ERROR, CTX_MAPPING):
|
||||
self._error_icon.hide()
|
||||
self._error = False
|
||||
if self._warning:
|
||||
self._warning_icon.show()
|
||||
|
||||
if context_id == CTX_WARNING:
|
||||
self._warning_icon.hide()
|
||||
self._warning = False
|
||||
if self._error:
|
||||
self._error_icon.show()
|
||||
|
||||
status_bar.set_tooltip_text("")
|
||||
return
|
||||
|
||||
if tooltip is None:
|
||||
tooltip = message
|
||||
|
||||
self._error_icon.hide()
|
||||
self._warning_icon.hide()
|
||||
|
||||
if context_id in (CTX_ERROR, CTX_MAPPING):
|
||||
self._error_icon.show()
|
||||
self._error = True
|
||||
|
||||
if context_id == CTX_WARNING:
|
||||
self._warning_icon.show()
|
||||
self._warning = True
|
||||
|
||||
status_bar.push(context_id, message)
|
||||
status_bar.set_tooltip_text(tooltip)
|
||||
@ -0,0 +1,106 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
|
||||
"""All components that are visible on the page that shows all the presets."""
|
||||
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from gi.repository import Gtk
|
||||
|
||||
from inputremapper.gui.components.common import FlowBoxEntry, FlowBoxWrapper
|
||||
from inputremapper.gui.components.main import Stack
|
||||
from inputremapper.gui.controller import Controller
|
||||
from inputremapper.gui.messages.message_broker import (
|
||||
MessageBroker,
|
||||
MessageType,
|
||||
)
|
||||
from inputremapper.gui.messages.message_data import (
|
||||
GroupData,
|
||||
PresetData,
|
||||
DoStackSwitch,
|
||||
)
|
||||
from inputremapper.logger import logger
|
||||
|
||||
|
||||
class PresetEntry(FlowBoxEntry):
|
||||
"""A preset that can be selected in the GUI."""
|
||||
|
||||
__gtype_name__ = "PresetEntry"
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message_broker: MessageBroker,
|
||||
controller: Controller,
|
||||
preset_name: str,
|
||||
):
|
||||
super().__init__(
|
||||
message_broker=message_broker, controller=controller, name=preset_name
|
||||
)
|
||||
self.preset_name = preset_name
|
||||
|
||||
def _on_gtk_toggle(self, *_, **__):
|
||||
logger.debug('Selecting preset "%s"', self.preset_name)
|
||||
self._controller.load_preset(self.preset_name)
|
||||
self.message_broker.publish(DoStackSwitch(Stack.editor_page))
|
||||
|
||||
|
||||
class PresetSelection(FlowBoxWrapper):
|
||||
"""A wrapper for the container with our presets.
|
||||
|
||||
Selectes the active_preset.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message_broker: MessageBroker,
|
||||
controller: Controller,
|
||||
flowbox: Gtk.FlowBox,
|
||||
):
|
||||
super().__init__(flowbox)
|
||||
|
||||
self._message_broker = message_broker
|
||||
self._controller = controller
|
||||
self._gui = flowbox
|
||||
self._connect_message_listener()
|
||||
|
||||
def _connect_message_listener(self):
|
||||
self._message_broker.subscribe(MessageType.group, self._on_group_changed)
|
||||
self._message_broker.subscribe(MessageType.preset, self._on_preset_changed)
|
||||
|
||||
def _on_group_changed(self, data: GroupData):
|
||||
self._gui.foreach(self._gui.remove)
|
||||
for preset_name in data.presets:
|
||||
preset_entry = PresetEntry(
|
||||
self._message_broker,
|
||||
self._controller,
|
||||
preset_name,
|
||||
)
|
||||
self._gui.insert(preset_entry, -1)
|
||||
|
||||
def _on_preset_changed(self, data: PresetData):
|
||||
self.show_active_entry(data.name)
|
||||
|
||||
def set_active_preset(self, preset_name: str):
|
||||
"""Change the currently selected preset."""
|
||||
# TODO might only be needed in tests
|
||||
for child in self._gui.get_children():
|
||||
preset_entry: PresetEntry = child.get_children()[0]
|
||||
preset_entry.set_active(preset_entry.preset_name == preset_name)
|
||||
@ -0,0 +1,598 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
import glob
|
||||
import os
|
||||
import re
|
||||
import time
|
||||
from typing import Optional, List, Tuple, Set
|
||||
|
||||
import gi
|
||||
from gi.repository import GLib
|
||||
|
||||
from inputremapper.configs.global_config import GlobalConfig
|
||||
from inputremapper.configs.mapping import UIMapping, MappingData
|
||||
from inputremapper.configs.paths import get_preset_path, mkdir, split_all
|
||||
from inputremapper.configs.preset import Preset
|
||||
from inputremapper.configs.system_mapping import SystemMapping
|
||||
from inputremapper.daemon import DaemonProxy
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper.exceptions import DataManagementError
|
||||
from inputremapper.gui.gettext import _
|
||||
from inputremapper.groups import _Group
|
||||
from inputremapper.gui.messages.message_broker import (
|
||||
MessageBroker,
|
||||
)
|
||||
from inputremapper.gui.messages.message_data import (
|
||||
UInputsData,
|
||||
GroupData,
|
||||
PresetData,
|
||||
CombinationUpdate,
|
||||
)
|
||||
from inputremapper.gui.reader_client import ReaderClient
|
||||
from inputremapper.injection.global_uinputs import GlobalUInputs
|
||||
from inputremapper.injection.injector import (
|
||||
InjectorState,
|
||||
InjectorStateMessage,
|
||||
)
|
||||
from inputremapper.logger import logger
|
||||
|
||||
DEFAULT_PRESET_NAME = _("new preset")
|
||||
|
||||
# useful type aliases
|
||||
Name = str
|
||||
GroupKey = str
|
||||
|
||||
|
||||
class DataManager:
|
||||
"""DataManager provides an interface to create and modify configurations as well
|
||||
as modify the state of the Service.
|
||||
|
||||
Any state changes will be announced via the MessageBroker.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message_broker: MessageBroker,
|
||||
config: GlobalConfig,
|
||||
reader_client: ReaderClient,
|
||||
daemon: DaemonProxy,
|
||||
uinputs: GlobalUInputs,
|
||||
system_mapping: SystemMapping,
|
||||
):
|
||||
self.message_broker = message_broker
|
||||
self._reader_client = reader_client
|
||||
self._daemon = daemon
|
||||
self._uinputs = uinputs
|
||||
self._system_mapping = system_mapping
|
||||
uinputs.prepare_all()
|
||||
|
||||
self._config = config
|
||||
self._config.load_config()
|
||||
|
||||
self._active_preset: Optional[Preset[UIMapping]] = None
|
||||
self._active_mapping: Optional[UIMapping] = None
|
||||
self._active_input_config: Optional[InputConfig] = None
|
||||
|
||||
def publish_group(self):
|
||||
"""Send active group to the MessageBroker.
|
||||
|
||||
This is internally called whenever the group changes.
|
||||
It is usually not necessary to call this explicitly from
|
||||
outside DataManager.
|
||||
"""
|
||||
self.message_broker.publish(
|
||||
GroupData(self.active_group.key, self.get_preset_names())
|
||||
)
|
||||
|
||||
def publish_preset(self):
|
||||
"""Send active preset to the MessageBroker.
|
||||
|
||||
This is internally called whenever the preset changes.
|
||||
It is usually not necessary to call this explicitly from
|
||||
outside DataManager.
|
||||
"""
|
||||
self.message_broker.publish(
|
||||
PresetData(
|
||||
self.active_preset.name, self.get_mappings(), self.get_autoload()
|
||||
)
|
||||
)
|
||||
|
||||
def publish_mapping(self):
|
||||
"""Send active mapping to the MessageBroker
|
||||
|
||||
This is internally called whenever the mapping changes.
|
||||
It is usually not necessary to call this explicitly from
|
||||
outside DataManager.
|
||||
"""
|
||||
if self.active_mapping:
|
||||
self.message_broker.publish(self.active_mapping.get_bus_message())
|
||||
|
||||
def publish_event(self):
|
||||
"""Send active event to the MessageBroker.
|
||||
|
||||
This is internally called whenever the event changes.
|
||||
It is usually not necessary to call this explicitly from
|
||||
outside DataManager
|
||||
"""
|
||||
if self.active_input_config:
|
||||
assert self.active_input_config in self.active_mapping.input_combination
|
||||
self.message_broker.publish(self.active_input_config)
|
||||
|
||||
def publish_uinputs(self):
|
||||
"""Send the "uinputs" message on the MessageBroker."""
|
||||
self.message_broker.publish(
|
||||
UInputsData(
|
||||
{
|
||||
name: uinput.capabilities()
|
||||
for name, uinput in self._uinputs.devices.items()
|
||||
}
|
||||
)
|
||||
)
|
||||
|
||||
def publish_groups(self):
|
||||
"""Publish the "groups" message on the MessageBroker."""
|
||||
self._reader_client.publish_groups()
|
||||
|
||||
def publish_injector_state(self):
|
||||
"""Publish the "injector_state" message for the active_group."""
|
||||
if not self.active_group:
|
||||
return
|
||||
|
||||
self.message_broker.publish(InjectorStateMessage(self.get_state()))
|
||||
|
||||
@property
|
||||
def active_group(self) -> Optional[_Group]:
|
||||
"""The currently loaded group."""
|
||||
return self._reader_client.group
|
||||
|
||||
@property
|
||||
def active_preset(self) -> Optional[Preset[UIMapping]]:
|
||||
"""The currently loaded preset."""
|
||||
return self._active_preset
|
||||
|
||||
@property
|
||||
def active_mapping(self) -> Optional[UIMapping]:
|
||||
"""The currently loaded mapping."""
|
||||
return self._active_mapping
|
||||
|
||||
@property
|
||||
def active_input_config(self) -> Optional[InputConfig]:
|
||||
"""The currently loaded event."""
|
||||
return self._active_input_config
|
||||
|
||||
def get_group_keys(self) -> Tuple[GroupKey, ...]:
|
||||
"""Get all group keys (plugged devices)."""
|
||||
return tuple(group.key for group in self._reader_client.groups.filter())
|
||||
|
||||
def get_preset_names(self) -> Tuple[Name, ...]:
|
||||
"""Get all preset names for active_group and current user sorted by age."""
|
||||
if not self.active_group:
|
||||
raise DataManagementError("Cannot find presets: Group is not set")
|
||||
device_folder = get_preset_path(self.active_group.name)
|
||||
mkdir(device_folder)
|
||||
|
||||
paths = glob.glob(os.path.join(device_folder, "*.json"))
|
||||
presets = [
|
||||
os.path.splitext(os.path.basename(path))[0]
|
||||
for path in sorted(paths, key=os.path.getmtime)
|
||||
]
|
||||
# the highest timestamp to the front
|
||||
presets.reverse()
|
||||
return tuple(presets)
|
||||
|
||||
def get_mappings(self) -> Optional[List[MappingData]]:
|
||||
"""All mappings from the active_preset."""
|
||||
if not self._active_preset:
|
||||
return None
|
||||
|
||||
return [mapping.get_bus_message() for mapping in self._active_preset]
|
||||
|
||||
def get_autoload(self) -> bool:
|
||||
"""The autoload status of the active_preset."""
|
||||
if not self.active_preset or not self.active_group:
|
||||
return False
|
||||
return self._config.is_autoloaded(
|
||||
self.active_group.key, self.active_preset.name
|
||||
)
|
||||
|
||||
def set_autoload(self, status: bool):
|
||||
"""Set the autoload status of the active_preset.
|
||||
|
||||
Will send "preset" message on the MessageBroker.
|
||||
"""
|
||||
if not self.active_preset or not self.active_group:
|
||||
raise DataManagementError("Cannot set autoload status: Preset is not set")
|
||||
|
||||
if status:
|
||||
self._config.set_autoload_preset(
|
||||
self.active_group.key, self.active_preset.name
|
||||
)
|
||||
elif self.get_autoload():
|
||||
self._config.set_autoload_preset(self.active_group.key, None)
|
||||
|
||||
self.publish_preset()
|
||||
|
||||
def get_newest_group_key(self) -> GroupKey:
|
||||
"""group_key of the group with the most recently modified preset."""
|
||||
paths = []
|
||||
for path in glob.glob(os.path.join(get_preset_path(), "*/*.json")):
|
||||
if self._reader_client.groups.find(key=split_all(path)[-2]):
|
||||
paths.append((path, os.path.getmtime(path)))
|
||||
|
||||
if not paths:
|
||||
raise FileNotFoundError()
|
||||
|
||||
path, _ = max(paths, key=lambda x: x[1])
|
||||
return split_all(path)[-2]
|
||||
|
||||
def get_newest_preset_name(self) -> Name:
|
||||
"""Preset name of the most recently modified preset in the active group."""
|
||||
if not self.active_group:
|
||||
raise DataManagementError("Cannot find newest preset: Group is not set")
|
||||
|
||||
paths = [
|
||||
(path, os.path.getmtime(path))
|
||||
for path in glob.glob(
|
||||
os.path.join(get_preset_path(self.active_group.name), "*.json")
|
||||
)
|
||||
]
|
||||
if not paths:
|
||||
raise FileNotFoundError()
|
||||
|
||||
path, _ = max(paths, key=lambda x: x[1])
|
||||
return os.path.split(path)[-1].split(".")[0]
|
||||
|
||||
def get_available_preset_name(self, name=DEFAULT_PRESET_NAME) -> Name:
|
||||
"""The first available preset in the active group."""
|
||||
if not self.active_group:
|
||||
raise DataManagementError("Unable find preset name. Group is not set")
|
||||
|
||||
name = name.strip()
|
||||
|
||||
# find a name that is not already taken
|
||||
if os.path.exists(get_preset_path(self.active_group.name, name)):
|
||||
# if there already is a trailing number, increment it instead of
|
||||
# adding another one
|
||||
match = re.match(r"^(.+) (\d+)$", name)
|
||||
if match:
|
||||
name = match[1]
|
||||
i = int(match[2]) + 1
|
||||
else:
|
||||
i = 2
|
||||
|
||||
while os.path.exists(
|
||||
get_preset_path(self.active_group.name, f"{name} {i}")
|
||||
):
|
||||
i += 1
|
||||
|
||||
return f"{name} {i}"
|
||||
|
||||
return name
|
||||
|
||||
def load_group(self, group_key: str):
|
||||
"""Load a group. will publish "groups" and "injector_state" messages.
|
||||
|
||||
This will render the active_mapping and active_preset invalid.
|
||||
"""
|
||||
if group_key not in self.get_group_keys():
|
||||
raise DataManagementError("Unable to load non existing group")
|
||||
|
||||
logger.info('Loading group "%s"', group_key)
|
||||
|
||||
self._active_input_config = None
|
||||
self._active_mapping = None
|
||||
self._active_preset = None
|
||||
group = self._reader_client.groups.find(key=group_key)
|
||||
self._reader_client.set_group(group)
|
||||
self.publish_group()
|
||||
self.publish_injector_state()
|
||||
|
||||
def load_preset(self, name: str):
|
||||
"""Load a preset. Will send "preset" message on the MessageBroker.
|
||||
|
||||
This will render the active_mapping invalid.
|
||||
"""
|
||||
if not self.active_group:
|
||||
raise DataManagementError("Unable to load preset. Group is not set")
|
||||
|
||||
logger.info('Loading preset "%s"', name)
|
||||
|
||||
preset_path = get_preset_path(self.active_group.name, name)
|
||||
preset = Preset(preset_path, mapping_factory=UIMapping)
|
||||
preset.load()
|
||||
self._active_input_config = None
|
||||
self._active_mapping = None
|
||||
self._active_preset = preset
|
||||
self.publish_preset()
|
||||
|
||||
def load_mapping(self, combination: InputCombination):
|
||||
"""Load a mapping. Will send "mapping" message on the MessageBroker."""
|
||||
if not self._active_preset:
|
||||
raise DataManagementError("Unable to load mapping. Preset is not set")
|
||||
|
||||
mapping = self._active_preset.get_mapping(combination)
|
||||
if not mapping:
|
||||
raise KeyError(
|
||||
f"the mapping with {combination = } does not "
|
||||
f"exist in the {self._active_preset.path}"
|
||||
)
|
||||
self._active_input_config = None
|
||||
self._active_mapping = mapping
|
||||
self.publish_mapping()
|
||||
|
||||
def load_input_config(self, input_config: InputConfig):
|
||||
"""Load a InputConfig from the combination in the active mapping.
|
||||
|
||||
Will send "event" message on the MessageBroker,
|
||||
"""
|
||||
if not self.active_mapping:
|
||||
raise DataManagementError("Unable to load event. Mapping is not set")
|
||||
if input_config not in self.active_mapping.input_combination:
|
||||
raise ValueError(
|
||||
f"{input_config} is not member of active_mapping.input_combination: "
|
||||
f"{self.active_mapping.input_combination}"
|
||||
)
|
||||
self._active_input_config = input_config
|
||||
self.publish_event()
|
||||
|
||||
def rename_preset(self, new_name: str):
|
||||
"""Rename the current preset and move the correct file.
|
||||
|
||||
Will send "group" and then "preset" message on the MessageBroker
|
||||
"""
|
||||
if not self.active_preset or not self.active_group:
|
||||
raise DataManagementError("Unable rename preset: Preset is not set")
|
||||
|
||||
if self.active_preset.path == get_preset_path(self.active_group.name, new_name):
|
||||
return
|
||||
|
||||
old_path = self.active_preset.path
|
||||
assert old_path is not None
|
||||
old_name = os.path.basename(old_path).split(".")[0]
|
||||
new_path = get_preset_path(self.active_group.name, new_name)
|
||||
if os.path.exists(new_path):
|
||||
raise ValueError(
|
||||
f"cannot rename {old_name} to " f"{new_name}, preset already exists"
|
||||
)
|
||||
|
||||
logger.info('Moving "%s" to "%s"', old_path, new_path)
|
||||
os.rename(old_path, new_path)
|
||||
now = time.time()
|
||||
os.utime(new_path, (now, now))
|
||||
|
||||
if self._config.is_autoloaded(self.active_group.key, old_name):
|
||||
self._config.set_autoload_preset(self.active_group.key, new_name)
|
||||
|
||||
self.active_preset.path = get_preset_path(self.active_group.name, new_name)
|
||||
self.publish_group()
|
||||
self.publish_preset()
|
||||
|
||||
def copy_preset(self, name: str):
|
||||
"""Copy the current preset to the given name.
|
||||
|
||||
Will send "group" and "preset" message to the MessageBroker and load the copy
|
||||
"""
|
||||
# todo: Do we want to load the copy here? or is this up to the controller?
|
||||
if not self.active_preset or not self.active_group:
|
||||
raise DataManagementError("Unable to copy preset: Preset is not set")
|
||||
|
||||
if self.active_preset.path == get_preset_path(self.active_group.name, name):
|
||||
return
|
||||
|
||||
if name in self.get_preset_names():
|
||||
raise ValueError(f"a preset with the name {name} already exits")
|
||||
|
||||
new_path = get_preset_path(self.active_group.name, name)
|
||||
logger.info('Copy "%s" to "%s"', self.active_preset.path, new_path)
|
||||
self.active_preset.path = new_path
|
||||
self.save()
|
||||
self.publish_group()
|
||||
self.publish_preset()
|
||||
|
||||
def create_preset(self, name: str):
|
||||
"""Create empty preset in the active_group.
|
||||
|
||||
Will send "group" message to the MessageBroker
|
||||
"""
|
||||
if not self.active_group:
|
||||
raise DataManagementError("Unable to add preset. Group is not set")
|
||||
|
||||
path = get_preset_path(self.active_group.name, name)
|
||||
if os.path.exists(path):
|
||||
raise DataManagementError("Unable to add preset. Preset exists")
|
||||
|
||||
Preset(path).save()
|
||||
self.publish_group()
|
||||
|
||||
def delete_preset(self):
|
||||
"""Delete the active preset.
|
||||
|
||||
Will send "group" message to the MessageBroker
|
||||
this will invalidate the active mapping,
|
||||
"""
|
||||
preset_path = self._active_preset.path
|
||||
logger.info('Removing "%s"', preset_path)
|
||||
os.remove(preset_path)
|
||||
self._active_mapping = None
|
||||
self._active_preset = None
|
||||
self.publish_group()
|
||||
|
||||
def update_mapping(self, **kwargs):
|
||||
"""Update the active mapping with the given keywords and values.
|
||||
|
||||
Will send "mapping" message to the MessageBroker. In case of a new
|
||||
input_combination. This will first send a "combination_update" message.
|
||||
"""
|
||||
if not self._active_mapping:
|
||||
raise DataManagementError("Cannot modify Mapping: Mapping is not set")
|
||||
|
||||
if symbol := kwargs.get("output_symbol"):
|
||||
kwargs["output_symbol"] = self._system_mapping.correct_case(symbol)
|
||||
|
||||
combination = self.active_mapping.input_combination
|
||||
for key, value in kwargs.items():
|
||||
setattr(self._active_mapping, key, value)
|
||||
|
||||
if (
|
||||
"input_combination" in kwargs
|
||||
and combination != self.active_mapping.input_combination
|
||||
):
|
||||
self._active_input_config = None
|
||||
self.message_broker.publish(
|
||||
CombinationUpdate(combination, self._active_mapping.input_combination)
|
||||
)
|
||||
|
||||
if "mapping_type" in kwargs:
|
||||
# mapping_type must be the last update because it is automatically updated
|
||||
# by a validation function
|
||||
self._active_mapping.mapping_type = kwargs["mapping_type"]
|
||||
|
||||
self.publish_mapping()
|
||||
|
||||
def update_input_config(self, new_input_config: InputConfig):
|
||||
"""Update the active input configuration.
|
||||
|
||||
Will send "combination_update", "mapping" and "event" messages to the
|
||||
MessageBroker (in that order)
|
||||
"""
|
||||
if not self.active_mapping or not self.active_input_config:
|
||||
raise DataManagementError("Cannot modify event: Event is not set")
|
||||
|
||||
combination = list(self.active_mapping.input_combination)
|
||||
combination[combination.index(self.active_input_config)] = new_input_config
|
||||
self.update_mapping(input_combination=InputCombination(combination))
|
||||
self._active_input_config = new_input_config
|
||||
self.publish_event()
|
||||
|
||||
def create_mapping(self):
|
||||
"""Create empty mapping in the active preset.
|
||||
|
||||
Will send "preset" message to the MessageBroker
|
||||
"""
|
||||
if not self._active_preset:
|
||||
raise DataManagementError("Cannot create mapping: Preset is not set")
|
||||
self._active_preset.add(UIMapping())
|
||||
self.publish_preset()
|
||||
|
||||
def delete_mapping(self):
|
||||
"""Delete the active mapping.
|
||||
|
||||
Will send "preset" message to the MessageBroker
|
||||
"""
|
||||
if not self._active_mapping:
|
||||
raise DataManagementError(
|
||||
"cannot delete active mapping: active mapping is not set"
|
||||
)
|
||||
|
||||
self._active_preset.remove(self._active_mapping.input_combination)
|
||||
self._active_mapping = None
|
||||
self.publish_preset()
|
||||
|
||||
def save(self):
|
||||
"""Save the active preset."""
|
||||
if self._active_preset:
|
||||
self._active_preset.save()
|
||||
|
||||
def refresh_groups(self):
|
||||
"""Refresh the groups (plugged devices).
|
||||
|
||||
Should send "groups" message to MessageBroker this will not happen immediately
|
||||
because the system might take a bit until the groups are available
|
||||
"""
|
||||
self._reader_client.refresh_groups()
|
||||
|
||||
def start_combination_recording(self):
|
||||
"""Record user input.
|
||||
|
||||
Will send "combination_recorded" messages as new input arrives.
|
||||
Will eventually send a "recording_finished" message.
|
||||
"""
|
||||
self._reader_client.start_recorder()
|
||||
|
||||
def stop_combination_recording(self):
|
||||
"""Stop recording user input.
|
||||
|
||||
Will send a recording_finished signal if a recording is running.
|
||||
"""
|
||||
self._reader_client.stop_recorder()
|
||||
|
||||
def stop_injecting(self) -> None:
|
||||
"""Stop injecting for the active group.
|
||||
|
||||
Will send "injector_state" message once the injector has stopped."""
|
||||
if not self.active_group:
|
||||
raise DataManagementError("Cannot stop injection: Group is not set")
|
||||
self._daemon.stop_injecting(self.active_group.key)
|
||||
self.do_when_injector_state(
|
||||
{InjectorState.STOPPED}, self.publish_injector_state
|
||||
)
|
||||
|
||||
def start_injecting(self) -> bool:
|
||||
"""Start injecting the active preset for the active group.
|
||||
|
||||
returns if the startup was successfully initialized.
|
||||
Will send "injector_state" message once the startup is complete.
|
||||
"""
|
||||
if not self.active_preset or not self.active_group:
|
||||
raise DataManagementError("Cannot start injection: Preset is not set")
|
||||
|
||||
self._daemon.set_config_dir(self._config.get_dir())
|
||||
assert self.active_preset.name is not None
|
||||
if self._daemon.start_injecting(self.active_group.key, self.active_preset.name):
|
||||
self.do_when_injector_state(
|
||||
{
|
||||
InjectorState.RUNNING,
|
||||
InjectorState.FAILED,
|
||||
InjectorState.NO_GRAB,
|
||||
InjectorState.UPGRADE_EVDEV,
|
||||
},
|
||||
self.publish_injector_state,
|
||||
)
|
||||
return True
|
||||
return False
|
||||
|
||||
def get_state(self) -> InjectorState:
|
||||
"""The state of the injector."""
|
||||
if not self.active_group:
|
||||
raise DataManagementError("Cannot read state: Group is not set")
|
||||
return self._daemon.get_state(self.active_group.key)
|
||||
|
||||
def refresh_service_config_path(self):
|
||||
"""Tell the service to refresh its config path."""
|
||||
self._daemon.set_config_dir(self._config.get_dir())
|
||||
|
||||
def do_when_injector_state(self, states: Set[InjectorState], callback):
|
||||
"""Run callback once the injector state is one of states."""
|
||||
start = time.time()
|
||||
|
||||
def do():
|
||||
if time.time() - start > 3:
|
||||
# something went wrong, there should have been a state long ago.
|
||||
# the timeout prevents tons of GLib.timeouts to run forever, especially
|
||||
# after spamming the "Stop" button.
|
||||
logger.error("Timed out while waiting for injector state %s", states)
|
||||
return False
|
||||
|
||||
if self.get_state() in states:
|
||||
callback()
|
||||
return False
|
||||
return True
|
||||
|
||||
GLib.timeout_add(100, do)
|
||||
@ -1,692 +0,0 @@
|
||||
# -*- 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/>.
|
||||
|
||||
|
||||
"""The editor with multiline code input, recording toggle and autocompletion."""
|
||||
|
||||
|
||||
import re
|
||||
import time
|
||||
|
||||
from gi.repository import Gtk, GLib, Gdk
|
||||
|
||||
from inputremapper.gui.gettext import _
|
||||
from inputremapper.gui.editor.autocompletion import Autocompletion
|
||||
from inputremapper.configs.system_mapping import system_mapping
|
||||
from inputremapper.gui.active_preset import active_preset
|
||||
from inputremapper.event_combination import EventCombination
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.gui.reader import reader
|
||||
from inputremapper.gui.utils import CTX_KEYCODE, CTX_WARNING, CTX_ERROR
|
||||
from inputremapper.injection.global_uinputs import global_uinputs
|
||||
|
||||
|
||||
class SelectionLabel(Gtk.ListBoxRow):
|
||||
"""One label per mapping in the preset.
|
||||
|
||||
This wrapper serves as a storage for the information the inherited label represents.
|
||||
"""
|
||||
|
||||
__gtype_name__ = "SelectionLabel"
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.combination = None
|
||||
self.symbol = ""
|
||||
|
||||
label = Gtk.Label()
|
||||
|
||||
# Make the child label widget break lines, important for
|
||||
# long combinations
|
||||
label.set_line_wrap(True)
|
||||
label.set_line_wrap_mode(2)
|
||||
label.set_justify(Gtk.Justification.CENTER)
|
||||
|
||||
self.label = label
|
||||
self.add(label)
|
||||
|
||||
self.show_all()
|
||||
|
||||
def set_combination(self, combination: EventCombination):
|
||||
"""Set the combination this button represents
|
||||
|
||||
Parameters
|
||||
----------
|
||||
combination : EventCombination
|
||||
"""
|
||||
self.combination = combination
|
||||
if combination:
|
||||
self.label.set_label(combination.beautify())
|
||||
else:
|
||||
self.label.set_label(_("new entry"))
|
||||
|
||||
def get_combination(self) -> EventCombination:
|
||||
return self.combination
|
||||
|
||||
def set_label(self, label):
|
||||
return self.label.set_label(label)
|
||||
|
||||
def get_label(self):
|
||||
return self.label.get_label()
|
||||
|
||||
def __str__(self):
|
||||
return f"SelectionLabel({str(self.combination)})"
|
||||
|
||||
def __repr__(self):
|
||||
return self.__str__()
|
||||
|
||||
|
||||
def ensure_everything_saved(func):
|
||||
"""Make sure the editor has written its changes to active_preset and save."""
|
||||
|
||||
def wrapped(self, *args, **kwargs):
|
||||
if self.user_interface.preset_name:
|
||||
self.gather_changes_and_save()
|
||||
|
||||
return func(self, *args, **kwargs)
|
||||
|
||||
return wrapped
|
||||
|
||||
|
||||
SET_KEY_FIRST = _("Set the key first")
|
||||
|
||||
RECORD_ALL = float("inf")
|
||||
RECORD_NONE = 0
|
||||
|
||||
|
||||
class Editor:
|
||||
"""Maintains the widgets of the editor."""
|
||||
|
||||
def __init__(self, user_interface):
|
||||
self.user_interface = user_interface
|
||||
|
||||
self.autocompletion = None
|
||||
|
||||
self._setup_target_selector()
|
||||
self._setup_source_view()
|
||||
self._setup_recording_toggle()
|
||||
|
||||
self.window = self.get("window")
|
||||
self.timeouts = [
|
||||
GLib.timeout_add(100, self.check_add_new_key),
|
||||
GLib.timeout_add(1000, self.update_toggle_opacity),
|
||||
]
|
||||
self.active_selection_label: SelectionLabel = None
|
||||
|
||||
selection_label_listbox = self.get("selection_label_listbox")
|
||||
selection_label_listbox.connect("row-selected", self.on_mapping_selected)
|
||||
|
||||
self.device = user_interface.group
|
||||
|
||||
# keys were not pressed yet
|
||||
self._input_has_arrived = False
|
||||
|
||||
self.record_events_until = RECORD_NONE
|
||||
|
||||
text_input = self.get_text_input()
|
||||
text_input.connect("focus-out-event", self.on_text_input_unfocus)
|
||||
|
||||
delete_button = self.get_delete_button()
|
||||
delete_button.connect("clicked", self._on_delete_button_clicked)
|
||||
|
||||
target_selector = self.get_target_selector()
|
||||
target_selector.connect("changed", self._on_target_input_changed)
|
||||
|
||||
def __del__(self):
|
||||
for timeout in self.timeouts:
|
||||
GLib.source_remove(timeout)
|
||||
self.timeouts = []
|
||||
|
||||
def _on_toggle_clicked(self, toggle, event=None):
|
||||
if toggle.get_active():
|
||||
self._show_press_key()
|
||||
else:
|
||||
self._show_change_key()
|
||||
|
||||
@ensure_everything_saved
|
||||
def _on_toggle_unfocus(self, toggle, event=None):
|
||||
toggle.set_active(False)
|
||||
|
||||
@ensure_everything_saved
|
||||
def on_text_input_unfocus(self, *_):
|
||||
"""When unfocusing the text it saves.
|
||||
|
||||
Input Remapper doesn't save the editor on change, because that would cause
|
||||
an incredible amount of logs for every single input. The custom_mapping would
|
||||
need to be changed, which causes two logs, then it has to be saved
|
||||
to disk which is another two log messages. So every time a single character
|
||||
is typed it writes 4 lines.
|
||||
|
||||
Instead, it will save the preset when it is really needed, i.e. when a button
|
||||
that requires a saved preset is pressed. For this there exists the
|
||||
@ensure_everything_saved decorator.
|
||||
|
||||
To avoid maybe forgetting to add this decorator somewhere, it will also save
|
||||
when unfocusing the text input.
|
||||
|
||||
If the scroll wheel is used to interact with gtk widgets it won't unfocus,
|
||||
so this focus-out handler is not the solution to everything as well.
|
||||
|
||||
One could debounce saving on text-change to avoid those logs, but that just
|
||||
sounds like a huge source of race conditions and is also hard to test.
|
||||
"""
|
||||
pass # the decorator will be triggered
|
||||
|
||||
@ensure_everything_saved
|
||||
def _on_target_input_changed(self, *_):
|
||||
"""save when target changed"""
|
||||
pass
|
||||
|
||||
def clear(self):
|
||||
"""Clear all inputs, labels, etc. Reset the state.
|
||||
|
||||
This is really important to do before loading a different preset.
|
||||
Otherwise the inputs will be read and then saved into the next preset.
|
||||
"""
|
||||
if self.active_selection_label:
|
||||
self.set_combination(None)
|
||||
|
||||
self.disable_symbol_input(clear=True)
|
||||
self.set_target_selection("keyboard") # sane default
|
||||
self.disable_target_selector()
|
||||
self._reset_keycode_consumption()
|
||||
|
||||
self.clear_mapping_list()
|
||||
|
||||
def clear_mapping_list(self):
|
||||
"""Clear the labels from the mapping selection and add an empty one."""
|
||||
selection_label_listbox = self.get("selection_label_listbox")
|
||||
selection_label_listbox.forall(selection_label_listbox.remove)
|
||||
self.add_empty()
|
||||
selection_label_listbox.select_row(selection_label_listbox.get_children()[0])
|
||||
|
||||
def _setup_target_selector(self):
|
||||
"""Prepare the target selector combobox"""
|
||||
target_store = Gtk.ListStore(str)
|
||||
for uinput in global_uinputs.devices:
|
||||
target_store.append([uinput])
|
||||
|
||||
target_input = self.get_target_selector()
|
||||
target_input.set_model(target_store)
|
||||
renderer_text = Gtk.CellRendererText()
|
||||
target_input.pack_start(renderer_text, False)
|
||||
target_input.add_attribute(renderer_text, "text", 0)
|
||||
target_input.set_id_column(0)
|
||||
|
||||
def _setup_recording_toggle(self):
|
||||
"""Prepare the toggle button for recording key inputs."""
|
||||
toggle = self.get_recording_toggle()
|
||||
toggle.connect("focus-out-event", self._show_change_key)
|
||||
toggle.connect("focus-in-event", self._show_press_key)
|
||||
toggle.connect("clicked", self._on_toggle_clicked)
|
||||
toggle.connect("focus-out-event", self._reset_keycode_consumption)
|
||||
toggle.connect("focus-out-event", self._on_toggle_unfocus)
|
||||
toggle.connect("toggled", self._on_recording_toggle_toggle)
|
||||
# Don't leave the input when using arrow keys or tab. wait for the
|
||||
# window to consume the keycode from the reader. I.e. a tab input should
|
||||
# be recorded, instead of causing the recording to stop.
|
||||
toggle.connect("key-press-event", lambda *args: Gdk.EVENT_STOP)
|
||||
|
||||
def _show_press_key(self, *args):
|
||||
"""Show user friendly instructions."""
|
||||
self.get_recording_toggle().set_label(_("Press Key"))
|
||||
|
||||
def _show_change_key(self, *args):
|
||||
"""Show user friendly instructions."""
|
||||
self.get_recording_toggle().set_label(_("Change Key"))
|
||||
|
||||
def _setup_source_view(self):
|
||||
"""Prepare the code editor."""
|
||||
source_view = self.get("code_editor")
|
||||
|
||||
# without this the wrapping ScrolledWindow acts weird when new lines are added,
|
||||
# not offering enough space to the text editor so the whole thing is suddenly
|
||||
# scrollable by a few pixels.
|
||||
# Found this after making blind guesses with settings in glade, and then
|
||||
# actually looking at the snaphot preview! In glades editor this didn have an
|
||||
# effect.
|
||||
source_view.set_resize_mode(Gtk.ResizeMode.IMMEDIATE)
|
||||
|
||||
source_view.get_buffer().connect("changed", self.show_line_numbers_if_multiline)
|
||||
|
||||
# Syntax Highlighting
|
||||
# Thanks to https://github.com/wolfthefallen/py-GtkSourceCompletion-example
|
||||
# language_manager = GtkSource.LanguageManager()
|
||||
# fun fact: without saving LanguageManager into its own variable it doesn't work
|
||||
# python = language_manager.get_language("python")
|
||||
# source_view.get_buffer().set_language(python)
|
||||
# TODO there are some similarities with python, but overall it's quite useless.
|
||||
# commented out until there is proper highlighting for input-remappers syntax.
|
||||
|
||||
autocompletion = Autocompletion(source_view, self.get_target_selector())
|
||||
autocompletion.set_relative_to(self.get("code_editor_container"))
|
||||
autocompletion.connect("suggestion-inserted", self.gather_changes_and_save)
|
||||
self.autocompletion = autocompletion
|
||||
|
||||
def show_line_numbers_if_multiline(self, *_):
|
||||
"""Show line numbers if a macro is being edited."""
|
||||
code_editor = self.get("code_editor")
|
||||
symbol = self.get_symbol_input_text() or ""
|
||||
|
||||
if "\n" in symbol:
|
||||
code_editor.set_show_line_numbers(True)
|
||||
code_editor.set_monospace(True)
|
||||
code_editor.get_style_context().add_class("multiline")
|
||||
else:
|
||||
code_editor.set_show_line_numbers(False)
|
||||
code_editor.set_monospace(False)
|
||||
code_editor.get_style_context().remove_class("multiline")
|
||||
|
||||
def get_delete_button(self):
|
||||
return self.get("delete-mapping")
|
||||
|
||||
def check_add_new_key(self):
|
||||
"""If needed, add a new empty mapping to the list for the user to configure."""
|
||||
selection_label_listbox = self.get("selection_label_listbox")
|
||||
|
||||
selection_label_listbox = selection_label_listbox.get_children()
|
||||
|
||||
for selection_label in selection_label_listbox:
|
||||
if selection_label.get_combination() is None:
|
||||
# unfinished row found
|
||||
break
|
||||
else:
|
||||
self.add_empty()
|
||||
|
||||
return True
|
||||
|
||||
def disable_symbol_input(self, clear=False):
|
||||
"""Display help information and dont allow entering a symbol.
|
||||
|
||||
Without this, maybe a user enters a symbol or writes a macro, switches
|
||||
presets accidentally before configuring the key and then it's gone. It can
|
||||
only be saved to the preset if a key is configured. This avoids that pitfall.
|
||||
"""
|
||||
logger.debug("Disabling the text input")
|
||||
text_input = self.get_text_input()
|
||||
|
||||
# beware that this also appeared to disable event listeners like
|
||||
# focus-out-event:
|
||||
text_input.set_sensitive(False)
|
||||
|
||||
text_input.set_opacity(0.5)
|
||||
|
||||
if clear or self.get_symbol_input_text() == "":
|
||||
# don't overwrite user input
|
||||
self.set_symbol_input_text(SET_KEY_FIRST)
|
||||
|
||||
def enable_symbol_input(self):
|
||||
"""Don't display help information anymore and allow changing the symbol."""
|
||||
logger.debug("Enabling the text input")
|
||||
text_input = self.get_text_input()
|
||||
text_input.set_sensitive(True)
|
||||
text_input.set_opacity(1)
|
||||
|
||||
buffer = text_input.get_buffer()
|
||||
symbol = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(), True)
|
||||
if symbol == SET_KEY_FIRST:
|
||||
# don't overwrite user input
|
||||
self.set_symbol_input_text("")
|
||||
|
||||
def disable_target_selector(self):
|
||||
"""don't allow any selection"""
|
||||
selector = self.get_target_selector()
|
||||
selector.set_sensitive(False)
|
||||
selector.set_opacity(0.5)
|
||||
|
||||
def enable_target_selector(self):
|
||||
selector = self.get_target_selector()
|
||||
selector.set_sensitive(True)
|
||||
selector.set_opacity(1)
|
||||
|
||||
@ensure_everything_saved
|
||||
def on_mapping_selected(self, _=None, selection_label=None):
|
||||
"""One of the buttons in the left "combination" column was clicked.
|
||||
|
||||
Load the information from that mapping entry into the editor.
|
||||
"""
|
||||
self.active_selection_label = selection_label
|
||||
|
||||
if selection_label is None:
|
||||
return
|
||||
|
||||
combination = selection_label.combination
|
||||
self.set_combination(combination)
|
||||
|
||||
if combination is None:
|
||||
self.disable_symbol_input(clear=True)
|
||||
# default target should fit in most cases
|
||||
self.set_target_selection("keyboard")
|
||||
# symbol input disabled until a combination is configured
|
||||
self.disable_target_selector()
|
||||
# symbol input disabled until a combination is configured
|
||||
else:
|
||||
if active_preset.get_mapping(combination):
|
||||
self.set_symbol_input_text(active_preset.get_mapping(combination)[0])
|
||||
self.set_target_selection(active_preset.get_mapping(combination)[1])
|
||||
|
||||
self.enable_symbol_input()
|
||||
self.enable_target_selector()
|
||||
|
||||
self.get("window").set_focus(self.get_text_input())
|
||||
|
||||
def add_empty(self):
|
||||
"""Add one empty row for a single mapped key."""
|
||||
selection_label_listbox = self.get("selection_label_listbox")
|
||||
mapping_selection = SelectionLabel()
|
||||
mapping_selection.set_label(_("new entry"))
|
||||
mapping_selection.show_all()
|
||||
selection_label_listbox.insert(mapping_selection, -1)
|
||||
|
||||
@ensure_everything_saved
|
||||
def load_custom_mapping(self):
|
||||
"""Display the entries in active_preset."""
|
||||
selection_label_listbox = self.get("selection_label_listbox")
|
||||
|
||||
selection_label_listbox.forall(selection_label_listbox.remove)
|
||||
|
||||
for key, _ in active_preset:
|
||||
selection_label = SelectionLabel()
|
||||
selection_label.set_combination(key)
|
||||
selection_label_listbox.insert(selection_label, -1)
|
||||
|
||||
self.check_add_new_key()
|
||||
|
||||
# select the first entry
|
||||
selection_labels = selection_label_listbox.get_children()
|
||||
|
||||
if len(selection_labels) == 0:
|
||||
self.add_empty()
|
||||
selection_labels = selection_label_listbox.get_children()
|
||||
|
||||
selection_label_listbox.select_row(selection_labels[0])
|
||||
|
||||
def get_recording_toggle(self) -> Gtk.ToggleButton:
|
||||
return self.get("key_recording_toggle")
|
||||
|
||||
def get_text_input(self):
|
||||
return self.get("code_editor")
|
||||
|
||||
def get_target_selector(self):
|
||||
return self.get("target-selector")
|
||||
|
||||
def set_combination(self, combination):
|
||||
"""Show what the user is currently pressing in the user interface."""
|
||||
self.active_selection_label.set_combination(combination)
|
||||
|
||||
if combination and len(combination) > 0:
|
||||
self.enable_symbol_input()
|
||||
else:
|
||||
self.disable_symbol_input()
|
||||
|
||||
def get_combination(self):
|
||||
"""Get the EventCombination object from the left column.
|
||||
|
||||
Or None if no code is mapped on this row.
|
||||
"""
|
||||
if self.active_selection_label is None:
|
||||
return None
|
||||
|
||||
return self.active_selection_label.combination
|
||||
|
||||
def set_symbol_input_text(self, symbol):
|
||||
self.get("code_editor").get_buffer().set_text(symbol or "")
|
||||
# move cursor location to the beginning, like any code editor does
|
||||
Gtk.TextView.do_move_cursor(
|
||||
self.get("code_editor"),
|
||||
Gtk.MovementStep.BUFFER_ENDS,
|
||||
-1,
|
||||
False,
|
||||
)
|
||||
|
||||
def get_symbol_input_text(self):
|
||||
"""Get the assigned symbol from the text input.
|
||||
|
||||
This might not be stored in active_preset yet, and might therefore also not
|
||||
be part of the preset json file yet.
|
||||
|
||||
If there is no symbol, this returns None. This is important for some other
|
||||
logic down the road in active_preset or something.
|
||||
"""
|
||||
buffer = self.get("code_editor").get_buffer()
|
||||
symbol = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(), True)
|
||||
|
||||
if symbol == SET_KEY_FIRST:
|
||||
# not configured yet
|
||||
return ""
|
||||
|
||||
return symbol.strip()
|
||||
|
||||
def set_target_selection(self, target):
|
||||
selector = self.get_target_selector()
|
||||
selector.set_active_id(target)
|
||||
|
||||
def get_target_selection(self):
|
||||
return self.get_target_selector().get_active_id()
|
||||
|
||||
def get(self, name):
|
||||
"""Get a widget from the window"""
|
||||
return self.user_interface.builder.get_object(name)
|
||||
|
||||
def update_toggle_opacity(self):
|
||||
"""If the key can't be mapped, grey it out.
|
||||
|
||||
During injection, when the device is grabbed and weird things are being
|
||||
done, it is not possible.
|
||||
"""
|
||||
toggle = self.get_recording_toggle()
|
||||
if not self.user_interface.can_modify_preset():
|
||||
toggle.set_opacity(0.4)
|
||||
else:
|
||||
toggle.set_opacity(1)
|
||||
|
||||
return True
|
||||
|
||||
def _on_recording_toggle_toggle(self, toggle):
|
||||
"""Refresh useful usage information."""
|
||||
if not toggle.get_active():
|
||||
# if more events arrive from the time when the toggle was still on,
|
||||
# use them.
|
||||
self.record_events_until = time.time()
|
||||
return
|
||||
|
||||
self.record_events_until = RECORD_ALL
|
||||
|
||||
self._reset_keycode_consumption()
|
||||
reader.clear()
|
||||
if not self.user_interface.can_modify_preset():
|
||||
# because the device is in grab mode by the daemon and
|
||||
# therefore the original keycode inaccessible
|
||||
logger.info("Cannot change keycodes while injecting")
|
||||
self.user_interface.show_status(
|
||||
CTX_ERROR, _('Use "Stop Injection" to stop before editing')
|
||||
)
|
||||
toggle.set_active(False)
|
||||
|
||||
def _on_delete_button_clicked(self, *_):
|
||||
"""Destroy the row and remove it from the config."""
|
||||
accept = Gtk.ResponseType.ACCEPT
|
||||
if (
|
||||
len(self.get_symbol_input_text()) > 0
|
||||
and self._show_confirm_delete() != accept
|
||||
):
|
||||
return
|
||||
|
||||
key = self.get_combination()
|
||||
if key is not None:
|
||||
active_preset.clear(key)
|
||||
|
||||
# make sure there is no outdated information lying around in memory
|
||||
self.set_combination(None)
|
||||
|
||||
self.load_custom_mapping()
|
||||
|
||||
def _show_confirm_delete(self):
|
||||
"""Blocks until the user decided about an action."""
|
||||
confirm_delete = self.get("confirm-delete")
|
||||
|
||||
text = _("Are you sure to delete this mapping?")
|
||||
self.get("confirm-delete-label").set_text(text)
|
||||
|
||||
confirm_delete.show()
|
||||
response = confirm_delete.run()
|
||||
confirm_delete.hide()
|
||||
return response
|
||||
|
||||
def gather_changes_and_save(self, *_):
|
||||
"""Look into the ui if new changes should be written, and save the preset."""
|
||||
# correct case
|
||||
symbol = self.get_symbol_input_text()
|
||||
target = self.get_target_selection()
|
||||
|
||||
if not symbol or not target:
|
||||
return
|
||||
|
||||
correct_case = system_mapping.correct_case(symbol)
|
||||
if symbol != correct_case:
|
||||
self.get_text_input().get_buffer().set_text(correct_case)
|
||||
|
||||
# make sure the active_preset is up to date
|
||||
key = self.get_combination()
|
||||
if correct_case and key and target:
|
||||
active_preset.change(key, target, correct_case)
|
||||
|
||||
# save to disk if required
|
||||
if active_preset.has_unsaved_changes():
|
||||
self.user_interface.save_preset()
|
||||
|
||||
def is_waiting_for_input(self):
|
||||
"""Check if the user is trying to record buttons."""
|
||||
return self.get_recording_toggle().get_active()
|
||||
|
||||
def should_record_combination(self, combination):
|
||||
"""Check if the combination was written when the toggle was active."""
|
||||
# At this point the toggle might already be off, because some keys that are
|
||||
# used while the toggle was still on might cause the focus of the toggle to
|
||||
# be lost, like multimedia keys. This causes the toggle to be disabled.
|
||||
# Yet, this event should be mapped.
|
||||
timestamp = max([event.timestamp() for event in combination])
|
||||
return timestamp < self.record_events_until
|
||||
|
||||
def consume_newest_keycode(self, combination: EventCombination):
|
||||
"""To capture events from keyboards, mice and gamepads."""
|
||||
self._switch_focus_if_complete()
|
||||
|
||||
if combination is None:
|
||||
return
|
||||
|
||||
if not self.should_record_combination(combination):
|
||||
# the event arrived after the toggle has been deactivated
|
||||
logger.debug("Recording toggle is not on")
|
||||
return
|
||||
|
||||
if not isinstance(combination, EventCombination):
|
||||
raise TypeError("Expected new_key to be a EventCombination object")
|
||||
|
||||
# keycode is already set by some other row
|
||||
existing = active_preset.get_mapping(combination)
|
||||
if existing is not None:
|
||||
existing = list(existing)
|
||||
existing[0] = re.sub(r"\s", "", existing[0])
|
||||
msg = _('"%s" already mapped to "%s"') % (
|
||||
combination.beautify(),
|
||||
tuple(existing),
|
||||
)
|
||||
logger.info("%s %s", combination, msg)
|
||||
self.user_interface.show_status(CTX_KEYCODE, msg)
|
||||
return
|
||||
|
||||
if combination.is_problematic():
|
||||
self.user_interface.show_status(
|
||||
CTX_WARNING,
|
||||
_("ctrl, alt and shift may not combine properly"),
|
||||
_("Your system might reinterpret combinations ")
|
||||
+ _("with those after they are injected, and by doing so ")
|
||||
+ _("break them."),
|
||||
)
|
||||
|
||||
# the newest_keycode is populated since the ui regularly polls it
|
||||
# in order to display it in the status bar.
|
||||
previous_key = self.get_combination()
|
||||
|
||||
# it might end up being a key combination, wait for more
|
||||
self._input_has_arrived = True
|
||||
|
||||
# keycode didn't change, do nothing
|
||||
if combination == previous_key:
|
||||
logger.debug("%s didn't change", previous_key)
|
||||
return
|
||||
|
||||
self.set_combination(combination)
|
||||
|
||||
symbol = self.get_symbol_input_text()
|
||||
target = self.get_target_selection()
|
||||
|
||||
if not symbol:
|
||||
# has not been entered yet
|
||||
logger.debug("Symbol missing")
|
||||
return
|
||||
|
||||
if not target:
|
||||
logger.debug("Target missing")
|
||||
return
|
||||
|
||||
# else, the keycode has changed, the symbol is set, all good
|
||||
active_preset.change(
|
||||
new_combination=combination,
|
||||
target=target,
|
||||
symbol=symbol,
|
||||
previous_combination=previous_key,
|
||||
)
|
||||
|
||||
def _switch_focus_if_complete(self):
|
||||
"""If keys are released, it will switch to the text_input.
|
||||
|
||||
States:
|
||||
1. not doing anything, waiting for the user to start using it
|
||||
2. user focuses it, no keys pressed
|
||||
3. user presses keys
|
||||
4. user releases keys. no keys are pressed, just like in step 2, but this time
|
||||
the focus needs to switch.
|
||||
"""
|
||||
if not self.is_waiting_for_input():
|
||||
self._reset_keycode_consumption()
|
||||
return
|
||||
|
||||
all_keys_released = reader.get_unreleased_keys() is None
|
||||
if all_keys_released and self._input_has_arrived and self.get_combination():
|
||||
logger.debug("Recording complete")
|
||||
# A key was pressed and then released.
|
||||
# Switch to the symbol. idle_add this so that the
|
||||
# keycode event won't write into the symbol input as well.
|
||||
window = self.user_interface.window
|
||||
self.enable_symbol_input()
|
||||
self.enable_target_selector()
|
||||
GLib.idle_add(lambda: window.set_focus(self.get_text_input()))
|
||||
|
||||
if not all_keys_released:
|
||||
# currently the user is using the widget, and certain keys have already
|
||||
# reached it.
|
||||
self._input_has_arrived = True
|
||||
return
|
||||
|
||||
self._reset_keycode_consumption()
|
||||
|
||||
def _reset_keycode_consumption(self, *_):
|
||||
self._input_has_arrived = False
|
||||
@ -1,234 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2022 sezanzeb <proxima@hip70890b.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/>.
|
||||
|
||||
|
||||
"""Process that sends stuff to the GUI.
|
||||
|
||||
It should be started via input-remapper-control and pkexec.
|
||||
|
||||
GUIs should not run as root
|
||||
https://wiki.archlinux.org/index.php/Running_GUI_applications_as_root
|
||||
|
||||
The service shouldn't do that even though it has root rights, because that
|
||||
would provide a key-logger that can be accessed by any user at all times,
|
||||
whereas for the helper to start a password is needed and it stops when the ui
|
||||
closes.
|
||||
"""
|
||||
|
||||
|
||||
import sys
|
||||
import select
|
||||
import multiprocessing
|
||||
import subprocess
|
||||
import time
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import EV_KEY, EV_ABS
|
||||
|
||||
from inputremapper.ipc.pipe import Pipe
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.groups import groups
|
||||
from inputremapper import utils
|
||||
from inputremapper.user import USER
|
||||
|
||||
|
||||
# received by the helper
|
||||
CMD_TERMINATE = "terminate"
|
||||
CMD_REFRESH_GROUPS = "refresh_groups"
|
||||
|
||||
# sent by the helper to the reader
|
||||
MSG_GROUPS = "groups"
|
||||
MSG_EVENT = "event"
|
||||
|
||||
|
||||
def is_helper_running():
|
||||
"""Check if the helper is running."""
|
||||
try:
|
||||
subprocess.check_output(["pgrep", "-f", "input-remapper-helper"])
|
||||
except subprocess.CalledProcessError:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
class RootHelper:
|
||||
"""Client that runs as root and works for the GUI.
|
||||
|
||||
Sends device information and keycodes to the GUIs socket.
|
||||
|
||||
Commands are either numbers for generic commands,
|
||||
or strings to start listening on a specific device.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
"""Construct the helper and initialize its sockets."""
|
||||
self._results = Pipe(f"/tmp/input-remapper-{USER}/results")
|
||||
self._commands = Pipe(f"/tmp/input-remapper-{USER}/commands")
|
||||
|
||||
self._send_groups()
|
||||
|
||||
self.group = None
|
||||
self._pipe = multiprocessing.Pipe()
|
||||
|
||||
def run(self):
|
||||
"""Start doing stuff. Blocks."""
|
||||
logger.debug("Waiting for the first command")
|
||||
# the reader will check for new commands later, once it is running
|
||||
# it keeps running for one device or another.
|
||||
select.select([self._commands], [], [])
|
||||
|
||||
# possibly an alternative to select:
|
||||
"""while True:
|
||||
if self._commands.poll():
|
||||
break
|
||||
|
||||
time.sleep(0.1)"""
|
||||
|
||||
logger.debug("Starting mainloop")
|
||||
while True:
|
||||
self._read_commands()
|
||||
self._start_reading()
|
||||
|
||||
def _send_groups(self):
|
||||
"""Send the groups to the gui."""
|
||||
logger.debug("Sending groups")
|
||||
self._results.send({"type": MSG_GROUPS, "message": groups.dumps()})
|
||||
|
||||
def _read_commands(self):
|
||||
"""Handle all unread commands."""
|
||||
while self._commands.poll():
|
||||
cmd = self._commands.recv()
|
||||
logger.debug('Received command "%s"', cmd)
|
||||
|
||||
if cmd == CMD_TERMINATE:
|
||||
logger.debug("Helper terminates")
|
||||
sys.exit(0)
|
||||
|
||||
if cmd == CMD_REFRESH_GROUPS:
|
||||
groups.refresh()
|
||||
self._send_groups()
|
||||
continue
|
||||
|
||||
group = groups.find(key=cmd)
|
||||
if group is None:
|
||||
groups.refresh()
|
||||
group = groups.find(key=cmd)
|
||||
|
||||
if group is not None:
|
||||
self.group = group
|
||||
continue
|
||||
|
||||
logger.error('Received unknown command "%s"', cmd)
|
||||
|
||||
logger.debug("No more commands in pipe")
|
||||
|
||||
def _start_reading(self):
|
||||
"""Tell the evdev lib to start looking for keycodes.
|
||||
|
||||
If read is called without prior start_reading, no keycodes
|
||||
will be available.
|
||||
|
||||
This blocks forever until it discovers a new command on the socket.
|
||||
"""
|
||||
rlist = {}
|
||||
|
||||
if self.group is None:
|
||||
logger.error("group is None")
|
||||
return
|
||||
|
||||
virtual_devices = []
|
||||
# Watch over each one of the potentially multiple devices per
|
||||
# hardware
|
||||
for path in self.group.paths:
|
||||
try:
|
||||
device = evdev.InputDevice(path)
|
||||
except FileNotFoundError:
|
||||
continue
|
||||
|
||||
if evdev.ecodes.EV_KEY in device.capabilities():
|
||||
virtual_devices.append(device)
|
||||
|
||||
if len(virtual_devices) == 0:
|
||||
logger.debug('No interesting device for "%s"', self.group.key)
|
||||
return
|
||||
|
||||
for device in virtual_devices:
|
||||
rlist[device.fd] = device
|
||||
|
||||
logger.debug(
|
||||
'Starting reading keycodes from "%s"',
|
||||
'", "'.join([device.name for device in virtual_devices]),
|
||||
)
|
||||
|
||||
rlist[self._commands] = self._commands
|
||||
|
||||
while True:
|
||||
ready_fds = select.select(rlist, [], [])
|
||||
if len(ready_fds[0]) == 0:
|
||||
# happens with sockets sometimes. Sockets are not stable and
|
||||
# not used, so nothing to worry about now.
|
||||
continue
|
||||
|
||||
for fd in ready_fds[0]:
|
||||
if rlist[fd] == self._commands:
|
||||
# all commands will cause the reader to start over
|
||||
# (possibly for a different device).
|
||||
# _read_commands will check what is going on
|
||||
logger.debug("Stops reading due to new command")
|
||||
return
|
||||
|
||||
device = rlist[fd]
|
||||
|
||||
try:
|
||||
event = device.read_one()
|
||||
if event:
|
||||
self._send_event(event, device)
|
||||
except OSError:
|
||||
logger.debug('Device "%s" disappeared', device.path)
|
||||
return
|
||||
|
||||
def _send_event(self, event, device):
|
||||
"""Write the event into the pipe to the main process.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
event : evdev.InputEvent
|
||||
device : evdev.InputDevice
|
||||
"""
|
||||
# value: 1 for down, 0 for up, 2 for hold.
|
||||
if event.type == EV_KEY and event.value == 2:
|
||||
# ignore hold-down events
|
||||
return
|
||||
|
||||
blacklisted_keys = [evdev.ecodes.BTN_TOOL_DOUBLETAP]
|
||||
|
||||
if event.type == EV_KEY and event.code in blacklisted_keys:
|
||||
return
|
||||
|
||||
if event.type == EV_ABS:
|
||||
abs_range = utils.get_abs_range(device, event.code)
|
||||
event.value = utils.classify_action(event, abs_range)
|
||||
else:
|
||||
event.value = utils.classify_action(event)
|
||||
|
||||
self._results.send(
|
||||
{
|
||||
"type": MSG_EVENT,
|
||||
"message": (event.sec, event.usec, event.type, event.code, event.value),
|
||||
}
|
||||
)
|
||||
@ -0,0 +1,125 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
import os.path
|
||||
import re
|
||||
import traceback
|
||||
from collections import defaultdict, deque
|
||||
from typing import (
|
||||
Callable,
|
||||
Dict,
|
||||
Set,
|
||||
Protocol,
|
||||
Tuple,
|
||||
Deque,
|
||||
Any,
|
||||
TYPE_CHECKING,
|
||||
)
|
||||
|
||||
from inputremapper.gui.messages.message_types import MessageType
|
||||
from inputremapper.logger import logger
|
||||
|
||||
if TYPE_CHECKING:
|
||||
pass
|
||||
|
||||
|
||||
class Message(Protocol):
|
||||
"""The protocol any message must follow to be sent with the MessageBroker."""
|
||||
|
||||
@property
|
||||
def message_type(self) -> MessageType:
|
||||
...
|
||||
|
||||
|
||||
# useful type aliases
|
||||
MessageListener = Callable[[Any], None]
|
||||
|
||||
|
||||
class MessageBroker:
|
||||
shorten_path = re.compile("inputremapper/")
|
||||
|
||||
def __init__(self):
|
||||
self._listeners: Dict[MessageType, Set[MessageListener]] = defaultdict(set)
|
||||
self._messages: Deque[Tuple[Message, str, int]] = deque()
|
||||
self._publishing = False
|
||||
|
||||
def publish(self, data: Message):
|
||||
"""Schedule a massage to be sent.
|
||||
The message will be sent after all currently pending messages are sent."""
|
||||
self._messages.append((data, *self.get_caller()))
|
||||
self._publish_all()
|
||||
|
||||
def signal(self, signal: MessageType):
|
||||
"""Send a signal without any data payload."""
|
||||
# This is different from calling self.publish because self.get_caller()
|
||||
# looks back at the current stack 3 frames
|
||||
self._messages.append((Signal(signal), *self.get_caller()))
|
||||
self._publish_all()
|
||||
|
||||
def _publish(self, data: Message, file: str, line: int):
|
||||
logger.debug(
|
||||
"from %s:%d: Signal=%s: %s", file, line, data.message_type.name, data
|
||||
)
|
||||
for listener in self._listeners[data.message_type].copy():
|
||||
listener(data)
|
||||
|
||||
def _publish_all(self):
|
||||
"""Send all scheduled messages in order."""
|
||||
if self._publishing:
|
||||
# don't run this twice, so we not mess up the order
|
||||
return
|
||||
|
||||
self._publishing = True
|
||||
try:
|
||||
while self._messages:
|
||||
self._publish(*self._messages.popleft())
|
||||
finally:
|
||||
self._publishing = False
|
||||
|
||||
def subscribe(self, massage_type: MessageType, listener: MessageListener):
|
||||
"""Attach a listener to an event."""
|
||||
logger.debug("adding new Listener for %s: %s", massage_type, listener)
|
||||
self._listeners[massage_type].add(listener)
|
||||
return self
|
||||
|
||||
@staticmethod
|
||||
def get_caller(position: int = 3) -> Tuple[str, int]:
|
||||
"""Extract a file and line from current stack and format for logging."""
|
||||
tb = traceback.extract_stack(limit=position)[0]
|
||||
return os.path.basename(tb.filename), tb.lineno or 0
|
||||
|
||||
def unsubscribe(self, listener: MessageListener) -> None:
|
||||
for listeners in self._listeners.values():
|
||||
try:
|
||||
listeners.remove(listener)
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
|
||||
class Signal:
|
||||
"""Send a Message without any associated data over the MassageBus."""
|
||||
|
||||
def __init__(self, message_type: MessageType):
|
||||
self.message_type: MessageType = message_type
|
||||
|
||||
def __str__(self):
|
||||
return f"Signal: {self.message_type}"
|
||||
|
||||
def __eq__(self, other: Any):
|
||||
return type(self) == type(other) and self.message_type == other.message_type
|
||||
@ -0,0 +1,126 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
from typing import Dict, Tuple, Optional, Callable
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination
|
||||
from inputremapper.configs.mapping import MappingData
|
||||
from inputremapper.gui.messages.message_types import (
|
||||
MessageType,
|
||||
Name,
|
||||
Capabilities,
|
||||
Key,
|
||||
DeviceTypes,
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class UInputsData:
|
||||
message_type = MessageType.uinputs
|
||||
uinputs: Dict[Name, Capabilities]
|
||||
|
||||
def __str__(self):
|
||||
string = f"{self.__class__.__name__}(uinputs={self.uinputs})"
|
||||
|
||||
# find all sequences of comma+space separated numbers, and shorten them
|
||||
# to the first and last number
|
||||
all_matches = list(re.finditer("(\d+, )+", string))
|
||||
all_matches.reverse()
|
||||
for match in all_matches:
|
||||
start = match.start()
|
||||
end = match.end()
|
||||
start += string[start:].find(",") + 2
|
||||
if start == end:
|
||||
continue
|
||||
string = f"{string[:start]}... {string[end:]}"
|
||||
|
||||
return string
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class GroupsData:
|
||||
"""Message containing all available groups and their device types."""
|
||||
|
||||
message_type = MessageType.groups
|
||||
groups: Dict[Key, DeviceTypes]
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class GroupData:
|
||||
"""Message with the active group and available presets for the group."""
|
||||
|
||||
message_type = MessageType.group
|
||||
group_key: str
|
||||
presets: Tuple[str, ...]
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class PresetData:
|
||||
"""Message with the active preset name and mapping names/combinations."""
|
||||
|
||||
message_type = MessageType.preset
|
||||
name: Optional[Name]
|
||||
mappings: Optional[Tuple[MappingData, ...]]
|
||||
autoload: bool = False
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class StatusData:
|
||||
"""Message with the strings and id for the status bar."""
|
||||
|
||||
message_type = MessageType.status_msg
|
||||
ctx_id: int
|
||||
msg: Optional[str] = None
|
||||
tooltip: Optional[str] = None
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class CombinationRecorded:
|
||||
"""Message with the latest recoded combination."""
|
||||
|
||||
message_type = MessageType.combination_recorded
|
||||
combination: "InputCombination"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class CombinationUpdate:
|
||||
"""Message with the old and new combination (hash for a mapping) when it changed."""
|
||||
|
||||
message_type = MessageType.combination_update
|
||||
old_combination: "InputCombination"
|
||||
new_combination: "InputCombination"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class UserConfirmRequest:
|
||||
"""Message for requesting a user response (confirm/cancel) from the gui."""
|
||||
|
||||
message_type = MessageType.user_confirm_request
|
||||
msg: str
|
||||
respond: Callable[[bool], None] = lambda _: None
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class DoStackSwitch:
|
||||
"""Command the stack to switch to a different page."""
|
||||
|
||||
message_type = MessageType.do_stack_switch
|
||||
page_index: int
|
||||
@ -0,0 +1,60 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 enum import Enum
|
||||
from typing import Dict, List
|
||||
|
||||
from inputremapper.groups import DeviceType
|
||||
|
||||
# useful type aliases
|
||||
Capabilities = Dict[int, List]
|
||||
Name = str
|
||||
Key = str
|
||||
DeviceTypes = List[DeviceType]
|
||||
|
||||
|
||||
class MessageType(Enum):
|
||||
reset_gui = "reset_gui"
|
||||
terminate = "terminate"
|
||||
init = "init"
|
||||
|
||||
uinputs = "uinputs"
|
||||
groups = "groups"
|
||||
group = "group"
|
||||
preset = "preset"
|
||||
mapping = "mapping"
|
||||
selected_event = "selected_event"
|
||||
combination_recorded = "combination_recorded"
|
||||
|
||||
# only the reader_client should send those messages:
|
||||
recording_started = "recording_started"
|
||||
recording_finished = "recording_finished"
|
||||
|
||||
combination_update = "combination_update"
|
||||
status_msg = "status_msg"
|
||||
injector_state = "injector_state"
|
||||
|
||||
gui_focus_request = "gui_focus_request"
|
||||
user_confirm_request = "user_confirm_request"
|
||||
|
||||
do_stack_switch = "do_stack_switch"
|
||||
|
||||
# for unit tests:
|
||||
test1 = "test1"
|
||||
test2 = "test2"
|
||||
@ -1,251 +0,0 @@
|
||||
# -*- 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/>.
|
||||
|
||||
|
||||
"""Talking to the GUI helper that has root permissions.
|
||||
|
||||
see gui.helper.helper
|
||||
"""
|
||||
|
||||
from typing import Optional
|
||||
from evdev.ecodes import EV_REL
|
||||
from inputremapper.input_event import InputEvent
|
||||
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.event_combination import EventCombination
|
||||
from inputremapper.groups import groups, GAMEPAD
|
||||
from inputremapper.ipc.pipe import Pipe
|
||||
from inputremapper.gui.helper import (
|
||||
MSG_EVENT,
|
||||
MSG_GROUPS,
|
||||
CMD_TERMINATE,
|
||||
CMD_REFRESH_GROUPS,
|
||||
)
|
||||
from inputremapper import utils
|
||||
from inputremapper.gui.active_preset import active_preset
|
||||
from inputremapper.user import USER
|
||||
|
||||
|
||||
DEBOUNCE_TICKS = 3
|
||||
|
||||
|
||||
def will_report_up(ev_type):
|
||||
"""Check if this event will ever report a key up (wheels)."""
|
||||
return ev_type != EV_REL
|
||||
|
||||
|
||||
class Reader:
|
||||
"""Processes events from the helper for the GUI to use.
|
||||
|
||||
Does not serve any purpose for the injection service.
|
||||
|
||||
When a button was pressed, the newest keycode can be obtained from this
|
||||
object. GTK has get_key for keyboard keys, but Reader also
|
||||
has knowledge of buttons like the middle-mouse button.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.previous_event = None
|
||||
self.previous_result = None
|
||||
self._unreleased = {}
|
||||
self._debounce_remove = {}
|
||||
self._groups_updated = False
|
||||
self._cleared_at = 0
|
||||
self.group = None
|
||||
|
||||
self._results = None
|
||||
self._commands = None
|
||||
self.connect()
|
||||
|
||||
def connect(self):
|
||||
"""Connect to the helper."""
|
||||
self._results = Pipe(f"/tmp/input-remapper-{USER}/results")
|
||||
self._commands = Pipe(f"/tmp/input-remapper-{USER}/commands")
|
||||
|
||||
def are_new_groups_available(self):
|
||||
"""Check if groups contains new devices.
|
||||
|
||||
The ui should then update its list.
|
||||
"""
|
||||
outdated = self._groups_updated
|
||||
self._groups_updated = False # assume the ui will react accordingly
|
||||
return outdated
|
||||
|
||||
def _get_event(self, message) -> Optional[InputEvent]:
|
||||
"""Return an InputEvent if the message contains one. None otherwise."""
|
||||
message_type = message["type"]
|
||||
message_body = message["message"]
|
||||
|
||||
if message_type == MSG_GROUPS:
|
||||
if message_body != groups.dumps():
|
||||
groups.loads(message_body)
|
||||
logger.debug("Received %d devices", len(groups))
|
||||
self._groups_updated = True
|
||||
return None
|
||||
|
||||
if message_type == MSG_EVENT:
|
||||
return InputEvent(*message_body)
|
||||
|
||||
logger.error('Received unknown message "%s"', message)
|
||||
return None
|
||||
|
||||
def read(self):
|
||||
"""Get the newest key/combination as EventCombination object.
|
||||
|
||||
Only reports keys from down-events.
|
||||
|
||||
On key-down events the pipe returns changed combinations. Release
|
||||
events won't cause that and the reader will return None as in
|
||||
"nothing new to report". So In order to change a combination, one
|
||||
of its keys has to be released and then a different one pressed.
|
||||
|
||||
Otherwise making combinations wouldn't be possible. Because at
|
||||
some point the keys have to be released, and that shouldn't cause
|
||||
the combination to get trimmed.
|
||||
"""
|
||||
# this is in some ways similar to the keycode_mapper and
|
||||
# joystick_to_mouse, but its much simpler because it doesn't
|
||||
# have to trigger anything, manage any macros and only
|
||||
# reports key-down events. This function is called periodically
|
||||
# by the window.
|
||||
|
||||
# remember the previous down-event from the pipe in order to
|
||||
# be able to tell if the reader should return the updated combination
|
||||
previous_event = self.previous_event
|
||||
key_down_received = False
|
||||
|
||||
self._debounce_tick()
|
||||
|
||||
while self._results.poll():
|
||||
message = self._results.recv()
|
||||
event = self._get_event(message)
|
||||
if event is None:
|
||||
continue
|
||||
|
||||
gamepad = GAMEPAD in self.group.types
|
||||
if not utils.should_map_as_btn(event, active_preset, gamepad):
|
||||
continue
|
||||
|
||||
if event.value == 0:
|
||||
logger.debug_key(event, "release")
|
||||
self._release(event.type_and_code)
|
||||
continue
|
||||
|
||||
if self._unreleased.get(event.type_and_code) == event:
|
||||
logger.debug_key(event, "duplicate key down")
|
||||
self._debounce_start(event.event_tuple)
|
||||
continue
|
||||
|
||||
# to keep track of combinations.
|
||||
# "I have got this release event, what was this for?" A release
|
||||
# event for a D-Pad axis might be any direction, hence this maps
|
||||
# from release to input in order to remember it. Since all release
|
||||
# events have value 0, the value is not used in the combination.
|
||||
key_down_received = True
|
||||
logger.debug_key(event, "down")
|
||||
self._unreleased[event.type_and_code] = event
|
||||
self._debounce_start(event.event_tuple)
|
||||
previous_event = event
|
||||
|
||||
if not key_down_received:
|
||||
# This prevents writing a subset of the combination into
|
||||
# result after keys were released. In order to control the gui,
|
||||
# they have to be released.
|
||||
return None
|
||||
|
||||
self.previous_event = previous_event
|
||||
|
||||
if len(self._unreleased) > 0:
|
||||
result = EventCombination.from_events(self._unreleased.values())
|
||||
if result == self.previous_result:
|
||||
# don't return the same stuff twice
|
||||
return None
|
||||
|
||||
self.previous_result = result
|
||||
logger.debug_key(result, "read result")
|
||||
|
||||
return result
|
||||
|
||||
return None
|
||||
|
||||
def start_reading(self, group):
|
||||
"""Start reading keycodes for a device."""
|
||||
logger.debug('Sending start msg to helper for "%s"', group.key)
|
||||
self._commands.send(group.key)
|
||||
self.group = group
|
||||
self.clear()
|
||||
|
||||
def terminate(self):
|
||||
"""Stop reading keycodes for good."""
|
||||
logger.debug("Sending close msg to helper")
|
||||
self._commands.send(CMD_TERMINATE)
|
||||
|
||||
def refresh_groups(self):
|
||||
"""Ask the helper for new device groups."""
|
||||
self._commands.send(CMD_REFRESH_GROUPS)
|
||||
|
||||
def clear(self):
|
||||
"""Next time when reading don't return the previous keycode."""
|
||||
logger.debug("Clearing reader")
|
||||
while self._results.poll():
|
||||
# clear the results pipe and handle any non-event messages,
|
||||
# otherwise a 'groups' message might get lost
|
||||
message = self._results.recv()
|
||||
self._get_event(message)
|
||||
|
||||
self._unreleased = {}
|
||||
self.previous_event = None
|
||||
self.previous_result = None
|
||||
|
||||
def get_unreleased_keys(self):
|
||||
"""Get a EventCombination object of the current keyboard state."""
|
||||
unreleased = list(self._unreleased.values())
|
||||
|
||||
if len(unreleased) == 0:
|
||||
return None
|
||||
|
||||
return EventCombination.from_events(unreleased)
|
||||
|
||||
def _release(self, type_code):
|
||||
"""Modify the state to recognize the releasing of the key."""
|
||||
if type_code in self._unreleased:
|
||||
del self._unreleased[type_code]
|
||||
if type_code in self._debounce_remove:
|
||||
del self._debounce_remove[type_code]
|
||||
|
||||
def _debounce_start(self, event_tuple):
|
||||
"""Act like the key was released if no new event arrives in time."""
|
||||
if not will_report_up(event_tuple[0]):
|
||||
self._debounce_remove[event_tuple[:2]] = DEBOUNCE_TICKS
|
||||
|
||||
def _debounce_tick(self):
|
||||
"""If the counter reaches 0, the key is not considered held down."""
|
||||
for type_code in list(self._debounce_remove.keys()):
|
||||
if type_code not in self._unreleased:
|
||||
continue
|
||||
|
||||
# clear wheel events from unreleased after some time
|
||||
if self._debounce_remove[type_code] == 0:
|
||||
logger.debug_key(self._unreleased[type_code], "Considered as released")
|
||||
self._release(type_code)
|
||||
else:
|
||||
self._debounce_remove[type_code] -= 1
|
||||
|
||||
|
||||
reader = Reader()
|
||||
@ -0,0 +1,292 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
|
||||
"""Talking to the ReaderService that has root permissions.
|
||||
|
||||
see gui.reader_service.ReaderService
|
||||
"""
|
||||
|
||||
import time
|
||||
from typing import Optional, List, Generator, Dict, Tuple, Set
|
||||
|
||||
import evdev
|
||||
import gi
|
||||
|
||||
from gi.repository import GLib
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination
|
||||
from inputremapper.groups import _Groups, _Group
|
||||
from inputremapper.gui.reader_service import (
|
||||
MSG_EVENT,
|
||||
MSG_GROUPS,
|
||||
CMD_TERMINATE,
|
||||
CMD_REFRESH_GROUPS,
|
||||
CMD_STOP_READING,
|
||||
get_pipe_paths,
|
||||
ReaderService,
|
||||
)
|
||||
from inputremapper.gui.messages.message_types import MessageType
|
||||
from inputremapper.gui.messages.message_broker import MessageBroker
|
||||
from inputremapper.gui.messages.message_data import (
|
||||
GroupsData,
|
||||
CombinationRecorded,
|
||||
StatusData,
|
||||
)
|
||||
from inputremapper.gui.utils import CTX_ERROR
|
||||
from inputremapper.gui.gettext import _
|
||||
from inputremapper.input_event import InputEvent
|
||||
from inputremapper.ipc.pipe import Pipe
|
||||
from inputremapper.logger import logger
|
||||
|
||||
BLACKLISTED_EVENTS = [(1, evdev.ecodes.BTN_TOOL_DOUBLETAP)]
|
||||
RecordingGenerator = Generator[None, InputEvent, None]
|
||||
|
||||
|
||||
class ReaderClient:
|
||||
"""Processes events from the reader-service for the GUI to use.
|
||||
|
||||
Does not serve any purpose for the injection service.
|
||||
|
||||
When a button was pressed, the newest keycode can be obtained from this object.
|
||||
GTK has get_key for keyboard keys, but Reader also has knowledge of buttons like
|
||||
the middle-mouse button.
|
||||
"""
|
||||
|
||||
# how long to wait for the reader-service at most
|
||||
_timeout: int = 5
|
||||
|
||||
def __init__(self, message_broker: MessageBroker, groups: _Groups):
|
||||
self.groups = groups
|
||||
self.message_broker = message_broker
|
||||
|
||||
self.group: Optional[_Group] = None
|
||||
|
||||
self._recording_generator: Optional[RecordingGenerator] = None
|
||||
self._results_pipe, self._commands_pipe = self.connect()
|
||||
|
||||
self.attach_to_events()
|
||||
|
||||
self._read_timeout = GLib.timeout_add(30, self._read)
|
||||
|
||||
def ensure_reader_service_running(self):
|
||||
if ReaderService.is_running():
|
||||
return
|
||||
|
||||
logger.info("ReaderService not running anymore, restarting")
|
||||
ReaderService.pkexec_reader_service()
|
||||
|
||||
# wait until the ReaderService is up
|
||||
|
||||
# wait no more than:
|
||||
polling_period = 0.01
|
||||
# this will make the gui non-responsive for 0.4s or something. The pkexec
|
||||
# password prompt will appear, so the user understands that the lag has to
|
||||
# be connected to the authentication. I would actually prefer the frozen gui
|
||||
# over a reactive one here, because the short lag shows that stuff is going on
|
||||
# behind the scenes.
|
||||
for __ in range(int(self._timeout / polling_period)):
|
||||
if self._results_pipe.poll():
|
||||
logger.info("ReaderService started")
|
||||
break
|
||||
|
||||
time.sleep(polling_period)
|
||||
else:
|
||||
msg = "The reader-service did not start"
|
||||
logger.error(msg)
|
||||
self.message_broker.publish(StatusData(CTX_ERROR, _(msg)))
|
||||
|
||||
def _send_command(self, command: str):
|
||||
"""Send a command to the ReaderService."""
|
||||
if command not in [CMD_TERMINATE, CMD_STOP_READING]:
|
||||
self.ensure_reader_service_running()
|
||||
|
||||
logger.debug('Sending "%s" to ReaderService', command)
|
||||
self._commands_pipe.send(command)
|
||||
|
||||
def connect(self):
|
||||
"""Connect to the reader-service."""
|
||||
results_pipe = Pipe(get_pipe_paths()[0])
|
||||
commands_pipe = Pipe(get_pipe_paths()[1])
|
||||
return results_pipe, commands_pipe
|
||||
|
||||
def attach_to_events(self):
|
||||
"""Connect listeners to event_reader."""
|
||||
self.message_broker.subscribe(
|
||||
MessageType.terminate,
|
||||
lambda _: self.terminate(),
|
||||
)
|
||||
|
||||
def _read(self):
|
||||
"""Read the messages from the reader-service and handle them."""
|
||||
while self._results_pipe.poll():
|
||||
message = self._results_pipe.recv()
|
||||
|
||||
logger.debug("received %s", message)
|
||||
|
||||
message_type = message["type"]
|
||||
message_body = message["message"]
|
||||
|
||||
if message_type == MSG_GROUPS:
|
||||
self._update_groups(message_body)
|
||||
|
||||
if message_type == MSG_EVENT:
|
||||
# update the generator
|
||||
try:
|
||||
if self._recording_generator is not None:
|
||||
self._recording_generator.send(InputEvent(**message_body))
|
||||
else:
|
||||
# the ReaderService should only send events while the gui
|
||||
# is recording, so this is unexpected.
|
||||
logger.error("Got event, but recorder is not running.")
|
||||
except StopIteration:
|
||||
# the _recording_generator returned
|
||||
logger.debug("Recorder finished.")
|
||||
self.stop_recorder()
|
||||
break
|
||||
|
||||
return True
|
||||
|
||||
def start_recorder(self) -> None:
|
||||
"""Record user input."""
|
||||
if self.group is None:
|
||||
logger.error("No group set")
|
||||
return
|
||||
|
||||
logger.debug("Starting recorder.")
|
||||
self._send_command(self.group.key)
|
||||
|
||||
self._recording_generator = self._recorder()
|
||||
next(self._recording_generator)
|
||||
|
||||
self.message_broker.signal(MessageType.recording_started)
|
||||
|
||||
def stop_recorder(self) -> None:
|
||||
"""Stop recording the input.
|
||||
|
||||
Will send recording_finished signals.
|
||||
"""
|
||||
logger.debug("Stopping recorder.")
|
||||
self._send_command(CMD_STOP_READING)
|
||||
|
||||
if self._recording_generator:
|
||||
self._recording_generator.close()
|
||||
self._recording_generator = None
|
||||
else:
|
||||
# this would be unexpected. but this is not critical enough to
|
||||
# show to the user without debug logs
|
||||
logger.debug("No recording generator existed")
|
||||
|
||||
self.message_broker.signal(MessageType.recording_finished)
|
||||
|
||||
@staticmethod
|
||||
def _input_event_to_config(event: InputEvent):
|
||||
return {
|
||||
"type": event.type,
|
||||
"code": event.code,
|
||||
"analog_threshold": event.value,
|
||||
"origin_hash": event.origin_hash,
|
||||
}
|
||||
|
||||
def _recorder(self) -> RecordingGenerator:
|
||||
"""Generator which receives InputEvents.
|
||||
|
||||
It accumulates them into EventCombinations and sends those on the
|
||||
message_broker. It will stop once all keys or inputs are released.
|
||||
"""
|
||||
active: Set = set()
|
||||
accumulator: List[InputEvent] = []
|
||||
while True:
|
||||
event: InputEvent = yield
|
||||
if event.type_and_code in BLACKLISTED_EVENTS:
|
||||
continue
|
||||
|
||||
if event.value == 0:
|
||||
try:
|
||||
active.remove(event.input_match_hash)
|
||||
except KeyError:
|
||||
# we haven't seen this before probably a key got released which
|
||||
# was pressed before we started recording. ignore it.
|
||||
continue
|
||||
|
||||
if not active:
|
||||
# all previously recorded events are released
|
||||
return
|
||||
continue
|
||||
|
||||
active.add(event.input_match_hash)
|
||||
accu_input_hashes = [e.input_match_hash for e in accumulator]
|
||||
if event.input_match_hash in accu_input_hashes and event not in accumulator:
|
||||
# the value has changed but the event is already in the accumulator
|
||||
# update the event
|
||||
i = accu_input_hashes.index(event.input_match_hash)
|
||||
accumulator[i] = event
|
||||
self.message_broker.publish(
|
||||
CombinationRecorded(
|
||||
InputCombination(map(self._input_event_to_config, accumulator))
|
||||
)
|
||||
)
|
||||
|
||||
if event not in accumulator:
|
||||
accumulator.append(event)
|
||||
self.message_broker.publish(
|
||||
CombinationRecorded(
|
||||
InputCombination(map(self._input_event_to_config, accumulator))
|
||||
)
|
||||
)
|
||||
|
||||
def set_group(self, group: Optional[_Group]):
|
||||
"""Set the group for which input events should be read later."""
|
||||
# TODO load the active_group from the controller instead?
|
||||
self.group = group
|
||||
|
||||
def terminate(self):
|
||||
"""Stop reading keycodes for good."""
|
||||
self._send_command(CMD_TERMINATE)
|
||||
|
||||
self.stop_recorder()
|
||||
|
||||
if self._read_timeout is not None:
|
||||
GLib.source_remove(self._read_timeout)
|
||||
self._read_timeout = None
|
||||
|
||||
while self._results_pipe.poll():
|
||||
self._results_pipe.recv()
|
||||
|
||||
def refresh_groups(self):
|
||||
"""Ask the ReaderService for new device groups."""
|
||||
self._send_command(CMD_REFRESH_GROUPS)
|
||||
|
||||
def publish_groups(self):
|
||||
"""Announce all known groups."""
|
||||
groups: Dict[str, List[str]] = {
|
||||
group.key: group.types or []
|
||||
for group in self.groups.filter(include_inputremapper=False)
|
||||
}
|
||||
self.message_broker.publish(GroupsData(groups))
|
||||
|
||||
def _update_groups(self, dump: str):
|
||||
if dump != self.groups.dumps():
|
||||
self.groups.loads(dump)
|
||||
logger.debug("Received %d devices", len(self.groups))
|
||||
self._groups_updated = True
|
||||
|
||||
# send this even if the groups did not change, as the user expects the ui
|
||||
# to respond in some form
|
||||
self.publish_groups()
|
||||
@ -0,0 +1,411 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 sezanzeb <proxima@hip70890b.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/>.
|
||||
|
||||
"""Process that sends stuff to the GUI.
|
||||
|
||||
It should be started via input-remapper-control and pkexec.
|
||||
|
||||
GUIs should not run as root
|
||||
https://wiki.archlinux.org/index.php/Running_GUI_applications_as_root
|
||||
|
||||
The service shouldn't do that even though it has root rights, because that
|
||||
would enable key-loggers to just ask input-remapper for all user-input.
|
||||
|
||||
Instead, the ReaderService is used, which will be stopped when the gui closes.
|
||||
|
||||
Whereas for the reader-service to start a password is needed and it stops whe
|
||||
the ui closes.
|
||||
|
||||
This uses the backend injection.event_reader and mapping_handlers to process all the
|
||||
different input-events into simple on/off events and sends them to the gui.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import multiprocessing
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from collections import defaultdict
|
||||
from typing import Set, List
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import EV_KEY, EV_ABS, EV_REL, REL_HWHEEL, REL_WHEEL
|
||||
from inputremapper.utils import get_device_hash
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.groups import _Groups, _Group
|
||||
from inputremapper.injection.event_reader import EventReader
|
||||
from inputremapper.injection.mapping_handlers.abs_to_btn_handler import AbsToBtnHandler
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
NotifyCallback,
|
||||
InputEventHandler,
|
||||
MappingHandler,
|
||||
)
|
||||
from inputremapper.injection.mapping_handlers.rel_to_btn_handler import RelToBtnHandler
|
||||
from inputremapper.input_event import InputEvent, EventActions
|
||||
from inputremapper.ipc.pipe import Pipe
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.user import USER
|
||||
|
||||
# received by the reader-service
|
||||
CMD_TERMINATE = "terminate"
|
||||
CMD_STOP_READING = "stop-reading"
|
||||
CMD_REFRESH_GROUPS = "refresh_groups"
|
||||
|
||||
# sent by the reader-service to the reader
|
||||
MSG_GROUPS = "groups"
|
||||
MSG_EVENT = "event"
|
||||
MSG_STATUS = "status"
|
||||
|
||||
|
||||
def get_pipe_paths():
|
||||
"""Get the path where the pipe can be found."""
|
||||
return (
|
||||
f"/tmp/input-remapper-{USER}/reader-results",
|
||||
f"/tmp/input-remapper-{USER}/reader-commands",
|
||||
)
|
||||
|
||||
|
||||
class ReaderService:
|
||||
"""Service that only reads events and is supposed to run as root.
|
||||
|
||||
Sends device information and keycodes to the GUI.
|
||||
|
||||
Commands are either numbers for generic commands,
|
||||
or strings to start listening on a specific device.
|
||||
"""
|
||||
|
||||
# the speed threshold at which relative axis are considered moving
|
||||
# and will be sent as "pressed" to the frontend.
|
||||
# We want to allow some mouse movement before we record it as an input
|
||||
rel_xy_speed = defaultdict(lambda: 3)
|
||||
# wheel events usually don't produce values higher than 1
|
||||
rel_xy_speed[REL_WHEEL] = 1
|
||||
rel_xy_speed[REL_HWHEEL] = 1
|
||||
|
||||
# Polkit won't ask for another password if the pid stays the same or something, and
|
||||
# if the previous request was no more than 5 minutes ago. see
|
||||
# https://unix.stackexchange.com/a/458260.
|
||||
# If the user does something after 6 minutes they will get a prompt already if the
|
||||
# reader timed out already, which sounds annoying. Instead, I'd rather have the
|
||||
# password prompt appear at most every 15 minutes.
|
||||
_maximum_lifetime: int = 60 * 15
|
||||
_timeout_tolerance: int = 60
|
||||
|
||||
def __init__(self, groups: _Groups):
|
||||
"""Construct the reader-service and initialize its communication pipes."""
|
||||
self._start_time = time.time()
|
||||
self.groups = groups
|
||||
self._results_pipe = Pipe(get_pipe_paths()[0])
|
||||
self._commands_pipe = Pipe(get_pipe_paths()[1])
|
||||
self._pipe = multiprocessing.Pipe()
|
||||
|
||||
self._tasks: Set[asyncio.Task] = set()
|
||||
self._stop_event = asyncio.Event()
|
||||
|
||||
self._results_pipe.send({"type": MSG_STATUS, "message": "ready"})
|
||||
|
||||
@staticmethod
|
||||
def is_running():
|
||||
"""Check if the reader-service is running."""
|
||||
try:
|
||||
subprocess.check_output(["pgrep", "-f", "input-remapper-reader-service"])
|
||||
except subprocess.CalledProcessError:
|
||||
return False
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def pkexec_reader_service():
|
||||
"""Start reader-service via pkexec to run in the background."""
|
||||
debug = " -d" if logger.level <= logging.DEBUG else ""
|
||||
cmd = f"pkexec input-remapper-control --command start-reader-service{debug}"
|
||||
|
||||
logger.debug("Running `%s`", cmd)
|
||||
exit_code = os.system(cmd)
|
||||
|
||||
if exit_code != 0:
|
||||
raise Exception(f"Failed to pkexec the reader-service, code {exit_code}")
|
||||
|
||||
async def run(self):
|
||||
"""Start doing stuff."""
|
||||
# the reader will check for new commands later, once it is running
|
||||
# it keeps running for one device or another.
|
||||
logger.debug("Discovering initial groups")
|
||||
self.groups.refresh()
|
||||
self._send_groups()
|
||||
await asyncio.gather(self._read_commands(), self._timeout())
|
||||
|
||||
def _send_groups(self):
|
||||
"""Send the groups to the gui."""
|
||||
logger.debug("Sending groups")
|
||||
self._results_pipe.send({"type": MSG_GROUPS, "message": self.groups.dumps()})
|
||||
|
||||
async def _timeout(self):
|
||||
"""Stop automatically after some time."""
|
||||
# Prevents a permanent hole for key-loggers to exist, in case the gui crashes.
|
||||
# If the ReaderService stops even though the gui needs it, it needs to restart
|
||||
# it. This makes it also more comfortable to have debug mode running during
|
||||
# development, because it won't keep writing inputs containing passwords and
|
||||
# such to the terminal forever.
|
||||
|
||||
await asyncio.sleep(self._maximum_lifetime)
|
||||
|
||||
# if it is currently reading, wait a bit longer for the gui to complete
|
||||
# what it is doing.
|
||||
if self._is_reading():
|
||||
logger.debug("Waiting a bit longer for the gui to finish reading")
|
||||
|
||||
for _ in range(self._timeout_tolerance):
|
||||
if not self._is_reading():
|
||||
# once reading completes, it should terminate right away
|
||||
break
|
||||
|
||||
await asyncio.sleep(1)
|
||||
|
||||
logger.debug("Maximum life-span reached, terminating")
|
||||
sys.exit(1)
|
||||
|
||||
async def _read_commands(self):
|
||||
"""Handle all unread commands.
|
||||
this will run until it receives CMD_TERMINATE
|
||||
"""
|
||||
logger.debug("Waiting for commands")
|
||||
async for cmd in self._commands_pipe:
|
||||
logger.debug('Received command "%s"', cmd)
|
||||
|
||||
if cmd == CMD_TERMINATE:
|
||||
await self._stop_reading()
|
||||
logger.debug("Terminating")
|
||||
sys.exit(0)
|
||||
|
||||
if cmd == CMD_REFRESH_GROUPS:
|
||||
self.groups.refresh()
|
||||
self._send_groups()
|
||||
continue
|
||||
|
||||
if cmd == CMD_STOP_READING:
|
||||
await self._stop_reading()
|
||||
continue
|
||||
|
||||
group = self.groups.find(key=cmd)
|
||||
if group is None:
|
||||
# this will block for a bit maybe we want to do this async?
|
||||
self.groups.refresh()
|
||||
group = self.groups.find(key=cmd)
|
||||
|
||||
if group is not None:
|
||||
await self._stop_reading()
|
||||
self._start_reading(group)
|
||||
continue
|
||||
|
||||
logger.error('Received unknown command "%s"', cmd)
|
||||
|
||||
def _is_reading(self) -> bool:
|
||||
"""Check if the ReaderService is currently sending events to the GUI."""
|
||||
return len(self._tasks) > 0
|
||||
|
||||
def _start_reading(self, group: _Group):
|
||||
"""Find all devices of that group, filter interesting ones and send the events
|
||||
to the gui."""
|
||||
sources = []
|
||||
for path in group.paths:
|
||||
try:
|
||||
device = evdev.InputDevice(path)
|
||||
except (FileNotFoundError, OSError):
|
||||
logger.error('Could not find "%s"', path)
|
||||
return None
|
||||
|
||||
capabilities = device.capabilities(absinfo=False)
|
||||
if (
|
||||
EV_KEY in capabilities
|
||||
or EV_ABS in capabilities
|
||||
or EV_REL in capabilities
|
||||
):
|
||||
sources.append(device)
|
||||
|
||||
context = self._create_event_pipeline(sources)
|
||||
# create the event reader and start it
|
||||
for device in sources:
|
||||
reader = EventReader(context, device, self._stop_event)
|
||||
self._tasks.add(asyncio.create_task(reader.run()))
|
||||
|
||||
async def _stop_reading(self):
|
||||
"""Stop the running event_reader."""
|
||||
self._stop_event.set()
|
||||
if self._tasks:
|
||||
await asyncio.gather(*self._tasks)
|
||||
self._tasks = set()
|
||||
self._stop_event.clear()
|
||||
|
||||
def _create_event_pipeline(self, sources: List[evdev.InputDevice]) -> ContextDummy:
|
||||
"""Create a custom event pipeline for each event code in the capabilities.
|
||||
|
||||
Instead of sending the events to an uinput they will be sent to the frontend.
|
||||
"""
|
||||
context_dummy = ContextDummy()
|
||||
# create a context for each source
|
||||
for device in sources:
|
||||
device_hash = get_device_hash(device)
|
||||
capabilities = device.capabilities(absinfo=False)
|
||||
|
||||
for ev_code in capabilities.get(EV_KEY) or ():
|
||||
input_config = InputConfig(
|
||||
type=EV_KEY, code=ev_code, origin_hash=device_hash
|
||||
)
|
||||
context_dummy.add_handler(
|
||||
input_config, ForwardToUIHandler(self._results_pipe)
|
||||
)
|
||||
|
||||
for ev_code in capabilities.get(EV_ABS) or ():
|
||||
# positive direction
|
||||
input_config = InputConfig(
|
||||
type=EV_ABS,
|
||||
code=ev_code,
|
||||
analog_threshold=30,
|
||||
origin_hash=device_hash,
|
||||
)
|
||||
mapping = Mapping(
|
||||
input_combination=InputCombination([input_config]),
|
||||
target_uinput="keyboard",
|
||||
output_symbol="KEY_A",
|
||||
)
|
||||
handler: MappingHandler = AbsToBtnHandler(
|
||||
InputCombination([input_config]), mapping
|
||||
)
|
||||
handler.set_sub_handler(ForwardToUIHandler(self._results_pipe))
|
||||
context_dummy.add_handler(input_config, handler)
|
||||
|
||||
# negative direction
|
||||
input_config = input_config.modify(analog_threshold=-30)
|
||||
mapping = Mapping(
|
||||
input_combination=InputCombination([input_config]),
|
||||
target_uinput="keyboard",
|
||||
output_symbol="KEY_A",
|
||||
)
|
||||
handler = AbsToBtnHandler(InputCombination([input_config]), mapping)
|
||||
handler.set_sub_handler(ForwardToUIHandler(self._results_pipe))
|
||||
context_dummy.add_handler(input_config, handler)
|
||||
|
||||
for ev_code in capabilities.get(EV_REL) or ():
|
||||
# positive direction
|
||||
input_config = InputConfig(
|
||||
type=EV_REL,
|
||||
code=ev_code,
|
||||
analog_threshold=self.rel_xy_speed[ev_code],
|
||||
origin_hash=device_hash,
|
||||
)
|
||||
mapping = Mapping(
|
||||
input_combination=InputCombination([input_config]),
|
||||
target_uinput="keyboard",
|
||||
output_symbol="KEY_A",
|
||||
release_timeout=0.3,
|
||||
force_release_timeout=True,
|
||||
)
|
||||
handler = RelToBtnHandler(InputCombination([input_config]), mapping)
|
||||
handler.set_sub_handler(ForwardToUIHandler(self._results_pipe))
|
||||
context_dummy.add_handler(input_config, handler)
|
||||
|
||||
# negative direction
|
||||
input_config = input_config.modify(
|
||||
analog_threshold=-self.rel_xy_speed[ev_code]
|
||||
)
|
||||
mapping = Mapping(
|
||||
input_combination=InputCombination([input_config]),
|
||||
target_uinput="keyboard",
|
||||
output_symbol="KEY_A",
|
||||
release_timeout=0.3,
|
||||
force_release_timeout=True,
|
||||
)
|
||||
handler = RelToBtnHandler(InputCombination([input_config]), mapping)
|
||||
handler.set_sub_handler(ForwardToUIHandler(self._results_pipe))
|
||||
context_dummy.add_handler(input_config, handler)
|
||||
|
||||
return context_dummy
|
||||
|
||||
|
||||
class ForwardDummy:
|
||||
@staticmethod
|
||||
def write(*_):
|
||||
pass
|
||||
|
||||
|
||||
class ContextDummy:
|
||||
"""Used for the reader so that no events are actually written to any uinput."""
|
||||
|
||||
def __init__(self):
|
||||
self.listeners = set()
|
||||
self._notify_callbacks = defaultdict(list)
|
||||
self.forward_dummy = ForwardDummy()
|
||||
|
||||
def add_handler(self, input_config: InputConfig, handler: InputEventHandler):
|
||||
self._notify_callbacks[input_config.input_match_hash].append(handler.notify)
|
||||
|
||||
def get_notify_callbacks(self, input_event: InputEvent) -> List[NotifyCallback]:
|
||||
return self._notify_callbacks[input_event.input_match_hash]
|
||||
|
||||
def reset(self):
|
||||
pass
|
||||
|
||||
def get_forward_uinput(self, origin_hash) -> evdev.UInput:
|
||||
"""Don't actually write anything."""
|
||||
return self.forward_dummy
|
||||
|
||||
|
||||
class ForwardToUIHandler:
|
||||
"""Implements the InputEventHandler protocol. Sends all events into the pipe."""
|
||||
|
||||
def __init__(self, pipe: Pipe):
|
||||
self.pipe = pipe
|
||||
self._last_event = InputEvent.from_tuple((99, 99, 99))
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
"""Filter duplicates and send into the pipe."""
|
||||
if event != self._last_event:
|
||||
self._last_event = event
|
||||
if EventActions.negative_trigger in event.actions:
|
||||
event = event.modify(value=-1)
|
||||
|
||||
logger.debug("Sending to %s frontend", event)
|
||||
self.pipe.send(
|
||||
{
|
||||
"type": MSG_EVENT,
|
||||
"message": {
|
||||
"sec": event.sec,
|
||||
"usec": event.usec,
|
||||
"type": event.type,
|
||||
"code": event.code,
|
||||
"value": event.value,
|
||||
"origin_hash": event.origin_hash,
|
||||
},
|
||||
}
|
||||
)
|
||||
return True
|
||||
|
||||
def reset(self):
|
||||
pass
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,26 +0,0 @@
|
||||
# -*- 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/>.
|
||||
|
||||
"""The injection process.
|
||||
|
||||
This folder contains all classes that are only relevant for the injection
|
||||
process. There is one process for each hardware device that is being injected
|
||||
for, and one context object per process that is being passed around for all
|
||||
classes to use.
|
||||
"""
|
||||
@ -1,120 +0,0 @@
|
||||
# -*- 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/>.
|
||||
|
||||
|
||||
"""Because multiple calls to async_read_loop won't work."""
|
||||
import asyncio
|
||||
import evdev
|
||||
|
||||
from inputremapper.injection.consumers.joystick_to_mouse import JoystickToMouse
|
||||
from inputremapper.injection.consumers.keycode_mapper import KeycodeMapper
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.injection.context import Context
|
||||
|
||||
|
||||
consumer_classes = [
|
||||
KeycodeMapper,
|
||||
JoystickToMouse,
|
||||
]
|
||||
|
||||
|
||||
class ConsumerControl:
|
||||
"""Reads input events from a single device and distributes them.
|
||||
|
||||
There is one ConsumerControl object for each source, which tells multiple consumers
|
||||
that a new event is ready so that they can inject all sorts of funny
|
||||
things.
|
||||
|
||||
Other devnodes may be present for the hardware device, in which case this
|
||||
needs to be created multiple times.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
context: Context,
|
||||
source: evdev.InputDevice,
|
||||
forward_to: evdev.UInput,
|
||||
) -> None:
|
||||
"""Initialize all consumers
|
||||
|
||||
Parameters
|
||||
----------
|
||||
source : evdev.InputDevice
|
||||
where to read keycodes from
|
||||
forward_to : evdev.UInput
|
||||
where to write keycodes to that were not mapped to anything.
|
||||
Should be an UInput with capabilities that work for all forwarded
|
||||
events, so ideally they should be copied from source.
|
||||
"""
|
||||
self._source = source
|
||||
self._forward_to = forward_to
|
||||
|
||||
# add all consumers that are enabled for this particular configuration
|
||||
self._consumers = []
|
||||
for Consumer in consumer_classes:
|
||||
consumer = Consumer(context, source, forward_to)
|
||||
if consumer.is_enabled():
|
||||
self._consumers.append(consumer)
|
||||
|
||||
async def run(self):
|
||||
"""Start doing things.
|
||||
|
||||
Can be stopped by stopping the asyncio loop. This loop
|
||||
reads events from a single device only.
|
||||
"""
|
||||
for consumer in self._consumers:
|
||||
# run all of them in parallel
|
||||
asyncio.ensure_future(consumer.run())
|
||||
|
||||
logger.debug(
|
||||
"Starting to listen for events from %s, fd %s",
|
||||
self._source.path,
|
||||
self._source.fd,
|
||||
)
|
||||
|
||||
async for event in self._source.async_read_loop():
|
||||
if event.type == evdev.ecodes.EV_KEY and event.value == 2:
|
||||
# button-hold event. Environments (gnome, etc.) create them on
|
||||
# their own for the injection-fake-device if the release event
|
||||
# won't appear, no need to forward or map them.
|
||||
continue
|
||||
|
||||
handled = False
|
||||
for consumer in self._consumers:
|
||||
# copy so that the consumer doesn't screw this up for
|
||||
# all other future consumers
|
||||
event_copy = evdev.InputEvent(
|
||||
sec=event.sec,
|
||||
usec=event.usec,
|
||||
type=event.type,
|
||||
code=event.code,
|
||||
value=event.value,
|
||||
)
|
||||
if consumer.is_handled(event_copy):
|
||||
await consumer.notify(event_copy)
|
||||
handled = True
|
||||
|
||||
if not handled:
|
||||
# forward the rest
|
||||
self._forward_to.write(event.type, event.code, event.value)
|
||||
# this already includes SYN events, so need to syn here again
|
||||
|
||||
# This happens all the time in tests because the async_read_loop stops when
|
||||
# there is nothing to read anymore. Otherwise tests would block.
|
||||
logger.error('The async_read_loop for "%s" stopped early', self._source.path)
|
||||
@ -1,82 +0,0 @@
|
||||
# -*- 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/>.
|
||||
|
||||
|
||||
"""Consumer base class.
|
||||
|
||||
Can be notified of new events so that inheriting classes can map them and
|
||||
inject new events based on them.
|
||||
"""
|
||||
|
||||
|
||||
class Consumer:
|
||||
"""Can be notified of new events to inject them. Base class."""
|
||||
|
||||
def __init__(self, context, source, forward_to=None):
|
||||
"""Initialize event consuming functionality.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
context : Context
|
||||
The configuration of the Injector process
|
||||
source : InputDevice
|
||||
Where events used in handle_keycode come from
|
||||
forward_to : evdev.UInput
|
||||
Where to write keycodes to that were not mapped to anything.
|
||||
Should be an UInput with capabilities that work for all forwarded
|
||||
events, so ideally they should be copied from source.
|
||||
"""
|
||||
self.context = context
|
||||
self.forward_to = forward_to
|
||||
self.source = source
|
||||
self.context.update_purposes()
|
||||
|
||||
def is_enabled(self):
|
||||
"""Check if the consumer will have work to do."""
|
||||
raise NotImplementedError
|
||||
|
||||
def forward(self, key):
|
||||
"""Shorthand to forward an event."""
|
||||
self.forward_to.write(*key)
|
||||
|
||||
async def notify(self, event):
|
||||
"""A new event is ready.
|
||||
|
||||
Overwrite this function if the consumer should do something each time
|
||||
a new event arrives. E.g. mapping a single button once clicked.
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
def is_handled(self, event):
|
||||
"""Check if the consumer will take care of this event.
|
||||
|
||||
If this returns true, the event will not be forwarded anymore
|
||||
automatically. If you want to forward the event after all you can
|
||||
inject it into `self.forward_to`.
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
async def run(self):
|
||||
"""Start doing things.
|
||||
|
||||
Overwrite this function if the consumer should do something
|
||||
continuously even if no new event arrives. e.g. continuously injecting
|
||||
mouse movement events.
|
||||
"""
|
||||
raise NotImplementedError
|
||||
@ -1,272 +0,0 @@
|
||||
# -*- 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/>.
|
||||
|
||||
|
||||
"""Keeps mapping joystick to mouse movements."""
|
||||
|
||||
|
||||
import asyncio
|
||||
import time
|
||||
|
||||
from evdev.ecodes import (
|
||||
EV_REL,
|
||||
REL_X,
|
||||
REL_Y,
|
||||
REL_WHEEL,
|
||||
REL_HWHEEL,
|
||||
EV_ABS,
|
||||
ABS_X,
|
||||
ABS_Y,
|
||||
ABS_RX,
|
||||
ABS_RY,
|
||||
)
|
||||
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.configs.global_config import MOUSE, WHEEL
|
||||
from inputremapper import utils
|
||||
from inputremapper.injection.consumers.consumer import Consumer
|
||||
from inputremapper.groups import classify, GAMEPAD
|
||||
from inputremapper.injection.global_uinputs import global_uinputs
|
||||
|
||||
# miniscule movements on the joystick should not trigger a mouse wheel event
|
||||
WHEEL_THRESHOLD = 0.15
|
||||
|
||||
|
||||
def abs_max(value_1, value_2):
|
||||
"""Get the value with the higher abs value."""
|
||||
if abs(value_1) > abs(value_2):
|
||||
return value_1
|
||||
return value_2
|
||||
|
||||
|
||||
class JoystickToMouse(Consumer):
|
||||
"""Keeps producing events at 60hz if needed.
|
||||
|
||||
Maps joysticks to mouse movements.
|
||||
|
||||
This class does not handle injecting macro stuff over time, that is done
|
||||
by the keycode_mapper.
|
||||
"""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
"""Construct the event producer without it doing anything yet."""
|
||||
super().__init__(*args, **kwargs)
|
||||
|
||||
self._abs_range = None
|
||||
self._set_abs_range_from(self.source)
|
||||
|
||||
# events only take ints, so a movement of 0.3 needs to add
|
||||
# up to 1.2 to affect the cursor, with 0.2 remaining
|
||||
self.pending_rel = {REL_X: 0, REL_Y: 0, REL_WHEEL: 0, REL_HWHEEL: 0}
|
||||
# the last known position of the joystick
|
||||
self.abs_state = {ABS_X: 0, ABS_Y: 0, ABS_RX: 0, ABS_RY: 0}
|
||||
|
||||
def is_enabled(self):
|
||||
gamepad = classify(self.source) == GAMEPAD
|
||||
return gamepad and self.context.joystick_as_mouse()
|
||||
|
||||
def _write(self, ev_type, keycode, value):
|
||||
"""Inject."""
|
||||
# if the mouse won't move even though correct stuff is written here,
|
||||
# the capabilities are probably wrong
|
||||
try:
|
||||
global_uinputs.write((ev_type, keycode, value), "mouse")
|
||||
except OverflowError:
|
||||
# screwed up the calculation of mouse movements
|
||||
logger.error("OverflowError (%s, %s, %s)", ev_type, keycode, value)
|
||||
|
||||
def accumulate(self, code, input_value):
|
||||
"""Since devices can't do float values, stuff has to be accumulated.
|
||||
|
||||
If pending is 0.6 and input_value is 0.5, return 0.1 and 1.
|
||||
Because it should move 1px, and 0.1px is rememberd for the next value
|
||||
in pending.
|
||||
"""
|
||||
self.pending_rel[code] += input_value
|
||||
output_value = int(self.pending_rel[code])
|
||||
self.pending_rel[code] -= output_value
|
||||
return output_value
|
||||
|
||||
def _set_abs_range_from(self, device):
|
||||
"""Update the min and max values joysticks will report.
|
||||
|
||||
This information is needed for abs -> rel mapping.
|
||||
"""
|
||||
if device is None:
|
||||
# I don't think this ever happened
|
||||
logger.error("Expected device to not be None")
|
||||
return
|
||||
|
||||
abs_range = utils.get_abs_range(device)
|
||||
if abs_range is None:
|
||||
return
|
||||
|
||||
if abs_range[1] in [0, 1, None]:
|
||||
# max abs_range of joysticks is usually a much higher number
|
||||
return
|
||||
|
||||
self.set_abs_range(*abs_range)
|
||||
logger.debug('ABS range of "%s": %s', device.name, abs_range)
|
||||
|
||||
def set_abs_range(self, min_abs, max_abs):
|
||||
"""Update the min and max values joysticks will report.
|
||||
|
||||
This information is needed for abs -> rel mapping.
|
||||
"""
|
||||
self._abs_range = (min_abs, max_abs)
|
||||
|
||||
# all joysticks in resting position by default
|
||||
center = (self._abs_range[1] + self._abs_range[0]) / 2
|
||||
self.abs_state = {ABS_X: center, ABS_Y: center, ABS_RX: center, ABS_RY: center}
|
||||
|
||||
def get_abs_values(self):
|
||||
"""Get the raw values for wheel and mouse movement.
|
||||
|
||||
Returned values center around 0 and are normalized into -1 and 1.
|
||||
|
||||
If two joysticks have the same purpose, the one that reports higher
|
||||
absolute values takes over the control.
|
||||
"""
|
||||
# center is the value of the resting position
|
||||
center = (self._abs_range[1] + self._abs_range[0]) / 2
|
||||
# normalizer is the maximum possible value after centering
|
||||
normalizer = (self._abs_range[1] - self._abs_range[0]) / 2
|
||||
|
||||
mouse_x = 0
|
||||
mouse_y = 0
|
||||
wheel_x = 0
|
||||
wheel_y = 0
|
||||
|
||||
def standardize(value):
|
||||
return (value - center) / normalizer
|
||||
|
||||
if self.context.left_purpose == MOUSE:
|
||||
mouse_x = abs_max(mouse_x, standardize(self.abs_state[ABS_X]))
|
||||
mouse_y = abs_max(mouse_y, standardize(self.abs_state[ABS_Y]))
|
||||
|
||||
if self.context.left_purpose == WHEEL:
|
||||
wheel_x = abs_max(wheel_x, standardize(self.abs_state[ABS_X]))
|
||||
wheel_y = abs_max(wheel_y, standardize(self.abs_state[ABS_Y]))
|
||||
|
||||
if self.context.right_purpose == MOUSE:
|
||||
mouse_x = abs_max(mouse_x, standardize(self.abs_state[ABS_RX]))
|
||||
mouse_y = abs_max(mouse_y, standardize(self.abs_state[ABS_RY]))
|
||||
|
||||
if self.context.right_purpose == WHEEL:
|
||||
wheel_x = abs_max(wheel_x, standardize(self.abs_state[ABS_RX]))
|
||||
wheel_y = abs_max(wheel_y, standardize(self.abs_state[ABS_RY]))
|
||||
|
||||
# Some joysticks report from 0 to 255 (EMV101),
|
||||
# others from -32768 to 32767 (X-Box 360 Pad)
|
||||
return mouse_x, mouse_y, wheel_x, wheel_y
|
||||
|
||||
def is_handled(self, event):
|
||||
"""Check if the event is something this will take care of."""
|
||||
if event.type != EV_ABS or event.code not in utils.JOYSTICK:
|
||||
return False
|
||||
|
||||
if self._abs_range is None:
|
||||
return False
|
||||
|
||||
purposes = [MOUSE, WHEEL]
|
||||
left_purpose = self.context.left_purpose
|
||||
right_purpose = self.context.right_purpose
|
||||
|
||||
if event.code in (ABS_X, ABS_Y) and left_purpose in purposes:
|
||||
return True
|
||||
|
||||
if event.code in (ABS_RX, ABS_RY) and right_purpose in purposes:
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
async def notify(self, event):
|
||||
if event.type == EV_ABS and event.code in self.abs_state:
|
||||
self.abs_state[event.code] = event.value
|
||||
|
||||
async def run(self):
|
||||
"""Keep writing mouse movements based on the gamepad stick position.
|
||||
|
||||
Even if no new input event arrived because the joystick remained at
|
||||
its position, this will keep injecting the mouse movement events.
|
||||
"""
|
||||
abs_range = self._abs_range
|
||||
preset = self.context.preset
|
||||
pointer_speed = preset.get("gamepad.joystick.pointer_speed")
|
||||
non_linearity = preset.get("gamepad.joystick.non_linearity")
|
||||
x_scroll_speed = preset.get("gamepad.joystick.x_scroll_speed")
|
||||
y_scroll_speed = preset.get("gamepad.joystick.y_scroll_speed")
|
||||
max_speed = 2**0.5 # for normalized abs event values
|
||||
|
||||
if abs_range is not None:
|
||||
logger.info(
|
||||
"Left joystick as %s, right joystick as %s",
|
||||
self.context.left_purpose,
|
||||
self.context.right_purpose,
|
||||
)
|
||||
|
||||
start = time.time()
|
||||
while True:
|
||||
# try to do this as close to 60hz as possible
|
||||
time_taken = time.time() - start
|
||||
await asyncio.sleep(max(0.0, (1 / 60) - time_taken))
|
||||
start = time.time()
|
||||
|
||||
if abs_range is None:
|
||||
# no ev_abs events will be mapped to ev_rel
|
||||
continue
|
||||
|
||||
abs_values = self.get_abs_values()
|
||||
|
||||
if len([val for val in abs_values if not -1 <= val <= 1]) > 0:
|
||||
logger.error("Inconsistent values: %s", abs_values)
|
||||
continue
|
||||
|
||||
mouse_x, mouse_y, wheel_x, wheel_y = abs_values
|
||||
|
||||
# mouse movements
|
||||
if abs(mouse_x) > 0 or abs(mouse_y) > 0:
|
||||
if non_linearity != 1:
|
||||
# to make small movements smaller for more precision
|
||||
speed = (mouse_x**2 + mouse_y**2) ** 0.5 # pythagoras
|
||||
factor = (speed / max_speed) ** non_linearity
|
||||
else:
|
||||
factor = 1
|
||||
|
||||
rel_x = mouse_x * factor * pointer_speed
|
||||
rel_y = mouse_y * factor * pointer_speed
|
||||
rel_x = self.accumulate(REL_X, rel_x)
|
||||
rel_y = self.accumulate(REL_Y, rel_y)
|
||||
if rel_x != 0:
|
||||
self._write(EV_REL, REL_X, rel_x)
|
||||
if rel_y != 0:
|
||||
self._write(EV_REL, REL_Y, rel_y)
|
||||
|
||||
# wheel movements
|
||||
if abs(wheel_x) > 0:
|
||||
change = wheel_x * x_scroll_speed
|
||||
value = self.accumulate(REL_WHEEL, change)
|
||||
if abs(change) > WHEEL_THRESHOLD * x_scroll_speed:
|
||||
self._write(EV_REL, REL_HWHEEL, value)
|
||||
|
||||
if abs(wheel_y) > 0:
|
||||
change = wheel_y * y_scroll_speed
|
||||
value = self.accumulate(REL_HWHEEL, change)
|
||||
if abs(change) > WHEEL_THRESHOLD * y_scroll_speed:
|
||||
self._write(EV_REL, REL_WHEEL, -value)
|
||||
@ -1,560 +0,0 @@
|
||||
# -*- 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/>.
|
||||
|
||||
|
||||
"""Inject a keycode based on the mapping."""
|
||||
|
||||
|
||||
import itertools
|
||||
import asyncio
|
||||
import time
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import EV_KEY, EV_ABS
|
||||
|
||||
import inputremapper.exceptions
|
||||
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.configs.system_mapping import DISABLE_CODE
|
||||
from inputremapper import utils
|
||||
from inputremapper.injection.consumers.consumer import Consumer
|
||||
from inputremapper.utils import RELEASE
|
||||
from inputremapper.groups import classify, GAMEPAD
|
||||
from inputremapper.injection.global_uinputs import global_uinputs
|
||||
|
||||
|
||||
# this state is shared by all KeycodeMappers of this process
|
||||
|
||||
# maps mouse buttons to macro instances that have been executed.
|
||||
# They may still be running or already be done. Just like unreleased,
|
||||
# this is a mapping of (type, code). The value is not included in the
|
||||
# key, because a key release event with a value of 0 needs to be able
|
||||
# to find the running macro. The downside is that a d-pad cannot
|
||||
# execute two macros at once, one for each direction.
|
||||
# Only sequentially.
|
||||
active_macros = {}
|
||||
|
||||
|
||||
# mapping of future release event (type, code) to an Unreleased object,
|
||||
# All key-up events have a value of 0, so it is not added to
|
||||
# the tuple. This is needed in order to release the correct event
|
||||
# mapped on a D-Pad. Each direction on one D-Pad axis reports the
|
||||
# same type and code, but different values. There cannot be both at
|
||||
# the same time, as pressing one side of a D-Pad forces the other
|
||||
# side to go up. If both sides of a D-Pad are mapped to different
|
||||
# event-codes, this data structure helps to figure out which of those
|
||||
# two to release on an event of value 0. Same goes for the Wheel.
|
||||
# The input event is remembered to make sure no duplicate down-events
|
||||
# are written. Since wheels report a lot of "down" events that don't
|
||||
# serve any purpose when mapped to a key, those duplicate down events
|
||||
# should be removed. If the same type and code arrives but with a
|
||||
# different value (direction), there must be a way to check if the
|
||||
# event is actually a duplicate and not a different event.
|
||||
unreleased = {}
|
||||
|
||||
|
||||
COMBINATION_INCOMPLETE = 1 # not all keys of the combination are pressed
|
||||
NOT_COMBINED = 2 # this key is not part of a combination
|
||||
|
||||
|
||||
def subsets(combination):
|
||||
"""Return a list of subsets of the combination.
|
||||
|
||||
If combination is only one element long it returns an empty list,
|
||||
because it's not a combination and there is no reason to iterate.
|
||||
|
||||
Includes the complete input as well.
|
||||
|
||||
Parameters
|
||||
-----------
|
||||
combination : tuple
|
||||
tuple of 3-tuples, each being int, int, int (type, code, action)
|
||||
"""
|
||||
combination = list(combination)
|
||||
lengths = list(range(2, len(combination) + 1))
|
||||
lengths.reverse()
|
||||
return list(
|
||||
itertools.chain.from_iterable(
|
||||
itertools.combinations(combination, length) for length in lengths
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class Unreleased:
|
||||
"""This represents a key that has been pressed but not released yet."""
|
||||
|
||||
__slots__ = (
|
||||
"target",
|
||||
"input_event_tuple",
|
||||
"triggered_key",
|
||||
)
|
||||
|
||||
def __init__(self, target, input_event_tuple, triggered_key):
|
||||
"""
|
||||
Parameters
|
||||
----------
|
||||
target : 3-tuple
|
||||
int type, int code of what was injected or forwarded
|
||||
and string target_uinput for injected events,
|
||||
None for forwarded events
|
||||
input_event_tuple : 3-tuple
|
||||
int, int, int / type, code, action
|
||||
triggered_key : tuple of 3-tuples
|
||||
What was used to index key_to_code or macros when stuff
|
||||
was triggered.
|
||||
If nothing was triggered and input_event_tuple forwarded,
|
||||
insert None.
|
||||
"""
|
||||
self.target = target
|
||||
self.input_event_tuple = input_event_tuple
|
||||
self.triggered_key = triggered_key
|
||||
|
||||
if not isinstance(input_event_tuple[0], int) or len(input_event_tuple) != 3:
|
||||
raise ValueError(
|
||||
"Expected input_event_tuple to be a 3-tuple of ints, but "
|
||||
f"got {input_event_tuple}"
|
||||
)
|
||||
|
||||
unreleased[input_event_tuple[:2]] = self
|
||||
|
||||
def is_mapped(self):
|
||||
"""If true, the key-down event was written to context.uinput.
|
||||
|
||||
That means the release event should also be injected into that one.
|
||||
If this returns false, just forward the release event instead.
|
||||
"""
|
||||
# This should end up being equal to context.is_mapped(key)
|
||||
return self.triggered_key is not None
|
||||
|
||||
def __str__(self):
|
||||
return (
|
||||
"Unreleased("
|
||||
f"target{self.target},"
|
||||
f"input{self.input_event_tuple},"
|
||||
f'key{self.triggered_key or "(None)"}'
|
||||
")"
|
||||
)
|
||||
|
||||
def __repr__(self):
|
||||
return self.__str__()
|
||||
|
||||
|
||||
def find_by_event(key):
|
||||
"""Find an unreleased entry by an event.
|
||||
|
||||
If such an entry exists, it was created by an event that is exactly
|
||||
like the input parameter (except for the timestamp).
|
||||
|
||||
That doesn't mean it triggered something, only that it was seen before.
|
||||
"""
|
||||
unreleased_entry = unreleased.get(key[:2])
|
||||
if unreleased_entry and unreleased_entry.input_event_tuple == key:
|
||||
return unreleased_entry
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def find_by_key(key):
|
||||
"""Find an unreleased entry by a combination of keys.
|
||||
|
||||
If such an entry exist, it was created when a combination of keys
|
||||
(which matches the parameter, can also be of len 1 = single key)
|
||||
ended up triggering something.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
key : tuple of int
|
||||
type, code, action
|
||||
"""
|
||||
unreleased_entry = unreleased.get(key[-1][:2])
|
||||
if unreleased_entry and unreleased_entry.triggered_key == key:
|
||||
return unreleased_entry
|
||||
|
||||
return None
|
||||
|
||||
|
||||
class KeycodeMapper(Consumer):
|
||||
"""Injects keycodes and starts macros.
|
||||
|
||||
This really is somewhat complicated because it needs to be able to handle
|
||||
combinations (which is actually not that trivial because the order of keys
|
||||
matters). The nature of some events (D-Pads and Wheels) adds to the
|
||||
complexity. Since macros are mapped the same way keys are, this class
|
||||
takes care of both.
|
||||
"""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
"""Create a keycode mapper for one virtual device.
|
||||
|
||||
There may be multiple KeycodeMappers for one hardware device. They
|
||||
share some state (unreleased and active_macros) with each other.
|
||||
"""
|
||||
super().__init__(*args, **kwargs)
|
||||
|
||||
self._abs_range = None
|
||||
|
||||
if self.context.maps_joystick():
|
||||
self._abs_range = utils.get_abs_range(self.source)
|
||||
|
||||
self._gamepad = classify(self.source) == GAMEPAD
|
||||
|
||||
self.debounces = {}
|
||||
|
||||
# some type checking, prevents me from forgetting what that stuff
|
||||
# is supposed to be when writing tests.
|
||||
for combination in self.context.key_to_code:
|
||||
for event in combination:
|
||||
if abs(event.value) > 1:
|
||||
raise ValueError(
|
||||
f"Expected values to be one of -1, 0 or 1, "
|
||||
f"but got {combination}"
|
||||
)
|
||||
|
||||
def is_enabled(self):
|
||||
# even if the source does not provide a capability that is used here, it might
|
||||
# be important for notifying macros of new events that run on other sources.
|
||||
return len(self.context.key_to_code) > 0 or len(self.context.macros) > 0
|
||||
|
||||
def is_handled(self, event):
|
||||
return utils.should_map_as_btn(event, self.context.preset, self._gamepad)
|
||||
|
||||
async def run(self):
|
||||
"""Provide a debouncer to inject wheel releases."""
|
||||
start = time.time()
|
||||
while True:
|
||||
# try to do this as close to 60hz as possible
|
||||
time_taken = time.time() - start
|
||||
await asyncio.sleep(max(0.0, (1 / 60) - time_taken))
|
||||
start = time.time()
|
||||
|
||||
for debounce in self.debounces.values():
|
||||
if debounce[2] == -1:
|
||||
# has already been triggered
|
||||
continue
|
||||
if debounce[2] == 0:
|
||||
debounce[0](*debounce[1])
|
||||
debounce[2] = -1
|
||||
else:
|
||||
debounce[2] -= 1
|
||||
|
||||
def debounce(self, debounce_id, func, args, ticks):
|
||||
"""Debounce a function call.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
debounce_id : hashable
|
||||
If this function is called with the same debounce_id again,
|
||||
the previous debouncing is overwritten, and therefore restarted.
|
||||
func : function
|
||||
args : tuple
|
||||
ticks : int
|
||||
After ticks * 1 / 60 seconds the function will be executed,
|
||||
unless debounce is called again with the same debounce_id
|
||||
"""
|
||||
self.debounces[debounce_id] = [func, args, ticks]
|
||||
|
||||
async def notify(self, event):
|
||||
"""Receive the newest event that should be mapped."""
|
||||
action = utils.classify_action(event, self._abs_range)
|
||||
|
||||
for macro, _ in self.context.macros.values():
|
||||
macro.notify(event, action)
|
||||
|
||||
will_report_key_up = utils.will_report_key_up(event)
|
||||
if not will_report_key_up:
|
||||
# simulate a key-up event if no down event arrives anymore.
|
||||
# this may release macros, combinations or keycodes.
|
||||
release = evdev.InputEvent(0, 0, event.type, event.code, 0)
|
||||
self.debounce(
|
||||
debounce_id=(event.type, event.code, action),
|
||||
func=self.handle_keycode,
|
||||
args=(release, RELEASE, False),
|
||||
ticks=3,
|
||||
)
|
||||
|
||||
async def delayed_handle_keycode():
|
||||
# give macros a priority of working on their asyncio iterations
|
||||
# first before handle_keycode. This is important for if_single.
|
||||
# If if_single injects a modifier to modify the key that canceled
|
||||
# its sleep, it needs to inject it before handle_keycode injects
|
||||
# anything. This is important for the space cadet shift.
|
||||
# 1. key arrives
|
||||
# 2. stop if_single
|
||||
# 3. make if_single inject `then`
|
||||
# 4. inject key
|
||||
# But I can't just wait for if_single to do its thing because it might
|
||||
# be a macro that sleeps for a few seconds.
|
||||
# This appears to me to be incredibly race-conditiony. For that
|
||||
# reason wait a few more asyncio ticks before continuing.
|
||||
# But a single one also worked. I can't wait for the specific
|
||||
# macro task here because it might block forever. I'll just give
|
||||
# it a few asyncio iterations advance before continuing here.
|
||||
for _ in range(10):
|
||||
# Noticable delays caused by this start at 10000 iterations
|
||||
# Also see the python docs on asyncio.sleep. Sleeping for 0
|
||||
# seconds just iterates the loop once.
|
||||
await asyncio.sleep(0)
|
||||
|
||||
self.handle_keycode(event, action)
|
||||
|
||||
await delayed_handle_keycode()
|
||||
|
||||
def macro_write(self, target_uinput):
|
||||
def f(ev_type, code, value):
|
||||
"""Handler for macros."""
|
||||
logger.debug(
|
||||
f"Macro sending %s to %s", (ev_type, code, value), target_uinput
|
||||
)
|
||||
global_uinputs.write((ev_type, code, value), target_uinput)
|
||||
|
||||
return f
|
||||
|
||||
def _get_key(self, key):
|
||||
"""If the event triggers stuff, get the key for that.
|
||||
|
||||
This key can be used to index `key_to_code` and `macros` and it might
|
||||
be a combination of keys.
|
||||
|
||||
Otherwise, for unmapped events, returns the input.
|
||||
|
||||
The return format is always a tuple of 3-tuples, each 3-tuple being
|
||||
type, code, action (int, int, int)
|
||||
|
||||
Parameters
|
||||
----------
|
||||
key : tuple of int
|
||||
3-tuple of type, code, action
|
||||
Action should be one of -1, 0 or 1
|
||||
"""
|
||||
unreleased_entry = find_by_event(key)
|
||||
|
||||
# The key used to index the mappings `key_to_code` and `macros`.
|
||||
# If the key triggers a combination, the returned key will be that one
|
||||
# instead
|
||||
action = key[2]
|
||||
key = (key,)
|
||||
|
||||
if unreleased_entry and unreleased_entry.triggered_key is not None:
|
||||
# seen before. If this key triggered a combination,
|
||||
# use the combination that was triggered by this as key.
|
||||
return unreleased_entry.triggered_key
|
||||
|
||||
if utils.is_key_down(action):
|
||||
# get the key/combination that the key-down would trigger
|
||||
|
||||
# the triggering key-down has to be the last element in
|
||||
# combination, all others can have any arbitrary order. By
|
||||
# checking all unreleased keys, a + b + c takes priority over
|
||||
# b + c, if both mappings exist.
|
||||
# WARNING! the combination-down triggers, but a single key-up
|
||||
# releases. Do not check if key in macros and such, if it is an
|
||||
# up event. It's going to be False.
|
||||
combination = tuple(
|
||||
value.input_event_tuple for value in unreleased.values()
|
||||
)
|
||||
if key[0] not in combination: # might be a duplicate-down event
|
||||
combination += key
|
||||
|
||||
# find any triggered combination. macros and key_to_code contain
|
||||
# every possible equivalent permutation of possible macros. The
|
||||
# last key in the combination needs to remain the newest key
|
||||
# though.
|
||||
for subset in subsets(combination):
|
||||
if subset[-1] != key[0]:
|
||||
# only combinations that are completed and triggered by
|
||||
# the newest input are of interest
|
||||
continue
|
||||
|
||||
if self.context.is_mapped(subset):
|
||||
key = subset
|
||||
break
|
||||
else:
|
||||
# no subset found, just use the key. all indices are tuples of
|
||||
# tuples, both for combinations and single keys.
|
||||
if len(combination) > 1:
|
||||
logger.debug_key(combination, "unknown combination")
|
||||
|
||||
return key
|
||||
|
||||
async def run_macro(self, macro, target_uinput):
|
||||
"""Run the provided macro."""
|
||||
try:
|
||||
await macro.run(self.macro_write(target_uinput))
|
||||
except Exception as e:
|
||||
logger.error(f'Macro "%s" failed: %s', macro.code, e)
|
||||
|
||||
def handle_keycode(self, event, action, forward=True):
|
||||
"""Write mapped keycodes, forward unmapped ones and manage macros.
|
||||
|
||||
As long as the provided event is mapped it will handle it, it won't
|
||||
check any type, code or capability anymore. Otherwise it forwards
|
||||
it as it is.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
action : int
|
||||
One of PRESS, PRESS_NEGATIVE or RELEASE
|
||||
Just looking at the events value is not enough, because then mapping
|
||||
trigger-values that are between 1 and 255 is not possible. They might skip
|
||||
the 1 when pressed fast enough.
|
||||
event : evdev.InputEvent
|
||||
forward : bool
|
||||
if False, will not forward the event if it didn't trigger any
|
||||
mapping
|
||||
"""
|
||||
assert isinstance(action, int)
|
||||
|
||||
type_and_code = (event.type, event.code)
|
||||
active_macro = active_macros.get(type_and_code)
|
||||
original_tuple = (event.type, event.code, event.value)
|
||||
key = self._get_key((*type_and_code, action))
|
||||
is_mapped = self.context.is_mapped(key)
|
||||
|
||||
"""Releasing keys and macros"""
|
||||
|
||||
if utils.is_key_up(action):
|
||||
if active_macro is not None and active_macro.is_holding():
|
||||
# Tell the macro for that keycode that the key is released and
|
||||
# let it decide what to do with that information.
|
||||
active_macro.release_trigger()
|
||||
logger.debug_key(key, "releasing macro")
|
||||
|
||||
if type_and_code in unreleased:
|
||||
# figure out what this release event was for
|
||||
unreleased_entry = unreleased[type_and_code]
|
||||
target_type, target_code, target_uinput = unreleased_entry.target
|
||||
del unreleased[type_and_code]
|
||||
|
||||
if target_code == DISABLE_CODE:
|
||||
logger.debug_key(key, "releasing disabled key")
|
||||
return
|
||||
|
||||
if target_code is None:
|
||||
logger.debug_key(key, "releasing key")
|
||||
return
|
||||
|
||||
if unreleased_entry.is_mapped():
|
||||
# release what the input is mapped to
|
||||
try:
|
||||
logger.debug_key(
|
||||
key, "releasing (%s, %s)", target_code, target_uinput
|
||||
)
|
||||
global_uinputs.write(
|
||||
(target_type, target_code, 0), target_uinput
|
||||
)
|
||||
return
|
||||
except inputremapper.exceptions.Error:
|
||||
logger.debug_key(key, "could not map")
|
||||
pass
|
||||
|
||||
if forward:
|
||||
# forward the release event
|
||||
logger.debug_key((original_tuple,), "forwarding release")
|
||||
self.forward(original_tuple)
|
||||
else:
|
||||
logger.debug_key(key, "not forwarding release")
|
||||
|
||||
return
|
||||
|
||||
if event.type != EV_ABS:
|
||||
# ABS events might be spammed like crazy every time the
|
||||
# position slightly changes
|
||||
logger.debug_key(key, "unexpected key up")
|
||||
|
||||
# everything that can be released is released now
|
||||
return
|
||||
|
||||
"""Filtering duplicate key downs"""
|
||||
|
||||
if is_mapped and utils.is_key_down(action):
|
||||
# unmapped keys should not be filtered here, they should just
|
||||
# be forwarded to populate unreleased and then be written.
|
||||
|
||||
if find_by_key(key) is not None:
|
||||
# this key/combination triggered stuff before.
|
||||
# duplicate key-down. skip this event. Avoid writing millions
|
||||
# of key-down events when a continuous value is reported, for
|
||||
# example for gamepad triggers or mouse-wheel-side buttons
|
||||
logger.debug_key(key, "duplicate key down")
|
||||
return
|
||||
|
||||
# it would start a macro usually
|
||||
in_macros = key in self.context.macros
|
||||
running = active_macro and active_macro.running
|
||||
if in_macros and running:
|
||||
# for key-down events and running macros, don't do anything.
|
||||
# This avoids spawning a second macro while the first one is
|
||||
# not finished, especially since gamepad-triggers report a ton
|
||||
# of events with a positive value.
|
||||
logger.debug_key(key, "macro already running")
|
||||
self.context.macros[key][0].press_trigger()
|
||||
return
|
||||
|
||||
"""starting new macros or injecting new keys"""
|
||||
|
||||
if utils.is_key_down(action):
|
||||
# also enter this for unmapped keys, as they might end up
|
||||
# triggering a combination, so they should be remembered in
|
||||
# unreleased
|
||||
|
||||
if key in self.context.macros:
|
||||
macro, target_uinput = self.context.macros[key]
|
||||
active_macros[type_and_code] = macro
|
||||
Unreleased((None, None, None), (*type_and_code, action), key)
|
||||
macro.press_trigger()
|
||||
logger.debug_key(
|
||||
key, "maps to macro (%s, %s)", macro.code, target_uinput
|
||||
)
|
||||
asyncio.ensure_future(self.run_macro(macro, target_uinput))
|
||||
return
|
||||
|
||||
if key in self.context.key_to_code:
|
||||
target_code, target_uinput = self.context.key_to_code[key]
|
||||
# remember the key that triggered this
|
||||
# (this combination or this single key)
|
||||
Unreleased(
|
||||
(EV_KEY, target_code, target_uinput), (*type_and_code, action), key
|
||||
)
|
||||
|
||||
if target_code == DISABLE_CODE:
|
||||
logger.debug_key(key, "disabled")
|
||||
return
|
||||
|
||||
try:
|
||||
logger.debug_key(
|
||||
key, "maps to (%s, %s)", target_code, target_uinput
|
||||
)
|
||||
global_uinputs.write((EV_KEY, target_code, 1), target_uinput)
|
||||
return
|
||||
except inputremapper.exceptions.Error:
|
||||
logger.debug_key(key, "could not map")
|
||||
pass
|
||||
|
||||
if forward:
|
||||
logger.debug_key((original_tuple,), "forwarding")
|
||||
self.forward(original_tuple)
|
||||
else:
|
||||
logger.debug_key(((*type_and_code, action),), "not forwarding")
|
||||
|
||||
# unhandled events may still be important for triggering
|
||||
# combinations later, so remember them as well.
|
||||
Unreleased((*type_and_code, None), (*type_and_code, action), None)
|
||||
return
|
||||
|
||||
logger.error("%s unhandled", key)
|
||||
@ -0,0 +1,206 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
|
||||
"""Because multiple calls to async_read_loop won't work."""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import traceback
|
||||
from typing import AsyncIterator, Protocol, Set, List
|
||||
|
||||
import evdev
|
||||
|
||||
from inputremapper.utils import get_device_hash, DeviceHash
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
EventListener,
|
||||
NotifyCallback,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent
|
||||
from inputremapper.logger import logger
|
||||
|
||||
|
||||
class Context(Protocol):
|
||||
listeners: Set[EventListener]
|
||||
|
||||
def reset(self):
|
||||
...
|
||||
|
||||
def get_notify_callbacks(self, input_event: InputEvent) -> List[NotifyCallback]:
|
||||
...
|
||||
|
||||
def get_forward_uinput(self, origin_hash: DeviceHash) -> evdev.UInput:
|
||||
...
|
||||
|
||||
|
||||
class EventReader:
|
||||
"""Reads input events from a single device and distributes them.
|
||||
|
||||
There is one EventReader object for each source, which tells multiple
|
||||
mapping_handlers that a new event is ready so that they can inject all sorts of
|
||||
funny things.
|
||||
|
||||
Other devnodes may be present for the hardware device, in which case this
|
||||
needs to be created multiple times.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
context: Context,
|
||||
source: evdev.InputDevice,
|
||||
stop_event: asyncio.Event,
|
||||
) -> None:
|
||||
"""Initialize all mapping_handlers
|
||||
|
||||
Parameters
|
||||
----------
|
||||
source
|
||||
where to read keycodes from
|
||||
"""
|
||||
self._device_hash = get_device_hash(source)
|
||||
self._source = source
|
||||
self.context = context
|
||||
self.stop_event = stop_event
|
||||
|
||||
def stop(self):
|
||||
"""Stop the reader."""
|
||||
self.stop_event.set()
|
||||
|
||||
async def read_loop(self) -> AsyncIterator[evdev.InputEvent]:
|
||||
stop_task = asyncio.Task(self.stop_event.wait())
|
||||
loop = asyncio.get_running_loop()
|
||||
events_ready = asyncio.Event()
|
||||
loop.add_reader(self._source.fileno(), events_ready.set)
|
||||
|
||||
while True:
|
||||
_, pending = await asyncio.wait(
|
||||
{stop_task, asyncio.Task(events_ready.wait())},
|
||||
return_when=asyncio.FIRST_COMPLETED,
|
||||
)
|
||||
|
||||
fd_broken = os.stat(self._source.fileno()).st_nlink == 0
|
||||
if fd_broken:
|
||||
# happens when the device is unplugged while reading, causing 100% cpu
|
||||
# usage because events_ready.set is called repeatedly forever,
|
||||
# while read_loop will hang at self._source.read_one().
|
||||
logger.error("fd broke, was the device unplugged?")
|
||||
|
||||
if stop_task.done() or fd_broken:
|
||||
for task in pending:
|
||||
task.cancel()
|
||||
loop.remove_reader(self._source.fileno())
|
||||
logger.debug("read loop stopped")
|
||||
return
|
||||
|
||||
events_ready.clear()
|
||||
while event := self._source.read_one():
|
||||
yield event
|
||||
|
||||
def send_to_handlers(self, event: InputEvent) -> bool:
|
||||
"""Send the event to the NotifyCallbacks.
|
||||
|
||||
Return if anyone took care of the event.
|
||||
"""
|
||||
if event.type == evdev.ecodes.EV_MSC:
|
||||
return False
|
||||
|
||||
if event.type == evdev.ecodes.EV_SYN:
|
||||
return False
|
||||
|
||||
handled = False
|
||||
notify_callbacks = self.context.get_notify_callbacks(event)
|
||||
|
||||
if notify_callbacks:
|
||||
for notify_callback in notify_callbacks:
|
||||
handled = notify_callback(event, source=self._source) | handled
|
||||
|
||||
return handled
|
||||
|
||||
async def send_to_listeners(self, event: InputEvent) -> None:
|
||||
"""Send the event to listeners."""
|
||||
if event.type == evdev.ecodes.EV_MSC:
|
||||
return
|
||||
|
||||
if event.type == evdev.ecodes.EV_SYN:
|
||||
return
|
||||
|
||||
for listener in self.context.listeners.copy():
|
||||
# use a copy, since the listeners might remove themselves form the set
|
||||
|
||||
# fire and forget, run them in parallel and don't wait for them, since
|
||||
# a listener might be blocking forever while waiting for more events.
|
||||
asyncio.ensure_future(listener(event))
|
||||
|
||||
# Running macros have priority, give them a head-start for processing the
|
||||
# event. If if_single injects a modifier, this modifier should be active
|
||||
# before the next handler injects an "a" or something, so that it is
|
||||
# possible to capitalize it via if_single.
|
||||
# 1. Event from keyboard arrives (e.g. an "a")
|
||||
# 2. the listener for if_single is called
|
||||
# 3. if_single decides runs then (e.g. injects shift_L)
|
||||
# 4. The original event is forwarded (or whatever it is supposed to do)
|
||||
# 5. Capitalized "A" is injected.
|
||||
# So make sure to call the listeners before notifying the handlers.
|
||||
await asyncio.sleep(0)
|
||||
|
||||
def forward(self, event: InputEvent) -> None:
|
||||
"""Forward an event, which injects it unmodified."""
|
||||
forward_to = self.context.get_forward_uinput(self._device_hash)
|
||||
|
||||
if event.type == evdev.ecodes.EV_KEY:
|
||||
logger.write(event, forward_to)
|
||||
|
||||
forward_to.write(*event.event_tuple)
|
||||
|
||||
async def handle(self, event: InputEvent) -> None:
|
||||
if event.type == evdev.ecodes.EV_KEY and event.value == 2:
|
||||
# button-hold event. Environments (gnome, etc.) create them on
|
||||
# their own for the injection-fake-device if the release event
|
||||
# won't appear, no need to forward or map them.
|
||||
return
|
||||
|
||||
await self.send_to_listeners(event)
|
||||
|
||||
if not self.send_to_handlers(event):
|
||||
# no handler took care of it, forward it
|
||||
self.forward(event)
|
||||
|
||||
async def run(self):
|
||||
"""Start doing things.
|
||||
|
||||
Can be stopped by stopping the asyncio loop or by setting the stop_event.
|
||||
This loop reads events from a single device only.
|
||||
"""
|
||||
logger.debug(
|
||||
"Starting to listen for events from %s, fd %s",
|
||||
self._source.path,
|
||||
self._source.fd,
|
||||
)
|
||||
|
||||
async for event in self.read_loop():
|
||||
try:
|
||||
await self.handle(
|
||||
InputEvent.from_event(event, origin_hash=self._device_hash)
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error("Handling event %s failed: %s", event, e)
|
||||
traceback.print_exception(e)
|
||||
|
||||
self.context.reset()
|
||||
logger.info("read loop for %s stopped", self._source.path)
|
||||
@ -0,0 +1,152 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 typing import Tuple, Optional, Dict
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import EV_ABS
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper import exceptions
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.injection.global_uinputs import global_uinputs
|
||||
from inputremapper.injection.mapping_handlers.axis_transform import Transformation
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
HandlerEnums,
|
||||
InputEventHandler,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent, EventActions
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.utils import get_evdev_constant_name
|
||||
|
||||
|
||||
class AbsToAbsHandler(MappingHandler):
|
||||
"""Handler which transforms EV_ABS to EV_ABS events."""
|
||||
|
||||
_map_axis: InputConfig # the InputConfig for the axis we map
|
||||
_output_axis: Tuple[int, int] # the (type, code) of the output axis
|
||||
_transform: Optional[Transformation]
|
||||
_target_absinfo: evdev.AbsInfo
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
**_,
|
||||
) -> None:
|
||||
super().__init__(combination, mapping)
|
||||
|
||||
# find the input event we are supposed to map. If the input combination is
|
||||
# BTN_A + ABS_X + BTN_B, then use the value of ABS_X for the transformation
|
||||
assert (map_axis := combination.find_analog_input_config(type_=EV_ABS))
|
||||
self._map_axis = map_axis
|
||||
|
||||
assert mapping.output_code is not None
|
||||
assert mapping.output_type == EV_ABS
|
||||
self._output_axis = (mapping.output_type, mapping.output_code)
|
||||
|
||||
target_uinput = global_uinputs.get_uinput(mapping.target_uinput)
|
||||
assert target_uinput is not None
|
||||
abs_capabilities = target_uinput.capabilities(absinfo=True)[EV_ABS]
|
||||
self._target_absinfo = dict(abs_capabilities)[mapping.output_code]
|
||||
|
||||
self._transform = None
|
||||
|
||||
def __str__(self):
|
||||
name = get_evdev_constant_name(*self._map_axis.type_and_code)
|
||||
return f'AbsToAbsHandler for "{name}" {self._map_axis}'
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self): # used for logging
|
||||
return (
|
||||
f"maps to: {self.mapping.get_output_name_constant()} "
|
||||
f"{self.mapping.get_output_type_code()} at "
|
||||
f"{self.mapping.target_uinput}"
|
||||
)
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
if event.input_match_hash != self._map_axis.input_match_hash:
|
||||
return False
|
||||
|
||||
if EventActions.recenter in event.actions:
|
||||
self._write(self._scale_to_target(0))
|
||||
return True
|
||||
|
||||
if not self._transform:
|
||||
absinfo = dict(source.capabilities(absinfo=True)[EV_ABS])[event.code]
|
||||
self._transform = Transformation(
|
||||
max_=absinfo.max,
|
||||
min_=absinfo.min,
|
||||
deadzone=self.mapping.deadzone,
|
||||
gain=self.mapping.gain,
|
||||
expo=self.mapping.expo,
|
||||
)
|
||||
|
||||
try:
|
||||
self._write(self._scale_to_target(self._transform(event.value)))
|
||||
return True
|
||||
except (exceptions.UinputNotAvailable, exceptions.EventNotHandled):
|
||||
return False
|
||||
|
||||
def reset(self) -> None:
|
||||
self._write(self._scale_to_target(0))
|
||||
|
||||
def _scale_to_target(self, x: float) -> int:
|
||||
"""Scales a x value between -1 and 1 to an integer between
|
||||
target_absinfo.min and target_absinfo.max
|
||||
|
||||
input values above 1 or below -1 are clamped to the extreme values
|
||||
"""
|
||||
factor = (self._target_absinfo.max - self._target_absinfo.min) / 2
|
||||
offset = self._target_absinfo.min + factor
|
||||
y = factor * x + offset
|
||||
if y > offset:
|
||||
return int(min(self._target_absinfo.max, y))
|
||||
else:
|
||||
return int(max(self._target_absinfo.min, y))
|
||||
|
||||
def _write(self, value: int):
|
||||
"""Inject."""
|
||||
try:
|
||||
global_uinputs.write(
|
||||
(*self._output_axis, value), self.mapping.target_uinput
|
||||
)
|
||||
except OverflowError:
|
||||
# screwed up the calculation of the event value
|
||||
logger.error("OverflowError (%s, %s, %s)", *self._output_axis, value)
|
||||
|
||||
def needs_wrapping(self) -> bool:
|
||||
return len(self.input_configs) > 1
|
||||
|
||||
def set_sub_handler(self, handler: InputEventHandler) -> None:
|
||||
assert False # cannot have a sub-handler
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
if self.needs_wrapping():
|
||||
return {InputCombination(self.input_configs): HandlerEnums.axisswitch}
|
||||
return {}
|
||||
@ -0,0 +1,127 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 typing import Tuple
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import EV_ABS
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
InputEventHandler,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent, EventActions
|
||||
from inputremapper.utils import get_evdev_constant_name
|
||||
|
||||
|
||||
class AbsToBtnHandler(MappingHandler):
|
||||
"""Handler which transforms an EV_ABS to a button event."""
|
||||
|
||||
_input_config: InputConfig
|
||||
_active: bool
|
||||
_sub_handler: InputEventHandler
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
**_,
|
||||
):
|
||||
super().__init__(combination, mapping)
|
||||
|
||||
self._active = False
|
||||
self._input_config = combination[0]
|
||||
assert self._input_config.analog_threshold
|
||||
assert len(combination) == 1
|
||||
|
||||
def __str__(self):
|
||||
name = get_evdev_constant_name(*self._input_config.type_and_code)
|
||||
return f'AbsToBtnHandler for "{name}" ' f"{self._input_config.type_and_code}"
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self): # used for logging
|
||||
return self._sub_handler
|
||||
|
||||
def _trigger_point(self, abs_min: int, abs_max: int) -> Tuple[float, float]:
|
||||
"""Calculate the axis mid and trigger point."""
|
||||
# TODO: potentially cache this function
|
||||
assert self._input_config.analog_threshold
|
||||
if abs_min == -1 and abs_max == 1:
|
||||
# this is a hat switch
|
||||
# return +-1
|
||||
return (
|
||||
self._input_config.analog_threshold
|
||||
// abs(self._input_config.analog_threshold),
|
||||
0,
|
||||
)
|
||||
|
||||
half_range = (abs_max - abs_min) / 2
|
||||
middle = half_range + abs_min
|
||||
trigger_offset = half_range * self._input_config.analog_threshold / 100
|
||||
|
||||
# threshold, middle
|
||||
return middle + trigger_offset, middle
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
if event.input_match_hash != self._input_config.input_match_hash:
|
||||
return False
|
||||
|
||||
absinfo = {
|
||||
entry[0]: entry[1] for entry in source.capabilities(absinfo=True)[EV_ABS]
|
||||
}
|
||||
threshold, mid_point = self._trigger_point(
|
||||
absinfo[event.code].min, absinfo[event.code].max
|
||||
)
|
||||
value = event.value
|
||||
if (value < threshold > mid_point) or (value > threshold < mid_point):
|
||||
if self._active:
|
||||
event = event.modify(value=0, actions=(EventActions.as_key,))
|
||||
else:
|
||||
# consume the event.
|
||||
# We could return False to forward events
|
||||
return True
|
||||
else:
|
||||
if value >= threshold > mid_point:
|
||||
direction = EventActions.positive_trigger
|
||||
else:
|
||||
direction = EventActions.negative_trigger
|
||||
event = event.modify(value=1, actions=(EventActions.as_key, direction))
|
||||
|
||||
self._active = bool(event.value)
|
||||
# logger.debug(event.event_tuple, "sending to sub_handler")
|
||||
return self._sub_handler.notify(
|
||||
event,
|
||||
source=source,
|
||||
suppress=suppress,
|
||||
)
|
||||
|
||||
def reset(self) -> None:
|
||||
self._active = False
|
||||
self._sub_handler.reset()
|
||||
@ -0,0 +1,245 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
import asyncio
|
||||
import math
|
||||
import time
|
||||
from functools import partial
|
||||
from typing import Dict, Tuple, Optional
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import (
|
||||
EV_REL,
|
||||
EV_ABS,
|
||||
REL_WHEEL,
|
||||
REL_HWHEEL,
|
||||
REL_WHEEL_HI_RES,
|
||||
REL_HWHEEL_HI_RES,
|
||||
)
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper.configs.mapping import (
|
||||
Mapping,
|
||||
REL_XY_SCALING,
|
||||
WHEEL_SCALING,
|
||||
WHEEL_HI_RES_SCALING,
|
||||
DEFAULT_REL_RATE,
|
||||
)
|
||||
from inputremapper.injection.global_uinputs import global_uinputs
|
||||
from inputremapper.injection.mapping_handlers.axis_transform import Transformation
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
HandlerEnums,
|
||||
InputEventHandler,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent, EventActions
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.utils import get_evdev_constant_name
|
||||
|
||||
|
||||
def calculate_output(value, weight, remainder):
|
||||
# self._value is between 0 and 1, scale up with weight
|
||||
scaled = value * weight + remainder
|
||||
# float_value % 1 will result in wrong calculations for negative values
|
||||
remainder = math.fmod(scaled, 1)
|
||||
return int(scaled), remainder
|
||||
|
||||
|
||||
# TODO move into class?
|
||||
async def _run_normal_output(self) -> None:
|
||||
"""Start injecting events."""
|
||||
self._running = True
|
||||
self._stop = False
|
||||
remainder = 0.0
|
||||
start = time.time()
|
||||
|
||||
# if the rate is configured to be slower than the default, increase the value, so
|
||||
# that the overall speed stays the same.
|
||||
rate_compensation = DEFAULT_REL_RATE / self.mapping.rel_rate
|
||||
weight = REL_XY_SCALING * rate_compensation
|
||||
|
||||
while not self._stop:
|
||||
value, remainder = calculate_output(
|
||||
self._value,
|
||||
weight,
|
||||
remainder,
|
||||
)
|
||||
|
||||
self._write(EV_REL, self.mapping.output_code, value)
|
||||
|
||||
time_taken = time.time() - start
|
||||
sleep = max(0.0, (1 / self.mapping.rel_rate) - time_taken)
|
||||
await asyncio.sleep(sleep)
|
||||
start = time.time()
|
||||
|
||||
self._running = False
|
||||
|
||||
|
||||
# TODO move into class?
|
||||
async def _run_wheel_output(self, codes: Tuple[int, int]) -> None:
|
||||
"""Start injecting wheel events.
|
||||
|
||||
made to inject both REL_WHEEL and REL_WHEEL_HI_RES events, because otherwise
|
||||
wheel output doesn't work for some people. See issue #354
|
||||
"""
|
||||
weights = (WHEEL_SCALING, WHEEL_HI_RES_SCALING)
|
||||
|
||||
self._running = True
|
||||
self._stop = False
|
||||
remainder = [0.0, 0.0]
|
||||
start = time.time()
|
||||
while not self._stop:
|
||||
for i in range(len(codes)):
|
||||
value, remainder[i] = calculate_output(
|
||||
self._value,
|
||||
weights[i],
|
||||
remainder[i],
|
||||
)
|
||||
|
||||
self._write(EV_REL, codes[i], value)
|
||||
|
||||
time_taken = time.time() - start
|
||||
await asyncio.sleep(max(0.0, (1 / self.mapping.rel_rate) - time_taken))
|
||||
start = time.time()
|
||||
|
||||
self._running = False
|
||||
|
||||
|
||||
class AbsToRelHandler(MappingHandler):
|
||||
"""Handler which transforms an EV_ABS to EV_REL events."""
|
||||
|
||||
_map_axis: InputConfig # the InputConfig for the axis we map
|
||||
_value: float # the current output value
|
||||
_running: bool # if the run method is active
|
||||
_stop: bool # if the run loop should return
|
||||
_transform: Optional[Transformation]
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
**_,
|
||||
) -> None:
|
||||
super().__init__(combination, mapping)
|
||||
|
||||
# find the input event we are supposed to map
|
||||
assert (map_axis := combination.find_analog_input_config(type_=EV_ABS))
|
||||
self._map_axis = map_axis
|
||||
|
||||
self._value = 0
|
||||
self._running = False
|
||||
self._stop = True
|
||||
self._transform = None
|
||||
|
||||
# bind the correct run method
|
||||
if self.mapping.output_code in (
|
||||
REL_WHEEL,
|
||||
REL_HWHEEL,
|
||||
REL_WHEEL_HI_RES,
|
||||
REL_HWHEEL_HI_RES,
|
||||
):
|
||||
if self.mapping.output_code in (REL_WHEEL, REL_WHEEL_HI_RES):
|
||||
codes = (REL_WHEEL, REL_WHEEL_HI_RES)
|
||||
else:
|
||||
codes = (REL_HWHEEL, REL_HWHEEL_HI_RES)
|
||||
|
||||
self._run = partial(_run_wheel_output, self, codes=codes)
|
||||
|
||||
else:
|
||||
self._run = partial(_run_normal_output, self)
|
||||
|
||||
def __str__(self):
|
||||
name = get_evdev_constant_name(*self._map_axis.type_and_code)
|
||||
return f'AbsToRelHandler for "{name}" {self._map_axis}'
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self): # used for logging
|
||||
return (
|
||||
f"maps to: {self.mapping.get_output_name_constant()} "
|
||||
f"{self.mapping.get_output_type_code()} at "
|
||||
f"{self.mapping.target_uinput}"
|
||||
)
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
if event.input_match_hash != self._map_axis.input_match_hash:
|
||||
return False
|
||||
|
||||
if EventActions.recenter in event.actions:
|
||||
self._stop = True
|
||||
return True
|
||||
|
||||
if not self._transform:
|
||||
absinfo = {
|
||||
entry[0]: entry[1]
|
||||
for entry in source.capabilities(absinfo=True)[EV_ABS]
|
||||
}
|
||||
self._transform = Transformation(
|
||||
max_=absinfo[event.code].max,
|
||||
min_=absinfo[event.code].min,
|
||||
deadzone=self.mapping.deadzone,
|
||||
gain=self.mapping.gain,
|
||||
expo=self.mapping.expo,
|
||||
)
|
||||
|
||||
transformed = self._transform(event.value)
|
||||
|
||||
self._value = transformed
|
||||
|
||||
if transformed == 0:
|
||||
self._stop = True
|
||||
return True
|
||||
|
||||
if not self._running:
|
||||
asyncio.ensure_future(self._run())
|
||||
return True
|
||||
|
||||
def reset(self) -> None:
|
||||
self._stop = True
|
||||
|
||||
def _write(self, type_, keycode, value):
|
||||
"""Inject."""
|
||||
# if the mouse won't move even though correct stuff is written here,
|
||||
# the capabilities are probably wrong
|
||||
if value == 0:
|
||||
return # rel 0 does not make sense
|
||||
|
||||
try:
|
||||
global_uinputs.write((type_, keycode, value), self.mapping.target_uinput)
|
||||
except OverflowError:
|
||||
# screwed up the calculation of mouse movements
|
||||
logger.error("OverflowError (%s, %s, %s)", type_, keycode, value)
|
||||
|
||||
def needs_wrapping(self) -> bool:
|
||||
return len(self.input_configs) > 1
|
||||
|
||||
def set_sub_handler(self, handler: InputEventHandler) -> None:
|
||||
assert False # cannot have a sub-handler
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
if self.needs_wrapping():
|
||||
return {InputCombination(self.input_configs): HandlerEnums.axisswitch}
|
||||
return {}
|
||||
@ -0,0 +1,185 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 typing import Dict, Tuple, Hashable, TYPE_CHECKING
|
||||
|
||||
import evdev
|
||||
from inputremapper.configs.input_config import InputConfig
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
HandlerEnums,
|
||||
InputEventHandler,
|
||||
ContextProtocol,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent, EventActions
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.utils import get_device_hash
|
||||
|
||||
|
||||
class AxisSwitchHandler(MappingHandler):
|
||||
"""Enables or disables an axis.
|
||||
|
||||
Generally, if multiple events are mapped to something in a combination, all of
|
||||
them need to be triggered in order to map to the output.
|
||||
|
||||
If an analog input is combined with a key input, then the same thing should happen.
|
||||
The key needs to be pressed and the joystick needs to be moved in order to generate
|
||||
output.
|
||||
"""
|
||||
|
||||
_map_axis: InputConfig # the InputConfig for the axis we switch on or off
|
||||
_trigger_keys: Tuple[Hashable, ...] # all events that can switch the axis
|
||||
_active: bool # whether the axis is on or off
|
||||
_last_value: int # the value of the last axis event that arrived
|
||||
_axis_source: evdev.InputDevice # the cached source of the axis input events
|
||||
_forward_device: evdev.UInput # the cached forward uinput
|
||||
_sub_handler: InputEventHandler
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
context: ContextProtocol,
|
||||
**_,
|
||||
):
|
||||
super().__init__(combination, mapping)
|
||||
trigger_keys = tuple(
|
||||
event.input_match_hash
|
||||
for event in combination
|
||||
if not event.defines_analog_input
|
||||
)
|
||||
assert len(trigger_keys) >= 1
|
||||
assert (map_axis := combination.find_analog_input_config())
|
||||
self._map_axis = map_axis
|
||||
self._trigger_keys = trigger_keys
|
||||
self._active = False
|
||||
|
||||
self._last_value = 0
|
||||
self._axis_source = None
|
||||
self._forward_device = None
|
||||
|
||||
self.context = context
|
||||
|
||||
def __str__(self):
|
||||
return f"AxisSwitchHandler for {self._map_axis.type_and_code}"
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self):
|
||||
return self._sub_handler
|
||||
|
||||
def _handle_key_input(self, event: InputEvent):
|
||||
"""If a key is pressed, allow mapping analog events in subhandlers.
|
||||
|
||||
Analog events (e.g. ABS_X, REL_Y) that have gone through Handlers that
|
||||
transform them to buttons also count as keys.
|
||||
"""
|
||||
key_is_pressed = bool(event.value)
|
||||
if self._active == key_is_pressed:
|
||||
# nothing changed
|
||||
return False
|
||||
|
||||
self._active = key_is_pressed
|
||||
|
||||
if self._axis_source is None:
|
||||
return True
|
||||
|
||||
if not key_is_pressed:
|
||||
# recenter the axis
|
||||
logger.debug("Stopping axis for %s", self.mapping.input_combination)
|
||||
event = InputEvent(
|
||||
0,
|
||||
0,
|
||||
*self._map_axis.type_and_code,
|
||||
0,
|
||||
actions=(EventActions.recenter,),
|
||||
origin_hash=self._map_axis.origin_hash,
|
||||
)
|
||||
self._sub_handler.notify(event, self._axis_source)
|
||||
return True
|
||||
|
||||
if self._map_axis.type == evdev.ecodes.EV_ABS:
|
||||
# send the last cached value so that the abs axis
|
||||
# is at the correct position
|
||||
logger.debug("Starting axis for %s", self.mapping.input_combination)
|
||||
event = InputEvent(
|
||||
0,
|
||||
0,
|
||||
*self._map_axis.type_and_code,
|
||||
self._last_value,
|
||||
origin_hash=self._map_axis.origin_hash,
|
||||
)
|
||||
self._sub_handler.notify(event, self._axis_source)
|
||||
return True
|
||||
|
||||
return True
|
||||
|
||||
def _should_map(self, event: InputEvent):
|
||||
return (
|
||||
event.input_match_hash in self._trigger_keys
|
||||
or event.input_match_hash == self._map_axis.input_match_hash
|
||||
)
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
if not self._should_map(event):
|
||||
return False
|
||||
|
||||
if event.is_key_event:
|
||||
return self._handle_key_input(event)
|
||||
|
||||
# do some caching so that we can generate the
|
||||
# recenter event and an initial abs event
|
||||
if self._axis_source is None:
|
||||
self._axis_source = source
|
||||
|
||||
if self._forward_device is None:
|
||||
device_hash = get_device_hash(source)
|
||||
self._forward_device = self.context.get_forward_uinput(device_hash)
|
||||
|
||||
# always cache the value
|
||||
self._last_value = event.value
|
||||
|
||||
if self._active:
|
||||
return self._sub_handler.notify(event, source, suppress)
|
||||
|
||||
return False
|
||||
|
||||
def reset(self) -> None:
|
||||
self._last_value = 0
|
||||
self._active = False
|
||||
self._sub_handler.reset()
|
||||
|
||||
def needs_wrapping(self) -> bool:
|
||||
return True
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
combination = [
|
||||
config for config in self.input_configs if not config.defines_analog_input
|
||||
]
|
||||
return {InputCombination(combination): HandlerEnums.combination}
|
||||
@ -0,0 +1,141 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
import math
|
||||
from typing import Dict, Union
|
||||
|
||||
|
||||
class Transformation:
|
||||
"""Callable that returns the axis transformation at x."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
# if input values are > max_, the return value will be > 1
|
||||
max_: Union[int, float],
|
||||
min_: Union[int, float],
|
||||
deadzone: float,
|
||||
gain: float = 1,
|
||||
expo: float = 0,
|
||||
) -> None:
|
||||
self._max = max_
|
||||
self._min = min_
|
||||
self._deadzone = deadzone
|
||||
self._gain = gain
|
||||
self._expo = expo
|
||||
self._cache: Dict[float, float] = {}
|
||||
|
||||
def __call__(self, /, x: Union[int, float]) -> float:
|
||||
if x not in self._cache:
|
||||
y = (
|
||||
self._calc_qubic(self._flatten_deadzone(self._normalize(x)))
|
||||
* self._gain
|
||||
)
|
||||
self._cache[x] = y
|
||||
|
||||
return self._cache[x]
|
||||
|
||||
def set_range(self, min_, max_):
|
||||
# TODO docstring
|
||||
if min_ != self._min or max_ != self._max:
|
||||
self._cache = {}
|
||||
|
||||
self._min = min_
|
||||
self._max = max_
|
||||
|
||||
def _normalize(self, x: Union[int, float]) -> float:
|
||||
"""Move and scale x to be between -1 and 1
|
||||
return: x
|
||||
"""
|
||||
if self._min == -1 and self._max == 1:
|
||||
return x
|
||||
|
||||
half_range = (self._max - self._min) / 2
|
||||
middle = half_range + self._min
|
||||
return (x - middle) / half_range
|
||||
|
||||
def _flatten_deadzone(self, x: float) -> float:
|
||||
"""
|
||||
y ^ y ^
|
||||
| |
|
||||
1 | / 1 | /
|
||||
| / | /
|
||||
| / ==> | ---
|
||||
| / | /
|
||||
-1 | / -1 | /
|
||||
|------------> |------------>
|
||||
-1 1 x -1 1 x
|
||||
"""
|
||||
if abs(x) <= self._deadzone:
|
||||
return 0
|
||||
|
||||
return (x - self._deadzone * x / abs(x)) / (1 - self._deadzone)
|
||||
|
||||
def _calc_qubic(self, x: float) -> float:
|
||||
"""Transforms an x value by applying a qubic function
|
||||
|
||||
k = 0 : will yield no transformation f(x) = x
|
||||
1 > k > 0 : will yield low sensitivity for low x values
|
||||
and high sensitivity for high x values
|
||||
-1 < k < 0 : will yield high sensitivity for low x values
|
||||
and low sensitivity for high x values
|
||||
|
||||
see also: https://www.geogebra.org/calculator/mkdqueky
|
||||
|
||||
Mathematical definition:
|
||||
f(x,d) = d * x + (1 - d) * x ** 3 | d = 1 - k | k ∈ [0,1]
|
||||
the function is designed such that if follows these constraints:
|
||||
f'(0, d) = d and f(1, d) = 1 and f(-x,d) = -f(x,d)
|
||||
|
||||
for k ∈ [-1,0) the above function is mirrored at y = x
|
||||
and d = 1 + k
|
||||
"""
|
||||
k = self._expo
|
||||
|
||||
if k == 0 or x == 0:
|
||||
return x
|
||||
|
||||
if 0 < k <= 1:
|
||||
d = 1 - k
|
||||
return d * x + (1 - d) * x**3
|
||||
|
||||
if -1 <= k < 0:
|
||||
# calculate return value with the real inverse solution
|
||||
# of y = b * x + a * x ** 3
|
||||
# LaTeX for better readability:
|
||||
#
|
||||
# y=\frac{{{\left( \sqrt{27 {{x}^{2}}+\frac{4 {{b}^{3}}}{a}}
|
||||
# +{{3}^{\frac{3}{2}}} x\right) }^{\frac{1}{3}}}}
|
||||
# {{{2}^{\frac{1}{3}}} \sqrt{3} {{a}^{\frac{1}{3}}}}
|
||||
# -\frac{{{2}^{\frac{1}{3}}} b}
|
||||
# {\sqrt{3} {{a}^{\frac{2}{3}}}
|
||||
# {{\left( \sqrt{27 {{x}^{2}}+\frac{4 {{b}^{3}}}{a}}
|
||||
# +{{3}^{\frac{3}{2}}} x\right) }^{\frac{1}{3}}}}
|
||||
sign = x / abs(x)
|
||||
x = math.fabs(x)
|
||||
d = 1 + k
|
||||
a = 1 - d
|
||||
b = d
|
||||
c = (math.sqrt(27 * x**2 + (4 * b**3) / a) + 3 ** (3 / 2) * x) ** (
|
||||
1 / 3
|
||||
)
|
||||
y = c / (2 ** (1 / 3) * math.sqrt(3) * a ** (1 / 3)) - (
|
||||
2 ** (1 / 3) * b
|
||||
) / (math.sqrt(3) * a ** (2 / 3) * c)
|
||||
return y * sign
|
||||
|
||||
raise ValueError("k must be between -1 and 1")
|
||||
@ -0,0 +1,197 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 # needed for the TYPE_CHECKING import
|
||||
from typing import TYPE_CHECKING, Dict, Hashable
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import EV_ABS, EV_REL
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
InputEventHandler,
|
||||
HandlerEnums,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent
|
||||
from inputremapper.logger import logger
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from inputremapper.injection.context import Context
|
||||
|
||||
|
||||
class CombinationHandler(MappingHandler):
|
||||
"""Keeps track of a combination and notifies a sub handler."""
|
||||
|
||||
# map of InputEvent.input_match_hash -> bool , keep track of the combination state
|
||||
_pressed_keys: Dict[Hashable, bool]
|
||||
_output_state: bool # the last update we sent to a sub-handler
|
||||
_sub_handler: InputEventHandler
|
||||
_handled_input_hashes: list[Hashable]
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
context: Context,
|
||||
**_,
|
||||
) -> None:
|
||||
logger.debug(str(mapping))
|
||||
super().__init__(combination, mapping)
|
||||
self._pressed_keys = {}
|
||||
self._output_state = False
|
||||
self._context = context
|
||||
|
||||
# prepare a key map for all events with non-zero value
|
||||
for input_config in combination:
|
||||
assert not input_config.defines_analog_input
|
||||
self._pressed_keys[input_config.input_match_hash] = False
|
||||
|
||||
self._handled_input_hashes = [
|
||||
input_config.input_match_hash for input_config in combination
|
||||
]
|
||||
|
||||
assert len(self._pressed_keys) > 0 # no combination handler without a key
|
||||
|
||||
def __str__(self):
|
||||
return (
|
||||
f'CombinationHandler for "{str(self.mapping.input_combination)}" '
|
||||
f"{tuple(t for t in self._pressed_keys.keys())}"
|
||||
)
|
||||
|
||||
def __repr__(self):
|
||||
description = (
|
||||
f'CombinationHandler for "{repr(self.mapping.input_combination)}" '
|
||||
f"{tuple(t for t in self._pressed_keys.keys())}"
|
||||
)
|
||||
return f"<{description} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self):
|
||||
# used for logging
|
||||
return self._sub_handler
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
if event.input_match_hash not in self._handled_input_hashes:
|
||||
# we are not responsible for the event
|
||||
return False
|
||||
|
||||
was_activated = self.is_activated()
|
||||
|
||||
# update the state
|
||||
# The value of non-key input should have been changed to either 0 or 1 at this
|
||||
# point by other handlers.
|
||||
is_pressed = event.value == 1
|
||||
self._pressed_keys[event.input_match_hash] = is_pressed
|
||||
# maybe this changes the activation status (triggered/not-triggered)
|
||||
is_activated = self.is_activated()
|
||||
|
||||
if is_activated == was_activated or is_activated == self._output_state:
|
||||
# nothing changed
|
||||
if self._output_state:
|
||||
# combination is active, consume the event
|
||||
return True
|
||||
else:
|
||||
# combination inactive, forward the event
|
||||
return False
|
||||
|
||||
if is_activated:
|
||||
# send key up events to the forwarded uinput
|
||||
self.forward_release()
|
||||
event = event.modify(value=1)
|
||||
else:
|
||||
if self._output_state or self.mapping.is_axis_mapping():
|
||||
# we ignore the suppress argument for release events
|
||||
# otherwise we might end up with stuck keys
|
||||
# (test_event_pipeline.test_combination)
|
||||
|
||||
# we also ignore it if the mapping specifies an output axis
|
||||
# this will enable us to activate multiple axis with the same button
|
||||
suppress = False
|
||||
event = event.modify(value=0)
|
||||
|
||||
if suppress:
|
||||
return False
|
||||
|
||||
logger.debug("Sending %s to sub-handler", self.mapping.input_combination)
|
||||
self._output_state = bool(event.value)
|
||||
return self._sub_handler.notify(event, source, suppress)
|
||||
|
||||
def reset(self) -> None:
|
||||
self._sub_handler.reset()
|
||||
for key in self._pressed_keys:
|
||||
self._pressed_keys[key] = False
|
||||
self._output_state = False
|
||||
|
||||
def is_activated(self) -> bool:
|
||||
"""Return if all keys in the keymap are set to True."""
|
||||
return False not in self._pressed_keys.values()
|
||||
|
||||
def forward_release(self) -> None:
|
||||
"""Forward a button release for all keys if this is a combination.
|
||||
|
||||
This might cause duplicate key-up events but those are ignored by evdev anyway
|
||||
"""
|
||||
if len(self._pressed_keys) == 1 or not self.mapping.release_combination_keys:
|
||||
return
|
||||
|
||||
keys_to_release = filter(
|
||||
lambda cfg: self._pressed_keys.get(cfg.input_match_hash),
|
||||
self.mapping.input_combination,
|
||||
)
|
||||
|
||||
logger.debug("Forwarding release for %s", self.mapping.input_combination)
|
||||
|
||||
for input_config in keys_to_release:
|
||||
origin_hash = input_config.origin_hash
|
||||
if origin_hash is None:
|
||||
logger.error(
|
||||
f"Can't forward due to missing origin_hash in {repr(input_config)}"
|
||||
)
|
||||
continue
|
||||
|
||||
forward_to = self._context.get_forward_uinput(origin_hash)
|
||||
logger.write(input_config, forward_to)
|
||||
forward_to.write(*input_config.type_and_code, 0)
|
||||
forward_to.syn()
|
||||
|
||||
def needs_ranking(self) -> bool:
|
||||
return bool(self.input_configs)
|
||||
|
||||
def rank_by(self) -> InputCombination:
|
||||
return InputCombination(
|
||||
[event for event in self.input_configs if not event.defines_analog_input]
|
||||
)
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
return_dict = {}
|
||||
for config in self.input_configs:
|
||||
if config.type == EV_ABS and not config.defines_analog_input:
|
||||
return_dict[InputCombination([config])] = HandlerEnums.abs2btn
|
||||
|
||||
if config.type == EV_REL and not config.defines_analog_input:
|
||||
return_dict[InputCombination([config])] = HandlerEnums.rel2btn
|
||||
|
||||
return return_dict
|
||||
@ -0,0 +1,97 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 typing import List, Dict
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import EV_ABS, EV_REL
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
InputEventHandler,
|
||||
HandlerEnums,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent
|
||||
|
||||
|
||||
class HierarchyHandler(MappingHandler):
|
||||
"""Handler consisting of an ordered list of MappingHandler
|
||||
|
||||
only the first handler which successfully handles the event will execute it,
|
||||
all other handlers will be notified, but suppressed
|
||||
"""
|
||||
|
||||
_input_config: InputConfig
|
||||
|
||||
def __init__(
|
||||
self, handlers: List[MappingHandler], input_config: InputConfig
|
||||
) -> None:
|
||||
self.handlers = handlers
|
||||
self._input_config = input_config
|
||||
combination = InputCombination([input_config])
|
||||
# use the mapping from the first child TODO: find a better solution
|
||||
mapping = handlers[0].mapping
|
||||
super().__init__(combination, mapping)
|
||||
|
||||
def __str__(self):
|
||||
return f"HierarchyHandler for {self._input_config}"
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self): # used for logging
|
||||
return self.handlers
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice = None,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
if event.input_match_hash != self._input_config.input_match_hash:
|
||||
return False
|
||||
|
||||
success = False
|
||||
for handler in self.handlers:
|
||||
if not success:
|
||||
success = handler.notify(event, source)
|
||||
else:
|
||||
handler.notify(event, source, suppress=True)
|
||||
return success
|
||||
|
||||
def reset(self) -> None:
|
||||
for sub_handler in self.handlers:
|
||||
sub_handler.reset()
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
if (
|
||||
self._input_config.type == EV_ABS
|
||||
and not self._input_config.defines_analog_input
|
||||
):
|
||||
return {InputCombination([self._input_config]): HandlerEnums.abs2btn}
|
||||
if (
|
||||
self._input_config.type == EV_REL
|
||||
and not self._input_config.defines_analog_input
|
||||
):
|
||||
return {InputCombination([self._input_config]): HandlerEnums.rel2btn}
|
||||
return {}
|
||||
|
||||
def set_sub_handler(self, handler: InputEventHandler) -> None:
|
||||
assert False
|
||||
@ -0,0 +1,91 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 typing import Tuple, Dict
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination
|
||||
from inputremapper import exceptions
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.exceptions import MappingParsingError
|
||||
from inputremapper.injection.global_uinputs import global_uinputs
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
HandlerEnums,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.utils import get_evdev_constant_name
|
||||
|
||||
|
||||
class KeyHandler(MappingHandler):
|
||||
"""Injects the target key if notified."""
|
||||
|
||||
_active: bool
|
||||
_maps_to: Tuple[int, int]
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
**_,
|
||||
):
|
||||
super().__init__(combination, mapping)
|
||||
maps_to = mapping.get_output_type_code()
|
||||
if not maps_to:
|
||||
raise MappingParsingError(
|
||||
"Unable to create key handler from mapping", mapping=mapping
|
||||
)
|
||||
|
||||
self._maps_to = maps_to
|
||||
self._active = False
|
||||
|
||||
def __str__(self):
|
||||
return f"KeyHandler to {self._maps_to}"
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self): # used for logging
|
||||
name = get_evdev_constant_name(*self._maps_to)
|
||||
return f"maps to: {name} {self._maps_to} on {self.mapping.target_uinput}"
|
||||
|
||||
def notify(self, event: InputEvent, *_, **__) -> bool:
|
||||
"""Inject event.value to the target key."""
|
||||
|
||||
event_tuple = (*self._maps_to, event.value)
|
||||
try:
|
||||
global_uinputs.write(event_tuple, self.mapping.target_uinput)
|
||||
self._active = bool(event.value)
|
||||
return True
|
||||
except exceptions.Error:
|
||||
return False
|
||||
|
||||
def reset(self) -> None:
|
||||
logger.debug("resetting key_handler")
|
||||
if self._active:
|
||||
event_tuple = (*self._maps_to, 0)
|
||||
global_uinputs.write(event_tuple, self.mapping.target_uinput)
|
||||
self._active = False
|
||||
|
||||
def needs_wrapping(self) -> bool:
|
||||
return True
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
return {InputCombination(self.input_configs): HandlerEnums.combination}
|
||||
@ -0,0 +1,102 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
import asyncio
|
||||
from typing import Dict, Callable
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.injection.global_uinputs import global_uinputs
|
||||
from inputremapper.injection.macros.macro import Macro
|
||||
from inputremapper.injection.macros.parse import parse
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
ContextProtocol,
|
||||
MappingHandler,
|
||||
HandlerEnums,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent
|
||||
from inputremapper.logger import logger
|
||||
|
||||
|
||||
class MacroHandler(MappingHandler):
|
||||
"""Runs the target macro if notified."""
|
||||
|
||||
# TODO: replace this by the macro itself
|
||||
_macro: Macro
|
||||
_active: bool
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
*,
|
||||
context: ContextProtocol,
|
||||
):
|
||||
super().__init__(combination, mapping)
|
||||
self._active = False
|
||||
assert self.mapping.output_symbol is not None
|
||||
self._macro = parse(self.mapping.output_symbol, context, mapping)
|
||||
|
||||
def __str__(self):
|
||||
return f"MacroHandler"
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self): # used for logging
|
||||
return f"maps to {self._macro} on {self.mapping.target_uinput}"
|
||||
|
||||
async def run_macro(self, handler: Callable):
|
||||
"""Run the macro with the provided function."""
|
||||
try:
|
||||
await self._macro.run(handler)
|
||||
except Exception as exception:
|
||||
logger.error('Macro "%s" failed: %s', self._macro.code, exception)
|
||||
|
||||
def notify(self, event: InputEvent, *_, **__) -> bool:
|
||||
if event.value == 1:
|
||||
self._active = True
|
||||
self._macro.press_trigger()
|
||||
if self._macro.running:
|
||||
return True
|
||||
|
||||
def handler(type_, code, value) -> None:
|
||||
"""Handler for macros."""
|
||||
global_uinputs.write((type_, code, value), self.mapping.target_uinput)
|
||||
|
||||
asyncio.ensure_future(self.run_macro(handler))
|
||||
return True
|
||||
else:
|
||||
self._active = False
|
||||
if self._macro.is_holding():
|
||||
self._macro.release_trigger()
|
||||
|
||||
return True
|
||||
|
||||
def reset(self) -> None:
|
||||
self._active = False
|
||||
if self._macro.is_holding():
|
||||
self._macro.release_trigger()
|
||||
|
||||
def needs_wrapping(self) -> bool:
|
||||
return True
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
return {InputCombination(self.input_configs): HandlerEnums.combination}
|
||||
@ -0,0 +1,229 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
"""Provides protocols for mapping handlers
|
||||
|
||||
*** The architecture behind mapping handlers ***
|
||||
|
||||
Handling an InputEvent is done in 3 steps:
|
||||
1. Input Event Handling
|
||||
A MappingHandler that does Input event handling receives Input Events directly
|
||||
from the EventReader.
|
||||
To do so it must implement the InputEventHandler protocol.
|
||||
An InputEventHandler may handle multiple events (InputEvent.type_and_code)
|
||||
|
||||
2. Event Transformation
|
||||
The event gets transformed as described by the mapping.
|
||||
e.g.: combining multiple events to a single one
|
||||
transforming EV_ABS to EV_REL
|
||||
macros
|
||||
...
|
||||
Multiple transformations may get chained
|
||||
|
||||
3. Event Injection
|
||||
The transformed event gets injected to a global_uinput
|
||||
|
||||
MappingHandlers can implement one or more of these steps.
|
||||
|
||||
Overview of implemented handlers and the steps they implement:
|
||||
|
||||
Step 1:
|
||||
- HierarchyHandler
|
||||
|
||||
Step 1 and 2:
|
||||
- CombinationHandler
|
||||
- AbsToBtnHandler
|
||||
- RelToBtnHandler
|
||||
|
||||
Step 1, 2 and 3:
|
||||
- AbsToRelHandler
|
||||
- NullHandler
|
||||
|
||||
Step 2 and 3:
|
||||
- KeyHandler
|
||||
- MacroHandler
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import enum
|
||||
from typing import Dict, Protocol, Set, Optional, List
|
||||
|
||||
import evdev
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.exceptions import MappingParsingError
|
||||
from inputremapper.input_event import InputEvent
|
||||
from inputremapper.logger import logger
|
||||
|
||||
|
||||
class EventListener(Protocol):
|
||||
async def __call__(self, event: evdev.InputEvent) -> None:
|
||||
...
|
||||
|
||||
|
||||
class ContextProtocol(Protocol):
|
||||
"""The parts from context needed for handlers."""
|
||||
|
||||
listeners: Set[EventListener]
|
||||
|
||||
def get_forward_uinput(self, origin_hash) -> evdev.UInput:
|
||||
pass
|
||||
|
||||
|
||||
class NotifyCallback(Protocol):
|
||||
"""Type signature of InputEventHandler.notify
|
||||
|
||||
return True if the event was actually taken care of
|
||||
"""
|
||||
|
||||
def __call__(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
...
|
||||
|
||||
|
||||
class InputEventHandler(Protocol):
|
||||
"""The protocol any handler, which can be part of an event pipeline, must follow."""
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
...
|
||||
|
||||
def reset(self) -> None:
|
||||
"""Reset the state of the handler e.g. release any buttons."""
|
||||
...
|
||||
|
||||
|
||||
class HandlerEnums(enum.Enum):
|
||||
# converting to btn
|
||||
abs2btn = enum.auto()
|
||||
rel2btn = enum.auto()
|
||||
|
||||
macro = enum.auto()
|
||||
key = enum.auto()
|
||||
|
||||
# converting to "analog"
|
||||
btn2rel = enum.auto()
|
||||
rel2rel = enum.auto()
|
||||
abs2rel = enum.auto()
|
||||
|
||||
btn2abs = enum.auto()
|
||||
rel2abs = enum.auto()
|
||||
abs2abs = enum.auto()
|
||||
|
||||
# special handlers
|
||||
combination = enum.auto()
|
||||
hierarchy = enum.auto()
|
||||
axisswitch = enum.auto()
|
||||
disable = enum.auto()
|
||||
|
||||
|
||||
class MappingHandler:
|
||||
"""The protocol an InputEventHandler must follow if it should be
|
||||
dynamically integrated in an event-pipeline by the mapping parser
|
||||
"""
|
||||
|
||||
mapping: Mapping
|
||||
# all input events this handler cares about
|
||||
# should always be a subset of mapping.input_combination
|
||||
input_configs: List[InputConfig]
|
||||
_sub_handler: Optional[InputEventHandler]
|
||||
|
||||
# https://bugs.python.org/issue44807
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
**_,
|
||||
) -> None:
|
||||
"""Initialize the handler
|
||||
|
||||
Parameters
|
||||
----------
|
||||
combination
|
||||
the combination from sub_handler.wrap_with()
|
||||
mapping
|
||||
"""
|
||||
self.mapping = mapping
|
||||
self.input_configs = list(combination)
|
||||
self._sub_handler = None
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
"""Notify this handler about an incoming event.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
event
|
||||
The newest event that came from `source`, and that should be mapped to
|
||||
something else
|
||||
source
|
||||
Where `event` comes from
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
def reset(self) -> None:
|
||||
"""Reset the state of the handler e.g. release any buttons."""
|
||||
raise NotImplementedError
|
||||
|
||||
def needs_wrapping(self) -> bool:
|
||||
"""If this handler needs to be wrapped in another MappingHandler."""
|
||||
return len(self.wrap_with()) > 0
|
||||
|
||||
def needs_ranking(self) -> bool:
|
||||
"""If this handler needs ranking and wrapping with a HierarchyHandler."""
|
||||
return False
|
||||
|
||||
def rank_by(self) -> Optional[InputCombination]:
|
||||
"""The combination for which this handler needs ranking."""
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
"""A dict of InputCombination -> HandlerEnums.
|
||||
|
||||
for each InputCombination this handler should be wrapped
|
||||
with the given MappingHandler.
|
||||
"""
|
||||
return {}
|
||||
|
||||
def set_sub_handler(self, handler: InputEventHandler) -> None:
|
||||
"""Give this handler a sub_handler."""
|
||||
self._sub_handler = handler
|
||||
|
||||
def occlude_input_event(self, input_config: InputConfig) -> None:
|
||||
"""Remove the config from self.input_configs."""
|
||||
if not self.input_configs:
|
||||
logger.debug_mapping_handler(self)
|
||||
raise MappingParsingError(
|
||||
"Cannot remove a non existing config", mapping_handler=self
|
||||
)
|
||||
|
||||
# should be called for each event a wrapping-handler
|
||||
# has in its input_configs InputCombination
|
||||
self.input_configs.remove(input_config)
|
||||
@ -0,0 +1,325 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
"""Functions to assemble the mapping handler tree."""
|
||||
|
||||
from collections import defaultdict
|
||||
from typing import Dict, List, Type, Optional, Set, Iterable, Sized, Tuple, Sequence
|
||||
|
||||
from evdev.ecodes import EV_KEY, EV_ABS, EV_REL
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.configs.preset import Preset
|
||||
from inputremapper.configs.system_mapping import DISABLE_CODE, DISABLE_NAME
|
||||
from inputremapper.exceptions import MappingParsingError
|
||||
from inputremapper.injection.macros.parse import is_this_a_macro
|
||||
from inputremapper.injection.mapping_handlers.abs_to_abs_handler import AbsToAbsHandler
|
||||
from inputremapper.injection.mapping_handlers.abs_to_btn_handler import AbsToBtnHandler
|
||||
from inputremapper.injection.mapping_handlers.abs_to_rel_handler import AbsToRelHandler
|
||||
from inputremapper.injection.mapping_handlers.axis_switch_handler import (
|
||||
AxisSwitchHandler,
|
||||
)
|
||||
from inputremapper.injection.mapping_handlers.combination_handler import (
|
||||
CombinationHandler,
|
||||
)
|
||||
from inputremapper.injection.mapping_handlers.hierarchy_handler import HierarchyHandler
|
||||
from inputremapper.injection.mapping_handlers.key_handler import KeyHandler
|
||||
from inputremapper.injection.mapping_handlers.macro_handler import MacroHandler
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
HandlerEnums,
|
||||
MappingHandler,
|
||||
ContextProtocol,
|
||||
InputEventHandler,
|
||||
)
|
||||
from inputremapper.injection.mapping_handlers.null_handler import NullHandler
|
||||
from inputremapper.injection.mapping_handlers.rel_to_abs_handler import RelToAbsHandler
|
||||
from inputremapper.injection.mapping_handlers.rel_to_btn_handler import RelToBtnHandler
|
||||
from inputremapper.injection.mapping_handlers.rel_to_rel_handler import RelToRelHandler
|
||||
from inputremapper.logger import logger
|
||||
from inputremapper.utils import get_evdev_constant_name
|
||||
|
||||
EventPipelines = Dict[InputConfig, Set[InputEventHandler]]
|
||||
|
||||
mapping_handler_classes: Dict[HandlerEnums, Optional[Type[MappingHandler]]] = {
|
||||
# all available mapping_handlers
|
||||
HandlerEnums.abs2btn: AbsToBtnHandler,
|
||||
HandlerEnums.rel2btn: RelToBtnHandler,
|
||||
HandlerEnums.macro: MacroHandler,
|
||||
HandlerEnums.key: KeyHandler,
|
||||
HandlerEnums.btn2rel: None, # can be a macro
|
||||
HandlerEnums.rel2rel: RelToRelHandler,
|
||||
HandlerEnums.abs2rel: AbsToRelHandler,
|
||||
HandlerEnums.btn2abs: None, # can be a macro
|
||||
HandlerEnums.rel2abs: RelToAbsHandler,
|
||||
HandlerEnums.abs2abs: AbsToAbsHandler,
|
||||
HandlerEnums.combination: CombinationHandler,
|
||||
HandlerEnums.hierarchy: HierarchyHandler,
|
||||
HandlerEnums.axisswitch: AxisSwitchHandler,
|
||||
HandlerEnums.disable: NullHandler,
|
||||
}
|
||||
|
||||
|
||||
def parse_mappings(preset: Preset, context: ContextProtocol) -> EventPipelines:
|
||||
"""Create a dict with a list of MappingHandler for each InputEvent."""
|
||||
handlers = []
|
||||
for mapping in preset:
|
||||
# start with the last handler in the chain, each mapping only has one output,
|
||||
# but may have multiple inputs, therefore the last handler is a good starting
|
||||
# point to assemble the pipeline
|
||||
handler_enum = _get_output_handler(mapping)
|
||||
constructor = mapping_handler_classes[handler_enum]
|
||||
if not constructor:
|
||||
logger.warning(
|
||||
"a mapping handler '%s' for %s is not implemented",
|
||||
handler_enum,
|
||||
mapping.format_name(),
|
||||
)
|
||||
continue
|
||||
|
||||
output_handler = constructor(
|
||||
mapping.input_combination,
|
||||
mapping,
|
||||
context=context,
|
||||
)
|
||||
|
||||
# layer other handlers on top until the outer handler needs ranking or can
|
||||
# directly handle a input event
|
||||
handlers.extend(_create_event_pipeline(output_handler, context))
|
||||
|
||||
# figure out which handlers need ranking and wrap them with hierarchy_handlers
|
||||
need_ranking = defaultdict(set)
|
||||
for handler in handlers.copy():
|
||||
if handler.needs_ranking():
|
||||
combination = handler.rank_by()
|
||||
if not combination:
|
||||
raise MappingParsingError(
|
||||
f"{type(handler).__name__} claims to need ranking but does not "
|
||||
f"return a combination to rank by",
|
||||
mapping_handler=handler,
|
||||
)
|
||||
|
||||
need_ranking[combination].add(handler)
|
||||
handlers.remove(handler)
|
||||
|
||||
# the HierarchyHandler's might not be the starting point of the event pipeline,
|
||||
# layer other handlers on top again.
|
||||
ranked_handlers = _create_hierarchy_handlers(need_ranking)
|
||||
for handler in ranked_handlers:
|
||||
handlers.extend(_create_event_pipeline(handler, context, ignore_ranking=True))
|
||||
|
||||
# group all handlers by the input events they take care of. One handler might end
|
||||
# up in multiple groups if it takes care of multiple InputEvents
|
||||
event_pipelines: EventPipelines = defaultdict(set)
|
||||
for handler in handlers:
|
||||
assert handler.input_configs
|
||||
for input_config in handler.input_configs:
|
||||
logger.debug(
|
||||
"event-pipeline with entry point: %s %s",
|
||||
get_evdev_constant_name(*input_config.type_and_code),
|
||||
input_config.input_match_hash,
|
||||
)
|
||||
logger.debug_mapping_handler(handler)
|
||||
event_pipelines[input_config].add(handler)
|
||||
|
||||
return event_pipelines
|
||||
|
||||
|
||||
def _create_event_pipeline(
|
||||
handler: MappingHandler, context: ContextProtocol, ignore_ranking=False
|
||||
) -> List[MappingHandler]:
|
||||
"""Recursively wrap a handler with other handlers until the
|
||||
outer handler needs ranking or is finished wrapping.
|
||||
"""
|
||||
if not handler.needs_wrapping() or (handler.needs_ranking() and not ignore_ranking):
|
||||
return [handler]
|
||||
|
||||
handlers = []
|
||||
for combination, handler_enum in handler.wrap_with().items():
|
||||
constructor = mapping_handler_classes[handler_enum]
|
||||
if not constructor:
|
||||
raise NotImplementedError(
|
||||
f"mapping handler {handler_enum} is not implemented"
|
||||
)
|
||||
|
||||
super_handler = constructor(combination, handler.mapping, context=context)
|
||||
super_handler.set_sub_handler(handler)
|
||||
for event in combination:
|
||||
# the handler now has a super_handler which takes care about the events.
|
||||
# so we need to hide them on the handler
|
||||
handler.occlude_input_event(event)
|
||||
|
||||
handlers.extend(_create_event_pipeline(super_handler, context))
|
||||
|
||||
if handler.input_configs:
|
||||
# the handler was only partially wrapped,
|
||||
# we need to return it as a toplevel handler
|
||||
handlers.append(handler)
|
||||
|
||||
return handlers
|
||||
|
||||
|
||||
def _get_output_handler(mapping: Mapping) -> HandlerEnums:
|
||||
"""Determine the correct output handler.
|
||||
|
||||
this is used as a starting point for the mapping parser
|
||||
"""
|
||||
if mapping.output_code == DISABLE_CODE or mapping.output_symbol == DISABLE_NAME:
|
||||
return HandlerEnums.disable
|
||||
|
||||
if mapping.output_symbol:
|
||||
if is_this_a_macro(mapping.output_symbol):
|
||||
return HandlerEnums.macro
|
||||
|
||||
return HandlerEnums.key
|
||||
|
||||
if mapping.output_type == EV_KEY:
|
||||
return HandlerEnums.key
|
||||
|
||||
input_event = _maps_axis(mapping.input_combination)
|
||||
if not input_event:
|
||||
raise MappingParsingError(
|
||||
f"This {mapping = } does not map to an axis, key or macro",
|
||||
mapping=Mapping,
|
||||
)
|
||||
|
||||
if mapping.output_type == EV_REL:
|
||||
if input_event.type == EV_KEY:
|
||||
return HandlerEnums.btn2rel
|
||||
if input_event.type == EV_REL:
|
||||
return HandlerEnums.rel2rel
|
||||
if input_event.type == EV_ABS:
|
||||
return HandlerEnums.abs2rel
|
||||
|
||||
if mapping.output_type == EV_ABS:
|
||||
if input_event.type == EV_KEY:
|
||||
return HandlerEnums.btn2abs
|
||||
if input_event.type == EV_REL:
|
||||
return HandlerEnums.rel2abs
|
||||
if input_event.type == EV_ABS:
|
||||
return HandlerEnums.abs2abs
|
||||
|
||||
raise MappingParsingError(f"the output of {mapping = } is unknown", mapping=Mapping)
|
||||
|
||||
|
||||
def _maps_axis(combination: InputCombination) -> Optional[InputConfig]:
|
||||
"""Whether this InputCombination contains an InputEvent that is treated as
|
||||
an axis and not a binary (key or button) event.
|
||||
"""
|
||||
for event in combination:
|
||||
if event.defines_analog_input:
|
||||
return event
|
||||
return None
|
||||
|
||||
|
||||
def _create_hierarchy_handlers(
|
||||
handlers: Dict[InputCombination, Set[MappingHandler]]
|
||||
) -> Set[MappingHandler]:
|
||||
"""Sort handlers by input events and create Hierarchy handlers."""
|
||||
sorted_handlers = set()
|
||||
all_combinations = handlers.keys()
|
||||
events = set()
|
||||
|
||||
# gather all InputEvents from all handlers
|
||||
for combination in all_combinations:
|
||||
for event in combination:
|
||||
events.add(event)
|
||||
|
||||
# create a ranking for each event
|
||||
for event in events:
|
||||
# find all combinations (from handlers) which contain the event
|
||||
combinations_with_event = [
|
||||
combination for combination in all_combinations if event in combination
|
||||
]
|
||||
|
||||
if len(combinations_with_event) == 1:
|
||||
# there was only one handler containing that event return it as is
|
||||
sorted_handlers.update(handlers[combinations_with_event[0]])
|
||||
continue
|
||||
|
||||
# there are multiple handler with the same event.
|
||||
# rank them and create the HierarchyHandler
|
||||
sorted_combinations = _order_combinations(combinations_with_event, event)
|
||||
sub_handlers: List[MappingHandler] = []
|
||||
for combination in sorted_combinations:
|
||||
sub_handlers.append(*handlers[combination])
|
||||
|
||||
sorted_handlers.add(HierarchyHandler(sub_handlers, event))
|
||||
for handler in sub_handlers:
|
||||
# the handler now has a HierarchyHandler which takes care about this event.
|
||||
# so we hide need to hide it on the handler
|
||||
handler.occlude_input_event(event)
|
||||
|
||||
return sorted_handlers
|
||||
|
||||
|
||||
def _order_combinations(
|
||||
combinations: List[InputCombination], common_config: InputConfig
|
||||
) -> List[InputCombination]:
|
||||
"""Reorder the keys according to some rules.
|
||||
|
||||
such that a combination a+b+c is in front of a+b which is in front of b
|
||||
for a+b+c vs. b+d+e: a+b+c would be in front of b+d+e, because the common key b
|
||||
has the higher index in the a+b+c (1), than in the b+c+d (0) list
|
||||
in this example b would be the common key
|
||||
as for combinations like a+b+c and e+d+c with the common key c: ¯\\_(ツ)_/¯
|
||||
|
||||
Parameters
|
||||
----------
|
||||
combinations
|
||||
the list which needs ordering
|
||||
common_config
|
||||
the InputConfig all InputCombination's in combinations have in common
|
||||
"""
|
||||
combinations.sort(key=len)
|
||||
|
||||
for start, end in _ranges_with_constant_length(combinations.copy()):
|
||||
sub_list = combinations[start:end]
|
||||
sub_list.sort(key=lambda x: x.index(common_config))
|
||||
combinations[start:end] = sub_list
|
||||
|
||||
combinations.reverse()
|
||||
return combinations
|
||||
|
||||
|
||||
def _ranges_with_constant_length(x: Sequence[Sized]) -> Iterable[Tuple[int, int]]:
|
||||
"""Get all ranges of x for which the elements have constant length
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x: Sequence[Sized]
|
||||
l must be ordered by increasing length of elements
|
||||
"""
|
||||
start_idx = 0
|
||||
last_len = 0
|
||||
for idx, y in enumerate(x):
|
||||
if len(y) > last_len and idx - start_idx > 1:
|
||||
yield start_idx, idx
|
||||
|
||||
if len(y) == last_len and idx + 1 == len(x):
|
||||
yield start_idx, idx + 1
|
||||
|
||||
if len(y) > last_len:
|
||||
start_idx = idx
|
||||
|
||||
if len(y) < last_len:
|
||||
raise MappingParsingError(
|
||||
"ranges_with_constant_length was called with an unordered list"
|
||||
)
|
||||
last_len = len(y)
|
||||
@ -0,0 +1,63 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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 typing import Dict
|
||||
|
||||
import evdev
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
HandlerEnums,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent
|
||||
|
||||
|
||||
class NullHandler(MappingHandler):
|
||||
"""Handler which consumes the event and does nothing."""
|
||||
|
||||
def __str__(self):
|
||||
return f"NullHandler for {self.mapping.input_combination}<{id(self)}>"
|
||||
|
||||
@property
|
||||
def child(self):
|
||||
return "Voids all events"
|
||||
|
||||
def needs_wrapping(self) -> bool:
|
||||
return False in [
|
||||
input_.defines_analog_input for input_ in self.mapping.input_combination
|
||||
]
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
if not self.mapping.input_combination.defines_analog_input:
|
||||
return {self.mapping.input_combination: HandlerEnums.combination}
|
||||
|
||||
assert len(self.mapping.input_combination) > 1, "nees_wrapping ensures this!"
|
||||
return {self.mapping.input_combination: HandlerEnums.axisswitch}
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
return True
|
||||
|
||||
def reset(self) -> None:
|
||||
pass
|
||||
@ -0,0 +1,246 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
import asyncio
|
||||
from typing import Tuple, Dict, Optional
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import (
|
||||
EV_ABS,
|
||||
EV_REL,
|
||||
REL_WHEEL,
|
||||
REL_HWHEEL,
|
||||
REL_HWHEEL_HI_RES,
|
||||
REL_WHEEL_HI_RES,
|
||||
)
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper import exceptions
|
||||
from inputremapper.configs.mapping import (
|
||||
Mapping,
|
||||
WHEEL_SCALING,
|
||||
WHEEL_HI_RES_SCALING,
|
||||
REL_XY_SCALING,
|
||||
DEFAULT_REL_RATE,
|
||||
)
|
||||
from inputremapper.injection.global_uinputs import global_uinputs
|
||||
from inputremapper.injection.mapping_handlers.axis_transform import Transformation
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
HandlerEnums,
|
||||
InputEventHandler,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent, EventActions
|
||||
from inputremapper.logger import logger
|
||||
|
||||
|
||||
class RelToAbsHandler(MappingHandler):
|
||||
"""Handler which transforms EV_REL to EV_ABS events.
|
||||
|
||||
High EV_REL input results in high EV_ABS output.
|
||||
If no new EV_REL events are seen, the EV_ABS output is set to 0 after
|
||||
release_timeout.
|
||||
"""
|
||||
|
||||
_map_axis: InputConfig # InputConfig for the relative movement we map
|
||||
_output_axis: Tuple[int, int] # the (type, code) of the output axis
|
||||
_transform: Transformation
|
||||
_target_absinfo: evdev.AbsInfo
|
||||
|
||||
# infinite loop which centers the output when input stops
|
||||
_recenter_loop: Optional[asyncio.Task]
|
||||
_moving: asyncio.Event # event to notify the _recenter_loop
|
||||
|
||||
_previous_event: Optional[InputEvent]
|
||||
_observed_rate: float # input events per second
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
**_,
|
||||
) -> None:
|
||||
super().__init__(combination, mapping)
|
||||
|
||||
# find the input event we are supposed to map. If the input combination is
|
||||
# BTN_A + REL_X + BTN_B, then use the value of REL_X for the transformation
|
||||
assert (map_axis := combination.find_analog_input_config(type_=EV_REL))
|
||||
self._map_axis = map_axis
|
||||
|
||||
assert mapping.output_code is not None
|
||||
assert mapping.output_type == EV_ABS
|
||||
self._output_axis = (mapping.output_type, mapping.output_code)
|
||||
|
||||
target_uinput = global_uinputs.get_uinput(mapping.target_uinput)
|
||||
assert target_uinput is not None
|
||||
abs_capabilities = target_uinput.capabilities(absinfo=True)[EV_ABS]
|
||||
self._target_absinfo = dict(abs_capabilities)[mapping.output_code]
|
||||
|
||||
max_ = self._get_default_cutoff()
|
||||
self._transform = Transformation(
|
||||
min_=-max(1, int(max_)),
|
||||
max_=max(1, int(max_)),
|
||||
deadzone=mapping.deadzone,
|
||||
gain=mapping.gain,
|
||||
expo=mapping.expo,
|
||||
)
|
||||
self._moving = asyncio.Event()
|
||||
self._recenter_loop = None
|
||||
|
||||
self._previous_event = None
|
||||
self._observed_rate = DEFAULT_REL_RATE
|
||||
|
||||
def __str__(self):
|
||||
return f"RelToAbsHandler for {self._map_axis}"
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self): # used for logging
|
||||
return (
|
||||
f"maps to: {self.mapping.get_output_name_constant()} "
|
||||
f"{self.mapping.get_output_type_code()} at "
|
||||
f"{self.mapping.target_uinput}"
|
||||
)
|
||||
|
||||
def _observe_rate(self, event: InputEvent):
|
||||
"""Watch incoming events and remember how many events appear per second."""
|
||||
if self._previous_event is not None:
|
||||
delta_time = event.timestamp() - self._previous_event.timestamp()
|
||||
if delta_time == 0:
|
||||
logger.error("Observed two events with the same timestamp")
|
||||
return
|
||||
|
||||
rate = 1 / delta_time
|
||||
# mice seem to have a constant rate. wheel events are jaggy and the
|
||||
# rate depends on how fast it is turned.
|
||||
if rate > self._observed_rate:
|
||||
logger.debug("Updating rate to %s", rate)
|
||||
self._observed_rate = rate
|
||||
self._calculate_cutoff()
|
||||
|
||||
self._previous_event = event
|
||||
|
||||
def _get_default_cutoff(self):
|
||||
"""Get the cutoff value assuming the default input rate."""
|
||||
if self._map_axis.code in [REL_WHEEL, REL_HWHEEL]:
|
||||
return self.mapping.rel_to_abs_input_cutoff * WHEEL_SCALING
|
||||
|
||||
if self._map_axis.code in [REL_WHEEL_HI_RES, REL_HWHEEL_HI_RES]:
|
||||
return self.mapping.rel_to_abs_input_cutoff * WHEEL_HI_RES_SCALING
|
||||
|
||||
return self.mapping.rel_to_abs_input_cutoff * REL_XY_SCALING
|
||||
|
||||
def _calculate_cutoff(self):
|
||||
"""Correct the default cutoff with the observed input rate, and set it."""
|
||||
# Mice that have very high input rates report low values at the same time.
|
||||
# If the rate is high, use a lower cutoff-value. If the rate is low, use a
|
||||
# higher cutoff-value.
|
||||
cutoff = self._get_default_cutoff()
|
||||
cutoff *= DEFAULT_REL_RATE / self._observed_rate
|
||||
|
||||
self._transform.set_range(-max(1, int(cutoff)), max(1, int(cutoff)))
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
self._observe_rate(event)
|
||||
|
||||
if event.input_match_hash != self._map_axis.input_match_hash:
|
||||
return False
|
||||
|
||||
if EventActions.recenter in event.actions:
|
||||
if self._recenter_loop:
|
||||
self._recenter_loop.cancel()
|
||||
self._recenter()
|
||||
return True
|
||||
|
||||
if not self._recenter_loop:
|
||||
self._recenter_loop = asyncio.create_task(self._create_recenter_loop())
|
||||
|
||||
self._moving.set() # notify the _recenter_loop
|
||||
try:
|
||||
self._write(self._scale_to_target(self._transform(event.value)))
|
||||
return True
|
||||
except (exceptions.UinputNotAvailable, exceptions.EventNotHandled):
|
||||
return False
|
||||
|
||||
def reset(self) -> None:
|
||||
if self._recenter_loop:
|
||||
self._recenter_loop.cancel()
|
||||
self._recenter()
|
||||
|
||||
def _recenter(self) -> None:
|
||||
"""Recenter the output."""
|
||||
self._write(self._scale_to_target(0))
|
||||
|
||||
async def _create_recenter_loop(self) -> None:
|
||||
"""Coroutine which waits for the input to start moving,
|
||||
then waits until the input stops moving, centers the output and repeat.
|
||||
|
||||
Runs forever.
|
||||
"""
|
||||
while True:
|
||||
await self._moving.wait() # input moving started
|
||||
while (
|
||||
await asyncio.wait(
|
||||
(self._moving.wait(),), timeout=self.mapping.release_timeout
|
||||
)
|
||||
)[0]:
|
||||
self._moving.clear() # still moving
|
||||
self._recenter() # input moving stopped
|
||||
|
||||
def _scale_to_target(self, x: float) -> int:
|
||||
"""Scales a x value between -1 and 1 to an integer between
|
||||
target_absinfo.min and target_absinfo.max
|
||||
|
||||
input values above 1 or below -1 are clamped to the extreme values
|
||||
"""
|
||||
factor = (self._target_absinfo.max - self._target_absinfo.min) / 2
|
||||
offset = self._target_absinfo.min + factor
|
||||
y = factor * x + offset
|
||||
if y > offset:
|
||||
return int(min(self._target_absinfo.max, y))
|
||||
else:
|
||||
return int(max(self._target_absinfo.min, y))
|
||||
|
||||
def _write(self, value: int) -> None:
|
||||
"""Inject."""
|
||||
try:
|
||||
global_uinputs.write(
|
||||
(*self._output_axis, value), self.mapping.target_uinput
|
||||
)
|
||||
except OverflowError:
|
||||
# screwed up the calculation of the event value
|
||||
logger.error("OverflowError (%s, %s, %s)", *self._output_axis, value)
|
||||
|
||||
def needs_wrapping(self) -> bool:
|
||||
return len(self.input_configs) > 1
|
||||
|
||||
def set_sub_handler(self, handler: InputEventHandler) -> None:
|
||||
assert False # cannot have a sub-handler
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
if self.needs_wrapping():
|
||||
return {InputCombination(self.input_configs): HandlerEnums.axisswitch}
|
||||
return {}
|
||||
@ -0,0 +1,143 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
import asyncio
|
||||
import time
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import EV_REL
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper.configs.mapping import Mapping
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
InputEventHandler,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent, EventActions
|
||||
from inputremapper.logger import logger
|
||||
|
||||
|
||||
class RelToBtnHandler(MappingHandler):
|
||||
"""Handler which transforms an EV_REL to a button event
|
||||
and sends that to a sub_handler
|
||||
|
||||
adheres to the MappingHandler protocol
|
||||
"""
|
||||
|
||||
_active: bool
|
||||
_input_config: InputConfig
|
||||
_last_activation: float
|
||||
_sub_handler: InputEventHandler
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
**_,
|
||||
) -> None:
|
||||
super().__init__(combination, mapping)
|
||||
|
||||
self._active = False
|
||||
self._input_config = combination[0]
|
||||
self._last_activation = time.time()
|
||||
self._abort_release = False
|
||||
assert self._input_config.analog_threshold != 0
|
||||
assert len(combination) == 1
|
||||
|
||||
def __str__(self):
|
||||
return f'RelToBtnHandler for "{self._input_config}"'
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self): # used for logging
|
||||
return self._sub_handler
|
||||
|
||||
async def _stage_release(
|
||||
self,
|
||||
source: InputEvent,
|
||||
suppress: bool,
|
||||
):
|
||||
while time.time() < self._last_activation + self.mapping.release_timeout:
|
||||
await asyncio.sleep(1 / self.mapping.rel_rate)
|
||||
|
||||
if self._abort_release:
|
||||
self._abort_release = False
|
||||
return
|
||||
|
||||
event = InputEvent(
|
||||
0,
|
||||
0,
|
||||
*self._input_config.type_and_code,
|
||||
value=0,
|
||||
actions=(EventActions.as_key,),
|
||||
origin_hash=self._input_config.origin_hash,
|
||||
)
|
||||
logger.debug("Sending %s to sub_handler", event)
|
||||
self._sub_handler.notify(event, source, suppress)
|
||||
self._active = False
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
assert event.type == EV_REL
|
||||
if event.input_match_hash != self._input_config.input_match_hash:
|
||||
return False
|
||||
|
||||
assert (threshold := self._input_config.analog_threshold)
|
||||
value = event.value
|
||||
if (value < threshold > 0) or (value > threshold < 0):
|
||||
if self._active:
|
||||
# the axis is below the threshold and the stage_release
|
||||
# function is running
|
||||
if self.mapping.force_release_timeout:
|
||||
# consume the event
|
||||
return True
|
||||
event = event.modify(value=0, actions=(EventActions.as_key,))
|
||||
logger.debug("Sending %s to sub_handler", event)
|
||||
self._abort_release = True
|
||||
else:
|
||||
# don't consume the event.
|
||||
# We could return True to consume events
|
||||
return False
|
||||
else:
|
||||
# the axis is above the threshold
|
||||
if not self._active:
|
||||
asyncio.ensure_future(self._stage_release(source, suppress))
|
||||
if value >= threshold > 0:
|
||||
direction = EventActions.positive_trigger
|
||||
else:
|
||||
direction = EventActions.negative_trigger
|
||||
self._last_activation = time.time()
|
||||
event = event.modify(value=1, actions=(EventActions.as_key, direction))
|
||||
|
||||
self._active = bool(event.value)
|
||||
# logger.debug("Sending %s to sub_handler", event)
|
||||
return self._sub_handler.notify(event, source=source, suppress=suppress)
|
||||
|
||||
def reset(self) -> None:
|
||||
if self._active:
|
||||
self._abort_release = True
|
||||
|
||||
self._active = False
|
||||
self._sub_handler.reset()
|
||||
@ -0,0 +1,273 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# input-remapper - GUI for device specific keyboard mappings
|
||||
# Copyright (C) 2023 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/>.
|
||||
|
||||
import math
|
||||
from typing import Dict
|
||||
|
||||
import evdev
|
||||
from evdev.ecodes import (
|
||||
EV_REL,
|
||||
REL_WHEEL,
|
||||
REL_HWHEEL,
|
||||
REL_WHEEL_HI_RES,
|
||||
REL_HWHEEL_HI_RES,
|
||||
)
|
||||
|
||||
from inputremapper.configs.input_config import InputCombination, InputConfig
|
||||
from inputremapper import exceptions
|
||||
from inputremapper.configs.mapping import (
|
||||
Mapping,
|
||||
REL_XY_SCALING,
|
||||
WHEEL_SCALING,
|
||||
WHEEL_HI_RES_SCALING,
|
||||
)
|
||||
from inputremapper.injection.global_uinputs import global_uinputs
|
||||
from inputremapper.injection.mapping_handlers.axis_transform import Transformation
|
||||
from inputremapper.injection.mapping_handlers.mapping_handler import (
|
||||
MappingHandler,
|
||||
HandlerEnums,
|
||||
InputEventHandler,
|
||||
)
|
||||
from inputremapper.input_event import InputEvent
|
||||
from inputremapper.logger import logger
|
||||
|
||||
|
||||
def is_wheel(event) -> bool:
|
||||
return event.type == EV_REL and event.code in (REL_WHEEL, REL_HWHEEL)
|
||||
|
||||
|
||||
def is_high_res_wheel(event) -> bool:
|
||||
return event.type == EV_REL and event.code in (REL_WHEEL_HI_RES, REL_HWHEEL_HI_RES)
|
||||
|
||||
|
||||
class Remainder:
|
||||
_scale: float
|
||||
_remainder: float
|
||||
|
||||
def __init__(self, scale: float):
|
||||
self._scale = scale
|
||||
self._remainder = 0
|
||||
|
||||
def input(self, value: float) -> int:
|
||||
# if the mouse moves very slow, it might not move at all because of the
|
||||
# int-conversion (which is required when writing). store the remainder
|
||||
# (the decimal places) and add it up, until the mouse moves a little.
|
||||
scaled = value * self._scale + self._remainder
|
||||
self._remainder = math.fmod(scaled, 1)
|
||||
|
||||
return int(scaled)
|
||||
|
||||
|
||||
class RelToRelHandler(MappingHandler):
|
||||
"""Handler which transforms EV_REL to EV_REL events."""
|
||||
|
||||
_input_config: InputConfig # the relative movement we map
|
||||
|
||||
_max_observed_input: float
|
||||
|
||||
_transform: Transformation
|
||||
|
||||
_remainder: Remainder
|
||||
_wheel_remainder: Remainder
|
||||
_wheel_hi_res_remainder: Remainder
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
combination: InputCombination,
|
||||
mapping: Mapping,
|
||||
**_,
|
||||
) -> None:
|
||||
super().__init__(combination, mapping)
|
||||
|
||||
assert self.mapping.output_code is not None
|
||||
|
||||
# find the input event we are supposed to map. If the input combination is
|
||||
# BTN_A + REL_X + BTN_B, then use the value of REL_X for the transformation
|
||||
input_config = combination.find_analog_input_config(type_=EV_REL)
|
||||
assert input_config is not None
|
||||
self._input_config = input_config
|
||||
|
||||
self._max_observed_input = 1
|
||||
|
||||
self._remainder = Remainder(REL_XY_SCALING)
|
||||
self._wheel_remainder = Remainder(WHEEL_SCALING)
|
||||
self._wheel_hi_res_remainder = Remainder(WHEEL_HI_RES_SCALING)
|
||||
|
||||
self._transform = Transformation(
|
||||
max_=1,
|
||||
min_=-1,
|
||||
deadzone=self.mapping.deadzone,
|
||||
gain=self.mapping.gain,
|
||||
expo=self.mapping.expo,
|
||||
)
|
||||
|
||||
def __str__(self):
|
||||
return f"RelToRelHandler for {self._input_config}"
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{str(self)} at {hex(id(self))}>"
|
||||
|
||||
@property
|
||||
def child(self): # used for logging
|
||||
return f"maps to: {self.mapping.output_code} at {self.mapping.target_uinput}"
|
||||
|
||||
def _should_map(self, event: InputEvent):
|
||||
"""Check if this input event is relevant for this handler."""
|
||||
return event.input_match_hash == self._input_config.input_match_hash
|
||||
|
||||
def notify(
|
||||
self,
|
||||
event: InputEvent,
|
||||
source: evdev.InputDevice,
|
||||
suppress: bool = False,
|
||||
) -> bool:
|
||||
if not self._should_map(event):
|
||||
return False
|
||||
"""
|
||||
There was the idea to define speed as "movemnt per second".
|
||||
There are deprecated mapping variables in this explanation.
|
||||
|
||||
rel2rel example:
|
||||
- input every 0.1s (`input_rate` of 10 events/s), value of 200
|
||||
- input speed is 2000, because in 1 second a value of 2000 acumulates
|
||||
- `input_rel_speed` is a const defined as 4000 px/s, how fast mice usually move
|
||||
- `transformed = Transformation(input.value, max=input_rel_speed / input_rate)`
|
||||
- get 0.5 because the expo is 0
|
||||
- `abs_to_rel_speed` is 5000
|
||||
- inject 2500 therefore per second, making it a bit faster
|
||||
- divide 2500 by the rate of 10 to inject a value of 250 each time input occurs
|
||||
|
||||
```
|
||||
output_value = Transformation(
|
||||
input.value,
|
||||
max=input_rel_speed / input_rate
|
||||
) * abs_to_rel_speed / input_rate
|
||||
```
|
||||
|
||||
The input_rel_speed could be used here instead of abs_to_rel_speed, because the
|
||||
gain already controls the speed. In that case it would be a 1:1 ratio of
|
||||
input-to-output value if the gain is 1.
|
||||
|
||||
for wheel and wheel_hi_res, different input speed constants must be set.
|
||||
|
||||
abs2rel needs a base value for the output, so `abs_to_rel_speed` is still
|
||||
required.
|
||||
`abs_to_rel_speed / rel_rate * transform(input.value, max=absinfo.max)`
|
||||
is the output value. Both abs_to_rel_speed and the transformation-gain control
|
||||
speed.
|
||||
|
||||
if abs_to_rel_speed controls speed in the abs2rel output, it should also do so
|
||||
in other handlers that have EV_REL output.
|
||||
|
||||
unfortunately input_rate needs to be determined during runtime, which screws
|
||||
the overall speed up when slowly moving the input device in the beginning,
|
||||
because slow input is thought to be the regular input.
|
||||
|
||||
---
|
||||
|
||||
transforming from rate based to rate based speed values won't work well.
|
||||
|
||||
better to use fractional speed values.
|
||||
REL_X of 40 = REL_WHEEL of 1 = REL_WHEE_HI_RES of 1/120
|
||||
|
||||
this is why abs_to_rel_speed does not affect the rel_to_rel handler.
|
||||
|
||||
The expo calculation will be wrong in the beginning, because it is based on
|
||||
the highest observed value. The overall gain will be fine though.
|
||||
"""
|
||||
|
||||
input_value = float(event.value)
|
||||
|
||||
# scale down now, the remainder calculation scales up by the same factor later
|
||||
# depending on what kind of event this becomes.
|
||||
if event.is_wheel_event:
|
||||
input_value /= WHEEL_SCALING
|
||||
elif event.is_wheel_hi_res_event:
|
||||
input_value /= WHEEL_HI_RES_SCALING
|
||||
else:
|
||||
# even though the input rate is unknown we can apply REL_XY_SCALING, which
|
||||
# is based on 60hz or something, because the un-scaling also uses values
|
||||
# based on 60hz. So the rate cancels out
|
||||
input_value /= REL_XY_SCALING
|
||||
|
||||
if abs(input_value) > self._max_observed_input:
|
||||
self._max_observed_input = abs(input_value)
|
||||
|
||||
# If _max_observed_input is wrong when the injection starts and the correct
|
||||
# value learned during runtime, results can be weird at the beginning.
|
||||
# If expo and deadzone are not set, then it is linear and doesn't matter.
|
||||
transformed = self._transform(input_value / self._max_observed_input)
|
||||
transformed *= self._max_observed_input
|
||||
|
||||
is_wheel_output = self.mapping.is_wheel_output()
|
||||
is_hi_res_wheel_output = self.mapping.is_high_res_wheel_output()
|
||||
|
||||
horizontal = self.mapping.output_code in (
|
||||
REL_HWHEEL_HI_RES,
|
||||
REL_HWHEEL,
|
||||
)
|
||||
|
||||
try:
|
||||
if is_wheel_output or is_hi_res_wheel_output:
|
||||
# inject both kinds of wheels, otherwise wheels don't work for some
|
||||
# people. See issue #354
|
||||
self._write(
|
||||
REL_HWHEEL if horizontal else REL_WHEEL,
|
||||
self._wheel_remainder.input(transformed),
|
||||
)
|
||||
self._write(
|
||||
REL_HWHEEL_HI_RES if horizontal else REL_WHEEL_HI_RES,
|
||||
self._wheel_hi_res_remainder.input(transformed),
|
||||
)
|
||||
else:
|
||||
self._write(
|
||||
self.mapping.output_code,
|
||||
self._remainder.input(transformed),
|
||||
)
|
||||
|
||||
return True
|
||||
except OverflowError:
|
||||
# screwed up the calculation of the event value
|
||||
logger.error("OverflowError while handling %s", event)
|
||||
return True
|
||||
except (exceptions.UinputNotAvailable, exceptions.EventNotHandled):
|
||||
return False
|
||||
|
||||
def reset(self) -> None:
|
||||
pass
|
||||
|
||||
def _write(self, code: int, value: int):
|
||||
if value == 0:
|
||||
return
|
||||
|
||||
global_uinputs.write(
|
||||
(EV_REL, code, value),
|
||||
self.mapping.target_uinput,
|
||||
)
|
||||
|
||||
def needs_wrapping(self) -> bool:
|
||||
return len(self.input_configs) > 1
|
||||
|
||||
def set_sub_handler(self, handler: InputEventHandler) -> None:
|
||||
assert False # cannot have a sub-handler
|
||||
|
||||
def wrap_with(self) -> Dict[InputCombination, HandlerEnums]:
|
||||
if self.needs_wrapping():
|
||||
return {InputCombination(self.input_configs): HandlerEnums.axisswitch}
|
||||
return {}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue