Gecko [ www.utparral.edu.mx ]

Name	Size	Permission
libinput-analyze	62.32 KB	-rwxr-xr-x
libinput-analyze-per-slot-delta	13.58 KB	-rwxr-xr-x
libinput-analyze-recording	7.66 KB	-rwxr-xr-x
libinput-analyze-touch-down-state	6.49 KB	-rwxr-xr-x
libinput-debug-events	95.45 KB	-rwxr-xr-x
libinput-debug-gui	99.52 KB	-rwxr-xr-x
libinput-debug-tablet	75.32 KB	-rwxr-xr-x
libinput-list-devices	70.24 KB	-rwxr-xr-x
libinput-list-kernel-devices	4.08 KB	-rwxr-xr-x
libinput-measure	62.32 KB	-rwxr-xr-x
libinput-measure-fuzz	16.22 KB	-rwxr-xr-x
libinput-measure-touchpad-pressure	12.51 KB	-rwxr-xr-x
libinput-measure-touchpad-size	13.51 KB	-rwxr-xr-x
libinput-measure-touchpad-tap	8.33 KB	-rwxr-xr-x
libinput-measure-touch-size	11.4 KB	-rwxr-xr-x
libinput-quirks	62.38 KB	-rwxr-xr-x
libinput-record	110.57 KB	-rwxr-xr-x
libinput-replay	11.82 KB	-rwxr-xr-x
libinput-test	62.32 KB	-rwxr-xr-x

Code Editor : libinput-measure-touchpad-tap

#!/usr/bin/env python3
# vim: set expandtab shiftwidth=4:
# -*- Mode: python; coding: utf-8; indent-tabs-mode: nil -*- */
#
# Copyright © 2017 Red Hat, Inc.
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice (including the next
# paragraph) shall be included in all copies or substantial portions of the
# Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
#

import sys
import argparse

try:
    import libevdev
    import textwrap
    import pyudev
except ModuleNotFoundError as e:
    print("Error: {}".format(e), file=sys.stderr)
    print(
        "One or more python modules are missing. Please install those "
        "modules and re-run this tool."
    )
    sys.exit(1)

print_dest = sys.stdout

def error(msg, **kwargs):
    print(msg, **kwargs, file=sys.stderr)

def msg(msg, **kwargs):
    print(msg, **kwargs, file=print_dest, flush=True)

def tv2us(sec, usec):
    return sec * 1000000 + usec

def us2ms(us):
    return int(us / 1000)

class Touch(object):
    def __init__(self, down):
        self._down = down
        self._up = down

@property
    def up(self):
        return us2ms(self._up)

@up.setter
    def up(self, up):
        assert up > self.down
        self._up = up

@property
    def down(self):
        return us2ms(self._down)

@property
    def tdelta(self):
        return self.up - self.down

class InvalidDeviceError(Exception):
    pass

class Device(libevdev.Device):
    def __init__(self, path):
        if path is None:
            self.path = self._find_touch_device()
        else:
            self.path = path
        fd = open(self.path, "rb")
        super().__init__(fd)

print("Using {}: {}\n".format(self.name, self.path))

if not self.has(libevdev.EV_KEY.BTN_TOUCH):
            raise InvalidDeviceError("device does not have BTN_TOUCH")

self.touches = []

def _find_touch_device(self):
        context = pyudev.Context()
        device_node = None
        for device in context.list_devices(subsystem="input"):
            if not device.device_node or not device.device_node.startswith(
                "/dev/input/event"
            ):
                continue

# pick the touchpad by default, fallback to the first
            # touchscreen only when there is no touchpad
            if device.get("ID_INPUT_TOUCHPAD", 0):
                device_node = device.device_node
                break

if device.get("ID_INPUT_TOUCHSCREEN", 0) and device_node is None:
                device_node = device.device_node

if device_node is not None:
            return device_node

error("Unable to find a touch device.")
        sys.exit(1)

def handle_btn_touch(self, event):
        if event.value != 0:
            t = Touch(tv2us(event.sec, event.usec))
            self.touches.append(t)
        else:
            self.touches[-1].up = tv2us(event.sec, event.usec)
            msg("\rTouch sequences detected: {}".format(len(self.touches)), end="")

def handle_key(self, event):
        tapcodes = [
            libevdev.EV_KEY.BTN_TOOL_DOUBLETAP,
            libevdev.EV_KEY.BTN_TOOL_TRIPLETAP,
            libevdev.EV_KEY.BTN_TOOL_QUADTAP,
            libevdev.EV_KEY.BTN_TOOL_QUINTTAP,
        ]
        if event.code in tapcodes and event.value > 0:
            error(
                "\rThis tool cannot handle multiple fingers, " "output will be invalid"
            )
            return

if event.matches(libevdev.EV_KEY.BTN_TOUCH):
            self.handle_btn_touch(event)

def handle_syn(self, event):
        if self.touch.dirty:
            self.current_sequence().append(self.touch)
            self.touch = Touch(
                major=self.touch.major,
                minor=self.touch.minor,
                orientation=self.touch.orientation,
            )

def handle_event(self, event):
        if event.matches(libevdev.EV_KEY):
            self.handle_key(event)

def read_events(self):
        while True:
            for event in self.events():
                self.handle_event(event)

def print_summary(self):
        deltas = sorted(t.tdelta for t in self.touches)

dmax = max(deltas)
        dmin = min(deltas)

ndeltas = len(deltas)

davg = sum(deltas) / ndeltas
        dmedian = deltas[int(ndeltas / 2)]
        d95pc = deltas[int(ndeltas * 0.95)]
        d90pc = deltas[int(ndeltas * 0.90)]

print("Time: ")
        print("  Max delta: {}ms".format(int(dmax)))
        print("  Min delta: {}ms".format(int(dmin)))
        print("  Average delta: {}ms".format(int(davg)))
        print("  Median delta: {}ms".format(int(dmedian)))
        print("  90th percentile: {}ms".format(int(d90pc)))
        print("  95th percentile: {}ms".format(int(d95pc)))

def print_dat(self):
        print("# libinput-measure-touchpad-tap")
        print(
            textwrap.dedent(
                """\
              # File contents:
              #    This file contains multiple prints of the data in
              #    different sort order. Row number is index of touch
              #    point within each group. Comparing data across groups
              #    will result in invalid analysis.
              # Columns (1-indexed):
              # Group 1, sorted by time of occurrence
              #  1: touch down time in ms, offset by first event
              #  2: touch up time in ms, offset by first event
              #  3: time delta in ms);
              # Group 2, sorted by touch down-up delta time (ascending)
              #  4: touch down time in ms, offset by first event
              #  5: touch up time in ms, offset by first event
              #  6: time delta in ms
              """
            )
        )

deltas = [t for t in self.touches]
        deltas_sorted = sorted(deltas, key=lambda t: t.tdelta)

offset = deltas[0].down

for t1, t2 in zip(deltas, deltas_sorted):
            print(
                t1.down - offset,
                t1.up - offset,
                t1.tdelta,
                t2.down - offset,
                t2.up - offset,
                t2.tdelta,
            )

def print(self, format):
        if not self.touches:
            error("No tap data available")
            return

if format == "summary":
            self.print_summary()
        elif format == "dat":
            self.print_dat()

def main(args):
    parser = argparse.ArgumentParser(
        description="Measure tap-to-click properties of devices"
    )
    parser.add_argument(
        "path",
        metavar="/dev/input/event0",
        nargs="?",
        type=str,
        help="Path to device (optional)",
    )
    parser.add_argument(
        "--format",
        metavar="format",
        choices=["summary", "dat"],
        default="summary",
        help='data format to print ("summary" or "dat")',
    )
    args = parser.parse_args()

if not sys.stdout.isatty():
        global print_dest
        print_dest = sys.stderr

try:
        device = Device(args.path)
        error(
            "Ready for recording data.\n"
            "Tap the touchpad multiple times with a single finger only.\n"
            "For useful data we recommend at least 20 taps.\n"
            "Ctrl+C to exit"
        )
        device.read_events()
    except KeyboardInterrupt:
        msg("")
        device.print(args.format)
    except (PermissionError, OSError) as e:
        error("Error: failed to open device. {}".format(e))
    except InvalidDeviceError as e:
        error("Error: {}".format(e))

if __name__ == "__main__":
    main(sys.argv)

${this.title}

Code Editor : libinput-measure-touchpad-tap