Fixing release events when keys are released in order of pressing

inputremapper/injection/mapping_handlers/combination_handler.py

@@ -45,7 +45,7 @@ class CombinationHandler(MappingHandler):
  _pressed_keys: Dict[Hashable, bool]
  # the last update we sent to a sub-handler. If this is true, the output key is
  # still being held down.
- _output_active: bool
+ _output_previously_active: bool
  _sub_handler: InputEventHandler
  _handled_input_hashes: list[Hashable]
  _requires_a_release: Dict[Tuple[int, int], bool]
@@ -60,7 +60,7 @@ def __init__(
  logger.debug(str(mapping))
  super().__init__(combination, mapping)
  self._pressed_keys = {}
- self._output_active = False
+ self._output_previously_active = False
  self._context = context
  self._requires_a_release = {}
 
@@ -109,74 +109,77 @@ def notify(
  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()
+ changed = self.is_activated() != self._output_previously_active
+
+ if changed:
+ if is_pressed:
+ return self._handle_freshly_activated(suppress, event, source)
+ else:
+ return self._handle_freshly_deactivated(event, source)
+ else:
+ if is_pressed:
+ return self._handle_no_change_press(event)
+ else:
+ return self._handle_no_change_release(event)
+
+ def _handle_no_change_press(self, event: InputEvent) -> bool:
+ """A key was pressed, but this doesn't change the combinations activation state.
+ Can only happen if either the combination wasn't already active, or a duplicate
+ key-down event arrived (EV_ABS?)
+ """
+ # self._output_previously_active is negated, because if the output is active, a
+ # key-down event triggered it, which then did not get forwarded, therefore
+ # it doesn't require a release.
+ self.require_release_later(not self._output_previously_active, event)
+ # output is active: consume the event
+ # output inactive: forward the event
+ return self._output_previously_active
+
+ def _handle_no_change_release(self, event: InputEvent) -> bool:
+ """One of the combinations keys was released, but it didn't untrigger the
+ combination yet."""
+ # Negate: `False` means that the event-reader will forward the release.
+ return not self.should_release_event(event)
 
- if is_activated == self._output_active:
- return self._handle_state_did_not_change(is_pressed, event)
+ def _handle_freshly_activated(
+ self,
+ suppress: bool,
+ event: InputEvent,
+ source: evdev.InputDevice,
+ ) -> bool:
+ """The combination was deactivated, but is activated now."""
+ if suppress:
+ return False
 
- # This depends on whether the key was pressed or released, therefore those are
- # equal
- assert is_activated == is_pressed
- return self._handle_state_changed(is_activated, suppress, event, source)
+ # Send key up events to the forwarded uinput if configured to do so.
+ self.forward_release()
 
- def _handle_state_did_not_change(self, is_pressed: bool, event: InputEvent) -> bool:
- """Handle the event when it didn't change the combination activation state.
+ logger.debug("Sending %s to sub-handler", self.mapping.input_combination)
+ self._output_previously_active = bool(event.value)
+ sub_handler_result = self._sub_handler.notify(event, source, suppress)
 
- The combination was previously triggered, and is still triggered,
- or it was not yet triggered and still isn't triggered.
- """
- if is_pressed:
- # self._output_active is negated, because if the output is active, a
- # key-down event triggered it, which then did not get forwarded, therefore
- # it doesn't require a release.
- self.require_release_later(not self._output_active, event)
- # output is active: consume the event
- # output inactive: forward the event
- return self._output_active
-
- # Else if it is released: Returning `False` means that the event-reader
- # will forward the release.
- return not self.should_release_event(event)
+ # Only if the sub-handler return False, we need a release-event later.
+ # If it handled the event, the user never sees this key-down event.
+ self.require_release_later(not sub_handler_result, event)
+ return sub_handler_result
 
- def _handle_state_changed(
+ def _handle_freshly_deactivated(
  self,
- is_activated: bool,
- suppress: bool,
  event: InputEvent,
  source: evdev.InputDevice,
  ) -> bool:
- """Handle a changed combination-activation state.
+ """The combination was activated, but is deactivated now."""
+ # We ignore the `suppress` argument for release events. Otherwise, we
+ # might end up with stuck keys (test_event_pipeline.test_combination).
+ # In the case of output axis, this will enable us to activate multiple
+ # axis with the same button.
 
- Either it was previously triggered, but not anymore, or it was not yet
- triggered, but is now.
- """
- if not is_activated:
- # We ignore the `suppress` argument for release events. Otherwise, we
- # might end up with stuck keys (test_event_pipeline.test_combination).
- # In the case of output axis, this will enable us to activate multiple
- # axis with the same button.
- suppress = False
-
- if not suppress:
- if is_activated:
- # Send key up events to the forwarded uinput if configured to do so.
- self.forward_release()
-
- logger.debug("Sending %s to sub-handler", self.mapping.input_combination)
- self._output_active = bool(event.value)
- sub_handler_result = self._sub_handler.notify(event, source, suppress)
-
- if is_activated:
- # Only if the sub-handler return False, we need a release-event later.
- # If it handled the event, the user never sees this key-down event.
- self.require_release_later(not sub_handler_result, event)
- return sub_handler_result
-
- # Else if it is released: Returning `False` means that the event-reader
- # will forward the release.
- return not self.should_release_event(event)
-
- return False
+ logger.debug("Sending %s to sub-handler", self.mapping.input_combination)
+ self._output_previously_active = bool(event.value)
+ self._sub_handler.notify(event, source, suppress=False)
+
+ # Negate: `False` means that the event-reader will forward the release.
+ return not self.should_release_event(event)
 
  def should_release_event(self, event: InputEvent) -> bool:
  """Check if the key-up event should be forwarded by the event-reader.
@@ -205,7 +208,7 @@ def reset(self) -> None:
  for key in self._pressed_keys:
  self._pressed_keys[key] = False
  self._requires_a_release = {}
- self._output_active = False
+ self._output_previously_active = False
 
  def is_activated(self) -> bool:
  """Return if all keys in the keymap are set to True."""