kmk_firmware/kmk/modules/mouse_keys.py

from supervisor import ticks_ms

from kmk.hid import HID_REPORT_SIZES, HIDReportTypes
from kmk.keys import make_key, make_mouse_key, Axis
from kmk.modules import Module


class PointingDevice:
    MB_LMB = 1
    MB_RMB = 2
    MB_MMB = 4
    _evt = bytearray(HID_REPORT_SIZES[HIDReportTypes.MOUSE] + 1)

    def __init__(self):
        self.key_states = {}
        self.hid_pending = False
        self.report_device = memoryview(self._evt)[0:1]
        self.report_device[0] = HIDReportTypes.MOUSE
        self.button_status = memoryview(self._evt)[1:2]
        self.report_x = memoryview(self._evt)[2:3]
        self.report_y = memoryview(self._evt)[3:4]
        self.report_w = memoryview(self._evt)[4:]


class MouseKeys(Module):
    def __init__(self):
        self._nav_key_activated = 0
        self._up_activated = False
        self._down_activated = False
        self._left_activated = False
        self._right_activated = False
        self._mw_up_activated = False
        self._mw_down_activated = False
        self.max_speed = 10
        self.ac_interval = 100  # Delta ms to apply acceleration
        self._next_interval = 0  # Time for next tick interval
        self.move_step = 1

        make_mouse_key(
            names=('MB_LMB',),
            code=1,
        )
        make_mouse_key(
            names=('MB_MMB',),
            code=4,
        )
        make_mouse_key(
            names=('MB_RMB',),
            code=2,
        )
        make_key(
            names=('MW_UP',),
            on_press=self._mw_up_press,
            on_release=self._mw_up_release,
        )
        make_key(
            names=(
                'MW_DOWN',
                'MW_DN',
            ),
            on_press=self._mw_down_press,
            on_release=self._mw_down_release,
        )
        make_key(
            names=('MS_UP',),
            on_press=self._ms_up_press,
            on_release=self._ms_up_release,
        )
        make_key(
            names=(
                'MS_DOWN',
                'MS_DN',
            ),
            on_press=self._ms_down_press,
            on_release=self._ms_down_release,
        )
        make_key(
            names=(
                'MS_LEFT',
                'MS_LT',
            ),
            on_press=self._ms_left_press,
            on_release=self._ms_left_release,
        )
        make_key(
            names=(
                'MS_RIGHT',
                'MS_RT',
            ),
            on_press=self._ms_right_press,
            on_release=self._ms_right_release,
        )

    def during_bootup(self, keyboard):
        keyboard.axes['W'] = Axis(2)
        keyboard.axes['X'] = Axis(0)
        keyboard.axes['Y'] = Axis(1)

    def before_matrix_scan(self, keyboard):
        return

    def after_matrix_scan(self, keyboard):
        if self._next_interval > ticks_ms():
            return

        self._next_interval = ticks_ms() + self.ac_interval

        if self._nav_key_activated:
            if self.move_step < self.max_speed:
                self.move_step = self.move_step + 1
            if self._right_activated:
                keyboard.axes['X'].delta += self.move_step
            if self._left_activated:
                keyboard.axes['X'].delta -= self.move_step
            if self._up_activated:
                keyboard.axes['Y'].delta -= self.move_step
            if self._down_activated:
                keyboard.axes['Y'].delta += self.move_step
            keyboard.hid_pending = True

        if self._mw_up_activated:
            keyboard.axes['W'].delta += self.move_step
            keyboard.hid_pending = True
        if self._mw_down_activated:
            keyboard.axes['W'].delta -= self.move_step
            keyboard.hid_pending = True

    def before_hid_send(self, keyboard):
        return

    def after_hid_send(self, keyboard):
        return

    def on_powersave_enable(self, keyboard):
        return

    def on_powersave_disable(self, keyboard):
        return

    def _mw_up_press(self, key, keyboard, *args, **kwargs):
        self._mw_up_activated = True

    def _mw_up_release(self, key, keyboard, *args, **kwargs):
        self._mw_up_activated = False

    def _mw_down_press(self, key, keyboard, *args, **kwargs):
        self._mw_down_activated = True

    def _mw_down_release(self, key, keyboard, *args, **kwargs):
        self._mw_down_activated = False

    # Mouse movement
    def _reset_next_interval(self):
        if self._nav_key_activated == 1:
            self._next_interval = ticks_ms() + self.ac_interval
            self.move_step = 1

    def _check_last(self):
        if self._nav_key_activated == 0:
            self.move_step = 1

    def _ms_up_press(self, key, keyboard, *args, **kwargs):
        self._nav_key_activated += 1
        self._reset_next_interval()
        self._up_activated = True

    def _ms_up_release(self, key, keyboard, *args, **kwargs):
        self._up_activated = False
        self._nav_key_activated -= 1
        self._check_last()

    def _ms_down_press(self, key, keyboard, *args, **kwargs):
        self._nav_key_activated += 1
        self._reset_next_interval()
        self._down_activated = True

    def _ms_down_release(self, key, keyboard, *args, **kwargs):
        self._down_activated = False
        self._nav_key_activated -= 1
        self._check_last()

    def _ms_left_press(self, key, keyboard, *args, **kwargs):
        self._nav_key_activated += 1
        self._reset_next_interval()
        self._left_activated = True

    def _ms_left_release(self, key, keyboard, *args, **kwargs):
        self._nav_key_activated -= 1
        self._left_activated = False
        self._check_last()

    def _ms_right_press(self, key, keyboard, *args, **kwargs):
        self._nav_key_activated += 1
        self._reset_next_interval()
        self._right_activated = True

    def _ms_right_release(self, key, keyboard, *args, **kwargs):
        self._nav_key_activated -= 1
        self._right_activated = False
        self._check_last()