Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-window

Source of release 0.6.3

0.6.3 / src / window / linux / pen.lucb

#==============================================================================================
#
#   pen - Tablet pens through the X Input Extension 2
#
#   DESCRIPTION:
#       Core X events carry no pressure. libXi.so.6 is opened at run time (like Xlib, nothing
#       is linked) and each window selects XI2 motion and button events on the slave devices
#       that are pens: those with an "Abs Pressure" valuator, or named as an eraser or a touch
#       screen. Their events only record the device's latest axes; the core event of the same
#       moment, handled as before, then takes them. Selecting on slave devices alone leaves
#       the master pointer's core events flowing, so nothing else changes. A tablet plugged in
#       later is found again on XI_HierarchyChanged. See docs/PEN.md.
#
#==============================================================================================

# mark: XI2 ABI ================================================================================

## XIEventMask.
extern struct XIEventMask:
    deviceid: i32
    mask_len: i32
    mask: u8*

## XIDeviceInfo.
extern struct XIDeviceInfo:
    deviceid: i32
    name: u8*
    use: i32
    attachment: i32
    enabled: i32
    num_classes: i32
    classes: void**

## XIValuatorClassInfo (class type 2).
extern struct XIValuatorClassInfo:
    kind: i32
    sourceid: i32
    number: i32
    label: u64
    min: f64
    max: f64
    value: f64
    resolution: i32
    mode: i32

## XGenericEventCookie, read from the XEvent union.
extern struct XGenericEventCookie:
    kind: i32
    serial: u64
    send_event: i32
    display: void*?
    extension: i32
    evtype: i32
    cookie: u32
    data: void*?

extern struct XIButtonState:
    mask_len: i32
    mask: u8*?

extern struct XIValuatorState:
    mask_len: i32
    mask: u8*?
    values: f64*?

## XIDeviceEvent, as far as the valuators.
extern struct XIDeviceEvent:
    kind: i32
    serial: u64
    send_event: i32
    display: void*?
    extension: i32
    evtype: i32
    time: u64
    deviceid: i32
    sourceid: i32
    detail: i32
    root: u64
    event: u64
    child: u64
    root_x: f64
    root_y: f64
    event_x: f64
    event_y: f64
    flags: i32
    buttons: XIButtonState
    valuators: XIValuatorState

let x_generic_event: i32 = 35
let xi_button_press: i32 = 4
let xi_button_release: i32 = 5
let xi_motion: i32 = 6
let xi_hierarchy_changed: i32 = 11
let xi_slave_pointer: i32 = 3
let xi_floating_slave: i32 = 5
let xi_valuator_class: i32 = 2

## libXi's functions, and the X Input opcode that marks its events.
struct XiApi:
    var query_version: func(void*, i32*, i32*) -> i32
    var select_events: func(void*, u64, XIEventMask*, i32) -> i32
    var query_device: func(void*, i32, i32*) -> XIDeviceInfo*?
    var free_device_info: func(XIDeviceInfo*) -> unit
    var query_extension: func(void*, c.str, i32*, i32*, i32*) -> i32
    var get_event_data: func(void*, XGenericEventCookie*) -> i32
    var free_event_data: func(void*, XGenericEventCookie*) -> unit
    var get_atom_name: func(void*, u64) -> u8*?
    var x_free: func(void*) -> i32
    var opcode: i32

# mark: Pens ===================================================================================

## What an axis means to a pen.
let axis_pressure: usize = 0
let axis_tilt_x: usize = 1
let axis_tilt_y: usize = 2
let axis_wheel: usize = 3
let axis_rotation: usize = 4

## One valuator a pen reports: its number plus one (0: the pen has none), its
## range and the last value seen (XI2 events carry only the valuators that changed).
struct X11Axis:
    var slot: i32
    var min: f64
    var max: f64
    var value: f64

## A pen device: its XI2 id, which end or kind it is, its axes, and when its
## last sample came.
struct X11Pen:
    var id: i32
    var kind: input.PointerKind
    var axes: X11Axis[5]
    var time: u64

var x11_xi: XiApi? = none
var x11_pens: X11Pen[16]
var x11_pen_count: usize = 0
## The pen that sampled last, plus one (0: none yet).
var x11_last_pen: usize = 0

## Open libXi and ask for XI 2.0; without either there are no pens, only the mouse.
func x11_pen_load(library: void*, display: void*, root: u64):
    let xi_library = dlopen("libXi.so.6", 2) else return
    let version = dlsym(xi_library, "XIQueryVersion") else return
    let select = dlsym(xi_library, "XISelectEvents") else return
    let query = dlsym(xi_library, "XIQueryDevice") else return
    let release = dlsym(xi_library, "XIFreeDeviceInfo") else return
    let extension = dlsym(library, "XQueryExtension") else return
    let get_data = dlsym(library, "XGetEventData") else return
    let free_data = dlsym(library, "XFreeEventData") else return
    let atom_name = dlsym(library, "XGetAtomName") else return
    let x_free = dlsym(library, "XFree") else return
    var api = XiApi(query_version = (func(void*, i32*, i32*) -> i32)version, select_events = (func(void*, u64, XIEventMask*, i32) -> i32)select,
                    query_device = (func(void*, i32, i32*) -> XIDeviceInfo*?)query, free_device_info = (func(XIDeviceInfo*) -> unit)release,
                    query_extension = (func(void*, c.str, i32*, i32*, i32*) -> i32)extension, get_event_data = (func(void*, XGenericEventCookie*) -> i32)get_data,
                    free_event_data = (func(void*, XGenericEventCookie*) -> unit)free_data, get_atom_name = (func(void*, u64) -> u8*?)atom_name,
                    x_free = (func(void*) -> i32)x_free, opcode = 0)
    var first_event: i32 = 0
    var first_error: i32 = 0
    if api.query_extension(display, "XInputExtension", &api.opcode, &first_event, &first_error) == 0:
        return
    var major: i32 = 2
    var minor: i32 = 0
    if api.query_version(display, &major, &minor) != 0 or major < 2:
        return
    x11_xi = api
    x11_pen_scan(api, display)
    # Tablets plugged in or out later: every device, the hierarchy event only.
    var bits: u8[4] = [0, 1 << 3, 0, 0]
    var mask = XIEventMask(deviceid = 0, mask_len = 4, mask = &bits[0])
    _ = api.select_events(display, root, &mask, 1)

## Find the pen devices: slave pointers with a pressure axis, or named as an
## eraser or a touch screen.
func x11_pen_scan(api: XiApi, display: void*):
    x11_pen_count = 0
    x11_last_pen = 0
    var count: i32 = 0
    let devices = api.query_device(display, 0, &count) else return
    for index in 0..<(usize)(count if count > 0 else 0):
        let device = devices[index]
        if (device.use != xi_slave_pointer and device.use != xi_floating_slave) or x11_pen_count == x11_pens.length:
            continue
        var pen = X11Pen(id = device.deviceid, kind = x11_device_kind(device.name))
        for which in 0..<(usize)(device.num_classes if device.num_classes > 0 else 0):
            let class = (XIValuatorClassInfo*)(device.classes[which])
            if class.kind != xi_valuator_class or class.label == 0:
                continue
            let name = api.get_atom_name(display, class.label) else continue
            let role = x11_axis_role(name)
            _ = api.x_free((void*)name)
            if role >= 0:
                pen.axes[(usize)role] = X11Axis(slot = class.number + 1, min = class.min, max = class.max, value = class.value)
        if pen.axes[axis_pressure].slot != 0 or pen.kind != input.PointerKind.pen:
            x11_pens[x11_pen_count] = pen
            x11_pen_count += 1
    api.free_device_info(devices)

## Ask for the pens' motion and buttons on `window`.
func x11_pen_select(display: void*, window: u64):
    let api = x11_xi else return
    for index in 0..<x11_pen_count:
        var bits: u8[4] = [(u8)((1 << xi_button_press) | (1 << xi_button_release) | (1 << xi_motion)), 0, 0, 0]
        var mask = XIEventMask(deviceid = x11_pens[index].id, mask_len = 4, mask = &bits[0])
        _ = api.select_events(display, window, &mask, 1)

## An XI2 event: a pen's sample is recorded; a hierarchy change finds the
## pens again and selects them on every window.
func x11_generic(x: X11Connection, event: XEventBuffer*):
    let api = x11_xi else return
    let cookie = (XGenericEventCookie*)(void*)event
    if cookie.extension != api.opcode:
        return
    if api.get_event_data(x.display, cookie) == 0:
        return
    defer api.free_event_data(x.display, cookie)
    if cookie.evtype == xi_hierarchy_changed:
        x11_pen_scan(api, x.display)
        for slot in x11_windows:
            if let state = slot:
                x11_pen_select(x.display, state.x_window)
        return
    if cookie.evtype != xi_motion and cookie.evtype != xi_button_press and cookie.evtype != xi_button_release:
        return
    let data = cookie.data else return
    let device = (XIDeviceEvent*)data
    for index in 0..<x11_pen_count:
        if x11_pens[index].id == device.sourceid or x11_pens[index].id == device.deviceid:
            let values = device.valuators.values else return
            let bits = device.valuators.mask else return
            x11_pen_values(&x11_pens[index], u8[](bits, (usize)device.valuators.mask_len), values)
            x11_pens[index].time = device.time
            x11_last_pen = index + 1
            return

## The core pointer event at X time `time` with the pen's axes, when a pen
## sampled at that moment (the XI2 and core events of one report arrive
## together, in either order); otherwise it is the mouse's.
func x11_pen_apply(event: input.Event, time: u64) -> input.Event:
    if x11_last_pen == 0:
        return event
    let pen = x11_pens[x11_last_pen - 1]
    let apart = time - pen.time if time >= pen.time else pen.time - time
    if apart > 30:
        return event
    return x11_pen_event(event, pen)

# mark: Decoding ===============================================================================

## What an axis labelled `name` is to a pen, or -1: the X server's axis labels
## (xserver-properties.h) as the wacom and libinput drivers set them.
func x11_axis_role(name: const u8*) -> i64:
    if x11_equals(name, "Abs Pressure"):
        return (i64)axis_pressure
    if x11_equals(name, "Abs Tilt X"):
        return (i64)axis_tilt_x
    if x11_equals(name, "Abs Tilt Y"):
        return (i64)axis_tilt_y
    if x11_equals(name, "Abs Wheel") or x11_equals(name, "Abs Throttle"):
        return (i64)axis_wheel
    if x11_equals(name, "Abs Rotary Z") or x11_equals(name, "Abs Z"):
        return (i64)axis_rotation
    return -1

## A device's kind by its name: the wacom driver names its eraser device
## "… eraser" (libinput "… Eraser"), and touch screens say so.
func x11_device_kind(name: const u8*) -> input.PointerKind:
    if x11_contains(name, "eraser"):
        return input.PointerKind.eraser
    if x11_contains(name, "touch") or x11_contains(name, "finger"):
        return input.PointerKind.touch
    return input.PointerKind.pen

## Take the values an event carries: one per set bit of `mask`, in order.
func x11_pen_values(pen: X11Pen*, mask: const u8[], values: const f64*):
    var taken: usize = 0
    for bit in 0..<(mask.length * 8):
        if (mask[bit // 8] & (u8)(1 << (bit % 8))) == 0:
            continue
        for which in 0..<pen.axes.length:
            if pen.axes[which].slot == (i32)bit + 1:
                pen.axes[which].value = values[taken]
        taken += 1

## `event` with a pen's axes: pressure over its range, tilt in degrees (the
## drivers report degrees, -64..63; a wider range is scaled to 60 degrees), the
## wheel over its range to 0..1, rotation over its range to 0..360.
func x11_pen_event(event: input.Event, pen: X11Pen) -> input.Event:
    var result = event
    result.pointer_kind = pen.kind
    if pen.axes[axis_pressure].slot != 0:
        result.pressure = x11_fraction(pen.axes[axis_pressure])
    elif pen.kind != input.PointerKind.mouse:
        result.pressure = 1.0
    result.tilt_x = x11_degrees(pen.axes[axis_tilt_x])
    result.tilt_y = x11_degrees(pen.axes[axis_tilt_y])
    if pen.axes[axis_wheel].slot != 0:
        result.tangential = x11_fraction(pen.axes[axis_wheel])
    if pen.axes[axis_rotation].slot != 0:
        result.rotation = x11_fraction(pen.axes[axis_rotation]) * 360.0
    if pen.kind == input.PointerKind.touch:
        return result
    return input.with_pen_angles(result)

func x11_fraction(axis: X11Axis) -> f64:
    if axis.slot == 0 or not (axis.max > axis.min):
        return 0.0
    return math.clamp((axis.value - axis.min) / (axis.max - axis.min), 0.0, 1.0)

func x11_degrees(axis: X11Axis) -> f64:
    if axis.slot == 0 or not math.is_finite(axis.value):
        return 0.0
    if axis.min >= -90.5 and axis.max <= 90.5:
        return math.clamp(axis.value, -90.0, 90.0)
    let middle = (axis.max + axis.min) * 0.5
    let half = (axis.max - axis.min) * 0.5
    return math.clamp((axis.value - middle) / half * 60.0, -90.0, 90.0) if half > 0.0 else 0.0

## Whether NUL-terminated `name` is `text`.
func x11_equals(name: const u8*, text: str) -> bool:
    for index in 0..<text.length:
        if name[index] != text.bytes[index]:
            return false
    return name[text.length] == 0

## Whether NUL-terminated `name` contains lower-case `text`, ignoring case.
func x11_contains(name: const u8*, text: str) -> bool:
    var start: usize = 0
    while start < 256 and name[start] != 0:
        var index: usize = 0
        while index < text.length:
            var byte = name[start + index]
            if byte >= 'A' and byte <= 'Z':
                byte += 32
            if byte != text.bytes[index]:
                break
            index += 1
        if index == text.length:
            return true
        start += 1
    return false

func c_name(text: c.str) -> const u8*:
    return (const u8*)text

test "X11 axis labels and device names are known":
    assert(x11_axis_role(c_name("Abs Pressure")) == 0 and x11_axis_role(c_name("Abs Tilt X")) == 1 and x11_axis_role(c_name("Abs Tilt Y")) == 2)
    assert(x11_axis_role(c_name("Abs Wheel")) == 3 and x11_axis_role(c_name("Abs Rotary Z")) == 4 and x11_axis_role(c_name("Abs X")) == -1)
    assert(x11_axis_role(c_name("Abs Pressure Extra")) == -1)
    assert(x11_device_kind(c_name("Wacom Intuos Pro M Pen eraser")) == input.PointerKind.eraser)
    assert(x11_device_kind(c_name("Wacom One Pen Eraser (0x1234)")) == input.PointerKind.eraser)
    assert(x11_device_kind(c_name("Wacom Intuos Pro M Pen stylus")) == input.PointerKind.pen)
    assert(x11_device_kind(c_name("ELAN Touchscreen")) == input.PointerKind.touch)

test "X11 valuators decode to pressure, tilt, wheel and rotation":
    # The ABI as the 64-bit Xlib and libXi headers lay it out.
    assert(memory.size_of(XIDeviceEvent) == 168 and memory.size_of(XIValuatorClassInfo) == 56 and memory.size_of(XIDeviceInfo) == 40 and memory.size_of(XGenericEventCookie) == 56)
    var pen = X11Pen(id = 12, kind = input.PointerKind.pen)
    pen.axes[axis_pressure] = X11Axis(slot = 3, min = 0.0, max = 65535.0)
    pen.axes[axis_tilt_x] = X11Axis(slot = 4, min = -64.0, max = 63.0)
    pen.axes[axis_tilt_y] = X11Axis(slot = 5, min = -64.0, max = 63.0)
    pen.axes[axis_wheel] = X11Axis(slot = 6, min = 0.0, max = 1023.0)
    # Valuators 0, 1 (x, y), 2 (pressure) and 4 (tilt y) changed; 3 kept its last value.
    pen.axes[axis_tilt_x].value = 20.0
    var mask: u8[1] = [0x17]
    var values: f64[4] = [100.0, 200.0, 32767.5, -30.0]
    x11_pen_values(&pen, mask[..<1], &values[0])
    let event = x11_pen_event(input.Event(kind = input.EventKind.pointer_moved, x = 3.0), pen)
    assert(event.pointer_kind == input.PointerKind.pen and event.x == 3.0)
    assert(event.pressure == 0.5 and event.tilt_x == 20.0 and event.tilt_y == -30.0 and event.tangential == 0.0)
    assert(event.azimuth > 270.0 and event.altitude < 70.0)
    # A driver reporting tilt in raw units is scaled to 60 degrees at its end.
    let raw = X11Axis(slot = 1, min = -1000.0, max = 1000.0, value = 500.0)
    assert(x11_degrees(raw) == 30.0)
    pen.axes[axis_wheel].value = 1023.0
    pen.axes[axis_rotation] = X11Axis(slot = 7, min = 0.0, max = 360.0, value = 90.0)
    let turned = x11_pen_event(input.Event(kind = input.EventKind.pointer_moved), pen)
    assert(turned.tangential == 1.0 and turned.rotation == 90.0)

test "XWayland's tablet devices and ranges decode as the drivers' do":
    # Under XWayland the tablet is "xwayland-tablet stylus:N" and "… eraser:N",
    # pressure 0..65535 and tilt about ±64, normalized by what XIQueryDevice says.
    assert(x11_device_kind(c_name("xwayland-tablet stylus:15")) == input.PointerKind.pen)
    assert(x11_device_kind(c_name("xwayland-tablet eraser:15")) == input.PointerKind.eraser)
    var pen = X11Pen(id = 15, kind = input.PointerKind.pen)
    pen.axes[axis_pressure] = X11Axis(slot = 3, min = 0.0, max = 65535.0, value = 49151.25)
    pen.axes[axis_tilt_x] = X11Axis(slot = 4, min = -64.0, max = 64.0, value = -64.0)
    pen.axes[axis_tilt_y] = X11Axis(slot = 5, min = -64.0, max = 64.0, value = 32.0)
    let event = x11_pen_event(input.Event(kind = input.EventKind.pointer_moved), pen)
    assert(event.pressure == 0.75 and event.tilt_x == -64.0 and event.tilt_y == 32.0)
    assert(event.azimuth > 90.0 and event.azimuth < 180.0 and event.altitude < 30.0)
    # A pressure range that does not start at zero still spans 0..1.
    pen.axes[axis_pressure] = X11Axis(slot = 3, min = 1024.0, max = 2048.0, value = 1536.0)
    assert(x11_pen_event(input.Event(kind = input.EventKind.pointer_moved), pen).pressure == 0.5)

test "a core event takes the pen's axes only from a sample at its moment":
    x11_pens[0] = X11Pen(id = 9, kind = input.PointerKind.eraser, time = 1000)
    x11_pen_count = 1
    x11_last_pen = 1
    let near = x11_pen_apply(input.Event(kind = input.EventKind.pointer_moved), 1010)
    assert(near.pointer_kind == input.PointerKind.eraser and near.pressure == 1.0)
    let later = x11_pen_apply(input.Event(kind = input.EventKind.pointer_moved), 2000)
    assert(later.pointer_kind == input.PointerKind.mouse and later.pressure == 0.0)
    x11_pen_count = 0
    x11_last_pen = 0