tools/testing/selftests/hid/tests/test_tablet.py

   1 #!/bin/env python3
   2 # SPDX-License-Identifier: GPL-2.0
   3 # -*- coding: utf-8 -*-
   4 #
   5 # Copyright (c) 2021 Benjamin Tissoires <[email protected]>
   6 # Copyright (c) 2021 Red Hat, Inc.
   7 #
   8
   9 from . import base
  10 import copy
  11 from enum import Enum
  12 from hidtools.util import BusType
  13 import libevdev
  14 import logging
  15 import pytest
  16 from typing import Dict, List, Optional, Tuple
  17
  18 logger = logging.getLogger("hidtools.test.tablet")
  19
  20
  21 class BtnTouch(Enum):
  22     """Represents whether the BTN_TOUCH event is set to True or False"""
  23
  24     DOWN = True
  25     UP = False
  26
  27
  28 class ToolType(Enum):
  29     PEN = libevdev.EV_KEY.BTN_TOOL_PEN
  30     RUBBER = libevdev.EV_KEY.BTN_TOOL_RUBBER
  31
  32
  33 class BtnPressed(Enum):
  34     """Represents whether a button is pressed on the stylus"""
  35
  36     PRIMARY_PRESSED = libevdev.EV_KEY.BTN_STYLUS
  37     SECONDARY_PRESSED = libevdev.EV_KEY.BTN_STYLUS2
  38     THIRD_PRESSED = libevdev.EV_KEY.BTN_STYLUS3
  39
  40
  41 class PenState(Enum):
  42     """Pen states according to Microsoft reference:
  43     https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-pen-states
  44
  45     We extend it with the various buttons when we need to check them.
  46     """
  47
  48     PEN_IS_OUT_OF_RANGE = BtnTouch.UP, None, False
  49     PEN_IS_IN_RANGE = BtnTouch.UP, ToolType.PEN, False
  50     PEN_IS_IN_RANGE_WITH_BUTTON = BtnTouch.UP, ToolType.PEN, True
  51     PEN_IS_IN_CONTACT = BtnTouch.DOWN, ToolType.PEN, False
  52     PEN_IS_IN_CONTACT_WITH_BUTTON = BtnTouch.DOWN, ToolType.PEN, True
  53     PEN_IS_IN_RANGE_WITH_ERASING_INTENT = BtnTouch.UP, ToolType.RUBBER, False
  54     PEN_IS_IN_RANGE_WITH_ERASING_INTENT_WITH_BUTTON = BtnTouch.UP, ToolType.RUBBER, True
  55     PEN_IS_ERASING = BtnTouch.DOWN, ToolType.RUBBER, False
  56     PEN_IS_ERASING_WITH_BUTTON = BtnTouch.DOWN, ToolType.RUBBER, True
  57
  58     def __init__(
  59         self, touch: BtnTouch, tool: Optional[ToolType], button: Optional[bool]
  60     ):
  61         self.touch = touch  # type: ignore
  62         self.tool = tool  # type: ignore
  63         self.button = button  # type: ignore
  64
  65     @classmethod
  66     def from_evdev(cls, evdev, test_button) -> "PenState":
  67         touch = BtnTouch(evdev.value[libevdev.EV_KEY.BTN_TOUCH])
  68         tool = None
  69         button = False
  70         if (
  71             evdev.value[libevdev.EV_KEY.BTN_TOOL_RUBBER]
  72             and not evdev.value[libevdev.EV_KEY.BTN_TOOL_PEN]
  73         ):
  74             tool = ToolType(libevdev.EV_KEY.BTN_TOOL_RUBBER)
  75         elif (
  76             evdev.value[libevdev.EV_KEY.BTN_TOOL_PEN]
  77             and not evdev.value[libevdev.EV_KEY.BTN_TOOL_RUBBER]
  78         ):
  79             tool = ToolType(libevdev.EV_KEY.BTN_TOOL_PEN)
  80         elif (
  81             evdev.value[libevdev.EV_KEY.BTN_TOOL_PEN]
  82             or evdev.value[libevdev.EV_KEY.BTN_TOOL_RUBBER]
  83         ):
  84             raise ValueError("2 tools are not allowed")
  85
  86         # we take only the provided button into account
  87         if test_button is not None:
  88             button = bool(evdev.value[test_button.value])
  89
  90         # the kernel tends to insert an EV_SYN once removing the tool, so
  91         # the button will be released after
  92         if tool is None:
  93             button = False
  94
  95         return cls((touch, tool, button))  # type: ignore
  96
  97     def apply(
  98         self, events: List[libevdev.InputEvent], strict: bool, test_button: BtnPressed
  99     ) -> "PenState":
 100         if libevdev.EV_SYN.SYN_REPORT in events:
 101             raise ValueError("EV_SYN is in the event sequence")
 102         touch = self.touch
 103         touch_found = False
 104         tool = self.tool
 105         tool_found = False
 106         button = self.button
 107         button_found = False
 108
 109         for ev in events:
 110             if ev == libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH):
 111                 if touch_found:
 112                     raise ValueError(f"duplicated BTN_TOUCH in {events}")
 113                 touch_found = True
 114                 touch = BtnTouch(ev.value)
 115             elif ev in (
 116                 libevdev.InputEvent(libevdev.EV_KEY.BTN_TOOL_PEN),
 117                 libevdev.InputEvent(libevdev.EV_KEY.BTN_TOOL_RUBBER),
 118             ):
 119                 if tool_found:
 120                     raise ValueError(f"duplicated BTN_TOOL_* in {events}")
 121                 tool_found = True
 122                 tool = ToolType(ev.code) if ev.value else None
 123             elif test_button is not None and ev in (test_button.value,):
 124                 if button_found:
 125                     raise ValueError(f"duplicated BTN_STYLUS* in {events}")
 126                 button_found = True
 127                 button = bool(ev.value)
 128
 129         # the kernel tends to insert an EV_SYN once removing the tool, so
 130         # the button will be released after
 131         if tool is None:
 132             button = False
 133
 134         new_state = PenState((touch, tool, button))  # type: ignore
 135         if strict:
 136             assert (
 137                 new_state in self.valid_transitions()
 138             ), f"moving from {self} to {new_state} is forbidden"
 139         else:
 140             assert (
 141                 new_state in self.historically_tolerated_transitions()
 142             ), f"moving from {self} to {new_state} is forbidden"
 143
 144         return new_state
 145
 146     def valid_transitions(self) -> Tuple["PenState", ...]:
 147         """Following the state machine in the URL above.
 148
 149         Note that those transitions are from the evdev point of view, not HID"""
 150         if self == PenState.PEN_IS_OUT_OF_RANGE:
 151             return (
 152                 PenState.PEN_IS_OUT_OF_RANGE,
 153                 PenState.PEN_IS_IN_RANGE,
 154                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 155                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 156                 PenState.PEN_IS_IN_CONTACT,
 157                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 158                 PenState.PEN_IS_ERASING,
 159             )
 160
 161         if self == PenState.PEN_IS_IN_RANGE:
 162             return (
 163                 PenState.PEN_IS_IN_RANGE,
 164                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 165                 PenState.PEN_IS_OUT_OF_RANGE,
 166                 PenState.PEN_IS_IN_CONTACT,
 167             )
 168
 169         if self == PenState.PEN_IS_IN_CONTACT:
 170             return (
 171                 PenState.PEN_IS_IN_CONTACT,
 172                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 173                 PenState.PEN_IS_IN_RANGE,
 174             )
 175
 176         if self == PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT:
 177             return (
 178                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 179                 PenState.PEN_IS_OUT_OF_RANGE,
 180                 PenState.PEN_IS_ERASING,
 181             )
 182
 183         if self == PenState.PEN_IS_ERASING:
 184             return (
 185                 PenState.PEN_IS_ERASING,
 186                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 187             )
 188
 189         if self == PenState.PEN_IS_IN_RANGE_WITH_BUTTON:
 190             return (
 191                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 192                 PenState.PEN_IS_IN_RANGE,
 193                 PenState.PEN_IS_OUT_OF_RANGE,
 194                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 195             )
 196
 197         if self == PenState.PEN_IS_IN_CONTACT_WITH_BUTTON:
 198             return (
 199                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 200                 PenState.PEN_IS_IN_CONTACT,
 201                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 202             )
 203
 204         return tuple()
 205
 206     def historically_tolerated_transitions(self) -> Tuple["PenState", ...]:
 207         """Following the state machine in the URL above, with a couple of addition
 208         for skipping the in-range state, due to historical reasons.
 209
 210         Note that those transitions are from the evdev point of view, not HID"""
 211         if self == PenState.PEN_IS_OUT_OF_RANGE:
 212             return (
 213                 PenState.PEN_IS_OUT_OF_RANGE,
 214                 PenState.PEN_IS_IN_RANGE,
 215                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 216                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 217                 PenState.PEN_IS_IN_CONTACT,
 218                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 219                 PenState.PEN_IS_ERASING,
 220             )
 221
 222         if self == PenState.PEN_IS_IN_RANGE:
 223             return (
 224                 PenState.PEN_IS_IN_RANGE,
 225                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 226                 PenState.PEN_IS_OUT_OF_RANGE,
 227                 PenState.PEN_IS_IN_CONTACT,
 228             )
 229
 230         if self == PenState.PEN_IS_IN_CONTACT:
 231             return (
 232                 PenState.PEN_IS_IN_CONTACT,
 233                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 234                 PenState.PEN_IS_IN_RANGE,
 235                 PenState.PEN_IS_OUT_OF_RANGE,
 236             )
 237
 238         if self == PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT:
 239             return (
 240                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 241                 PenState.PEN_IS_OUT_OF_RANGE,
 242                 PenState.PEN_IS_ERASING,
 243             )
 244
 245         if self == PenState.PEN_IS_ERASING:
 246             return (
 247                 PenState.PEN_IS_ERASING,
 248                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 249                 PenState.PEN_IS_OUT_OF_RANGE,
 250             )
 251
 252         if self == PenState.PEN_IS_IN_RANGE_WITH_BUTTON:
 253             return (
 254                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 255                 PenState.PEN_IS_IN_RANGE,
 256                 PenState.PEN_IS_OUT_OF_RANGE,
 257                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 258             )
 259
 260         if self == PenState.PEN_IS_IN_CONTACT_WITH_BUTTON:
 261             return (
 262                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 263                 PenState.PEN_IS_IN_CONTACT,
 264                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 265                 PenState.PEN_IS_OUT_OF_RANGE,
 266             )
 267
 268         return tuple()
 269
 270     @staticmethod
 271     def legal_transitions() -> Dict[str, Tuple["PenState", ...]]:
 272         """This is the first half of the Windows Pen Implementation state machine:
 273         we don't have Invert nor Erase bits, so just move in/out-of-range or proximity.
 274         https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-pen-states
 275         """
 276         return {
 277             "in-range": (PenState.PEN_IS_IN_RANGE,),
 278             "in-range -> out-of-range": (
 279                 PenState.PEN_IS_IN_RANGE,
 280                 PenState.PEN_IS_OUT_OF_RANGE,
 281             ),
 282             "in-range -> touch": (PenState.PEN_IS_IN_RANGE, PenState.PEN_IS_IN_CONTACT),
 283             "in-range -> touch -> release": (
 284                 PenState.PEN_IS_IN_RANGE,
 285                 PenState.PEN_IS_IN_CONTACT,
 286                 PenState.PEN_IS_IN_RANGE,
 287             ),
 288             "in-range -> touch -> release -> out-of-range": (
 289                 PenState.PEN_IS_IN_RANGE,
 290                 PenState.PEN_IS_IN_CONTACT,
 291                 PenState.PEN_IS_IN_RANGE,
 292                 PenState.PEN_IS_OUT_OF_RANGE,
 293             ),
 294         }
 295
 296     @staticmethod
 297     def legal_transitions_with_invert() -> Dict[str, Tuple["PenState", ...]]:
 298         """This is the second half of the Windows Pen Implementation state machine:
 299         we now have Invert and Erase bits, so move in/out or proximity with the intend
 300         to erase.
 301         https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-pen-states
 302         """
 303         return {
 304             "hover-erasing": (PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,),
 305             "hover-erasing -> out-of-range": (
 306                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 307                 PenState.PEN_IS_OUT_OF_RANGE,
 308             ),
 309             "hover-erasing -> erase": (
 310                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 311                 PenState.PEN_IS_ERASING,
 312             ),
 313             "hover-erasing -> erase -> release": (
 314                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 315                 PenState.PEN_IS_ERASING,
 316                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 317             ),
 318             "hover-erasing -> erase -> release -> out-of-range": (
 319                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 320                 PenState.PEN_IS_ERASING,
 321                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 322                 PenState.PEN_IS_OUT_OF_RANGE,
 323             ),
 324             "hover-erasing -> in-range": (
 325                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 326                 PenState.PEN_IS_IN_RANGE,
 327             ),
 328             "in-range -> hover-erasing": (
 329                 PenState.PEN_IS_IN_RANGE,
 330                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 331             ),
 332         }
 333
 334     @staticmethod
 335     def legal_transitions_with_button() -> Dict[str, Tuple["PenState", ...]]:
 336         """We revisit the Windows Pen Implementation state machine:
 337         we now have a button.
 338         """
 339         return {
 340             "hover-button": (PenState.PEN_IS_IN_RANGE_WITH_BUTTON,),
 341             "hover-button -> out-of-range": (
 342                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 343                 PenState.PEN_IS_OUT_OF_RANGE,
 344             ),
 345             "in-range -> button-press": (
 346                 PenState.PEN_IS_IN_RANGE,
 347                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 348             ),
 349             "in-range -> button-press -> button-release": (
 350                 PenState.PEN_IS_IN_RANGE,
 351                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 352                 PenState.PEN_IS_IN_RANGE,
 353             ),
 354             "in-range -> touch -> button-press -> button-release": (
 355                 PenState.PEN_IS_IN_RANGE,
 356                 PenState.PEN_IS_IN_CONTACT,
 357                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 358                 PenState.PEN_IS_IN_CONTACT,
 359             ),
 360             "in-range -> touch -> button-press -> release -> button-release": (
 361                 PenState.PEN_IS_IN_RANGE,
 362                 PenState.PEN_IS_IN_CONTACT,
 363                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 364                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 365                 PenState.PEN_IS_IN_RANGE,
 366             ),
 367             "in-range -> button-press -> touch -> release -> button-release": (
 368                 PenState.PEN_IS_IN_RANGE,
 369                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 370                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 371                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 372                 PenState.PEN_IS_IN_RANGE,
 373             ),
 374             "in-range -> button-press -> touch -> button-release -> release": (
 375                 PenState.PEN_IS_IN_RANGE,
 376                 PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
 377                 PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
 378                 PenState.PEN_IS_IN_CONTACT,
 379                 PenState.PEN_IS_IN_RANGE,
 380             ),
 381         }
 382
 383     @staticmethod
 384     def tolerated_transitions() -> Dict[str, Tuple["PenState", ...]]:
 385         """This is not adhering to the Windows Pen Implementation state machine
 386         but we should expect the kernel to behave properly, mostly for historical
 387         reasons."""
 388         return {
 389             "direct-in-contact": (PenState.PEN_IS_IN_CONTACT,),
 390             "direct-in-contact -> out-of-range": (
 391                 PenState.PEN_IS_IN_CONTACT,
 392                 PenState.PEN_IS_OUT_OF_RANGE,
 393             ),
 394         }
 395
 396     @staticmethod
 397     def tolerated_transitions_with_invert() -> Dict[str, Tuple["PenState", ...]]:
 398         """This is the second half of the Windows Pen Implementation state machine:
 399         we now have Invert and Erase bits, so move in/out or proximity with the intend
 400         to erase.
 401         https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-pen-states
 402         """
 403         return {
 404             "direct-erase": (PenState.PEN_IS_ERASING,),
 405             "direct-erase -> out-of-range": (
 406                 PenState.PEN_IS_ERASING,
 407                 PenState.PEN_IS_OUT_OF_RANGE,
 408             ),
 409         }
 410
 411     @staticmethod
 412     def broken_transitions() -> Dict[str, Tuple["PenState", ...]]:
 413         """Those tests are definitely not part of the Windows specification.
 414         However, a half broken device might export those transitions.
 415         For example, a pen that has the eraser button might wobble between
 416         touching and erasing if the tablet doesn't enforce the Windows
 417         state machine."""
 418         return {
 419             "in-range -> touch -> erase -> hover-erase": (
 420                 PenState.PEN_IS_IN_RANGE,
 421                 PenState.PEN_IS_IN_CONTACT,
 422                 PenState.PEN_IS_ERASING,
 423                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 424             ),
 425             "in-range -> erase -> hover-erase": (
 426                 PenState.PEN_IS_IN_RANGE,
 427                 PenState.PEN_IS_ERASING,
 428                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 429             ),
 430             "hover-erase -> erase -> touch -> in-range": (
 431                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 432                 PenState.PEN_IS_ERASING,
 433                 PenState.PEN_IS_IN_CONTACT,
 434                 PenState.PEN_IS_IN_RANGE,
 435             ),
 436             "hover-erase -> touch -> in-range": (
 437                 PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
 438                 PenState.PEN_IS_IN_CONTACT,
 439                 PenState.PEN_IS_IN_RANGE,
 440             ),
 441             "touch -> erase -> touch -> erase": (
 442                 PenState.PEN_IS_IN_CONTACT,
 443                 PenState.PEN_IS_ERASING,
 444                 PenState.PEN_IS_IN_CONTACT,
 445                 PenState.PEN_IS_ERASING,
 446             ),
 447         }
 448
 449
 450 class Pen(object):
 451     def __init__(self, x, y):
 452         self.x = x
 453         self.y = y
 454         self.tipswitch = False
 455         self.tippressure = 15
 456         self.azimuth = 0
 457         self.inrange = False
 458         self.width = 10
 459         self.height = 10
 460         self.barrelswitch = False
 461         self.secondarybarrelswitch = False
 462         self.invert = False
 463         self.eraser = False
 464         self.xtilt = 1
 465         self.ytilt = 1
 466         self.twist = 1
 467         self._old_values = None
 468         self.current_state = None
 469
 470     def restore(self):
 471         if self._old_values is not None:
 472             for i in [
 473                 "x",
 474                 "y",
 475                 "tippressure",
 476                 "azimuth",
 477                 "width",
 478                 "height",
 479                 "twist",
 480                 "xtilt",
 481                 "ytilt",
 482             ]:
 483                 setattr(self, i, getattr(self._old_values, i))
 484
 485     def backup(self):
 486         self._old_values = copy.copy(self)
 487
 488     def __assert_axis(self, evdev, axis, value):
 489         if (
 490             axis == libevdev.EV_KEY.BTN_TOOL_RUBBER
 491             and evdev.value[libevdev.EV_KEY.BTN_TOOL_RUBBER] is None
 492         ):
 493             return
 494
 495         assert (
 496             evdev.value[axis] == value
 497         ), f"assert evdev.value[{axis}] ({evdev.value[axis]}) != {value}"
 498
 499     def assert_expected_input_events(self, evdev, button):
 500         assert evdev.value[libevdev.EV_ABS.ABS_X] == self.x
 501         assert evdev.value[libevdev.EV_ABS.ABS_Y] == self.y
 502
 503         # assert no other buttons than the tested ones are set
 504         buttons = [
 505             BtnPressed.PRIMARY_PRESSED,
 506             BtnPressed.SECONDARY_PRESSED,
 507             BtnPressed.THIRD_PRESSED,
 508         ]
 509         if button is not None:
 510             buttons.remove(button)
 511         for b in buttons:
 512             assert evdev.value[b.value] is None or evdev.value[b.value] == False
 513
 514         assert self.current_state == PenState.from_evdev(evdev, button)
 515
 516
 517 class PenDigitizer(base.UHIDTestDevice):
 518     def __init__(
 519         self,
 520         name,
 521         rdesc_str=None,
 522         rdesc=None,
 523         application="Pen",
 524         physical="Stylus",
 525         input_info=(BusType.USB, 1, 2),
 526         evdev_name_suffix=None,
 527     ):
 528         super().__init__(name, application, rdesc_str, rdesc, input_info)
 529         self.physical = physical
 530         self.cur_application = application
 531         if evdev_name_suffix is not None:
 532             self.name += evdev_name_suffix
 533
 534         self.fields = []
 535         for r in self.parsed_rdesc.input_reports.values():
 536             if r.application_name == self.application:
 537                 physicals = [f.physical_name for f in r]
 538                 if self.physical not in physicals and None not in physicals:
 539                     continue
 540                 self.fields = [f.usage_name for f in r]
 541
 542     def move_to(self, pen, state, button):
 543         # fill in the previous values
 544         if pen.current_state == PenState.PEN_IS_OUT_OF_RANGE:
 545             pen.restore()
 546
 547         print(f"\n  *** pen is moving to {state} ***")
 548
 549         if state == PenState.PEN_IS_OUT_OF_RANGE:
 550             pen.backup()
 551             pen.x = 0
 552             pen.y = 0
 553             pen.tipswitch = False
 554             pen.tippressure = 0
 555             pen.azimuth = 0
 556             pen.inrange = False
 557             pen.width = 0
 558             pen.height = 0
 559             pen.invert = False
 560             pen.eraser = False
 561             pen.xtilt = 0
 562             pen.ytilt = 0
 563             pen.twist = 0
 564             pen.barrelswitch = False
 565             pen.secondarybarrelswitch = False
 566         elif state == PenState.PEN_IS_IN_RANGE:
 567             pen.tipswitch = False
 568             pen.inrange = True
 569             pen.invert = False
 570             pen.eraser = False
 571             pen.barrelswitch = False
 572             pen.secondarybarrelswitch = False
 573         elif state == PenState.PEN_IS_IN_CONTACT:
 574             pen.tipswitch = True
 575             pen.inrange = True
 576             pen.invert = False
 577             pen.eraser = False
 578             pen.barrelswitch = False
 579             pen.secondarybarrelswitch = False
 580         elif state == PenState.PEN_IS_IN_RANGE_WITH_BUTTON:
 581             pen.tipswitch = False
 582             pen.inrange = True
 583             pen.invert = False
 584             pen.eraser = False
 585             assert button is not None
 586             pen.barrelswitch = button == BtnPressed.PRIMARY_PRESSED
 587             pen.secondarybarrelswitch = button == BtnPressed.SECONDARY_PRESSED
 588         elif state == PenState.PEN_IS_IN_CONTACT_WITH_BUTTON:
 589             pen.tipswitch = True
 590             pen.inrange = True
 591             pen.invert = False
 592             pen.eraser = False
 593             assert button is not None
 594             pen.barrelswitch = button == BtnPressed.PRIMARY_PRESSED
 595             pen.secondarybarrelswitch = button == BtnPressed.SECONDARY_PRESSED
 596         elif state == PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT:
 597             pen.tipswitch = False
 598             pen.inrange = True
 599             pen.invert = True
 600             pen.eraser = False
 601             pen.barrelswitch = False
 602             pen.secondarybarrelswitch = False
 603         elif state == PenState.PEN_IS_ERASING:
 604             pen.tipswitch = False
 605             pen.inrange = True
 606             pen.invert = False
 607             pen.eraser = True
 608             pen.barrelswitch = False
 609             pen.secondarybarrelswitch = False
 610
 611         pen.current_state = state
 612
 613     def event(self, pen, button):
 614         rs = []
 615         r = self.create_report(application=self.cur_application, data=pen)
 616         self.call_input_event(r)
 617         rs.append(r)
 618         return rs
 619
 620     def get_report(self, req, rnum, rtype):
 621         if rtype != self.UHID_FEATURE_REPORT:
 622             return (1, [])
 623
 624         rdesc = None
 625         for v in self.parsed_rdesc.feature_reports.values():
 626             if v.report_ID == rnum:
 627                 rdesc = v
 628
 629         if rdesc is None:
 630             return (1, [])
 631
 632         return (1, [])
 633
 634     def set_report(self, req, rnum, rtype, data):
 635         if rtype != self.UHID_FEATURE_REPORT:
 636             return 1
 637
 638         rdesc = None
 639         for v in self.parsed_rdesc.feature_reports.values():
 640             if v.report_ID == rnum:
 641                 rdesc = v
 642
 643         if rdesc is None:
 644             return 1
 645
 646         return 1
 647
 648
 649 class BaseTest:
 650     class TestTablet(base.BaseTestCase.TestUhid):
 651         def create_device(self):
 652             raise Exception("please reimplement me in subclasses")
 653
 654         def post(self, uhdev, pen, test_button):
 655             r = uhdev.event(pen, test_button)
 656             events = uhdev.next_sync_events()
 657             self.debug_reports(r, uhdev, events)
 658             return events
 659
 660         def validate_transitions(
 661             self, from_state, pen, evdev, events, allow_intermediate_states, button
 662         ):
 663             # check that the final state is correct
 664             pen.assert_expected_input_events(evdev, button)
 665
 666             state = from_state
 667
 668             # check that the transitions are valid
 669             sync_events = []
 670             while libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT) in events:
 671                 # split the first EV_SYN from the list
 672                 idx = events.index(libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT))
 673                 sync_events = events[:idx]
 674                 events = events[idx + 1 :]
 675
 676                 # now check for a valid transition
 677                 state = state.apply(sync_events, not allow_intermediate_states, button)
 678
 679             if events:
 680                 state = state.apply(sync_events, not allow_intermediate_states, button)
 681
 682         def _test_states(
 683             self, state_list, scribble, allow_intermediate_states, button=None
 684         ):
 685             """Internal method to test against a list of
 686             transition between states.
 687             state_list is a list of PenState objects
 688             scribble is a boolean which tells if we need
 689             to wobble a little the X,Y coordinates of the pen
 690             between each state transition."""
 691             uhdev = self.uhdev
 692             evdev = uhdev.get_evdev()
 693
 694             cur_state = PenState.PEN_IS_OUT_OF_RANGE
 695
 696             p = Pen(50, 60)
 697             uhdev.move_to(p, PenState.PEN_IS_OUT_OF_RANGE, button)
 698             events = self.post(uhdev, p, button)
 699             self.validate_transitions(
 700                 cur_state, p, evdev, events, allow_intermediate_states, button
 701             )
 702
 703             cur_state = p.current_state
 704
 705             for state in state_list:
 706                 if scribble and cur_state != PenState.PEN_IS_OUT_OF_RANGE:
 707                     p.x += 1
 708                     p.y -= 1
 709                     events = self.post(uhdev, p, button)
 710                     self.validate_transitions(
 711                         cur_state, p, evdev, events, allow_intermediate_states, button
 712                     )
 713                     assert len(events) >= 3  # X, Y, SYN
 714                 uhdev.move_to(p, state, button)
 715                 if scribble and state != PenState.PEN_IS_OUT_OF_RANGE:
 716                     p.x += 1
 717                     p.y -= 1
 718                 events = self.post(uhdev, p, button)
 719                 self.validate_transitions(
 720                     cur_state, p, evdev, events, allow_intermediate_states, button
 721                 )
 722                 cur_state = p.current_state
 723
 724         @pytest.mark.parametrize("scribble", [True, False], ids=["scribble", "static"])
 725         @pytest.mark.parametrize(
 726             "state_list",
 727             [pytest.param(v, id=k) for k, v in PenState.legal_transitions().items()],
 728         )
 729         def test_valid_pen_states(self, state_list, scribble):
 730             """This is the first half of the Windows Pen Implementation state machine:
 731             we don't have Invert nor Erase bits, so just move in/out-of-range or proximity.
 732             https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-pen-states
 733             """
 734             self._test_states(state_list, scribble, allow_intermediate_states=False)
 735
 736         @pytest.mark.parametrize("scribble", [True, False], ids=["scribble", "static"])
 737         @pytest.mark.parametrize(
 738             "state_list",
 739             [
 740                 pytest.param(v, id=k)
 741                 for k, v in PenState.tolerated_transitions().items()
 742             ],
 743         )
 744         def test_tolerated_pen_states(self, state_list, scribble):
 745             """This is not adhering to the Windows Pen Implementation state machine
 746             but we should expect the kernel to behave properly, mostly for historical
 747             reasons."""
 748             self._test_states(state_list, scribble, allow_intermediate_states=True)
 749
 750         @pytest.mark.skip_if_uhdev(
 751             lambda uhdev: "Barrel Switch" not in uhdev.fields,
 752             "Device not compatible, missing Barrel Switch usage",
 753         )
 754         @pytest.mark.parametrize("scribble", [True, False], ids=["scribble", "static"])
 755         @pytest.mark.parametrize(
 756             "state_list",
 757             [
 758                 pytest.param(v, id=k)
 759                 for k, v in PenState.legal_transitions_with_button().items()
 760             ],
 761         )
 762         def test_valid_primary_button_pen_states(self, state_list, scribble):
 763             """Rework the transition state machine by adding the primary button."""
 764             self._test_states(
 765                 state_list,
 766                 scribble,
 767                 allow_intermediate_states=False,
 768                 button=BtnPressed.PRIMARY_PRESSED,
 769             )
 770
 771         @pytest.mark.skip_if_uhdev(
 772             lambda uhdev: "Secondary Barrel Switch" not in uhdev.fields,
 773             "Device not compatible, missing Secondary Barrel Switch usage",
 774         )
 775         @pytest.mark.parametrize("scribble", [True, False], ids=["scribble", "static"])
 776         @pytest.mark.parametrize(
 777             "state_list",
 778             [
 779                 pytest.param(v, id=k)
 780                 for k, v in PenState.legal_transitions_with_button().items()
 781             ],
 782         )
 783         def test_valid_secondary_button_pen_states(self, state_list, scribble):
 784             """Rework the transition state machine by adding the secondary button."""
 785             self._test_states(
 786                 state_list,
 787                 scribble,
 788                 allow_intermediate_states=False,
 789                 button=BtnPressed.SECONDARY_PRESSED,
 790             )
 791
 792         @pytest.mark.skip_if_uhdev(
 793             lambda uhdev: "Third Barrel Switch" not in uhdev.fields,
 794             "Device not compatible, missing Third Barrel Switch usage",
 795         )
 796         @pytest.mark.parametrize("scribble", [True, False], ids=["scribble", "static"])
 797         @pytest.mark.parametrize(
 798             "state_list",
 799             [
 800                 pytest.param(v, id=k)
 801                 for k, v in PenState.legal_transitions_with_button().items()
 802             ],
 803         )
 804         def test_valid_third_button_pen_states(self, state_list, scribble):
 805             """Rework the transition state machine by adding the secondary button."""
 806             self._test_states(
 807                 state_list,
 808                 scribble,
 809                 allow_intermediate_states=False,
 810                 button=BtnPressed.THIRD_PRESSED,
 811             )
 812
 813         @pytest.mark.skip_if_uhdev(
 814             lambda uhdev: "Invert" not in uhdev.fields,
 815             "Device not compatible, missing Invert usage",
 816         )
 817         @pytest.mark.parametrize("scribble", [True, False], ids=["scribble", "static"])
 818         @pytest.mark.parametrize(
 819             "state_list",
 820             [
 821                 pytest.param(v, id=k)
 822                 for k, v in PenState.legal_transitions_with_invert().items()
 823             ],
 824         )
 825         def test_valid_invert_pen_states(self, state_list, scribble):
 826             """This is the second half of the Windows Pen Implementation state machine:
 827             we now have Invert and Erase bits, so move in/out or proximity with the intend
 828             to erase.
 829             https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-pen-states
 830             """
 831             self._test_states(state_list, scribble, allow_intermediate_states=False)
 832
 833         @pytest.mark.skip_if_uhdev(
 834             lambda uhdev: "Invert" not in uhdev.fields,
 835             "Device not compatible, missing Invert usage",
 836         )
 837         @pytest.mark.parametrize("scribble", [True, False], ids=["scribble", "static"])
 838         @pytest.mark.parametrize(
 839             "state_list",
 840             [
 841                 pytest.param(v, id=k)
 842                 for k, v in PenState.tolerated_transitions_with_invert().items()
 843             ],
 844         )
 845         def test_tolerated_invert_pen_states(self, state_list, scribble):
 846             """This is the second half of the Windows Pen Implementation state machine:
 847             we now have Invert and Erase bits, so move in/out or proximity with the intend
 848             to erase.
 849             https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-pen-states
 850             """
 851             self._test_states(state_list, scribble, allow_intermediate_states=True)
 852
 853         @pytest.mark.skip_if_uhdev(
 854             lambda uhdev: "Invert" not in uhdev.fields,
 855             "Device not compatible, missing Invert usage",
 856         )
 857         @pytest.mark.parametrize("scribble", [True, False], ids=["scribble", "static"])
 858         @pytest.mark.parametrize(
 859             "state_list",
 860             [pytest.param(v, id=k) for k, v in PenState.broken_transitions().items()],
 861         )
 862         def test_tolerated_broken_pen_states(self, state_list, scribble):
 863             """Those tests are definitely not part of the Windows specification.
 864             However, a half broken device might export those transitions.
 865             For example, a pen that has the eraser button might wobble between
 866             touching and erasing if the tablet doesn't enforce the Windows
 867             state machine."""
 868             self._test_states(state_list, scribble, allow_intermediate_states=True)
 869
 870
 871 class GXTP_pen(PenDigitizer):
 872     def event(self, pen, test_button):
 873         if not hasattr(self, "prev_tip_state"):
 874             self.prev_tip_state = False
 875
 876         internal_pen = copy.copy(pen)
 877
 878         # bug in the controller: when the pen touches the
 879         # surface, in-range stays to 1, but when
 880         # the pen moves in-range gets reverted to 0
 881         if pen.tipswitch and self.prev_tip_state:
 882             internal_pen.inrange = False
 883
 884         self.prev_tip_state = pen.tipswitch
 885
 886         # another bug in the controller: when the pen is
 887         # inverted, invert is set to 1, but as soon as
 888         # the pen touches the surface, eraser is correctly
 889         # set to 1 but invert is released
 890         if pen.eraser:
 891             internal_pen.invert = False
 892
 893         return super().event(internal_pen, test_button)
 894
 895
 896 class USIPen(PenDigitizer):
 897     pass
 898
 899
 900 class XPPen_ArtistPro16Gen2_28bd_095b(PenDigitizer):
 901     """
 902     Pen with two buttons and a rubber end, but which reports
 903     the second button as an eraser
 904     """
 905
 906     def __init__(
 907         self,
 908         name,
 909         rdesc_str=None,
 910         rdesc=None,
 911         application="Pen",
 912         physical="Stylus",
 913         input_info=(BusType.USB, 0x28BD, 0x095B),
 914         evdev_name_suffix=None,
 915     ):
 916         super().__init__(
 917             name, rdesc_str, rdesc, application, physical, input_info, evdev_name_suffix
 918         )
 919         self.fields.append("Secondary Barrel Switch")
 920
 921     def move_to(self, pen, state, button):
 922         # fill in the previous values
 923         if pen.current_state == PenState.PEN_IS_OUT_OF_RANGE:
 924             pen.restore()
 925
 926         print(f"\n  *** pen is moving to {state} ***")
 927
 928         if state == PenState.PEN_IS_OUT_OF_RANGE:
 929             pen.backup()
 930             pen.x = 0
 931             pen.y = 0
 932             pen.tipswitch = False
 933             pen.tippressure = 0
 934             pen.azimuth = 0
 935             pen.inrange = False
 936             pen.width = 0
 937             pen.height = 0
 938             pen.invert = False
 939             pen.eraser = False
 940             pen.xtilt = 0
 941             pen.ytilt = 0
 942             pen.twist = 0
 943             pen.barrelswitch = False
 944         elif state == PenState.PEN_IS_IN_RANGE:
 945             pen.tipswitch = False
 946             pen.inrange = True
 947             pen.invert = False
 948             pen.eraser = False
 949             pen.barrelswitch = False
 950         elif state == PenState.PEN_IS_IN_CONTACT:
 951             pen.tipswitch = True
 952             pen.inrange = True
 953             pen.invert = False
 954             pen.eraser = False
 955             pen.barrelswitch = False
 956         elif state == PenState.PEN_IS_IN_RANGE_WITH_BUTTON:
 957             pen.tipswitch = False
 958             pen.inrange = True
 959             pen.invert = False
 960             assert button is not None
 961             pen.barrelswitch = button == BtnPressed.PRIMARY_PRESSED
 962             pen.eraser = button == BtnPressed.SECONDARY_PRESSED
 963         elif state == PenState.PEN_IS_IN_CONTACT_WITH_BUTTON:
 964             pen.tipswitch = True
 965             pen.inrange = True
 966             pen.invert = False
 967             assert button is not None
 968             pen.barrelswitch = button == BtnPressed.PRIMARY_PRESSED
 969             pen.eraser = button == BtnPressed.SECONDARY_PRESSED
 970         elif state == PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT:
 971             pen.tipswitch = False
 972             pen.inrange = True
 973             pen.invert = True
 974             pen.eraser = False
 975             pen.barrelswitch = False
 976         elif state == PenState.PEN_IS_ERASING:
 977             pen.tipswitch = True
 978             pen.inrange = True
 979             pen.invert = True
 980             pen.eraser = False
 981             pen.barrelswitch = False
 982
 983         pen.current_state = state
 984
 985     def event(self, pen, test_button):
 986         import math
 987
 988         pen_copy = copy.copy(pen)
 989         width = 13.567
 990         height = 8.480
 991         tip_height = 0.055677699
 992         hx = tip_height * (32767 / width)
 993         hy = tip_height * (32767 / height)
 994         if pen_copy.xtilt != 0:
 995             pen_copy.x += round(hx * math.sin(math.radians(pen_copy.xtilt)))
 996         if pen_copy.ytilt != 0:
 997             pen_copy.y += round(hy * math.sin(math.radians(pen_copy.ytilt)))
 998
 999         return super().event(pen_copy, test_button)
1000
1001
1002 class XPPen_Artist24_28bd_093a(PenDigitizer):
1003     """
1004     Pen that reports secondary barrel switch through eraser
1005     """
1006
1007     def __init__(
1008         self,
1009         name,
1010         rdesc_str=None,
1011         rdesc=None,
1012         application="Pen",
1013         physical="Stylus",
1014         input_info=(BusType.USB, 0x28BD, 0x093A),
1015         evdev_name_suffix=None,
1016     ):
1017         super().__init__(
1018             name, rdesc_str, rdesc, application, physical, input_info, evdev_name_suffix
1019         )
1020         self.fields.append("Secondary Barrel Switch")
1021         self.previous_state = PenState.PEN_IS_OUT_OF_RANGE
1022
1023     def move_to(self, pen, state, button, debug=True):
1024         # fill in the previous values
1025         if pen.current_state == PenState.PEN_IS_OUT_OF_RANGE:
1026             pen.restore()
1027
1028         if debug:
1029             print(f"\n  *** pen is moving to {state} ***")
1030
1031         if state == PenState.PEN_IS_OUT_OF_RANGE:
1032             pen.backup()
1033             pen.tipswitch = False
1034             pen.tippressure = 0
1035             pen.azimuth = 0
1036             pen.inrange = False
1037             pen.width = 0
1038             pen.height = 0
1039             pen.invert = False
1040             pen.eraser = False
1041             pen.xtilt = 0
1042             pen.ytilt = 0
1043             pen.twist = 0
1044             pen.barrelswitch = False
1045         elif state == PenState.PEN_IS_IN_RANGE:
1046             pen.tipswitch = False
1047             pen.inrange = True
1048             pen.invert = False
1049             pen.eraser = False
1050             pen.barrelswitch = False
1051         elif state == PenState.PEN_IS_IN_CONTACT:
1052             pen.tipswitch = True
1053             pen.inrange = True
1054             pen.invert = False
1055             pen.eraser = False
1056             pen.barrelswitch = False
1057         elif state == PenState.PEN_IS_IN_RANGE_WITH_BUTTON:
1058             pen.tipswitch = False
1059             pen.inrange = True
1060             pen.invert = False
1061             assert button is not None
1062             pen.barrelswitch = button == BtnPressed.PRIMARY_PRESSED
1063             pen.eraser = button == BtnPressed.SECONDARY_PRESSED
1064         elif state == PenState.PEN_IS_IN_CONTACT_WITH_BUTTON:
1065             pen.tipswitch = True
1066             pen.inrange = True
1067             pen.invert = False
1068             assert button is not None
1069             pen.barrelswitch = button == BtnPressed.PRIMARY_PRESSED
1070             pen.eraser = button == BtnPressed.SECONDARY_PRESSED
1071
1072         pen.current_state = state
1073
1074     def send_intermediate_state(self, pen, state, button):
1075         intermediate_pen = copy.copy(pen)
1076         self.move_to(intermediate_pen, state, button, debug=False)
1077         return super().event(intermediate_pen, button)
1078
1079     def event(self, pen, button):
1080         rs = []
1081
1082         # the pen reliably sends in-range events in a normal case (non emulation of eraser mode)
1083         if self.previous_state == PenState.PEN_IS_IN_CONTACT:
1084             if pen.current_state == PenState.PEN_IS_OUT_OF_RANGE:
1085                 rs.extend(
1086                     self.send_intermediate_state(pen, PenState.PEN_IS_IN_RANGE, button)
1087                 )
1088
1089         if button == BtnPressed.SECONDARY_PRESSED:
1090             if self.previous_state == PenState.PEN_IS_IN_RANGE:
1091                 if pen.current_state == PenState.PEN_IS_IN_RANGE_WITH_BUTTON:
1092                     rs.extend(
1093                         self.send_intermediate_state(
1094                             pen, PenState.PEN_IS_OUT_OF_RANGE, button
1095                         )
1096                     )
1097
1098             if self.previous_state == PenState.PEN_IS_IN_RANGE_WITH_BUTTON:
1099                 if pen.current_state == PenState.PEN_IS_IN_RANGE:
1100                     rs.extend(
1101                         self.send_intermediate_state(
1102                             pen, PenState.PEN_IS_OUT_OF_RANGE, button
1103                         )
1104                     )
1105
1106             if self.previous_state == PenState.PEN_IS_IN_CONTACT:
1107                 if pen.current_state == PenState.PEN_IS_IN_CONTACT_WITH_BUTTON:
1108                     rs.extend(
1109                         self.send_intermediate_state(
1110                             pen, PenState.PEN_IS_OUT_OF_RANGE, button
1111                         )
1112                     )
1113                     rs.extend(
1114                         self.send_intermediate_state(
1115                             pen, PenState.PEN_IS_IN_RANGE_WITH_BUTTON, button
1116                         )
1117                     )
1118
1119             if self.previous_state == PenState.PEN_IS_IN_CONTACT_WITH_BUTTON:
1120                 if pen.current_state == PenState.PEN_IS_IN_CONTACT:
1121                     rs.extend(
1122                         self.send_intermediate_state(
1123                             pen, PenState.PEN_IS_OUT_OF_RANGE, button
1124                         )
1125                     )
1126                     rs.extend(
1127                         self.send_intermediate_state(
1128                             pen, PenState.PEN_IS_IN_RANGE, button
1129                         )
1130                     )
1131
1132         rs.extend(super().event(pen, button))
1133         self.previous_state = pen.current_state
1134         return rs
1135
1136
1137 class Huion_Kamvas_Pro_19_256c_006b(PenDigitizer):
1138     """
1139     Pen that reports secondary barrel switch through secondary TipSwtich
1140     and 3rd button through Invert
1141     """
1142
1143     def __init__(
1144         self,
1145         name,
1146         rdesc_str=None,
1147         rdesc=None,
1148         application="Stylus",
1149         physical=None,
1150         input_info=(BusType.USB, 0x256C, 0x006B),
1151         evdev_name_suffix=None,
1152     ):
1153         super().__init__(
1154             name, rdesc_str, rdesc, application, physical, input_info, evdev_name_suffix
1155         )
1156         self.fields.append("Secondary Barrel Switch")
1157         self.fields.append("Third Barrel Switch")
1158         self.previous_state = PenState.PEN_IS_OUT_OF_RANGE
1159
1160     def move_to(self, pen, state, button, debug=True):
1161         # fill in the previous values
1162         if pen.current_state == PenState.PEN_IS_OUT_OF_RANGE:
1163             pen.restore()
1164
1165         if debug:
1166             print(f"\n  *** pen is moving to {state} ***")
1167
1168         if state == PenState.PEN_IS_OUT_OF_RANGE:
1169             pen.backup()
1170             pen.tipswitch = False
1171             pen.tippressure = 0
1172             pen.azimuth = 0
1173             pen.inrange = False
1174             pen.width = 0
1175             pen.height = 0
1176             pen.invert = False
1177             pen.eraser = False
1178             pen.xtilt = 0
1179             pen.ytilt = 0
1180             pen.twist = 0
1181             pen.barrelswitch = False
1182             pen.secondarytipswitch = False
1183         elif state == PenState.PEN_IS_IN_RANGE:
1184             pen.tipswitch = False
1185             pen.inrange = True
1186             pen.invert = False
1187             pen.eraser = False
1188             pen.barrelswitch = False
1189             pen.secondarytipswitch = False
1190         elif state == PenState.PEN_IS_IN_CONTACT:
1191             pen.tipswitch = True
1192             pen.inrange = True
1193             pen.invert = False
1194             pen.eraser = False
1195             pen.barrelswitch = False
1196             pen.secondarytipswitch = False
1197         elif state == PenState.PEN_IS_IN_RANGE_WITH_BUTTON:
1198             pen.tipswitch = False
1199             pen.inrange = True
1200             pen.eraser = False
1201             assert button is not None
1202             pen.barrelswitch = button == BtnPressed.PRIMARY_PRESSED
1203             pen.secondarytipswitch = button == BtnPressed.SECONDARY_PRESSED
1204             pen.invert = button == BtnPressed.THIRD_PRESSED
1205         elif state == PenState.PEN_IS_IN_CONTACT_WITH_BUTTON:
1206             pen.tipswitch = True
1207             pen.inrange = True
1208             pen.eraser = False
1209             assert button is not None
1210             pen.barrelswitch = button == BtnPressed.PRIMARY_PRESSED
1211             pen.secondarytipswitch = button == BtnPressed.SECONDARY_PRESSED
1212             pen.invert = button == BtnPressed.THIRD_PRESSED
1213         elif state == PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT:
1214             pen.tipswitch = False
1215             pen.inrange = True
1216             pen.invert = True
1217             pen.eraser = False
1218             pen.barrelswitch = False
1219             pen.secondarytipswitch = False
1220         elif state == PenState.PEN_IS_ERASING:
1221             pen.tipswitch = False
1222             pen.inrange = True
1223             pen.invert = False
1224             pen.eraser = True
1225             pen.barrelswitch = False
1226             pen.secondarytipswitch = False
1227
1228         pen.current_state = state
1229
1230     def call_input_event(self, report):
1231         if report[0] == 0x0a:
1232             # ensures the original second Eraser usage is null
1233             report[1] &= 0xdf
1234
1235             # ensures the original last bit is equal to bit 6 (In Range)
1236             if report[1] & 0x40:
1237                 report[1] |= 0x80
1238
1239         super().call_input_event(report)
1240
1241     def send_intermediate_state(self, pen, state, test_button):
1242         intermediate_pen = copy.copy(pen)
1243         self.move_to(intermediate_pen, state, test_button, debug=False)
1244         return super().event(intermediate_pen, test_button)
1245
1246     def event(self, pen, button):
1247         rs = []
1248
1249         # it's not possible to go between eraser mode or not without
1250         # going out-of-prox: the eraser mode is activated by presenting
1251         # the tail of the pen
1252         if self.previous_state in (
1253             PenState.PEN_IS_IN_RANGE,
1254             PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
1255             PenState.PEN_IS_IN_CONTACT,
1256             PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
1257         ) and pen.current_state in (
1258             PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
1259             PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT_WITH_BUTTON,
1260             PenState.PEN_IS_ERASING,
1261             PenState.PEN_IS_ERASING_WITH_BUTTON,
1262         ):
1263             rs.extend(
1264                 self.send_intermediate_state(pen, PenState.PEN_IS_OUT_OF_RANGE, button)
1265             )
1266
1267         # same than above except from eraser to normal
1268         if self.previous_state in (
1269             PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT,
1270             PenState.PEN_IS_IN_RANGE_WITH_ERASING_INTENT_WITH_BUTTON,
1271             PenState.PEN_IS_ERASING,
1272             PenState.PEN_IS_ERASING_WITH_BUTTON,
1273         ) and pen.current_state in (
1274             PenState.PEN_IS_IN_RANGE,
1275             PenState.PEN_IS_IN_RANGE_WITH_BUTTON,
1276             PenState.PEN_IS_IN_CONTACT,
1277             PenState.PEN_IS_IN_CONTACT_WITH_BUTTON,
1278         ):
1279             rs.extend(
1280                 self.send_intermediate_state(pen, PenState.PEN_IS_OUT_OF_RANGE, button)
1281             )
1282
1283         if self.previous_state == PenState.PEN_IS_OUT_OF_RANGE:
1284             if pen.current_state == PenState.PEN_IS_IN_RANGE_WITH_BUTTON:
1285                 rs.extend(
1286                     self.send_intermediate_state(pen, PenState.PEN_IS_IN_RANGE, button)
1287                 )
1288
1289         rs.extend(super().event(pen, button))
1290         self.previous_state = pen.current_state
1291         return rs
1292
1293
1294 ################################################################################
1295 #
1296 # Windows 7 compatible devices
1297 #
1298 ################################################################################
1299 # class TestEgalax_capacitive_0eef_7224(BaseTest.TestTablet):
1300 #     def create_device(self):
1301 #         return PenDigitizer('uhid test egalax-capacitive_0eef_7224',
1302 #                             rdesc='05 0d 09 04 a1 01 85 04 09 22 a1 00 09 42 15 00 25 01 75 01 95 01 81 02 09 32 15 00 25 01 81 02 09 51 75 05 95 01 16 00 00 26 10 00 81 02 09 47 75 01 95 01 15 00 25 01 81 02 05 01 09 30 75 10 95 01 55 0d 65 33 35 00 46 34 49 26 ff 7f 81 02 09 31 75 10 95 01 55 0d 65 33 35 00 46 37 29 26 ff 7f 81 02 05 0d 09 55 25 08 75 08 95 01 b1 02 c0 c0 05 01 09 01 a1 01 85 01 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 95 02 75 01 81 02 95 01 75 06 81 01 05 01 09 30 09 31 16 00 00 26 ff 0f 36 00 00 46 ff 0f 66 00 00 75 10 95 02 81 02 c0 c0 06 00 ff 09 01 a1 01 09 01 15 00 26 ff 00 85 03 75 08 95 3f 81 02 06 00 ff 09 01 15 00 26 ff 00 75 08 95 3f 91 02 c0 05 0d 09 04 a1 01 85 02 09 20 a1 00 09 42 09 32 15 00 25 01 95 02 75 01 81 02 95 06 75 01 81 03 05 01 09 30 75 10 95 01 a4 55 0d 65 33 36 00 00 46 34 49 16 00 00 26 ff 0f 81 02 09 31 16 00 00 26 ff 0f 36 00 00 46 37 29 81 02 b4 c0 c0 05 0d 09 0e a1 01 85 05 09 22 a1 00 09 52 09 53 15 00 25 0a 75 08 95 02 b1 02 c0 c0',
1303 #                             input_info=(BusType.USB, 0x0eef, 0x7224),
1304 #                             evdev_name_suffix=' Touchscreen')
1305 #
1306 #
1307 # class TestEgalax_capacitive_0eef_72fa(BaseTest.TestTablet):
1308 #     def create_device(self):
1309 #         return PenDigitizer('uhid test egalax-capacitive_0eef_72fa',
1310 #                             rdesc='05 0d 09 04 a1 01 85 04 09 22 a1 00 09 42 15 00 25 01 75 01 95 01 81 02 09 32 15 00 25 01 81 02 09 51 75 05 95 01 16 00 00 26 10 00 81 02 09 47 75 01 95 01 15 00 25 01 81 02 05 01 09 30 75 10 95 01 55 0d 65 33 35 00 46 72 22 26 ff 7f 81 02 09 31 75 10 95 01 55 0d 65 33 35 00 46 87 13 26 ff 7f 81 02 05 0d 09 55 25 08 75 08 95 01 b1 02 c0 c0 05 01 09 01 a1 01 85 01 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 95 02 75 01 81 02 95 01 75 06 81 01 05 01 09 30 09 31 16 00 00 26 ff 0f 36 00 00 46 ff 0f 66 00 00 75 10 95 02 81 02 c0 c0 06 00 ff 09 01 a1 01 09 01 15 00 26 ff 00 85 03 75 08 95 3f 81 02 06 00 ff 09 01 15 00 26 ff 00 75 08 95 3f 91 02 c0 05 0d 09 04 a1 01 85 02 09 20 a1 00 09 42 09 32 15 00 25 01 95 02 75 01 81 02 95 06 75 01 81 03 05 01 09 30 75 10 95 01 a4 55 0d 65 33 36 00 00 46 72 22 16 00 00 26 ff 0f 81 02 09 31 16 00 00 26 ff 0f 36 00 00 46 87 13 81 02 b4 c0 c0 05 0d 09 0e a1 01 85 05 09 22 a1 00 09 52 09 53 15 00 25 0a 75 08 95 02 b1 02 c0 c0',
1311 #                             input_info=(BusType.USB, 0x0eef, 0x72fa),
1312 #                             evdev_name_suffix=' Touchscreen')
1313 #
1314 #
1315 # class TestEgalax_capacitive_0eef_7336(BaseTest.TestTablet):
1316 #     def create_device(self):
1317 #         return PenDigitizer('uhid test egalax-capacitive_0eef_7336',
1318 #                             rdesc='05 0d 09 04 a1 01 85 04 09 22 a1 00 09 42 15 00 25 01 75 01 95 01 81 02 09 32 15 00 25 01 81 02 09 51 75 05 95 01 16 00 00 26 10 00 81 02 09 47 75 01 95 01 15 00 25 01 81 02 05 01 09 30 75 10 95 01 55 0d 65 33 35 00 46 c1 20 26 ff 7f 81 02 09 31 75 10 95 01 55 0d 65 33 35 00 46 c2 18 26 ff 7f 81 02 05 0d 09 55 25 08 75 08 95 01 b1 02 c0 c0 05 01 09 01 a1 01 85 01 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 95 02 75 01 81 02 95 01 75 06 81 01 05 01 09 30 09 31 16 00 00 26 ff 0f 36 00 00 46 ff 0f 66 00 00 75 10 95 02 81 02 c0 c0 06 00 ff 09 01 a1 01 09 01 15 00 26 ff 00 85 03 75 08 95 3f 81 02 06 00 ff 09 01 15 00 26 ff 00 75 08 95 3f 91 02 c0 05 0d 09 04 a1 01 85 02 09 20 a1 00 09 42 09 32 15 00 25 01 95 02 75 01 81 02 95 06 75 01 81 03 05 01 09 30 75 10 95 01 a4 55 0d 65 33 36 00 00 46 c1 20 16 00 00 26 ff 0f 81 02 09 31 16 00 00 26 ff 0f 36 00 00 46 c2 18 81 02 b4 c0 c0 05 0d 09 0e a1 01 85 05 09 22 a1 00 09 52 09 53 15 00 25 0a 75 08 95 02 b1 02 c0 c0',
1319 #                             input_info=(BusType.USB, 0x0eef, 0x7336),
1320 #                             evdev_name_suffix=' Touchscreen')
1321 #
1322 #
1323 # class TestEgalax_capacitive_0eef_7337(BaseTest.TestTablet):
1324 #     def create_device(self):
1325 #         return PenDigitizer('uhid test egalax-capacitive_0eef_7337',
1326 #                             rdesc='05 0d 09 04 a1 01 85 04 09 22 a1 00 09 42 15 00 25 01 75 01 95 01 81 02 09 32 15 00 25 01 81 02 09 51 75 05 95 01 16 00 00 26 10 00 81 02 09 47 75 01 95 01 15 00 25 01 81 02 05 01 09 30 75 10 95 01 55 0d 65 33 35 00 46 ae 17 26 ff 7f 81 02 09 31 75 10 95 01 55 0d 65 33 35 00 46 c3 0e 26 ff 7f 81 02 05 0d 09 55 25 08 75 08 95 01 b1 02 c0 c0 05 01 09 01 a1 01 85 01 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 95 02 75 01 81 02 95 01 75 06 81 01 05 01 09 30 09 31 16 00 00 26 ff 0f 36 00 00 46 ff 0f 66 00 00 75 10 95 02 81 02 c0 c0 06 00 ff 09 01 a1 01 09 01 15 00 26 ff 00 85 03 75 08 95 3f 81 02 06 00 ff 09 01 15 00 26 ff 00 75 08 95 3f 91 02 c0 05 0d 09 04 a1 01 85 02 09 20 a1 00 09 42 09 32 15 00 25 01 95 02 75 01 81 02 95 06 75 01 81 03 05 01 09 30 75 10 95 01 a4 55 0d 65 33 36 00 00 46 ae 17 16 00 00 26 ff 0f 81 02 09 31 16 00 00 26 ff 0f 36 00 00 46 c3 0e 81 02 b4 c0 c0 05 0d 09 0e a1 01 85 05 09 22 a1 00 09 52 09 53 15 00 25 0a 75 08 95 02 b1 02 c0 c0',
1327 #                             input_info=(BusType.USB, 0x0eef, 0x7337),
1328 #                             evdev_name_suffix=' Touchscreen')
1329 #
1330 #
1331 # class TestEgalax_capacitive_0eef_7349(BaseTest.TestTablet):
1332 #     def create_device(self):
1333 #         return PenDigitizer('uhid test egalax-capacitive_0eef_7349',
1334 #                             rdesc='05 0d 09 04 a1 01 85 04 09 22 a1 00 09 42 15 00 25 01 75 01 95 01 81 02 09 32 15 00 25 01 81 02 09 51 75 05 95 01 16 00 00 26 10 00 81 02 09 47 75 01 95 01 15 00 25 01 81 02 05 01 09 30 75 10 95 01 55 0d 65 33 35 00 46 34 49 26 ff 7f 81 02 09 31 75 10 95 01 55 0d 65 33 35 00 46 37 29 26 ff 7f 81 02 05 0d 09 55 25 08 75 08 95 01 b1 02 c0 c0 05 01 09 01 a1 01 85 01 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 95 02 75 01 81 02 95 01 75 06 81 01 05 01 09 30 09 31 16 00 00 26 ff 0f 36 00 00 46 ff 0f 66 00 00 75 10 95 02 81 02 c0 c0 06 00 ff 09 01 a1 01 09 01 15 00 26 ff 00 85 03 75 08 95 3f 81 02 06 00 ff 09 01 15 00 26 ff 00 75 08 95 3f 91 02 c0 05 0d 09 04 a1 01 85 02 09 20 a1 00 09 42 09 32 15 00 25 01 95 02 75 01 81 02 95 06 75 01 81 03 05 01 09 30 75 10 95 01 a4 55 0d 65 33 36 00 00 46 34 49 16 00 00 26 ff 0f 81 02 09 31 16 00 00 26 ff 0f 36 00 00 46 37 29 81 02 b4 c0 c0 05 0d 09 0e a1 01 85 05 09 22 a1 00 09 52 09 53 15 00 25 0a 75 08 95 02 b1 02 c0 c0',
1335 #                             input_info=(BusType.USB, 0x0eef, 0x7349),
1336 #                             evdev_name_suffix=' Touchscreen')
1337 #
1338 #
1339 # class TestEgalax_capacitive_0eef_73f4(BaseTest.TestTablet):
1340 #     def create_device(self):
1341 #         return PenDigitizer('uhid test egalax-capacitive_0eef_73f4',
1342 #                             rdesc='05 0d 09 04 a1 01 85 04 09 22 a1 00 09 42 15 00 25 01 75 01 95 01 81 02 09 32 15 00 25 01 81 02 09 51 75 05 95 01 16 00 00 26 10 00 81 02 09 47 75 01 95 01 15 00 25 01 81 02 05 01 09 30 75 10 95 01 55 0d 65 33 35 00 46 96 4e 26 ff 7f 81 02 09 31 75 10 95 01 55 0d 65 33 35 00 46 23 2c 26 ff 7f 81 02 05 0d 09 55 25 08 75 08 95 01 b1 02 c0 c0 05 01 09 01 a1 01 85 01 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 95 02 75 01 81 02 95 01 75 06 81 01 05 01 09 30 09 31 16 00 00 26 ff 0f 36 00 00 46 ff 0f 66 00 00 75 10 95 02 81 02 c0 c0 06 00 ff 09 01 a1 01 09 01 15 00 26 ff 00 85 03 75 08 95 3f 81 02 06 00 ff 09 01 15 00 26 ff 00 75 08 95 3f 91 02 c0 05 0d 09 04 a1 01 85 02 09 20 a1 00 09 42 09 32 15 00 25 01 95 02 75 01 81 02 95 06 75 01 81 03 05 01 09 30 75 10 95 01 a4 55 0d 65 33 36 00 00 46 96 4e 16 00 00 26 ff 0f 81 02 09 31 16 00 00 26 ff 0f 36 00 00 46 23 2c 81 02 b4 c0 c0 05 0d 09 0e a1 01 85 05 09 22 a1 00 09 52 09 53 15 00 25 0a 75 08 95 02 b1 02 c0 c0',
1343 #                             input_info=(BusType.USB, 0x0eef, 0x73f4),
1344 #                             evdev_name_suffix=' Touchscreen')
1345 #
1346 #  bogus: BTN_TOOL_PEN is not emitted
1347 # class TestIrtouch_6615_0070(BaseTest.TestTablet):
1348 #     def create_device(self):
1349 #         return PenDigitizer('uhid test irtouch_6615_0070',
1350 #                             rdesc='05 01 09 02 a1 01 85 10 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 95 02 75 01 81 02 95 06 81 03 05 01 09 30 09 31 15 00 26 ff 7f 75 10 95 02 81 02 c0 c0 05 0d 09 04 a1 01 85 30 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 09 51 75 08 95 01 81 02 05 01 09 30 26 ff 7f 55 0f 65 11 35 00 46 51 02 75 10 95 01 81 02 09 31 35 00 46 73 01 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 09 51 75 08 95 01 81 02 05 01 09 30 26 ff 7f 55 0f 65 11 35 00 46 51 02 75 10 95 01 81 02 09 31 35 00 46 73 01 81 02 c0 05 0d 09 54 15 00 26 02 00 75 08 95 01 81 02 85 03 09 55 15 00 26 ff 00 75 08 95 01 b1 02 c0 05 0d 09 0e a1 01 85 02 09 52 09 53 15 00 26 ff 00 75 08 95 02 b1 02 c0 05 0d 09 02 a1 01 85 20 09 20 a1 00 09 42 15 00 25 01 75 01 95 01 81 02 95 07 81 03 05 01 09 30 26 ff 7f 55 0f 65 11 35 00 46 51 02 75 10 95 01 81 02 09 31 35 00 46 73 01 81 02 85 01 06 00 ff 09 01 75 08 95 01 b1 02 c0 c0',
1351 #                             input_info=(BusType.USB, 0x6615, 0x0070))
1352
1353
1354 class TestNexio_1870_0100(BaseTest.TestTablet):
1355     def create_device(self):
1356         return PenDigitizer(
1357             "uhid test nexio_1870_0100",
1358             rdesc="05 0d 09 04 a1 01 85 01 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0e 65 11 09 30 35 00 46 1e 19 81 02 26 ff 3f 09 31 35 00 46 be 0f 81 02 26 ff 3f c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0e 65 11 09 30 35 00 46 1e 19 81 02 26 ff 3f 09 31 35 00 46 be 0f 81 02 26 ff 3f c0 05 0d 09 54 95 01 75 08 25 02 81 02 85 02 09 55 25 02 b1 02 c0 09 0e a1 01 85 03 09 23 a1 02 09 52 09 53 15 00 25 0a 75 08 95 02 b1 02 c0 c0 05 01 09 02 a1 01 09 01 a1 00 85 04 05 09 95 03 75 01 19 01 29 03 15 00 25 01 81 02 95 01 75 05 81 01 05 01 75 10 95 02 09 30 09 31 15 00 26 ff 7f 81 02 c0 c0 05 0d 09 02 a1 01 85 05 09 20 a1 00 09 42 09 32 15 00 25 01 75 01 95 02 81 02 95 0e 81 03 05 01 26 ff 3f 75 10 95 01 55 0e 65 11 09 30 35 00 46 1e 19 81 02 26 ff 3f 09 31 35 00 46 be 0f 81 02 26 ff 3f c0 c0 06 00 ff 09 01 a1 01 85 06 19 01 29 40 15 00 26 ff 00 75 08 95 40 81 00 19 01 29 40 91 00 c0",
1359             input_info=(BusType.USB, 0x1870, 0x0100),
1360         )
1361
1362
1363 class TestNexio_1870_010d(BaseTest.TestTablet):
1364     def create_device(self):
1365         return PenDigitizer(
1366             "uhid test nexio_1870_010d",
1367             rdesc="05 0d 09 04 a1 01 85 01 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 05 0d 09 54 95 01 75 08 25 02 81 02 85 02 09 55 25 06 b1 02 c0 09 0e a1 01 85 03 09 23 a1 02 09 52 09 53 15 00 25 0a 75 08 95 02 b1 02 c0 c0 05 01 09 02 a1 01 09 01 a1 00 85 04 05 09 95 03 75 01 19 01 29 03 15 00 25 01 81 02 95 01 75 05 81 01 05 01 75 10 95 02 09 30 09 31 15 00 26 ff 7f 81 02 c0 c0 05 0d 09 02 a1 01 85 05 09 20 a1 00 09 42 09 32 15 00 25 01 75 01 95 02 81 02 95 0e 81 03 05 01 26 ff 3f 75 10 95 01 55 0e 65 11 09 30 35 00 46 1e 19 81 02 26 ff 3f 09 31 35 00 46 be 0f 81 02 26 ff 3f c0 c0 06 00 ff 09 01 a1 01 85 06 19 01 29 40 15 00 26 ff 00 75 08 95 3e 81 00 19 01 29 40 91 00 c0",
1368             input_info=(BusType.USB, 0x1870, 0x010D),
1369         )
1370
1371
1372 class TestNexio_1870_0119(BaseTest.TestTablet):
1373     def create_device(self):
1374         return PenDigitizer(
1375             "uhid test nexio_1870_0119",
1376             rdesc="05 0d 09 04 a1 01 85 01 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 95 06 81 03 75 08 09 51 95 01 81 02 05 01 26 ff 3f 75 10 55 0d 65 00 09 30 35 00 46 00 00 81 02 26 ff 3f 09 31 35 00 46 00 00 81 02 26 ff 3f 05 0d 09 48 35 00 26 ff 3f 81 02 09 49 35 00 26 ff 3f 81 02 c0 05 0d 09 54 95 01 75 08 25 02 81 02 85 02 09 55 25 06 b1 02 c0 09 0e a1 01 85 03 09 23 a1 02 09 52 09 53 15 00 25 0a 75 08 95 02 b1 02 c0 c0 05 01 09 02 a1 01 09 01 a1 00 85 04 05 09 95 03 75 01 19 01 29 03 15 00 25 01 81 02 95 01 75 05 81 01 05 01 75 10 95 02 09 30 09 31 15 00 26 ff 7f 81 02 c0 c0 05 0d 09 02 a1 01 85 05 09 20 a1 00 09 42 09 32 15 00 25 01 75 01 95 02 81 02 95 0e 81 03 05 01 26 ff 3f 75 10 95 01 55 0e 65 11 09 30 35 00 46 1e 19 81 02 26 ff 3f 09 31 35 00 46 be 0f 81 02 26 ff 3f c0 c0 06 00 ff 09 01 a1 01 85 06 19 01 29 40 15 00 26 ff 00 75 08 95 3e 81 00 19 01 29 40 91 00 c0",
1377             input_info=(BusType.USB, 0x1870, 0x0119),
1378         )
1379
1380
1381 ################################################################################
1382 #
1383 # Windows 8 compatible devices
1384 #
1385 ################################################################################
1386
1387 # bogus: application is 'undefined'
1388 # class Testatmel_03eb_8409(BaseTest.TestTablet):
1389 #     def create_device(self):
1390 #         return PenDigitizer('uhid test atmel_03eb_8409', rdesc='05 0d 09 04 a1 01 85 01 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 02 46 c8 0a 26 6f 08 09 30 81 02 35 00 35 00 46 18 06 26 77 0f 09 31 81 02 35 00 35 00 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 48 81 02 09 49 81 02 c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 02 46 c8 0a 26 6f 08 09 30 81 02 35 00 35 00 46 18 06 26 77 0f 09 31 81 02 35 00 35 00 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 48 81 02 09 49 81 02 c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 02 46 c8 0a 26 6f 08 09 30 81 02 35 00 35 00 46 18 06 26 77 0f 09 31 81 02 35 00 35 00 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 48 81 02 09 49 81 02 c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 02 46 c8 0a 26 6f 08 09 30 81 02 35 00 35 00 46 18 06 26 77 0f 09 31 81 02 35 00 35 00 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 48 81 02 09 49 81 02 c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 02 46 c8 0a 26 6f 08 09 30 81 02 35 00 35 00 46 18 06 26 77 0f 09 31 81 02 35 00 35 00 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 48 81 02 09 49 81 02 c0 05 0d 27 ff ff 00 00 75 10 95 01 09 56 81 02 15 00 25 1f 75 05 09 54 95 01 81 02 75 03 25 01 95 01 81 03 75 08 85 02 09 55 25 10 b1 02 06 00 ff 85 05 09 c5 15 00 26 ff 00 75 08 96 00 01 b1 02 c0 05 0d 09 00 a1 01 85 03 09 20 a1 00 15 00 25 01 75 01 95 01 09 42 81 02 09 44 81 02 09 45 81 02 81 03 09 32 81 02 95 03 81 03 05 01 55 0e 65 11 35 00 75 10 95 02 46 c8 0a 26 6f 08 09 30 81 02 46 18 06 26 77 0f 09 31 81 02 05 0d 09 30 15 01 26 ff 00 75 08 95 01 81 02 c0 c0')
1391
1392
1393 class Testatmel_03eb_840b(BaseTest.TestTablet):
1394     def create_device(self):
1395         return PenDigitizer(
1396             "uhid test atmel_03eb_840b",
1397             rdesc="05 0d 09 04 a1 01 85 01 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 01 46 00 0a 26 ff 0f 09 30 81 02 09 00 81 03 46 a0 05 26 ff 0f 09 31 81 02 09 00 81 03 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 00 81 03 09 00 81 03 c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 01 46 00 0a 26 ff 0f 09 30 81 02 09 00 81 03 46 a0 05 26 ff 0f 09 31 81 02 09 00 81 03 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 00 81 03 09 00 81 03 c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 01 46 00 0a 26 ff 0f 09 30 81 02 09 00 81 03 46 a0 05 26 ff 0f 09 31 81 02 09 00 81 03 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 00 81 03 09 00 81 03 c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 01 46 00 0a 26 ff 0f 09 30 81 02 09 00 81 03 46 a0 05 26 ff 0f 09 31 81 02 09 00 81 03 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 00 81 03 09 00 81 03 c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 95 01 81 03 25 1f 75 05 09 51 81 02 05 01 55 0e 65 11 35 00 75 10 95 01 46 00 0a 26 ff 0f 09 30 81 02 09 00 81 03 46 a0 05 26 ff 0f 09 31 81 02 09 00 81 03 05 0d 95 01 75 08 15 00 26 ff 00 46 ff 00 09 00 81 03 09 00 81 03 c0 05 0d 27 ff ff 00 00 75 10 95 01 09 56 81 02 15 00 25 1f 75 05 09 54 95 01 81 02 75 03 25 01 95 01 81 03 75 08 85 02 09 55 25 10 b1 02 06 00 ff 85 05 09 c5 15 00 26 ff 00 75 08 96 00 01 b1 02 c0 05 0d 09 02 a1 01 85 03 09 20 a1 00 15 00 25 01 75 01 95 01 09 42 81 02 09 44 81 02 09 45 81 02 81 03 09 32 81 02 95 03 81 03 05 01 55 0e 65 11 35 00 75 10 95 02 46 00 0a 26 ff 0f 09 30 81 02 46 a0 05 26 ff 0f 09 31 81 02 05 0d 09 30 15 01 26 ff 00 75 08 95 01 81 02 c0 c0",
1398         )
1399
1400
1401 class Testn_trig_1b96_0c01(BaseTest.TestTablet):
1402     def create_device(self):
1403         return PenDigitizer(
1404             "uhid test n_trig_1b96_0c01",
1405             rdesc="75 08 15 00 26 ff 00 06 0b ff 09 0b a1 01 95 0f 09 29 85 29 b1 02 95 1f 09 2a 85 2a b1 02 95 3e 09 2b 85 2b b1 02 95 fe 09 2c 85 2c b1 02 96 fe 01 09 2d 85 2d b1 02 95 02 09 48 85 48 b1 02 95 0f 09 2e 85 2e 81 02 95 1f 09 2f 85 2f 81 02 95 3e 09 30 85 30 81 02 95 fe 09 31 85 31 81 02 96 fe 01 09 32 85 32 81 02 75 08 96 fe 0f 09 35 85 35 81 02 c0 05 0d 09 02 a1 01 85 01 09 20 35 00 a1 00 09 32 09 42 09 44 09 3c 09 45 15 00 25 01 75 01 95 05 81 02 95 03 81 03 05 01 09 30 75 10 95 01 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 b4 05 0d 09 30 26 00 01 81 02 06 00 ff 09 01 81 02 c0 85 0c 06 00 ff 09 0c 75 08 95 06 26 ff 00 b1 02 85 0b 09 0b 95 02 b1 02 85 11 09 11 b1 02 85 15 09 15 95 05 b1 02 85 18 09 18 95 0c b1 02 c0 05 0d 09 04 a1 01 85 03 06 00 ff 09 01 75 10 95 01 15 00 27 ff ff 00 00 81 02 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 09 32 81 02 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 54 95 01 75 08 81 02 09 56 75 20 95 01 27 ff ff ff 0f 81 02 85 04 09 55 75 08 95 01 25 0b b1 02 85 0a 06 00 ff 09 03 15 00 b1 02 85 1b 06 00 ff 09 c5 15 00 26 ff 00 75 08 96 00 01 b1 02 c0 05 01 09 02 a1 01 85 02 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 75 01 95 02 81 02 95 06 81 03 05 01 09 30 09 31 15 81 25 7f 75 08 95 02 81 06 c0 c0",
1406         )
1407
1408
1409 class Testn_trig_1b96_0c03(BaseTest.TestTablet):
1410     def create_device(self):
1411         return PenDigitizer(
1412             "uhid test n_trig_1b96_0c03",
1413             rdesc="75 08 15 00 26 ff 00 06 0b ff 09 0b a1 01 95 0f 09 29 85 29 b1 02 95 1f 09 2a 85 2a b1 02 95 3e 09 2b 85 2b b1 02 95 fe 09 2c 85 2c b1 02 96 fe 01 09 2d 85 2d b1 02 95 02 09 48 85 48 b1 02 95 0f 09 2e 85 2e 81 02 95 1f 09 2f 85 2f 81 02 95 3e 09 30 85 30 81 02 95 fe 09 31 85 31 81 02 96 fe 01 09 32 85 32 81 02 75 08 96 fe 0f 09 35 85 35 81 02 c0 05 0d 09 02 a1 01 85 01 09 20 35 00 a1 00 09 32 09 42 09 44 09 3c 09 45 15 00 25 01 75 01 95 05 81 02 95 03 81 03 05 01 09 30 75 10 95 01 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 b4 05 0d 09 30 26 00 01 81 02 06 00 ff 09 01 81 02 c0 85 0c 06 00 ff 09 0c 75 08 95 06 26 ff 00 b1 02 85 0b 09 0b 95 02 b1 02 85 11 09 11 b1 02 85 15 09 15 95 05 b1 02 85 18 09 18 95 0c b1 02 c0 05 0d 09 04 a1 01 85 03 06 00 ff 09 01 75 10 95 01 15 00 27 ff ff 00 00 81 02 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 15 0a 26 80 25 81 02 09 31 46 b4 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 54 95 01 75 08 81 02 09 56 75 20 95 01 27 ff ff ff 0f 81 02 85 04 09 55 75 08 95 01 25 0b b1 02 85 0a 06 00 ff 09 03 15 00 b1 02 85 1b 06 00 ff 09 c5 15 00 26 ff 00 75 08 96 00 01 b1 02 c0 05 01 09 02 a1 01 85 02 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 75 01 95 02 81 02 95 06 81 03 05 01 09 30 09 31 15 81 25 7f 75 08 95 02 81 06 c0 c0",
1414         )
1415
1416
1417 class Testn_trig_1b96_0f00(BaseTest.TestTablet):
1418     def create_device(self):
1419         return PenDigitizer(
1420             "uhid test n_trig_1b96_0f00",
1421             rdesc="75 08 15 00 26 ff 00 06 0b ff 09 0b a1 01 95 0f 09 29 85 29 b1 02 95 1f 09 2a 85 2a b1 02 95 3e 09 2b 85 2b b1 02 95 fe 09 2c 85 2c b1 02 96 fe 01 09 2d 85 2d b1 02 95 02 09 48 85 48 b1 02 95 0f 09 2e 85 2e 81 02 95 1f 09 2f 85 2f 81 02 95 3e 09 30 85 30 81 02 95 fe 09 31 85 31 81 02 96 fe 01 09 32 85 32 81 02 75 08 96 fe 0f 09 35 85 35 81 02 c0 05 0d 09 02 a1 01 85 01 09 20 35 00 a1 00 09 32 09 42 09 44 09 3c 09 45 15 00 25 01 75 01 95 05 81 02 95 03 81 03 05 01 09 30 75 10 95 01 a4 55 0e 65 11 46 03 0a 26 80 25 81 02 09 31 46 a1 05 26 20 1c 81 02 b4 05 0d 09 30 26 00 01 81 02 06 00 ff 09 01 81 02 c0 85 0c 06 00 ff 09 0c 75 08 95 06 26 ff 00 b1 02 85 0b 09 0b 95 02 b1 02 85 11 09 11 b1 02 85 15 09 15 95 05 b1 02 85 18 09 18 95 0c b1 02 c0 05 0d 09 04 a1 01 85 03 06 00 ff 09 01 75 10 95 01 15 00 27 ff ff 00 00 81 02 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 03 0a 26 80 25 81 02 09 31 46 a1 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 03 0a 26 80 25 81 02 09 31 46 a1 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 54 95 01 75 08 81 02 09 56 75 20 95 01 27 ff ff ff 0f 81 02 85 04 09 55 75 08 95 01 25 0b b1 02 85 0a 06 00 ff 09 03 15 00 b1 02 85 1b 06 00 ff 09 c5 15 00 26 ff 00 75 08 96 00 01 b1 02 c0 05 01 09 02 a1 01 85 02 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 75 01 95 02 81 02 95 06 81 03 05 01 09 30 09 31 15 81 25 7f 75 08 95 02 81 06 c0 c0",
1422         )
1423
1424
1425 class Testn_trig_1b96_0f04(BaseTest.TestTablet):
1426     def create_device(self):
1427         return PenDigitizer(
1428             "uhid test n_trig_1b96_0f04",
1429             rdesc="75 08 15 00 26 ff 00 06 0b ff 09 0b a1 01 95 0f 09 29 85 29 b1 02 95 1f 09 2a 85 2a b1 02 95 3e 09 2b 85 2b b1 02 95 fe 09 2c 85 2c b1 02 96 fe 01 09 2d 85 2d b1 02 95 02 09 48 85 48 b1 02 95 0f 09 2e 85 2e 81 02 95 1f 09 2f 85 2f 81 02 95 3e 09 30 85 30 81 02 95 fe 09 31 85 31 81 02 96 fe 01 09 32 85 32 81 02 75 08 96 fe 0f 09 35 85 35 81 02 c0 05 0d 09 02 a1 01 85 01 09 20 35 00 a1 00 09 32 09 42 09 44 09 3c 09 45 15 00 25 01 75 01 95 05 81 02 95 03 81 03 05 01 09 30 75 10 95 01 a4 55 0e 65 11 46 7f 0b 26 80 25 81 02 09 31 46 78 06 26 20 1c 81 02 b4 05 0d 09 30 26 00 01 81 02 06 00 ff 09 01 81 02 c0 85 0c 06 00 ff 09 0c 75 08 95 06 26 ff 00 b1 02 85 0b 09 0b 95 02 b1 02 85 11 09 11 b1 02 85 15 09 15 95 05 b1 02 85 18 09 18 95 0c b1 02 c0 05 0d 09 04 a1 01 85 03 06 00 ff 09 01 75 10 95 01 15 00 27 ff ff 00 00 81 02 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 7f 0b 26 80 25 81 02 09 31 46 78 06 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 7f 0b 26 80 25 81 02 09 31 46 78 06 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 54 95 01 75 08 81 02 09 56 75 20 95 01 27 ff ff ff 0f 81 02 85 04 09 55 75 08 95 01 25 0b b1 02 85 0a 06 00 ff 09 03 15 00 b1 02 85 1b 06 00 ff 09 c5 15 00 26 ff 00 75 08 96 00 01 b1 02 c0 05 01 09 02 a1 01 85 02 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 75 01 95 02 81 02 95 06 81 03 05 01 09 30 09 31 15 81 25 7f 75 08 95 02 81 06 c0 c0",
1430         )
1431
1432
1433 class Testn_trig_1b96_1000(BaseTest.TestTablet):
1434     def create_device(self):
1435         return PenDigitizer(
1436             "uhid test n_trig_1b96_1000",
1437             rdesc="75 08 15 00 26 ff 00 06 0b ff 09 0b a1 01 95 0f 09 29 85 29 b1 02 95 1f 09 2a 85 2a b1 02 95 3e 09 2b 85 2b b1 02 95 fe 09 2c 85 2c b1 02 96 fe 01 09 2d 85 2d b1 02 95 02 09 48 85 48 b1 02 95 0f 09 2e 85 2e 81 02 95 1f 09 2f 85 2f 81 02 95 3e 09 30 85 30 81 02 95 fe 09 31 85 31 81 02 96 fe 01 09 32 85 32 81 02 75 08 96 fe 0f 09 35 85 35 81 02 c0 05 0d 09 02 a1 01 85 01 09 20 35 00 a1 00 09 32 09 42 09 44 09 3c 09 45 15 00 25 01 75 01 95 05 81 02 95 03 81 03 05 01 09 30 75 10 95 01 a4 55 0e 65 11 46 03 0a 26 80 25 81 02 09 31 46 a1 05 26 20 1c 81 02 b4 05 0d 09 30 26 00 01 81 02 06 00 ff 09 01 81 02 c0 85 0c 06 00 ff 09 0c 75 08 95 06 26 ff 00 b1 02 85 0b 09 0b 95 02 b1 02 85 11 09 11 b1 02 85 15 09 15 95 05 b1 02 85 18 09 18 95 0c b1 02 c0 05 0d 09 04 a1 01 85 03 06 00 ff 09 01 75 10 95 01 15 00 27 ff ff 00 00 81 02 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 03 0a 26 80 25 81 02 09 31 46 a1 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 01 81 03 09 47 81 02 95 05 81 03 75 10 09 51 27 ff ff 00 00 95 01 81 02 05 01 09 30 75 10 95 02 a4 55 0e 65 11 46 03 0a 26 80 25 81 02 09 31 46 a1 05 26 20 1c 81 02 05 0d 09 48 95 01 26 80 25 81 02 09 49 26 20 1c 81 02 b4 06 00 ff 09 02 75 08 95 04 15 00 26 ff 00 81 02 c0 05 0d 09 54 95 01 75 08 81 02 09 56 75 20 95 01 27 ff ff ff 0f 81 02 85 04 09 55 75 08 95 01 25 0b b1 02 85 0a 06 00 ff 09 03 15 00 b1 02 85 1b 06 00 ff 09 c5 15 00 26 ff 00 75 08 96 00 01 b1 02 c0 05 01 09 02 a1 01 85 02 09 01 a1 00 05 09 19 01 29 02 15 00 25 01 75 01 95 02 81 02 95 06 81 03 05 01 09 30 09 31 15 81 25 7f 75 08 95 02 81 06 c0 c0",
1438         )
1439
1440
1441 class TestGXTP_27c6_0113(BaseTest.TestTablet):
1442     def create_device(self):
1443         return GXTP_pen(
1444             "uhid test GXTP_27c6_0113",
1445             rdesc="05 0d 09 04 a1 01 85 01 09 22 a1 02 55 0e 65 11 35 00 15 00 09 42 25 01 75 01 95 01 81 02 95 07 81 01 95 01 75 08 09 51 81 02 75 10 05 01 26 00 14 46 1f 07 09 30 81 02 26 80 0c 46 77 04 09 31 81 02 05 0d c0 09 22 a1 02 09 42 25 01 75 01 95 01 81 02 95 07 81 01 95 01 75 08 09 51 81 02 75 10 05 01 26 00 14 46 1f 07 09 30 81 02 26 80 0c 46 77 04 09 31 81 02 05 0d c0 09 22 a1 02 09 42 25 01 75 01 95 01 81 02 95 07 81 01 95 01 75 08 09 51 81 02 75 10 05 01 26 00 14 46 1f 07 09 30 81 02 26 80 0c 46 77 04 09 31 81 02 05 0d c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 07 81 01 75 08 09 51 95 01 81 02 05 01 26 00 14 75 10 55 0e 65 11 09 30 35 00 46 1f 07 81 02 26 80 0c 46 77 04 09 31 81 02 05 0d c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 95 07 81 01 75 08 09 51 95 01 81 02 05 01 26 00 14 75 10 55 0e 65 11 09 30 35 00 46 1f 07 81 02 26 80 0c 46 77 04 09 31 81 02 05 0d c0 09 54 15 00 25 7f 75 08 95 01 81 02 85 02 09 55 95 01 25 0a b1 02 85 03 06 00 ff 09 c5 15 00 26 ff 00 75 08 96 00 01 b1 02 c0 05 0d 09 02 a1 01 85 08 09 20 a1 00 09 42 09 44 09 3c 09 45 15 00 25 01 75 01 95 04 81 02 95 01 81 03 09 32 81 02 95 02 81 03 95 01 75 08 09 51 81 02 05 01 09 30 75 10 95 01 a4 55 0e 65 11 35 00 26 00 14 46 1f 07 81 42 09 31 26 80 0c 46 77 04 81 42 b4 05 0d 09 30 26 ff 0f 81 02 09 3d 65 14 55 0e 36 d8 dc 46 28 23 16 d8 dc 26 28 23 81 02 09 3e 81 02 c0 c0 06 f0 ff 09 01 a1 01 85 0e 09 01 15 00 25 ff 75 08 95 40 91 02 09 01 15 00 25 ff 75 08 95 40 81 02 c0 05 01 09 06 a1 01 85 04 05 07 09 e3 15 00 25 01 75 01 95 01 81 02 95 07 81 03 c0",
1446         )
1447
1448
1449 ################################################################################
1450 #
1451 # Windows 8 compatible devices with USI Pen
1452 #
1453 ################################################################################
1454
1455
1456 class TestElan_04f3_2A49(BaseTest.TestTablet):
1457     def create_device(self):
1458         return USIPen(
1459             "uhid test Elan_04f3_2A49",
1460             rdesc="05 0d 09 04 a1 01 85 01 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 75 01 81 03 75 06 09 51 25 3f 81 02 26 ff 00 75 08 55 0f 65 11 35 00 45 ff 09 48 81 02 09 49 81 02 09 30 81 02 95 01 05 01 a4 26 cf 0f 75 10 55 0f 65 11 09 30 35 00 46 26 01 95 01 81 02 26 77 0a 46 a6 00 09 31 81 02 b4 c0 05 0d 09 22 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 75 01 81 03 75 06 09 51 25 3f 81 02 26 ff 00 75 08 55 0f 65 11 35 00 45 ff 09 48 81 02 09 49 81 02 09 30 81 02 95 01 05 01 a4 26 cf 0f 75 10 55 0f 65 11 09 30 35 00 46 26 01 95 01 81 02 26 77 0a 46 a6 00 09 31 81 02 b4 c0 05 0d 09 22 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 75 01 81 03 75 06 09 51 25 3f 81 02 26 ff 00 75 08 55 0f 65 11 35 00 45 ff 09 48 81 02 09 49 81 02 09 30 81 02 95 01 05 01 a4 26 cf 0f 75 10 55 0f 65 11 09 30 35 00 46 26 01 95 01 81 02 26 77 0a 46 a6 00 09 31 81 02 b4 c0 05 0d 09 22 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 75 01 81 03 75 06 09 51 25 3f 81 02 26 ff 00 75 08 55 0f 65 11 35 00 45 ff 09 48 81 02 09 49 81 02 09 30 81 02 95 01 05 01 a4 26 cf 0f 75 10 55 0f 65 11 09 30 35 00 46 26 01 95 01 81 02 26 77 0a 46 a6 00 09 31 81 02 b4 c0 05 0d 09 22 a1 02 05 0d 09 42 15 00 25 01 75 01 95 01 81 02 75 01 81 03 75 06 09 51 25 3f 81 02 26 ff 00 75 08 55 0f 65 11 35 00 45 ff 09 48 81 02 09 49 81 02 09 30 81 02 95 01 05 01 a4 26 cf 0f 75 10 55 0f 65 11 09 30 35 00 46 26 01 95 01 81 02 26 77 0a 46 a6 00 09 31 81 02 b4 c0 05 0d 09 54 25 7f 96 01 00 75 08 81 02 85 0a 09 55 25 0a b1 02 85 44 06 00 ff 09 c5 16 00 00 26 ff 00 75 08 96 00 01 b1 02 c0 06 ff 01 09 01 a1 01 85 02 16 00 00 26 ff 00 75 08 95 40 09 00 81 02 c0 06 00 ff 09 01 a1 01 85 03 75 08 95 20 09 01 91 02 c0 06 00 ff 09 01 a1 01 85 06 09 03 75 08 95 12 91 02 09 04 75 08 95 03 b1 02 c0 06 01 ff 09 01 a1 01 85 04 15 00 26 ff 00 75 08 95 13 09 00 81 02 c0 05 0d 09 02 a1 01 85 07 35 00 09 20 a1 00 09 32 09 42 09 44 09 3c 09 45 15 00 25 01 75 01 95 05 81 02 95 03 81 03 05 01 09 30 75 10 95 01 a4 55 0f 65 11 46 26 01 26 1c 48 81 42 09 31 46 a6 00 26 bc 2f 81 42 b4 05 0d 09 30 26 00 10 81 02 75 08 95 01 09 3b 25 64 81 42 09 38 15 00 25 02 81 02 09 5c 26 ff 00 81 02 09 5e 81 02 09 70 a1 02 15 01 25 06 09 72 09 73 09 74 09 75 09 76 09 77 81 20 09 5b 25 ff 75 40 81 02 c0 06 00 ff 75 08 95 02 09 01 81 02 c0 05 0d 85 60 09 81 a1 02 09 38 75 08 95 01 15 00 25 02 81 02 09 81 15 01 25 04 09 82 09 83 09 84 09 85 81 20 c0 85 61 09 5c a1 02 15 00 26 ff 00 75 08 95 01 09 38 b1 02 09 5c 26 ff 00 b1 02 09 5d 75 01 95 01 25 01 b1 02 95 07 b1 03 c0 85 62 09 5e a1 02 09 38 15 00 25 02 75 08 95 01 b1 02 09 5e 26 ff 00 b1 02 09 5f 75 01 25 01 b1 02 75 07 b1 03 c0 85 63 09 70 a1 02 75 08 95 01 15 00 25 02 09 38 b1 02 09 70 a1 02 25 06 09 72 09 73 09 74 09 75 09 76 09 77 b1 20 c0 09 71 75 01 25 01 b1 02 75 07 b1 03 c0 85 64 09 80 15 00 25 ff 75 40 95 01 b1 02 85 65 09 44 a1 02 09 38 75 08 95 01 25 02 b1 02 15 01 25 03 09 44 a1 02 09 a4 09 44 09 5a 09 45 09 a3 b1 20 c0 09 5a a1 02 09 a4 09 44 09 5a 09 45 09 a3 b1 20 c0 09 45 a1 02 09 a4 09 44 09 5a 09 45 09 a3 b1 20 c0 c0 85 66 75 08 95 01 05 0d 09 90 a1 02 09 38 25 02 b1 02 09 91 75 10 26 ff 0f b1 02 09 92 75 40 25 ff b1 02 05 06 09 2a 75 08 26 ff 00 a1 02 09 2d b1 02 09 2e b1 02 c0 c0 85 67 05 06 09 2b a1 02 05 0d 25 02 09 38 b1 02 05 06 09 2b a1 02 09 2d 26 ff 00 b1 02 09 2e b1 02 c0 c0 85 68 06 00 ff 09 01 a1 02 05 0d 09 38 75 08 95 01 25 02 b1 02 06 00 ff 09 01 75 10 27 ff ff 00 00 b1 02 c0 85 69 05 0d 09 38 75 08 95 01 15 00 25 02 b1 02 c0 06 00 ff 09 81 a1 01 85 17 75 08 95 1f 09 05 81 02 c0",
1461             input_info=(BusType.I2C, 0x04F3, 0x2A49),
1462         )
1463
1464
1465 class TestGoodix_27c6_0e00(BaseTest.TestTablet):
1466     def create_device(self):
1467         return USIPen(
1468             "uhid test Elan_04f3_2A49",
1469             rdesc="05 0d 09 04 a1 01 85 01 09 22 a1 02 55 0e 65 11 35 00 15 00 09 42 25 01 75 01 95 01 81 02 25 7f 09 30 75 07 81 42 95 01 75 08 09 51 81 02 75 10 05 01 26 04 20 46 e6 09 09 30 81 02 26 60 15 46 9a 06 09 31 81 02 05 0d 55 0f 75 08 25 ff 45 ff 09 48 81 42 09 49 81 42 55 0e c0 09 22 a1 02 09 42 25 01 75 01 95 01 81 02 25 7f 09 30 75 07 81 42 95 01 75 08 09 51 81 02 75 10 05 01 26 04 20 46 e6 09 09 30 81 02 26 60 15 46 9a 06 09 31 81 02 05 0d 55 0f 75 08 25 ff 45 ff 09 48 81 42 09 49 81 42 55 0e c0 09 22 a1 02 09 42 25 01 75 01 95 01 81 02 25 7f 09 30 75 07 81 42 95 01 75 08 09 51 81 02 75 10 05 01 26 04 20 46 e6 09 09 30 81 02 26 60 15 46 9a 06 09 31 81 02 05 0d 55 0f 75 08 25 ff 45 ff 09 48 81 42 09 49 81 42 55 0e c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 25 7f 09 30 75 07 81 42 75 08 09 51 95 01 81 02 05 01 26 04 20 75 10 55 0e 65 11 09 30 35 00 46 e6 09 81 02 26 60 15 46 9a 06 09 31 81 02 05 0d 55 0f 75 08 25 ff 45 ff 09 48 81 42 09 49 81 42 55 0e c0 09 22 a1 02 09 42 15 00 25 01 75 01 95 01 81 02 25 7f 09 30 75 07 81 42 75 08 09 51 95 01 81 02 05 01 26 04 20 75 10 55 0e 65 11 09 30 35 00 46 e6 09 81 02 26 60 15 46 9a 06 09 31 81 02 05 0d 55 0f 75 08 25 ff 45 ff 09 48 81 42 09 49 81 42 55 0e c0 09 54 15 00 25 7f 75 08 95 01 81 02 85 02 09 55 95 01 25 0a b1 02 85 03 06 00 ff 09 c5 15 00 26 ff 00 75 08 96 00 01 b1 02 c0 05 0d 09 02 a1 01 09 20 a1 00 85 08 05 01 a4 09 30 35 00 46 e6 09 15 00 26 04 20 55 0d 65 13 75 10 95 01 81 02 09 31 46 9a 06 26 60 15 81 02 b4 05 0d 09 38 95 01 75 08 15 00 25 01 81 02 09 30 75 10 26 ff 0f 81 02 09 31 81 02 09 42 09 44 09 5a 09 3c 09 45 09 32 75 01 95 06 25 01 81 02 95 02 81 03 09 3d 55 0e 65 14 36 d8 dc 46 28 23 16 d8 dc 26 28 23 95 01 75 10 81 02 09 3e 81 02 09 41 15 00 27 a0 8c 00 00 35 00 47 a0 8c 00 00 81 02 05 20 0a 53 04 65 00 16 01 f8 26 ff 07 75 10 95 01 81 02 0a 54 04 81 02 0a 55 04 81 02 0a 57 04 81 02 0a 58 04 81 02 0a 59 04 81 02 0a 72 04 81 02 0a 73 04 81 02 0a 74 04 81 02 05 0d 09 3b 15 00 25 64 75 08 81 02 09 5b 25 ff 75 40 81 02 06 00 ff 09 5b 75 20 81 02 05 0d 09 5c 26 ff 00 75 08 81 02 09 5e 81 02 09 70 a1 02 15 01 25 06 09 72 09 73 09 74 09 75 09 76 09 77 81 20 c0 06 00 ff 09 01 15 00 27 ff ff 00 00 75 10 95 01 81 02 85 09 09 81 a1 02 09 81 15 01 25 04 09 82 09 83 09 84 09 85 81 20 c0 85 10 09 5c a1 02 15 00 25 01 75 08 95 01 09 38 b1 02 09 5c 26 ff 00 b1 02 09 5d 75 01 95 01 25 01 b1 02 95 07 b1 03 c0 85 11 09 5e a1 02 09 38 15 00 25 01 75 08 95 01 b1 02 09 5e 26 ff 00 b1 02 09 5f 75 01 25 01 b1 02 75 07 b1 03 c0 85 12 09 70 a1 02 75 08 95 01 15 00 25 01 09 38 b1 02 09 70 a1 02 25 06 09 72 09 73 09 74 09 75 09 76 09 77 b1 20 c0 09 71 75 01 25 01 b1 02 75 07 b1 03 c0 85 13 09 80 15 00 25 ff 75 40 95 01 b1 02 85 14 09 44 a1 02 09 38 75 08 95 01 25 01 b1 02 15 01 25 03 09 44 a1 02 09 a4 09 44 09 5a 09 45 09 a3 b1 20 c0 09 5a a1 02 09 a4 09 44 09 5a 09 45 09 a3 b1 20 c0 09 45 a1 02 09 a4 09 44 09 5a 09 45 09 a3 b1 20 c0 c0 85 15 75 08 95 01 05 0d 09 90 a1 02 09 38 25 01 b1 02 09 91 75 10 26 ff 0f b1 02 09 92 75 40 25 ff b1 02 05 06 09 2a 75 08 26 ff 00 a1 02 09 2d b1 02 09 2e b1 02 c0 c0 85 16 05 06 09 2b a1 02 05 0d 25 01 09 38 b1 02 05 06 09 2b a1 02 09 2d 26 ff 00 b1 02 09 2e b1 02 c0 c0 85 17 06 00 ff 09 01 a1 02 05 0d 09 38 75 08 95 01 25 01 b1 02 06 00 ff 09 01 75 10 27 ff ff 00 00 b1 02 c0 85 18 05 0d 09 38 75 08 95 01 15 00 25 01 b1 02 c0 c0 06 f0 ff 09 01 a1 01 85 0e 09 01 15 00 25 ff 75 08 95 40 91 02 09 01 15 00 25 ff 75 08 95 40 81 02 c0",
1470             input_info=(BusType.I2C, 0x27C6, 0x0E00),
1471         )
1472
1473
1474 class TestXPPen_ArtistPro16Gen2_28bd_095b(BaseTest.TestTablet):
1475     hid_bpfs = [("XPPen__ArtistPro16Gen2.bpf.o", True)]
1476
1477     def create_device(self):
1478         dev = XPPen_ArtistPro16Gen2_28bd_095b(
1479             "uhid test XPPen Artist Pro 16 Gen2 28bd 095b",
1480             rdesc="05 0d 09 02 a1 01 85 07 09 20 a1 00 09 42 09 44 09 45 09 3c 15 00 25 01 75 01 95 04 81 02 95 01 81 03 09 32 15 00 25 01 95 01 81 02 95 02 81 03 75 10 95 01 35 00 a4 05 01 09 30 65 13 55 0d 46 ff 34 26 ff 7f 81 02 09 31 46 20 21 26 ff 7f 81 02 b4 09 30 45 00 26 ff 3f 81 42 09 3d 15 81 25 7f 75 08 95 01 81 02 09 3e 15 81 25 7f 81 02 c0 c0",
1481             input_info=(BusType.USB, 0x28BD, 0x095B),
1482         )
1483         return dev
1484
1485
1486 class TestXPPen_Artist24_28bd_093a(BaseTest.TestTablet):
1487     hid_bpfs = [("XPPen__Artist24.bpf.o", True)]
1488
1489     def create_device(self):
1490         return XPPen_Artist24_28bd_093a(
1491             "uhid test XPPen Artist 24 28bd 093a",
1492             rdesc="05 0d 09 02 a1 01 85 07 09 20 a1 00 09 42 09 44 09 45 15 00 25 01 75 01 95 03 81 02 95 02 81 03 09 32 95 01 81 02 95 02 81 03 75 10 95 01 35 00 a4 05 01 09 30 65 13 55 0d 46 f0 50 26 ff 7f 81 02 09 31 46 91 2d 26 ff 7f 81 02 b4 09 30 45 00 26 ff 1f 81 42 09 3d 15 81 25 7f 75 08 95 01 81 02 09 3e 15 81 25 7f 81 02 c0 c0",
1493             input_info=(BusType.USB, 0x28BD, 0x093A),
1494         )
1495
1496
1497 class TestHuion_Kamvas_Pro_19_256c_006b(BaseTest.TestTablet):
1498     hid_bpfs = [("Huion__Kamvas-Pro-19.bpf.o", True)]
1499
1500     def create_device(self):
1501         return Huion_Kamvas_Pro_19_256c_006b(
1502             "uhid test HUION Huion Tablet_GT1902",
1503             rdesc="05 0d 09 02 a1 01 85 0a 09 20 a1 01 09 42 09 44 09 43 09 3c 09 45 15 00 25 01 75 01 95 06 81 02 09 32 75 01 95 01 81 02 81 03 05 01 09 30 09 31 55 0d 65 33 26 ff 7f 35 00 46 00 08 75 10 95 02 81 02 05 0d 09 30 26 ff 3f 75 10 95 01 81 02 09 3d 09 3e 15 a6 25 5a 75 08 95 02 81 02 c0 c0 05 0d 09 04 a1 01 85 04 09 22 a1 02 05 0d 95 01 75 06 09 51 15 00 25 3f 81 02 09 42 25 01 75 01 95 01 81 02 75 01 95 01 81 03 05 01 75 10 55 0e 65 11 09 30 26 ff 7f 35 00 46 15 0c 81 42 09 31 26 ff 7f 46 cb 06 81 42 05 0d 09 30 26 ff 1f 75 10 95 01 81 02 c0 05 0d 09 22 a1 02 05 0d 95 01 75 06 09 51 15 00 25 3f 81 02 09 42 25 01 75 01 95 01 81 02 75 01 95 01 81 03 05 01 75 10 55 0e 65 11 09 30 26 ff 7f 35 00 46 15 0c 81 42 09 31 26 ff 7f 46 cb 06 81 42 05 0d 09 30 26 ff 1f 75 10 95 01 81 02 c0 05 0d 09 56 55 00 65 00 27 ff ff ff 7f 95 01 75 20 81 02 09 54 25 7f 95 01 75 08 81 02 75 08 95 08 81 03 85 05 09 55 25 0a 75 08 95 01 b1 02 06 00 ff 09 c5 85 06 15 00 26 ff 00 75 08 96 00 01 b1 02 c0",
1504             input_info=(BusType.USB, 0x256C, 0x006B),
1505         )