@desklink/host 0.1.0

package/engine/vendor/inputtino/bindings/python/src/inputtino/joypad.py

@@ -0,0 +1,248 @@
+"""Provides joypad device implementations."""
+
+from collections.abc import Callable
+from enum import IntFlag
+
+from . import _core
+from ._core import (
+    ControllerButton as CoreButton,
+    PS5BatteryState,
+    PS5MotionType,
+    StickPosition,
+)
+from .base import DeviceDefinition, VirtualDevice
+
+
+class ControllerButton(IntFlag):
+    """Button flags for controller input."""
+
+    DPAD_UP = CoreButton.DPAD_UP.value
+    DPAD_DOWN = CoreButton.DPAD_DOWN.value
+    DPAD_LEFT = CoreButton.DPAD_LEFT.value
+    DPAD_RIGHT = CoreButton.DPAD_RIGHT.value
+
+    START = CoreButton.START.value
+    BACK = CoreButton.BACK.value
+    HOME = CoreButton.HOME.value
+
+    LEFT_STICK = CoreButton.LEFT_STICK.value
+    RIGHT_STICK = CoreButton.RIGHT_STICK.value
+    LEFT_BUTTON = CoreButton.LEFT_BUTTON.value
+    RIGHT_BUTTON = CoreButton.RIGHT_BUTTON.value
+
+    SPECIAL = CoreButton.SPECIAL_FLAG.value
+    PADDLE1 = CoreButton.PADDLE1_FLAG.value
+    PADDLE2 = CoreButton.PADDLE2_FLAG.value
+    PADDLE3 = CoreButton.PADDLE3_FLAG.value
+    PADDLE4 = CoreButton.PADDLE4_FLAG.value
+    TOUCHPAD = CoreButton.TOUCHPAD_FLAG.value
+    MISC = CoreButton.MISC_FLAG.value
+
+    A = CoreButton.A.value
+    B = CoreButton.B.value
+    X = CoreButton.X.value
+    Y = CoreButton.Y.value
+
+
+class Joypad(VirtualDevice):
+    """Base class for all joypad implementations."""
+
+    def __init__(self, device_def: DeviceDefinition, joypad: _core.Joypad) -> None:
+        """Initialize joypad.
+
+        Args:
+            device_def: Device definition for the joypad
+            joypad: Core joypad instance
+        """
+        super().__init__(joypad)
+        self._device_def = device_def
+        self._joypad = joypad
+
+    def set_pressed_buttons(self, buttons: ControllerButton) -> None:
+        """Set currently pressed buttons.
+
+        Args:
+            buttons: Button flags indicating which buttons are pressed
+        """
+        self._joypad.set_pressed_buttons(int(buttons))
+
+    def set_triggers(self, left: int, right: int) -> None:
+        """Set trigger values.
+
+        Args:
+            left: Left trigger value (0-65535)
+            right: Right trigger value (0-65535)
+        """
+        self._joypad.set_triggers(left, right)
+
+    def set_stick(self, stick: StickPosition, x: int, y: int) -> None:
+        """Set stick position.
+
+        Args:
+            stick: Which stick to move (LS or RS)
+            x: X position (-32768 to 32767)
+            y: Y position (-32768 to 32767)
+        """
+        self._joypad.set_stick(stick, x, y)
+
+
+DEFAULT_XBOX_ONE_JOYPAD_DEF = DeviceDefinition(
+    name="Wolf X-Box One (virtual) pad",
+    vendor_id=0x045E,
+    product_id=0x02EA,
+    version=0x0408,
+)
+
+
+class XBoxOneJoypad(Joypad):
+    """Xbox One controller implementation."""
+
+    def __init__(
+        self, device_def: DeviceDefinition = DEFAULT_XBOX_ONE_JOYPAD_DEF
+    ) -> None:
+        """Initialize Xbox One controller.
+
+        Args:
+            device_def: Optional device definition.
+        """
+        joypad = _core.XboxOneJoypad.create(device_def.to_core())
+        super().__init__(device_def, joypad)
+        self._xbox_joypad = joypad
+
+    def set_on_rumble(self, callback: Callable[[int, int], None]) -> None:
+        """Set rumble feedback callback.
+
+        Args:
+            callback: Function called when rumble event occurs.
+                     Takes (low_freq, high_freq) as arguments
+        """
+        self._xbox_joypad.set_on_rumble(callback)
+
+
+DEFAULT_SWITCH_JOYPAD_DEF = DeviceDefinition(
+    name="Wolf Nintendo (virtual) pad",
+    vendor_id=0x057E,
+    product_id=0x2009,
+    version=0x8111,
+)
+
+
+class SwitchJoypad(Joypad):
+    """Nintendo Switch controller implementation."""
+
+    def __init__(
+        self, device_def: DeviceDefinition = DEFAULT_SWITCH_JOYPAD_DEF
+    ) -> None:
+        """Initialize Switch controller.
+
+        Args:
+            device_def: Optional device definition.
+        """
+        joypad = _core.SwitchJoypad.create(device_def.to_core())
+        super().__init__(device_def, joypad)
+        self._switch_joypad = joypad
+
+    def set_on_rumble(self, callback: Callable[[int, int], None]) -> None:
+        """Set rumble feedback callback.
+
+        Args:
+            callback: Function called when rumble event occurs.
+                     Takes (low_freq, high_freq) as arguments
+        """
+        self._switch_joypad.set_on_rumble(callback)
+
+
+DEFAULT_PS5_JOYPAD_DEF = DeviceDefinition(
+    name="Wolf DualSense (virtual) pad",
+    vendor_id=0x054C,
+    product_id=0x0CE6,
+    version=0x8111,
+)
+
+
+class PS5Joypad(Joypad):
+    """PlayStation 5 DualSense controller implementation."""
+
+    def __init__(self, device_def: DeviceDefinition = DEFAULT_PS5_JOYPAD_DEF) -> None:
+        """Initialize PS5 controller.
+
+        Args:
+            device_def: Optional device definition.
+        """
+        joypad = _core.PS5Joypad.create(device_def.to_core())
+        super().__init__(device_def, joypad)
+        self._ps5_joypad = joypad
+
+    @property
+    def mac_address(self) -> str:
+        """Get MAC address of the controller.
+
+        Returns:
+            MAC address string
+        """
+        return self._ps5_joypad.get_mac_address()
+
+    @property
+    def sys_nodes(self) -> list[str]:
+        """Get system device nodes.
+
+        Returns:
+            List of system node paths
+        """
+        return self._ps5_joypad.get_sys_nodes()
+
+    def place_finger(self, finger_nr: int, x: int, y: int) -> None:
+        """Place finger on touchpad.
+
+        Args:
+            finger_nr: Finger number (multi-touch index)
+            x: X position (0-1920)
+            y: Y position (0-1080)
+        """
+        self._ps5_joypad.place_finger(finger_nr, x, y)
+
+    def release_finger(self, finger_nr: int) -> None:
+        """Release finger from touchpad.
+
+        Args:
+            finger_nr: Finger number to release
+        """
+        self._ps5_joypad.release_finger(finger_nr)
+
+    def set_motion(self, type_: PS5MotionType, x: float, y: float, z: float) -> None:
+        """Set motion sensor values.
+
+        Args:
+            type_: Sensor type (acceleration or gyroscope)
+            x: X-axis value (m/s² for accel, deg/s for gyro)
+            y: Y-axis value
+            z: Z-axis value
+        """
+        self._ps5_joypad.set_motion(type_, x, y, z)
+
+    def set_battery(self, state: PS5BatteryState, percentage: int) -> None:
+        """Set battery state.
+
+        Args:
+            state: Battery state
+            percentage: Battery level percentage (0-100)
+        """
+        self._ps5_joypad.set_battery(state, percentage)
+
+    def set_on_rumble(self, callback: Callable[[int, int], None]) -> None:
+        """Set rumble feedback callback.
+
+        Args:
+            callback: Function called when rumble event occurs.
+                     Takes (low_freq, high_freq) as arguments
+        """
+        self._ps5_joypad.set_on_rumble(callback)
+
+    def set_on_led(self, callback: Callable[[int, int, int], None]) -> None:
+        """Set LED color callback.
+
+        Args:
+            callback: Function called when LED color changes.
+                     Takes (r, g, b) as arguments
+        """
+        self._ps5_joypad.set_on_led(callback)

package/engine/vendor/inputtino/bindings/python/src/inputtino/keyboard.py

@@ -0,0 +1,256 @@
+"""Keyboard input device implementation."""
+
+from __future__ import annotations
+
+import time
+from enum import IntEnum
+
+from typing_extensions import Self
+
+from . import _core
+from .base import DeviceDefinition, VirtualDevice
+
+# Default device definition for keyboard
+DEFAULT_KEYBOARD = DeviceDefinition(
+    name="Wolf (virtual) keyboard",
+    vendor_id=0xAB00,
+    product_id=0xAB05,
+    version=0xAB00,
+)
+
+
+class Keyboard(VirtualDevice):
+    """Virtual keyboard input device.
+
+    This class provides functionality to simulate keyboard input.
+    The device appears as a real keyboard input device to the system.
+    Key codes used are Win32 Virtual Key (VK) codes.
+
+    Example:
+        >>> from inputtino.keyboard import Keyboard, KeyCode
+        >>> kb = Keyboard()
+        >>> kb.press(KeyCode.CTRL)
+        >>> kb.press(KeyCode.C)
+        >>> kb.release(KeyCode.C)
+        >>> kb.release(KeyCode.CTRL)
+    """
+
+    def __init__(
+        self,
+        device_def: DeviceDefinition = DEFAULT_KEYBOARD,
+        millis_repress_key: int = 50,
+    ) -> None:
+        """Initialize the keyboard device with optional custom device
+        definition.
+
+        Args:
+            device_def: Optional device definition for customizing the virtual device properties
+            millis_repress_key: Time in milliseconds between key press repeats (default: 50)
+
+        Raises:
+            RuntimeError: If device creation fails
+        """
+        self._keyboard = _core.Keyboard.create(device_def.to_core(), millis_repress_key)
+        super().__init__(self._keyboard)
+
+    def press(self, key_code: int) -> None:
+        """Press a keyboard key.
+
+        Args:
+            key_code: Win32 Virtual Key code of the key to press
+        """
+        self._keyboard.press(key_code)
+
+    def release(self, key_code: int) -> None:
+        """Release a keyboard key.
+
+        Args:
+            key_code: Win32 Virtual Key code of the key to release
+        """
+        self._keyboard.release(key_code)
+
+    def type(self, key_code: int, duration: float = 0.1) -> None:
+        """Press and release a key with specified duration.
+
+        Args:
+            key_code: Win32 Virtual Key code of the key
+            duration: Time in seconds to hold the key (default: 0.1)
+        """
+        try:
+            self.press(key_code)
+            if duration > 0:
+                time.sleep(duration)
+        finally:
+            self.release(key_code)
+
+
+class KeyCode(IntEnum):
+    """KeyCode mapping for virtual key codes.
+
+    This class provides a mapping between human-readable key names and
+    their corresponding virtual key codes used by the input system.
+
+    Key codes are referred from
+    <https://learn.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes>
+    """
+
+    # Standard Keys
+    BACKSPACE = 0x08
+    TAB = 0x09
+    CLEAR = 0x0C
+    ENTER = 0x0D
+    SHIFT = 0x10
+    CTRL = 0x11
+    ALT = 0x12
+    PAUSE = 0x13
+    CAPS_LOCK = 0x14
+    ESC = 0x1B
+    SPACE = 0x20
+    PAGE_UP = 0x21
+    PAGE_DOWN = 0x22
+    END = 0x23
+    HOME = 0x24
+    LEFT = 0x25
+    UP = 0x26
+    RIGHT = 0x27
+    DOWN = 0x28
+    PRINTSCREEN = 0x2C
+    INSERT = 0x2D
+    DELETE = 0x2E
+
+    # Numbers
+    KEY_0 = 0x30
+    KEY_1 = 0x31
+    KEY_2 = 0x32
+    KEY_3 = 0x33
+    KEY_4 = 0x34
+    KEY_5 = 0x35
+    KEY_6 = 0x36
+    KEY_7 = 0x37
+    KEY_8 = 0x38
+    KEY_9 = 0x39
+
+    # Letters
+    A = 0x41
+    B = 0x42
+    C = 0x43
+    D = 0x44
+    E = 0x45
+    F = 0x46
+    G = 0x47
+    H = 0x48
+    I = 0x49
+    J = 0x4A
+    K = 0x4B
+    L = 0x4C
+    M = 0x4D
+    N = 0x4E
+    O = 0x4F
+    P = 0x50
+    Q = 0x51
+    R = 0x52
+    S = 0x53
+    T = 0x54
+    U = 0x55
+    V = 0x56
+    W = 0x57
+    X = 0x58
+    Y = 0x59
+    Z = 0x5A
+
+    # Windows Keys
+    LEFT_WIN = 0x5B
+    RIGHT_WIN = 0x5C
+    APP = 0x5D
+
+    # Numpad
+    NUMPAD_0 = 0x60
+    NUMPAD_1 = 0x61
+    NUMPAD_2 = 0x62
+    NUMPAD_3 = 0x63
+    NUMPAD_4 = 0x64
+    NUMPAD_5 = 0x65
+    NUMPAD_6 = 0x66
+    NUMPAD_7 = 0x67
+    NUMPAD_8 = 0x68
+    NUMPAD_9 = 0x69
+    MULTIPLY = 0x6A
+    ADD = 0x6B
+    SUBTRACT = 0x6D
+    DECIMAL = 0x6E
+    DIVIDE = 0x6F
+
+    # Function Keys
+    F1 = 0x70
+    F2 = 0x71
+    F3 = 0x72
+    F4 = 0x73
+    F5 = 0x74
+    F6 = 0x75
+    F7 = 0x76
+    F8 = 0x77
+    F9 = 0x78
+    F10 = 0x79
+    F11 = 0x7A
+    F12 = 0x7B
+    F13 = 0x7C
+    F14 = 0x7D
+    F15 = 0x7E
+    F16 = 0x7F
+    F17 = 0x80
+    F18 = 0x81
+    F19 = 0x82
+    F20 = 0x83
+    F21 = 0x84
+    F22 = 0x85
+    F23 = 0x86
+    F24 = 0x87
+
+    # Lock Keys
+    NUM_LOCK = 0x90
+    SCROLL_LOCK = 0x91
+
+    # Left/Right Keys
+    LEFT_SHIFT = 0xA0
+    RIGHT_SHIFT = 0xA1
+    LEFT_CONTROL = 0xA2
+    RIGHT_CONTROL = 0xA3
+    LEFT_ALT = 0xA4
+    RIGHT_ALT = 0xA5
+
+    # Media Keys
+    VOLUME_MUTE = 0xAD
+    VOLUME_DOWN = 0xAE
+    VOLUME_UP = 0xAF
+    MEDIA_NEXT = 0xB0
+    MEDIA_PREV = 0xB1
+    MEDIA_STOP = 0xB2
+    MEDIA_PLAY_PAUSE = 0xB3
+
+    # OEM Keys
+    SEMICOLON = 0xBA  # ;:
+    PLUS = 0xBB  # =+
+    COMMA = 0xBC  # ,<
+    MINUS = 0xBD  # -_
+    PERIOD = 0xBE  # .>
+    SLASH = 0xBF  # /?
+    TILDE = 0xC0  # `~
+    OPEN_BRACKET = 0xDB  # [{
+    BACKSLASH = 0xDC  # \|
+    CLOSE_BRACKET = 0xDD  # ]}
+    QUOTE = 0xDE  # '"
+
+    @classmethod
+    def from_str(cls, string: str) -> Self:
+        """Retrieves key code from string.
+
+        Args:
+            string: Key name.
+
+        Returns:
+            KeyCode member.
+
+        Raises:
+            KeyError: If provided name is not in KeyCode enum members.
+        """
+        return cls[string.upper()]

package/engine/vendor/inputtino/bindings/python/src/inputtino/mouse.py

@@ -0,0 +1,106 @@
+"""Mouse input device implementation."""
+
+import time
+
+from . import _core
+from ._core import MouseButton
+from .base import DeviceDefinition, VirtualDevice
+
+# Default device definition for mouse
+DEFAULT_MOUSE = DeviceDefinition(
+    name="Wolf mouse virtual device",
+    vendor_id=0xAB00,
+    product_id=0xAB01,
+    version=0xAB00,
+)
+
+
+class Mouse(VirtualDevice):
+    """Virtual mouse input device.
+
+    This class provides functionality to simulate mouse movements,
+    clicks, and scrolling. The device appears as a real mouse input
+    device to the system.
+    """
+
+    def __init__(self, device_def: DeviceDefinition = DEFAULT_MOUSE) -> None:
+        """Initialize the mouse device with optional custom device definition.
+
+        Args:
+            device_def: Optional device definition for customizing the virtual device properties
+
+        Raises:
+            RuntimeError: If device creation fails
+        """
+        self._mouse = _core.Mouse.create(device_def.to_core())
+        super().__init__(self._mouse)
+
+    def move(self, delta_x: int, delta_y: int) -> None:
+        """Move the mouse cursor relative to its current position.
+
+        Args:
+            delta_x: Horizontal movement (positive is right, negative is left)
+            delta_y: Vertical movement (positive is down, negative is up)
+        """
+        self._mouse.move(delta_x, delta_y)
+
+    def move_abs(self, x: int, y: int, screen_width: int, screen_height: int) -> None:
+        """Move the mouse cursor to an absolute screen position.
+
+        Args:
+            x: Target X coordinate
+            y: Target Y coordinate
+            screen_width: Width of the screen in pixels
+            screen_height: Height of the screen in pixels
+        """
+        self._mouse.move_abs(x, y, screen_width, screen_height)
+
+    def press(self, button: MouseButton) -> None:
+        """Press a mouse button.
+
+        Args:
+            button: The button to press
+        """
+        self._mouse.press(button)
+
+    def release(self, button: MouseButton) -> None:
+        """Release a mouse button.
+
+        Args:
+            button: The button to release
+        """
+        self._mouse.release(button)
+
+    def scroll_vertical(self, distance: int) -> None:
+        """Scroll vertically.
+
+        Args:
+            distance: Scroll distance in high resolution units (±120 per notch).
+                     Positive values scroll down, negative values scroll up.
+        """
+        self._mouse.vertical_scroll(distance)
+
+    def scroll_horizontal(self, distance: int) -> None:
+        """Scroll horizontally.
+
+        Args:
+            distance: Scroll distance in high resolution units (±120 per notch).
+                     Positive values scroll right, negative values scroll left.
+        """
+        self._mouse.horizontal_scroll(distance)
+
+    def click(
+        self, button: MouseButton = MouseButton.LEFT, duration: float = 0.0
+    ) -> None:
+        """Perform a mouse click by pressing and releasing a button.
+
+        Args:
+            button: The button to click
+            duration: How long to hold the button down in seconds
+        """
+        try:
+            self.press(button)
+            if duration > 0:
+                time.sleep(duration)
+        finally:
+            self.release(button)

package/engine/vendor/inputtino/bindings/python/src/inputtino/pentablet.py

@@ -0,0 +1,73 @@
+"""Pen tablet input device implementation."""
+
+from . import _core
+from ._core import PenButtonType, PenToolType
+from .base import DeviceDefinition, VirtualDevice
+
+# Default device definition for pen tablet
+DEFAULT_PEN_TABLET = DeviceDefinition(
+    name="Wolf (virtual) pen tablet",
+    vendor_id=0xAB00,
+    product_id=0xAB04,
+    version=0xAB00,
+)
+
+
+class PenTablet(VirtualDevice):
+    """Virtual pen tablet input device.
+
+    This class provides functionality to simulate pen tablet input with
+    various tools and buttons. The device appears as a real pen tablet
+    input device to the system.
+
+    implements a pen tablet as defined in libinput
+    https://wayland.freedesktop.org/libinput/doc/latest/tablet-support.html
+    """
+
+    def __init__(self, device_def: DeviceDefinition = DEFAULT_PEN_TABLET) -> None:
+        """Initialize the pentablet device with optional custom device
+        definition.
+
+        Args:
+            device_def: Optional device definition for customizing the virtual device properties
+
+        Raises:
+            RuntimeError: If device creation fails
+        """
+        self._tablet = _core.PenTablet.create(device_def.to_core())
+        super().__init__(self._tablet)
+
+    def place_tool(
+        self,
+        tool_type: PenToolType,
+        x: float,
+        y: float,
+        pressure: float,
+        distance: float,
+        tilt_x: float,
+        tilt_y: float,
+    ) -> None:
+        """Place a tool on the tablet surface.
+
+        Args:
+            tool_type: Type of tool being used
+            x: X coordinate in range [0.0, 1.0]
+            y: Y coordinate in range [0.0, 1.0]
+            pressure: Tool pressure in range [0.0, 1.0]
+            distance: Tool distance from surface in range [0.0, 1.0]
+            tilt_x: Tool tilt on X axis in range [-90.0, 90.0] degrees
+            tilt_y: Tool tilt on Y axis in range [-90.0, 90.0] degrees
+
+        Refer to the libinput docs to better understand what each param means:
+        https://wayland.freedesktop.org/libinput/doc/latest/tablet-support.html#special-axes-on-tablet-tools
+        """
+        self._tablet.place_tool(tool_type, x, y, pressure, distance, tilt_x, tilt_y)
+
+    def set_button(self, button: PenButtonType, pressed: bool) -> None:
+        """Set the state of a pen button.
+
+        Args:
+            button: The button to modify
+            pressed: True if button is pressed, False if released
+        """
+        self._tablet.set_btn(button, pressed)