input/

lib.rs

//! Experimental Rust implementation of the libinput.so ABI.
//!
//! The complete C ABI surface is exported, but behavioral compatibility is
//! still gated by the upstream test suite. Do not install this library over a
//! system libinput until every compatibility gate is complete.

#![allow(non_snake_case, clippy::missing_safety_doc)]

mod backend;
pub mod evdev;
mod ffi_types;
mod quirks;
mod udev;
#[doc(hidden)]
pub mod udev_callout;

use crate::ffi_types::{
    BackendKind, EventPayload, LibinputContext, LibinputDevice, LibinputDeviceGroup, LibinputEvent,
    LibinputEventType, LibinputInterface, LibinputSeat, LibinputTabletPadModeGroup,
    LibinputTabletTool,
};

use std::ffi::CStr;
use std::os::unix::io::RawFd;

extern "C" {
    fn input_emit_log(
        handler: *mut libc::c_void,
        context: *mut libc::c_void,
        priority: u32,
        format: *const libc::c_char,
        ...
    );
}

#[repr(C)]
pub struct LibinputConfigAreaRectangle {
    pub x1: f64,
    pub y1: f64,
    pub x2: f64,
    pub y2: f64,
}

// ---------------------------------------------------------------------------
// Internal helpers
// ---------------------------------------------------------------------------

unsafe fn populate_events(ctx: *mut LibinputContext) {
    if ctx.is_null() {
        return;
    }
    let ctx_ref = &mut *ctx;
    let mut tmp: std::collections::VecDeque<LibinputEvent> = std::collections::VecDeque::new();
    if let Ok(mut backend) = ctx_ref.backend.lock() {
        backend.drain_into_queue(ctx, &mut tmp);
    }
    ctx_ref.event_queue.extend(tmp);
}

pub(crate) unsafe fn emit_debug_log(ctx: *mut LibinputContext, message: &str) {
    if ctx.is_null() || (*ctx).log_priority > 10 {
        return;
    }
    let Some(handler) = (*ctx).log_handler else {
        return;
    };
    let Ok(message) = std::ffi::CString::new(format!("{}\n", message.replace('%', "%%"))) else {
        return;
    };
    input_emit_log(
        handler as *mut libc::c_void,
        ctx.cast(),
        10,
        message.as_ptr(),
    );
}

pub(crate) unsafe fn emit_error_log(ctx: *mut LibinputContext, message: &str) {
    if ctx.is_null() || (*ctx).log_priority > 30 {
        return;
    }
    let Some(handler) = (*ctx).log_handler else {
        return;
    };
    let Ok(message) = std::ffi::CString::new(format!("{}\n", message.replace('%', "%%"))) else {
        return;
    };
    input_emit_log(
        handler as *mut libc::c_void,
        ctx.cast(),
        30,
        message.as_ptr(),
    );
}

pub(crate) unsafe fn emit_info_log(ctx: *mut LibinputContext, message: &str) {
    if ctx.is_null() || (*ctx).log_priority > 20 {
        return;
    }
    let Some(handler) = (*ctx).log_handler else {
        return;
    };
    let Ok(message) = std::ffi::CString::new(format!("{}\n", message.replace('%', "%%"))) else {
        return;
    };
    input_emit_log(
        handler as *mut libc::c_void,
        ctx.cast(),
        20,
        message.as_ptr(),
    );
}

// ---------------------------------------------------------------------------
// Context lifecycle
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_udev_create_context(
    interface: *const LibinputInterface,
    user_data: *mut libc::c_void,
    udev: *mut libc::c_void,
) -> *mut LibinputContext {
    if interface.is_null() || udev.is_null() {
        return std::ptr::null_mut();
    }
    let ctx = Box::into_raw(Box::new(LibinputContext::new(
        interface,
        user_data,
        BackendKind::Udev,
    )));
    (*(*ctx).seat).context = ctx;
    ctx
}

#[no_mangle]
pub unsafe extern "C" fn libinput_path_create_context(
    interface: *const LibinputInterface,
    user_data: *mut libc::c_void,
) -> *mut LibinputContext {
    if interface.is_null() {
        return std::ptr::null_mut();
    }
    let ctx = Box::into_raw(Box::new(LibinputContext::new(
        interface,
        user_data,
        BackendKind::Path,
    )));
    (*(*ctx).seat).context = ctx;
    ctx
}

#[no_mangle]
pub unsafe extern "C" fn libinput_ref(ctx: *mut LibinputContext) -> *mut LibinputContext {
    if ctx.is_null() {
        return std::ptr::null_mut();
    }
    (*ctx).inc_ref();
    ctx
}

#[no_mangle]
pub unsafe extern "C" fn libinput_unref(ctx: *mut LibinputContext) -> *mut LibinputContext {
    if ctx.is_null() {
        return std::ptr::null_mut();
    }
    if (*ctx).dec_ref() == 0 {
        drop(Box::from_raw(ctx));
        return std::ptr::null_mut();
    }
    ctx
}

#[no_mangle]
pub unsafe extern "C" fn libinput_udev_assign_seat(
    ctx: *mut LibinputContext,
    seat_name: *const libc::c_char,
) -> libc::c_int {
    if ctx.is_null()
        || seat_name.is_null()
        || (*ctx).backend_kind != BackendKind::Udev
        || (*ctx).seat_assigned
    {
        return -1;
    }
    let seat_name = CStr::from_ptr(seat_name);
    if seat_name.to_bytes().len() > 255 {
        return -1;
    }
    let name = seat_name.to_string_lossy().into_owned();
    if let Ok(cname) = std::ffi::CString::new(name) {
        (*(*ctx).seat).physical_name = cname;
    }
    (*ctx).seat_assigned = true;
    let mut tmp: Vec<LibinputEvent> = Vec::new();
    if let Ok(mut backend) = (*ctx).backend.lock() {
        backend.scan_and_open(ctx, &mut tmp);
    }
    for ev in tmp {
        (*ctx).event_queue.push_back(ev);
    }
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_path_add_device(
    ctx: *mut LibinputContext,
    path: *const libc::c_char,
) -> *mut LibinputDevice {
    if ctx.is_null() || path.is_null() || (*ctx).backend_kind != BackendKind::Path {
        return std::ptr::null_mut();
    }
    let path = CStr::from_ptr(path);
    if path.to_bytes().len() > libc::PATH_MAX as usize {
        emit_error_log(
            ctx,
            &format!(
                "client bug: Unexpected path, limited to {} characters.",
                libc::PATH_MAX
            ),
        );
        return std::ptr::null_mut();
    }
    let devnode = path.to_string_lossy().into_owned();
    let p = std::path::PathBuf::from(&devnode);
    use std::os::unix::fs::FileTypeExt;
    if !p
        .metadata()
        .is_ok_and(|metadata| metadata.file_type().is_char_device())
    {
        emit_error_log(ctx, "failed to add device");
        return std::ptr::null_mut();
    }
    let mut tmp: Vec<LibinputEvent> = Vec::new();
    let old_len = (*ctx).devices.len();
    if let Ok(mut backend) = (*ctx).backend.lock() {
        backend.try_open(ctx, &p, &mut tmp);
    }
    for ev in tmp {
        (*ctx).event_queue.push_back(ev);
    }
    if (*ctx).devices.len() == old_len + 1 {
        if let Ok(mut backend) = (*ctx).backend.lock() {
            backend.remember_path(&p);
        }
        emit_info_log(ctx, "device added");
        (&(*ctx).devices)[old_len]
    } else {
        emit_error_log(ctx, "failed to add device");
        std::ptr::null_mut()
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_path_remove_device(dev: *mut LibinputDevice) {
    if dev.is_null() {
        return;
    }
    let ctx = (*dev).context;
    if ctx.is_null() || (*ctx).backend_kind != BackendKind::Path {
        return;
    }
    let path = std::path::PathBuf::from((*dev).devnode.to_string_lossy().into_owned());
    let mut events = std::collections::VecDeque::new();
    let removed = if let Ok(mut backend) = (*ctx).backend.lock() {
        backend.forget_path(&path);
        backend.remove_device(ctx, dev, &mut events)
    } else {
        false
    };
    if removed {
        (*ctx).devices.retain(|candidate| *candidate != dev);
        (*ctx).event_queue.extend(events);
        libinput_device_unref(dev);
    }
}

// ---------------------------------------------------------------------------
// FD & dispatch
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_get_fd(ctx: *mut LibinputContext) -> RawFd {
    if ctx.is_null() {
        return -1;
    }
    (*ctx).epoll_fd
}

#[no_mangle]
pub unsafe extern "C" fn libinput_dispatch(ctx: *mut LibinputContext) -> libc::c_int {
    if ctx.is_null() {
        return -1;
    }
    let mut events: [libc::epoll_event; 16] = std::mem::zeroed();
    libc::epoll_wait((*ctx).epoll_fd, events.as_mut_ptr(), 16, 0);
    (*ctx).drain_fd();
    populate_events(ctx);
    0
}

// ---------------------------------------------------------------------------
// Event retrieval & destruction
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_get_event(ctx: *mut LibinputContext) -> *mut LibinputEvent {
    if ctx.is_null() {
        return std::ptr::null_mut();
    }
    match (*ctx).event_queue.pop_front() {
        Some(ev) => Box::into_raw(Box::new(ev)),
        None => std::ptr::null_mut(),
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_next_event_type(ctx: *mut LibinputContext) -> LibinputEventType {
    if ctx.is_null() {
        return LibinputEventType::LIBINPUT_EVENT_NONE;
    }
    (*ctx)
        .event_queue
        .front()
        .map(|e| e.event_type)
        .unwrap_or(LibinputEventType::LIBINPUT_EVENT_NONE)
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_destroy(event: *mut LibinputEvent) {
    if !event.is_null() {
        drop(Box::from_raw(event));
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_type(event: *const LibinputEvent) -> LibinputEventType {
    if event.is_null() {
        return LibinputEventType::LIBINPUT_EVENT_NONE;
    }
    (*event).event_type
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_context(
    event: *const LibinputEvent,
) -> *mut LibinputContext {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    (*event).context
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_device(
    event: *const LibinputEvent,
) -> *mut LibinputDevice {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    (*event).device
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_device_notify_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    match (*event).event_type {
        LibinputEventType::LIBINPUT_EVENT_DEVICE_ADDED
        | LibinputEventType::LIBINPUT_EVENT_DEVICE_REMOVED => event,
        _ => std::ptr::null_mut(),
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_device_notify_get_base_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    event
}

// ---------------------------------------------------------------------------
// Pointer event accessors
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_pointer_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    match (*event).event_type {
        LibinputEventType::LIBINPUT_EVENT_POINTER_MOTION
        | LibinputEventType::LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE
        | LibinputEventType::LIBINPUT_EVENT_POINTER_BUTTON
        | LibinputEventType::LIBINPUT_EVENT_POINTER_AXIS
        | LibinputEventType::LIBINPUT_EVENT_POINTER_SCROLL_WHEEL
        | LibinputEventType::LIBINPUT_EVENT_POINTER_SCROLL_FINGER
        | LibinputEventType::LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS => event,
        _ => std::ptr::null_mut(),
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_base_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    event
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_time(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::PointerMotion(e) => (e.time_usec / 1000) as u32,
        EventPayload::PointerMotionAbsolute(e) => (e.time_usec / 1000) as u32,
        EventPayload::PointerButton(e) => (e.time_usec / 1000) as u32,
        EventPayload::PointerAxis(e) => (e.time_usec / 1000) as u32,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_time_usec(event: *const LibinputEvent) -> u64 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::PointerMotion(e) => e.time_usec,
        EventPayload::PointerMotionAbsolute(e) => e.time_usec,
        EventPayload::PointerButton(e) => e.time_usec,
        EventPayload::PointerAxis(e) => e.time_usec,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_dx(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerMotion(e) = &(*event).payload {
        e.dx
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_dy(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerMotion(e) = &(*event).payload {
        e.dy
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_dx_unaccelerated(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerMotion(e) = &(*event).payload {
        e.dx_unaccel
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_dy_unaccelerated(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerMotion(e) = &(*event).payload {
        e.dy_unaccel
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_absolute_x(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerMotionAbsolute(e) = &(*event).payload {
        e.abs_x
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_absolute_y(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerMotionAbsolute(e) = &(*event).payload {
        e.abs_y
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_button(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::PointerButton(e) = &(*event).payload {
        e.button
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_button_state(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::PointerButton(e) = &(*event).payload {
        e.state
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_seat_button_count(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::PointerButton(e) = &(*event).payload {
        e.seat_button_count
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_axis_value(
    event: *const LibinputEvent,
    axis: u32,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerAxis(e) = &(*event).payload {
        e.value(axis)
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_axis_value_discrete(
    event: *const LibinputEvent,
    axis: u32,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerAxis(e) = &(*event).payload {
        e.value_discrete(axis) as f64
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_axis_source(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::PointerAxis(e) = &(*event).payload {
        e.source
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_has_axis(
    event: *const LibinputEvent,
    axis: u32,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    matches!(&(*event).payload, EventPayload::PointerAxis(e) if e.has_axis(axis)) as libc::c_int
}

// ---------------------------------------------------------------------------
// Keyboard event accessors
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_keyboard_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    if (*event).event_type == LibinputEventType::LIBINPUT_EVENT_KEYBOARD_KEY {
        event
    } else {
        std::ptr::null_mut()
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_keyboard_get_base_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    event
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_keyboard_get_time(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::KeyboardKey(e) = &(*event).payload {
        (e.time_usec / 1000) as u32
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_keyboard_get_time_usec(event: *const LibinputEvent) -> u64 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::KeyboardKey(e) = &(*event).payload {
        e.time_usec
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_keyboard_get_key(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::KeyboardKey(e) = &(*event).payload {
        e.key
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_keyboard_get_key_state(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::KeyboardKey(e) = &(*event).payload {
        e.state
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_keyboard_get_seat_key_count(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::KeyboardKey(e) = &(*event).payload {
        e.seat_key_count
    } else {
        0
    }
}

// ---------------------------------------------------------------------------
// Touch event accessors
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_touch_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    match (*event).event_type {
        LibinputEventType::LIBINPUT_EVENT_TOUCH_DOWN
        | LibinputEventType::LIBINPUT_EVENT_TOUCH_UP
        | LibinputEventType::LIBINPUT_EVENT_TOUCH_MOTION
        | LibinputEventType::LIBINPUT_EVENT_TOUCH_CANCEL
        | LibinputEventType::LIBINPUT_EVENT_TOUCH_FRAME => event,
        _ => std::ptr::null_mut(),
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_touch_get_base_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    event
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_touch_get_time(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TouchDown(e)
        | EventPayload::TouchUp(e)
        | EventPayload::TouchMotion(e)
        | EventPayload::TouchCancel(e) => (e.time_usec / 1000) as u32,
        EventPayload::TouchFrame { time_usec } => (*time_usec / 1000) as u32,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_touch_get_time_usec(event: *const LibinputEvent) -> u64 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TouchDown(e)
        | EventPayload::TouchUp(e)
        | EventPayload::TouchMotion(e)
        | EventPayload::TouchCancel(e) => e.time_usec,
        EventPayload::TouchFrame { time_usec } => *time_usec,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_touch_get_slot(event: *const LibinputEvent) -> i32 {
    if event.is_null() {
        return -1;
    }
    match &(*event).payload {
        EventPayload::TouchDown(e) | EventPayload::TouchMotion(e) | EventPayload::TouchUp(e) => {
            e.slot
        }
        _ => -1,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_touch_get_seat_slot(event: *const LibinputEvent) -> i32 {
    if event.is_null() {
        return -1;
    }
    match &(*event).payload {
        EventPayload::TouchDown(e) | EventPayload::TouchMotion(e) | EventPayload::TouchUp(e) => {
            e.seat_slot
        }
        _ => -1,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_touch_get_x(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TouchDown(e) | EventPayload::TouchMotion(e) => {
            let device = (*event).device;
            if !device.is_null() {
                if let (Some((minimum, _)), Some(resolution)) =
                    ((*device).abs_x_range, (*device).abs_x_resolution)
                {
                    return (e.x - minimum as f64) / resolution as f64;
                }
            }
            e.x
        }
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_touch_get_y(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TouchDown(e) | EventPayload::TouchMotion(e) => {
            let device = (*event).device;
            if !device.is_null() {
                if let (Some((minimum, _)), Some(resolution)) =
                    ((*device).abs_y_range, (*device).abs_y_resolution)
                {
                    return (e.y - minimum as f64) / resolution as f64;
                }
            }
            e.y
        }
        _ => 0.0,
    }
}

unsafe fn transformed_touch_coordinates(event: *const LibinputEvent) -> Option<(f64, f64)> {
    let touch = match &(*event).payload {
        EventPayload::TouchDown(e) | EventPayload::TouchMotion(e) => e,
        _ => return None,
    };
    let device = (*event).device;
    if device.is_null() {
        return None;
    }
    let ((xmin, xmax), (ymin, ymax)) = ((*device).abs_x_range?, (*device).abs_y_range?);
    let x_span = (xmax as i64 - xmin as i64 + 1).max(1) as f64;
    let y_span = (ymax as i64 - ymin as i64 + 1).max(1) as f64;
    let x = (touch.x - xmin as f64) / x_span;
    let y = (touch.y - ymin as f64) / y_span;
    let matrix = (*device).calibration;
    Some((
        matrix[0] as f64 * x + matrix[1] as f64 * y + matrix[2] as f64,
        matrix[3] as f64 * x + matrix[4] as f64 * y + matrix[5] as f64,
    ))
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_touch_get_x_transformed(
    event: *const LibinputEvent,
    width: u32,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    transformed_touch_coordinates(event)
        .map(|(x, _)| x * width as f64)
        .unwrap_or(0.0)
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_touch_get_y_transformed(
    event: *const LibinputEvent,
    height: u32,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    transformed_touch_coordinates(event)
        .map(|(_, y)| y * height as f64)
        .unwrap_or(0.0)
}

// ---------------------------------------------------------------------------
// Gesture event accessors
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_gesture_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    match (*event).event_type {
        LibinputEventType::LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN
        | LibinputEventType::LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE
        | LibinputEventType::LIBINPUT_EVENT_GESTURE_SWIPE_END
        | LibinputEventType::LIBINPUT_EVENT_GESTURE_PINCH_BEGIN
        | LibinputEventType::LIBINPUT_EVENT_GESTURE_PINCH_UPDATE
        | LibinputEventType::LIBINPUT_EVENT_GESTURE_PINCH_END
        | LibinputEventType::LIBINPUT_EVENT_GESTURE_HOLD_BEGIN
        | LibinputEventType::LIBINPUT_EVENT_GESTURE_HOLD_END => event,
        _ => std::ptr::null_mut(),
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_base_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    event
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_time(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::GestureSwipeBegin(e)
        | EventPayload::GestureSwipeUpdate(e)
        | EventPayload::GestureSwipeEnd(e)
        | EventPayload::GesturePinchBegin(e)
        | EventPayload::GesturePinchUpdate(e)
        | EventPayload::GesturePinchEnd(e)
        | EventPayload::GestureHoldBegin(e)
        | EventPayload::GestureHoldEnd(e) => (e.time_usec / 1000) as u32,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_time_usec(event: *const LibinputEvent) -> u64 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::GestureSwipeBegin(e)
        | EventPayload::GestureSwipeUpdate(e)
        | EventPayload::GestureSwipeEnd(e)
        | EventPayload::GesturePinchBegin(e)
        | EventPayload::GesturePinchUpdate(e)
        | EventPayload::GesturePinchEnd(e)
        | EventPayload::GestureHoldBegin(e)
        | EventPayload::GestureHoldEnd(e) => e.time_usec,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_finger_count(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::GestureSwipeBegin(e)
        | EventPayload::GestureSwipeUpdate(e)
        | EventPayload::GestureSwipeEnd(e)
        | EventPayload::GesturePinchBegin(e)
        | EventPayload::GesturePinchUpdate(e)
        | EventPayload::GesturePinchEnd(e)
        | EventPayload::GestureHoldBegin(e)
        | EventPayload::GestureHoldEnd(e) => e.finger_count,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_dx(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::GestureSwipeUpdate(e) | EventPayload::GesturePinchUpdate(e) => e.dx,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_dy(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::GestureSwipeUpdate(e) | EventPayload::GesturePinchUpdate(e) => e.dy,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_dx_unaccelerated(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::GestureSwipeUpdate(e) | EventPayload::GesturePinchUpdate(e) => e.dx / 1.2,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_dy_unaccelerated(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::GestureSwipeUpdate(e) | EventPayload::GesturePinchUpdate(e) => e.dy / 1.2,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_scale(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 1.0;
    }
    match &(*event).payload {
        EventPayload::GesturePinchUpdate(e) | EventPayload::GesturePinchEnd(e) => e.scale,
        _ => 1.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_angle_delta(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::GesturePinchUpdate(e) => e.angle,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_gesture_get_cancelled(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::GestureSwipeEnd(e)
        | EventPayload::GesturePinchEnd(e)
        | EventPayload::GestureHoldEnd(e) => e.cancelled as libc::c_int,
        _ => 0,
    }
}

// ---------------------------------------------------------------------------
// Switch event accessors
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_switch_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    if (*event).event_type == LibinputEventType::LIBINPUT_EVENT_SWITCH_TOGGLE {
        event
    } else {
        std::ptr::null_mut()
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_switch_get_base_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    event
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_switch_get_switch(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::SwitchToggle(e) = &(*event).payload {
        e.switch
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_switch_get_switch_state(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::SwitchToggle(e) = &(*event).payload {
        e.state
    } else {
        0
    }
}

// ---------------------------------------------------------------------------
// Device info
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_ref(dev: *mut LibinputDevice) -> *mut LibinputDevice {
    if dev.is_null() {
        return std::ptr::null_mut();
    }
    let current = (*dev)
        .refcount
        .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
    (*dev).abi.refcount = current + 1;
    dev
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_unref(dev: *mut LibinputDevice) -> *mut LibinputDevice {
    if dev.is_null() {
        return std::ptr::null_mut();
    }
    let remaining = (*dev)
        .refcount
        .fetch_sub(1, std::sync::atomic::Ordering::SeqCst)
        - 1;
    (*dev).abi.refcount = remaining;
    if remaining <= 0 {
        drop(Box::from_raw(dev));
        std::ptr::null_mut()
    } else {
        dev
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_name(
    dev: *const LibinputDevice,
) -> *const libc::c_char {
    if dev.is_null() {
        return std::ptr::null();
    }
    (*dev).name.as_ptr()
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_sysname(
    dev: *const LibinputDevice,
) -> *const libc::c_char {
    if dev.is_null() {
        return std::ptr::null();
    }
    (*dev).sysname.as_ptr()
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_output_name(
    dev: *const LibinputDevice,
) -> *const libc::c_char {
    if dev.is_null() {
        return std::ptr::null();
    }
    (*dev)
        .output_name
        .as_ref()
        .map_or(std::ptr::null(), |name| name.as_ptr())
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_id_vendor(dev: *const LibinputDevice) -> libc::c_uint {
    if dev.is_null() {
        return 0;
    }
    (*dev).vendor_id
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_id_product(
    dev: *const LibinputDevice,
) -> libc::c_uint {
    if dev.is_null() {
        return 0;
    }
    (*dev).product_id
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_context(
    dev: *const LibinputDevice,
) -> *mut LibinputContext {
    if dev.is_null() {
        return std::ptr::null_mut();
    }
    (*dev).context
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_devnode(
    dev: *const LibinputDevice,
) -> *const libc::c_char {
    if dev.is_null() {
        return std::ptr::null();
    }
    (*dev).devnode.as_ptr()
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_touch_get_touch_count(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() || !(*dev).has_touch {
        return -1;
    }
    (*dev).touch_count
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_has_capability(
    dev: *const LibinputDevice,
    capability: u32,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    let has = match capability {
        0 => (*dev).has_keyboard,
        1 => (*dev).has_pointer,
        2 => (*dev).has_touch,
        3 => (*dev).has_tablet,
        4 => (*dev).has_tablet_pad,
        5 => (*dev).has_gesture,
        6 => (*dev).has_switch,
        _ => false,
    };
    has as libc::c_int
}

// ---------------------------------------------------------------------------
// Device configuration — tap
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_get_finger_count(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).tap_finger_count
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_set_enabled(
    dev: *mut LibinputDevice,
    enabled: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if enabled > 1 {
        return 2;
    }
    if (*dev).tap_finger_count == 0 {
        return if enabled == 0 { 0 } else { 1 };
    }
    (*dev).tap_enabled = enabled != 0;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_get_enabled(dev: *const LibinputDevice) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).tap_enabled as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_get_default_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).tap_default_enabled as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_set_drag_enabled(
    dev: *mut LibinputDevice,
    enabled: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if enabled > 1 {
        return 2;
    }
    if (*dev).tap_finger_count == 0 {
        return if enabled == 0 { 0 } else { 1 };
    }
    (*dev).tap_drag_enabled = enabled != 0;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_get_drag_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).tap_drag_enabled as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_get_default_drag_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    ((*dev).tap_finger_count != 0) as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_set_drag_lock_enabled(
    dev: *mut LibinputDevice,
    enabled: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if enabled > 2 {
        return 2;
    }
    if (*dev).tap_finger_count == 0 {
        return if enabled == 0 { 0 } else { 1 };
    }
    (*dev).tap_drag_lock_enabled = if enabled == 1 { 1 } else { enabled };
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_get_drag_lock_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).tap_drag_lock_enabled
}

/// Button map: 0 = LRM (default), 1 = LMR
#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_set_button_map(
    dev: *mut LibinputDevice,
    map: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if map > 1 {
        return 2;
    }
    if (*dev).tap_finger_count == 0 {
        return 1;
    }
    (*dev).tap_button_map = map;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_get_button_map(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).tap_button_map
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_get_default_button_map(
    _dev: *const LibinputDevice,
) -> u32 {
    0
} // LIBINPUT_CONFIG_TAP_MAP_LRM

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_3fg_drag_get_finger_count(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() || !(*dev).has_gesture {
        return 0;
    }
    (*dev).mt_slot_count
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_3fg_drag_set_enabled(
    dev: *mut LibinputDevice,
    enable: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if !matches!(enable, 0..=2) {
        return 2;
    }
    if libinput_device_config_3fg_drag_get_finger_count(dev) < 3 {
        return 1;
    }
    (*dev).drag_3fg_enabled = enable;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_3fg_drag_get_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).drag_3fg_enabled
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_3fg_drag_get_default_enabled(
    _dev: *const LibinputDevice,
) -> u32 {
    0
}

// ---------------------------------------------------------------------------
// Device configuration — pointer acceleration
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_config_accel_create(profile: u32) -> *mut libc::c_void {
    if !matches!(profile, 1 | 2 | 4) {
        return std::ptr::null_mut();
    }
    Box::into_raw(Box::new(profile)) as *mut libc::c_void
}

#[no_mangle]
pub unsafe extern "C" fn libinput_config_accel_destroy(accel_config: *mut libc::c_void) {
    if !accel_config.is_null() {
        drop(Box::from_raw(accel_config as *mut u32));
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_config_accel_set_points(
    accel_config: *mut libc::c_void,
    _accel_type: u32,
    step: f64,
    npoints: libc::size_t,
    points: *const f64,
) -> u32 {
    if accel_config.is_null()
        || points.is_null()
        || !step.is_finite()
        || step <= 0.0
        || step >= 1e10
        || npoints == 0
    {
        return 2;
    }
    let points = std::slice::from_raw_parts(points, npoints);
    if points
        .iter()
        .any(|point| !point.is_finite() || *point < 0.0 || *point >= 1e10)
    {
        return 2;
    }
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_accel_apply(
    dev: *mut LibinputDevice,
    accel_config: *mut libc::c_void,
) -> u32 {
    if dev.is_null() || accel_config.is_null() {
        return 2;
    }
    if !(*dev).accel_available {
        return 1;
    }
    let profile = *(accel_config as *const u32);
    if profile & libinput_device_config_accel_get_profiles(dev) == 0 {
        return 1;
    }
    (*dev).accel_profile = profile;
    (*dev).accel_speed = 0.0;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_accel_is_available(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).accel_available as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_accel_set_speed(
    dev: *mut LibinputDevice,
    speed: f64,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if !speed.is_finite() || !(-1.0..=1.0).contains(&speed) {
        return 2;
    }
    if !(*dev).accel_available {
        return 1;
    }
    (*dev).accel_speed = speed;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_accel_get_speed(dev: *const LibinputDevice) -> f64 {
    if dev.is_null() {
        return 0.0;
    }
    (*dev).accel_speed
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_accel_get_default_speed(
    _dev: *const LibinputDevice,
) -> f64 {
    0.0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_accel_get_profiles(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    if (*dev).accel_available
        && !((*dev).has_tablet && !(*dev).has_gesture && !(*dev).has_tablet_pad)
    {
        0b111
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_accel_set_profile(
    dev: *mut LibinputDevice,
    profile: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if profile == 0 || profile & !0b111 != 0 || profile.count_ones() != 1 {
        return 2;
    }
    if profile & libinput_device_config_accel_get_profiles(dev) == 0 {
        return 1;
    }
    (*dev).accel_profile = profile;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_accel_get_profile(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    if (*dev).accel_available
        && !((*dev).has_tablet && !(*dev).has_gesture && !(*dev).has_tablet_pad)
    {
        (*dev).accel_profile
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_accel_get_default_profile(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null()
        || !(*dev).accel_available
        || ((*dev).has_tablet && !(*dev).has_gesture && !(*dev).has_tablet_pad)
    {
        0
    } else {
        2
    }
}

// ---------------------------------------------------------------------------
// Device configuration — natural scroll
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_has_natural_scroll(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).has_pointer as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_set_natural_scroll_enabled(
    dev: *mut LibinputDevice,
    enabled: libc::c_int,
) -> u32 {
    if dev.is_null() || !(*dev).has_pointer {
        return 1;
    }
    (*dev).natural_scroll = enabled != 0;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_get_natural_scroll_enabled(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).natural_scroll as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_get_default_natural_scroll_enabled(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    ((*dev).scroll_methods & 2 != 0 && (*dev).vendor_id == 0x05ac) as libc::c_int
}

// ---------------------------------------------------------------------------
// Device configuration — left-handed
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_left_handed_is_available(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).left_handed_available as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_left_handed_set(
    dev: *mut LibinputDevice,
    enabled: libc::c_int,
) -> u32 {
    if dev.is_null() || !(*dev).left_handed_available {
        return 1;
    }
    (*dev).left_handed = enabled != 0;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_left_handed_get(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).left_handed as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_left_handed_get_default(
    _dev: *const LibinputDevice,
) -> libc::c_int {
    0
}

// ---------------------------------------------------------------------------
// Device configuration — scroll method
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_get_methods(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).scroll_methods
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_set_method(
    dev: *mut LibinputDevice,
    method: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if !matches!(method, 0 | 1 | 2 | 4) {
        return 2;
    }
    if method != 0 && method & (*dev).scroll_methods == 0 {
        return 1;
    }
    if (*dev).scroll_method == method {
        return 0;
    }
    let ctx = (*dev).context;
    if !ctx.is_null() {
        let mut events = std::collections::VecDeque::new();
        if let Ok(mut backend) = (*ctx).backend.try_lock() {
            backend.stop_scroll_for_device(ctx, dev, &mut events);
        }
        (*ctx).event_queue.extend(events);
    }
    (*dev).scroll_method = method;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_get_method(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).scroll_method
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_get_default_method(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        0
    } else {
        (*dev).scroll_default_method
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_set_button(
    dev: *mut LibinputDevice,
    button: u32,
) -> u32 {
    if dev.is_null() || !(*dev).supports_button_scroll {
        return 1;
    }
    if button != 0
        && match u16::try_from(button) {
            Ok(button) => !(*dev).event_codes.contains(&button),
            Err(_) => true,
        }
    {
        return 2;
    }
    (*dev).scroll_button = button;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_get_button(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).supports_button_scroll {
        0
    } else {
        (*dev).scroll_button
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_set_button_lock(
    dev: *mut LibinputDevice,
    state: u32,
) -> u32 {
    if dev.is_null() || !(*dev).supports_button_scroll {
        return 1;
    }
    if state > 1 {
        return 2;
    }
    (*dev).scroll_button_lock = state;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_get_button_lock(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).supports_button_scroll {
        0
    } else {
        (*dev).scroll_button_lock
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_get_default_button_lock(
    _dev: *const LibinputDevice,
) -> u32 {
    0
}

// ---------------------------------------------------------------------------
// Device configuration — click method
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_click_get_methods(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).click_methods
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_click_set_method(
    dev: *mut LibinputDevice,
    method: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if !matches!(method, 0..=2) {
        return 2;
    }
    if method != 0 && method & (*dev).click_methods == 0 {
        return 1;
    }
    (*dev).click_method = method;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_click_get_method(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).click_method
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_click_get_default_method(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        0
    } else {
        (*dev).click_default_method
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_click_set_clickfinger_button_map(
    dev: *mut LibinputDevice,
    map: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if !matches!(map, 0 | 1) {
        return 2;
    }
    if (*dev).click_methods & 2 == 0 {
        return 1;
    }
    (*dev).clickfinger_button_map = map;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_click_get_clickfinger_button_map(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || (*dev).click_methods & 2 == 0 {
        0
    } else {
        (*dev).clickfinger_button_map
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_click_get_default_clickfinger_button_map(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || (*dev).click_methods & 2 == 0 {
        0
    } else {
        (*dev).clickfinger_default_button_map
    }
}

// ---------------------------------------------------------------------------
// Device configuration — middle button emulation
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_middle_emulation_is_available(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).middle_emulation_available as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_middle_emulation_set_enabled(
    dev: *mut LibinputDevice,
    enabled: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if enabled > 1 {
        return 2;
    }
    if enabled == 1 && !(*dev).middle_emulation_available {
        return 1;
    }
    (*dev).middle_emulation = enabled != 0;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_middle_emulation_get_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).middle_emulation_available {
        return 0;
    }
    (*dev).middle_emulation as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_middle_emulation_get_default_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).middle_emulation_available {
        return 0;
    }
    (*dev).middle_emulation_default as u32
}

// ---------------------------------------------------------------------------
// Device configuration — disable-while-typing
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwt_is_available(
    dev: *const LibinputDevice,
) -> libc::c_int {
    (!dev.is_null() && (*dev).dwt_available) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwt_set_enabled(
    dev: *mut LibinputDevice,
    enabled: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if !matches!(enabled, 0 | 1) {
        return 2;
    }
    if !(*dev).dwt_available {
        return if enabled == 0 { 0 } else { 1 };
    }
    (*dev).dwt_enabled = enabled == 1;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwt_get_enabled(dev: *const LibinputDevice) -> u32 {
    if dev.is_null() || !(*dev).dwt_available {
        return 0;
    }
    (*dev).dwt_enabled as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwt_get_default_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    (!dev.is_null() && (*dev).dwt_available) as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwt_set_timeout(
    dev: *mut LibinputDevice,
    millis: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if millis == 0 {
        return 2;
    }
    if !(*dev).dwt_available {
        return 1;
    }
    if !(100..=5000).contains(&millis) {
        return 2;
    }
    (*dev).dwt_timeout = millis;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwt_get_timeout(dev: *const LibinputDevice) -> u32 {
    if dev.is_null() || !(*dev).dwt_available {
        0
    } else {
        (*dev).dwt_timeout
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwt_get_default_timeout(
    dev: *const LibinputDevice,
) -> u32 {
    if !dev.is_null() && (*dev).dwt_available {
        500
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwtp_is_available(
    dev: *const LibinputDevice,
) -> libc::c_int {
    (!dev.is_null() && (*dev).dwtp_available) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwtp_set_enabled(
    dev: *mut LibinputDevice,
    enabled: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if !matches!(enabled, 0 | 1) {
        return 2;
    }
    if !(*dev).dwtp_available {
        return if enabled == 0 { 0 } else { 1 };
    }
    (*dev).dwtp_enabled = enabled == 1;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwtp_get_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).dwtp_available {
        0
    } else {
        (*dev).dwtp_enabled as u32
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwtp_get_default_enabled(
    dev: *const LibinputDevice,
) -> u32 {
    (!dev.is_null() && (*dev).dwtp_available) as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwtp_set_timeout(
    dev: *mut LibinputDevice,
    millis: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if millis == 0 {
        return 2;
    }
    if !(*dev).dwtp_available {
        return 1;
    }
    if !(100..=5000).contains(&millis) {
        return 2;
    }
    (*dev).dwtp_timeout = millis;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwtp_get_timeout(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).dwtp_available {
        0
    } else {
        (*dev).dwtp_timeout
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_dwtp_get_default_timeout(
    dev: *const LibinputDevice,
) -> u32 {
    if !dev.is_null() && (*dev).dwtp_available {
        300
    } else {
        0
    }
}

// ---------------------------------------------------------------------------
// Device configuration — calibration matrix
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_calibration_has_matrix(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).calibration_available as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_calibration_set_matrix(
    dev: *mut LibinputDevice,
    matrix: *const f32,
) -> u32 {
    if dev.is_null() || matrix.is_null() || !(*dev).calibration_available {
        return 1;
    }
    (*dev)
        .calibration
        .copy_from_slice(std::slice::from_raw_parts(matrix, 6));
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_calibration_get_matrix(
    dev: *const LibinputDevice,
    matrix: *mut f32,
) -> libc::c_int {
    if dev.is_null() || matrix.is_null() || !(*dev).calibration_available {
        return 0;
    }
    std::slice::from_raw_parts_mut(matrix, 6).copy_from_slice(&(*dev).calibration);
    ((*dev).calibration != [1.0_f32, 0.0, 0.0, 0.0, 1.0, 0.0]) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_calibration_get_default_matrix(
    dev: *const LibinputDevice,
    matrix: *mut f32,
) -> libc::c_int {
    if dev.is_null() || matrix.is_null() || !(*dev).calibration_available {
        return 0;
    }
    std::slice::from_raw_parts_mut(matrix, 6).copy_from_slice(&(*dev).default_calibration);
    ((*dev).default_calibration != [1.0_f32, 0.0, 0.0, 0.0, 1.0, 0.0]) as libc::c_int
}

// ---------------------------------------------------------------------------
// Seat
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_seat(dev: *const LibinputDevice) -> *mut libc::c_void {
    if dev.is_null() {
        return std::ptr::null_mut();
    }
    (*dev).seat as *mut libc::c_void
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_set_seat_logical_name(
    dev: *mut LibinputDevice,
    name: *const libc::c_char,
) -> libc::c_int {
    if dev.is_null() || name.is_null() || (*dev).seat.is_null() {
        return -1;
    }
    let name = CStr::from_ptr(name);
    if name.to_bytes().is_empty() || name.to_bytes().len() > 255 {
        return -1;
    }
    if (*(*dev).seat).logical_name.as_c_str() == name {
        return 0;
    }
    let Ok(logical_name) = std::ffi::CString::new(name.to_bytes()) else {
        return -1;
    };
    let ctx = (*dev).context;
    if ctx.is_null() {
        return -1;
    }
    let physical_name = (*(*dev).seat).physical_name.clone();
    let new_seat = (*ctx)
        .seats
        .iter()
        .copied()
        .find(|seat| {
            !seat.is_null()
                && (**seat).physical_name == physical_name
                && (**seat).logical_name == logical_name
        })
        .unwrap_or_else(|| {
            let seat = Box::into_raw(Box::new(LibinputSeat {
                physical_name,
                logical_name,
                refcount: std::sync::atomic::AtomicI32::new(1),
                user_data: std::ptr::null_mut(),
                context: ctx,
                button_count: std::sync::atomic::AtomicU32::new(0),
                key_count: std::sync::atomic::AtomicU32::new(0),
            }));
            (*ctx).seats.push(seat);
            seat
        });

    let path = std::path::PathBuf::from((*dev).devnode.to_string_lossy().into_owned());
    let mut removed = std::collections::VecDeque::new();
    let mut added = Vec::new();
    let replaced = if let Ok(mut backend) = (*ctx).backend.lock() {
        if backend.remove_device(ctx, dev, &mut removed) {
            backend.try_open(ctx, &path, &mut added);
            true
        } else {
            false
        }
    } else {
        false
    };
    let Some(replacement) = added.first().map(|event| event.device) else {
        return -1;
    };
    if !replaced || replacement.is_null() {
        return -1;
    }
    (*ctx).devices.retain(|candidate| *candidate != dev);
    libinput_device_unref(dev);
    (*replacement).seat = new_seat;
    (*ctx).event_queue.extend(removed);
    (*ctx).event_queue.extend(added);
    (*replacement).abi.seat = new_seat;
    (*ctx).signal_fd();
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_seat_get_physical_name(
    seat: *const libc::c_void,
) -> *const libc::c_char {
    if seat.is_null() {
        return std::ptr::null();
    }
    (*(seat as *const LibinputSeat)).physical_name.as_ptr()
}

#[no_mangle]
pub unsafe extern "C" fn libinput_seat_get_logical_name(
    seat: *const libc::c_void,
) -> *const libc::c_char {
    if seat.is_null() {
        return std::ptr::null();
    }
    (*(seat as *const LibinputSeat)).logical_name.as_ptr()
}

#[no_mangle]
pub unsafe extern "C" fn libinput_seat_get_context(
    seat: *const libc::c_void,
) -> *mut LibinputContext {
    if seat.is_null() {
        return std::ptr::null_mut();
    }
    (*(seat as *const LibinputSeat)).context
}

#[no_mangle]
pub unsafe extern "C" fn libinput_seat_ref(seat: *mut libc::c_void) -> *mut libc::c_void {
    if !seat.is_null() {
        (*(seat as *mut LibinputSeat))
            .refcount
            .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
    }
    seat
}

#[no_mangle]
pub unsafe extern "C" fn libinput_seat_unref(seat: *mut libc::c_void) -> *mut libc::c_void {
    if !seat.is_null() {
        let seat = seat as *mut LibinputSeat;
        if (*seat)
            .refcount
            .fetch_sub(1, std::sync::atomic::Ordering::AcqRel)
            == 1
        {
            drop(Box::from_raw(seat));
        }
    }
    std::ptr::null_mut()
}

#[no_mangle]
pub unsafe extern "C" fn libinput_seat_set_user_data(
    seat: *mut libc::c_void,
    data: *mut libc::c_void,
) {
    if !seat.is_null() {
        (*(seat as *mut LibinputSeat)).user_data = data;
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_seat_get_user_data(
    seat: *const libc::c_void,
) -> *mut libc::c_void {
    if seat.is_null() {
        return std::ptr::null_mut();
    }
    (*(seat as *const LibinputSeat)).user_data
}

// ---------------------------------------------------------------------------
// Status strings
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_config_status_to_str(status: u32) -> *const libc::c_char {
    match status {
        0 => b"success\0".as_ptr().cast(),
        1 => b"unsupported\0".as_ptr().cast(),
        2 => b"invalid\0".as_ptr().cast(),
        _ => std::ptr::null(),
    }
}

// ---------------------------------------------------------------------------
// Logging
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_log_set_priority(ctx: *mut LibinputContext, priority: u32) {
    if !ctx.is_null() {
        (*ctx).log_priority = priority;
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_log_get_priority(ctx: *const LibinputContext) -> u32 {
    if ctx.is_null() {
        return 30;
    }
    (*ctx).log_priority
}

#[no_mangle]
pub unsafe extern "C" fn libinput_log_set_handler(
    ctx: *mut LibinputContext,
    handler: Option<
        unsafe extern "C" fn(
            ctx: *mut LibinputContext,
            priority: u32,
            format: *const libc::c_char,
            args: *mut libc::c_void,
        ),
    >,
) {
    if ctx.is_null() {
        return;
    }
    (*ctx).log_handler = handler;
}

// ---------------------------------------------------------------------------
// User data
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_set_user_data(
    ctx: *mut LibinputContext,
    data: *mut libc::c_void,
) {
    if ctx.is_null() {
        return;
    }
    (*ctx).user_data = data;
}

#[no_mangle]
pub unsafe extern "C" fn libinput_get_user_data(ctx: *const LibinputContext) -> *mut libc::c_void {
    if ctx.is_null() {
        return std::ptr::null_mut();
    }
    (*ctx).user_data
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_set_user_data(
    dev: *mut LibinputDevice,
    data: *mut libc::c_void,
) {
    if dev.is_null() {
        return;
    }
    (*dev).user_data = data;
    (*dev).abi.user_data = data;
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_user_data(
    dev: *const LibinputDevice,
) -> *mut libc::c_void {
    if dev.is_null() {
        return std::ptr::null_mut();
    }
    (*dev).user_data
}

// ---------------------------------------------------------------------------
// ABI compatibility surface for compositors (KWin/GNOME)
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_area_has_rectangle(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).area_available as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_area_set_rectangle(
    dev: *mut LibinputDevice,
    rectangle: *const LibinputConfigAreaRectangle,
) -> u32 {
    if dev.is_null() || !(*dev).area_available {
        return 1;
    }
    if rectangle.is_null() {
        return 2;
    }
    let rectangle = &*rectangle;
    if rectangle.x1 >= rectangle.x2
        || rectangle.y1 >= rectangle.y2
        || rectangle.x1 < 0.0
        || rectangle.x2 > 1.0
        || rectangle.y1 < 0.0
        || rectangle.y2 > 1.0
    {
        return 2;
    }
    (*dev).wanted_area = [rectangle.x1, rectangle.y1, rectangle.x2, rectangle.y2];
    if !(*dev).tablet_in_proximity {
        (*dev).area = (*dev).wanted_area;
    }
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_area_get_rectangle(
    dev: *const LibinputDevice,
) -> LibinputConfigAreaRectangle {
    let area = if dev.is_null() || !(*dev).area_available {
        [0.0, 0.0, 1.0, 1.0]
    } else {
        (*dev).area
    };
    LibinputConfigAreaRectangle {
        x1: area[0],
        y1: area[1],
        x2: area[2],
        y2: area[3],
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_area_get_default_rectangle(
    _dev: *const LibinputDevice,
) -> LibinputConfigAreaRectangle {
    LibinputConfigAreaRectangle {
        x1: 0.0,
        y1: 0.0,
        x2: 1.0,
        y2: 1.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_rotation_is_available(
    dev: *const LibinputDevice,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    (*dev).rotation_available as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_rotation_set_angle(
    dev: *mut LibinputDevice,
    degrees_cw: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    if degrees_cw >= 360 {
        return 2;
    }
    if !(*dev).rotation_available && degrees_cw != 0 {
        return 1;
    }
    (*dev).rotation_angle = degrees_cw;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_rotation_get_angle(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        0
    } else {
        (*dev).rotation_angle
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_rotation_get_default_angle(
    _dev: *const LibinputDevice,
) -> u32 {
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_scroll_get_default_button(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).supports_button_scroll {
        0
    } else {
        (*dev).scroll_default_button
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_send_events_get_modes(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).send_events_modes
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_send_events_set_mode(
    dev: *mut LibinputDevice,
    mode: u32,
) -> u32 {
    if dev.is_null() {
        return 1;
    }
    let supported = (*dev).send_events_modes;
    if mode & !supported != 0 {
        return 1;
    }
    let previous = (*dev).send_events_mode;
    let next = if mode & 1 != 0 { 1 } else { mode };
    (*dev).send_events_mode = next;
    if previous != 1 && next == 1 {
        let ctx = (*dev).context;
        if !ctx.is_null() {
            let mut events = std::collections::VecDeque::new();
            if let Ok(mut backend) = (*ctx).backend.lock() {
                backend.release_active_inputs(ctx, dev, &mut events);
            }
            (*ctx).event_queue.extend(events);
        }
    }
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_send_events_get_mode(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).send_events_mode
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_send_events_get_default_mode(
    _dev: *const LibinputDevice,
) -> u32 {
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_config_tap_get_default_drag_lock_enabled(
    _dev: *const LibinputDevice,
) -> u32 {
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_device_group(
    dev: *const LibinputDevice,
) -> *mut libc::c_void {
    if dev.is_null() {
        return std::ptr::null_mut();
    }
    (*dev).group.cast()
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_group_ref(group: *mut libc::c_void) -> *mut libc::c_void {
    if group.is_null() {
        return std::ptr::null_mut();
    }
    let group = group.cast::<LibinputDeviceGroup>();
    (*group)
        .refcount
        .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    group.cast()
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_group_unref(
    group: *mut libc::c_void,
) -> *mut libc::c_void {
    if group.is_null() {
        return std::ptr::null_mut();
    }
    let group = group.cast::<LibinputDeviceGroup>();
    if (*group)
        .refcount
        .fetch_sub(1, std::sync::atomic::Ordering::AcqRel)
        == 1
    {
        drop(Box::from_raw(group));
        std::ptr::null_mut()
    } else {
        group.cast()
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_group_set_user_data(
    group: *mut libc::c_void,
    data: *mut libc::c_void,
) {
    if !group.is_null() {
        (*group.cast::<LibinputDeviceGroup>()).user_data = data;
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_group_get_user_data(
    group: *const libc::c_void,
) -> *mut libc::c_void {
    if group.is_null() {
        return std::ptr::null_mut();
    }
    (*group.cast::<LibinputDeviceGroup>()).user_data
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_id_bustype(dev: *const LibinputDevice) -> u32 {
    if dev.is_null() {
        return 0;
    }
    (*dev).bus_type
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_size(
    dev: *const LibinputDevice,
    width: *mut f64,
    height: *mut f64,
) -> libc::c_int {
    if dev.is_null() || width.is_null() || height.is_null() {
        return 0;
    }
    match ((*dev).width_mm, (*dev).height_mm) {
        (Some(w), Some(h)) => {
            *width = w;
            *height = h;
            0
        }
        _ => -1,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_get_udev_device(
    dev: *const LibinputDevice,
) -> *mut libc::c_void {
    if dev.is_null() || (*dev).udev_device.is_null() {
        return std::ptr::null_mut();
    }
    udev::udev_device_ref((*dev).udev_device)
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_keyboard_has_key(
    dev: *const LibinputDevice,
    key: u32,
) -> libc::c_int {
    if dev.is_null() || !(*dev).has_keyboard {
        return -1;
    }
    if key > u16::MAX as u32 {
        return 0;
    }
    (*dev).event_codes.contains(&(key as u16)) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_led_update(dev: *mut LibinputDevice, _leds: u32) -> u32 {
    if dev.is_null() {
        return 1;
    }
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_pointer_has_button(
    dev: *const LibinputDevice,
    button: u32,
) -> libc::c_int {
    if dev.is_null() || button > u16::MAX as u32 {
        return 0;
    }
    if !(*dev).has_pointer {
        return -1;
    }
    (*dev).event_codes.contains(&(button as u16)) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_switch_has_switch(
    dev: *const LibinputDevice,
    sw: u32,
) -> libc::c_int {
    if dev.is_null() {
        return 0;
    }
    if !(*dev).has_switch {
        return 0;
    }
    let kernel_code = match sw {
        1 => 0,
        2 => 1,
        3 => 10,
        _ => return 0,
    };
    (*dev).switch_codes.contains(&kernel_code) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_tablet_pad_get_mode_group(
    dev: *const LibinputDevice,
    index: u32,
) -> *mut libc::c_void {
    if dev.is_null() || !(*dev).has_tablet_pad || index != 0 {
        return std::ptr::null_mut();
    }
    (*dev).tablet_pad_mode_group.cast()
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_tablet_pad_get_num_buttons(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).has_tablet_pad {
        return u32::MAX;
    }
    (*dev).tablet_pad_button_codes.len() as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_tablet_pad_get_num_dials(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).has_tablet_pad {
        return u32::MAX;
    }
    (*dev).tablet_pad_num_dials
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_tablet_pad_get_num_mode_groups(
    dev: *const LibinputDevice,
) -> u32 {
    u32::from(!dev.is_null() && (*dev).has_tablet_pad)
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_tablet_pad_get_num_rings(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).has_tablet_pad {
        return u32::MAX;
    }
    (*dev).tablet_pad_num_rings
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_tablet_pad_get_num_strips(
    dev: *const LibinputDevice,
) -> u32 {
    if dev.is_null() || !(*dev).has_tablet_pad {
        return u32::MAX;
    }
    (*dev).tablet_pad_num_strips
}

#[no_mangle]
pub unsafe extern "C" fn libinput_device_tablet_pad_has_key(
    dev: *const LibinputDevice,
    code: u32,
) -> libc::c_int {
    if dev.is_null() || !(*dev).has_tablet_pad {
        return -1;
    }
    (code <= u16::MAX as u32 && (*dev).event_codes.contains(&(code as u16))) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_tablet_pad_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    match (*event).event_type {
        LibinputEventType::LIBINPUT_EVENT_TABLET_PAD_BUTTON
        | LibinputEventType::LIBINPUT_EVENT_TABLET_PAD_RING
        | LibinputEventType::LIBINPUT_EVENT_TABLET_PAD_STRIP
        | LibinputEventType::LIBINPUT_EVENT_TABLET_PAD_KEY
        | LibinputEventType::LIBINPUT_EVENT_TABLET_PAD_DIAL => event,
        _ => std::ptr::null_mut(),
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_base_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    event
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_get_tablet_tool_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    match (*event).event_type {
        LibinputEventType::LIBINPUT_EVENT_TABLET_TOOL_AXIS
        | LibinputEventType::LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY
        | LibinputEventType::LIBINPUT_EVENT_TABLET_TOOL_TIP
        | LibinputEventType::LIBINPUT_EVENT_TABLET_TOOL_BUTTON => event,
        _ => std::ptr::null_mut(),
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_base_event(
    event: *mut LibinputEvent,
) -> *mut LibinputEvent {
    event
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_absolute_x_transformed(
    event: *const LibinputEvent,
    width: u32,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerMotionAbsolute(e) = &(*event).payload {
        let range = e.x_max - e.x_min;
        if range > 0.0 {
            (e.abs_x - e.x_min) * f64::from(width) / range
        } else {
            0.0
        }
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_absolute_y_transformed(
    event: *const LibinputEvent,
    height: u32,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerMotionAbsolute(e) = &(*event).payload {
        let range = e.y_max - e.y_min;
        if range > 0.0 {
            (e.abs_y - e.y_min) * f64::from(height) / range
        } else {
            0.0
        }
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_scroll_value(
    event: *const LibinputEvent,
    axis: u32,
) -> f64 {
    libinput_event_pointer_get_axis_value(event, axis)
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_pointer_get_scroll_value_v120(
    event: *const LibinputEvent,
    axis: u32,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::PointerAxis(e) = &(*event).payload {
        return e.value_v120(axis);
    }
    0.0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_switch_get_time_usec(event: *const LibinputEvent) -> u64 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::SwitchToggle(e) = &(*event).payload {
        e.time_usec
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_switch_get_time(event: *const LibinputEvent) -> u32 {
    (libinput_event_switch_get_time_usec(event) / 1000) as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_button_number(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.button,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_button_state(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.button_state,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_key(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.key,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_key_state(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.key_state,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_dial_delta_v120(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.dial_delta_v120,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_dial_number(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.dial_number,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_mode(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.mode,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_mode_group(
    event: *const LibinputEvent,
) -> *mut libc::c_void {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.mode_group.cast(),
        _ => std::ptr::null_mut(),
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_ring_number(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.ring_number,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_ring_position(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.ring_position,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_ring_source(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.ring_source,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_strip_number(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.strip_number,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_strip_position(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.strip_position,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_strip_source(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.strip_source,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_time_usec(
    event: *const LibinputEvent,
) -> u64 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletPad(pad) => pad.time_usec,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_pad_get_time(event: *const LibinputEvent) -> u32 {
    (libinput_event_tablet_pad_get_time_usec(event) / 1000) as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_button(event: *const LibinputEvent) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.button,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_button_state(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.button_state,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_seat_button_count(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.seat_button_count,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_distance(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.distance,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_dx(event: *const LibinputEvent) -> f64 {
    if event.is_null() || (*event).event_type != LibinputEventType::LIBINPUT_EVENT_TABLET_TOOL_AXIS
    {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.dx,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_dy(event: *const LibinputEvent) -> f64 {
    if event.is_null() || (*event).event_type != LibinputEventType::LIBINPUT_EVENT_TABLET_TOOL_AXIS
    {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.dy,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_pressure(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::TabletTool(tablet) = &(*event).payload {
        let range = tablet.pressure_max - tablet.pressure_min;
        if range > 0.0 {
            ((tablet.pressure - tablet.pressure_min) / range).clamp(0.0, 1.0)
        } else {
            0.0
        }
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_x(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::TabletTool(tablet) = &(*event).payload {
        if tablet.x_resolution > 0.0 {
            (tablet.x - tablet.x_min) / tablet.x_resolution
        } else {
            tablet.x - tablet.x_min
        }
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_y(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::TabletTool(tablet) = &(*event).payload {
        if tablet.y_resolution > 0.0 {
            (tablet.y - tablet.y_min) / tablet.y_resolution
        } else {
            tablet.y - tablet.y_min
        }
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_proximity_state(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::TabletTool(tablet) = &(*event).payload {
        tablet.proximity_state
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_rotation(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.rotation,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_slider_position(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.slider,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_wheel_delta(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.wheel_delta,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_wheel_delta_discrete(
    event: *const LibinputEvent,
) -> i32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.wheel_discrete,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_size_major(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.size_major,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_size_minor(
    event: *const LibinputEvent,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.size_minor,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_tilt_x(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.tilt_x,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_tilt_y(event: *const LibinputEvent) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.tilt_y,
        _ => 0.0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_time_usec(
    event: *const LibinputEvent,
) -> u64 {
    if event.is_null() {
        return 0;
    }
    if let EventPayload::TabletTool(tablet) = &(*event).payload {
        tablet.time_usec
    } else {
        0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_time(event: *const LibinputEvent) -> u32 {
    (libinput_event_tablet_tool_get_time_usec(event) / 1000) as u32
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_tip_state(
    event: *const LibinputEvent,
) -> u32 {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.tip_state,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_tool(
    event: *const LibinputEvent,
) -> *mut libc::c_void {
    if event.is_null() {
        return std::ptr::null_mut();
    }
    if let EventPayload::TabletTool(tablet) = &(*event).payload {
        tablet.tool.cast()
    } else {
        std::ptr::null_mut()
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_x_transformed(
    event: *const LibinputEvent,
    width: u32,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::TabletTool(tablet) = &(*event).payload {
        let range = tablet.x_max - tablet.x_min + 1.0;
        if range > 0.0 {
            (tablet.x - tablet.x_min) * f64::from(width) / range
        } else {
            0.0
        }
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_get_y_transformed(
    event: *const LibinputEvent,
    height: u32,
) -> f64 {
    if event.is_null() {
        return 0.0;
    }
    if let EventPayload::TabletTool(tablet) = &(*event).payload {
        let range = tablet.y_max - tablet.y_min + 1.0;
        if range > 0.0 {
            (tablet.y - tablet.y_min) * f64::from(height) / range
        } else {
            0.0
        }
    } else {
        0.0
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_x_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.x_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_y_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.y_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_pressure_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.pressure_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_distance_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.distance_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_tilt_x_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.tilt_x_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_tilt_y_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.tilt_y_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_rotation_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.rotation_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_slider_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.slider_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_wheel_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.wheel_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_size_major_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.size_major_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_event_tablet_tool_size_minor_has_changed(
    event: *const LibinputEvent,
) -> libc::c_int {
    if event.is_null() {
        return 0;
    }
    match &(*event).payload {
        EventPayload::TabletTool(tablet) => tablet.size_minor_changed as libc::c_int,
        _ => 0,
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_plugin_system_append_default_paths(_ctx: *mut LibinputContext) {}

#[no_mangle]
pub unsafe extern "C" fn libinput_plugin_system_append_path(
    _ctx: *mut LibinputContext,
    _path: *const libc::c_char,
) {
}

#[no_mangle]
pub unsafe extern "C" fn libinput_plugin_system_load_plugins(
    _ctx: *mut LibinputContext,
    _flags: libc::c_uint,
) -> libc::c_int {
    -libc::ENOSYS
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_button_is_toggle(
    _group: *const libc::c_void,
    _button: u32,
) -> libc::c_int {
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_get_index(
    group: *const libc::c_void,
) -> u32 {
    if group.is_null() {
        return 0;
    }
    (*group.cast::<LibinputTabletPadModeGroup>()).index
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_get_mode(
    group: *const libc::c_void,
) -> u32 {
    if group.is_null() {
        return 0;
    }
    (*group.cast::<LibinputTabletPadModeGroup>()).current_mode
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_get_num_modes(
    group: *const libc::c_void,
) -> u32 {
    if group.is_null() {
        return 0;
    }
    (*group.cast::<LibinputTabletPadModeGroup>()).num_modes
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_has_button(
    group: *const libc::c_void,
    button: u32,
) -> libc::c_int {
    if group.is_null() {
        return 0;
    }
    (button < (*group.cast::<LibinputTabletPadModeGroup>()).num_buttons) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_has_dial(
    group: *const libc::c_void,
    dial: u32,
) -> libc::c_int {
    if group.is_null() {
        return 0;
    }
    (dial < (*group.cast::<LibinputTabletPadModeGroup>()).num_dials) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_has_ring(
    group: *const libc::c_void,
    ring: u32,
) -> libc::c_int {
    if group.is_null() {
        return 0;
    }
    (ring < (*group.cast::<LibinputTabletPadModeGroup>()).num_rings) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_has_strip(
    group: *const libc::c_void,
    strip: u32,
) -> libc::c_int {
    if group.is_null() {
        return 0;
    }
    (strip < (*group.cast::<LibinputTabletPadModeGroup>()).num_strips) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_ref(
    group: *mut libc::c_void,
) -> *mut libc::c_void {
    if !group.is_null() {
        (*group.cast::<LibinputTabletPadModeGroup>())
            .refcount
            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    }
    group
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_unref(
    group: *mut libc::c_void,
) -> *mut libc::c_void {
    if group.is_null() {
        return std::ptr::null_mut();
    }
    let group_ref = &*group.cast::<LibinputTabletPadModeGroup>();
    let current = group_ref
        .refcount
        .load(std::sync::atomic::Ordering::Relaxed);
    if current > 1 {
        group_ref
            .refcount
            .fetch_sub(1, std::sync::atomic::Ordering::AcqRel);
    }
    group
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_set_user_data(
    group: *mut libc::c_void,
    data: *mut libc::c_void,
) {
    if !group.is_null() {
        (*group.cast::<LibinputTabletPadModeGroup>()).user_data = data;
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_pad_mode_group_get_user_data(
    group: *const libc::c_void,
) -> *mut libc::c_void {
    if group.is_null() {
        return std::ptr::null_mut();
    }
    (*group.cast::<LibinputTabletPadModeGroup>()).user_data
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_pressure_range_is_available(
    tool: *const LibinputTabletTool,
) -> libc::c_int {
    (!tool.is_null() && (*tool).has_pressure) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_pressure_range_set(
    tool: *mut LibinputTabletTool,
    minimum: f64,
    maximum: f64,
) -> u32 {
    if tool.is_null() || !(*tool).has_pressure {
        return 1;
    }
    if minimum < 0.0 || maximum > 1.0 || minimum >= maximum {
        return 2;
    }
    (*tool).wanted_pressure_range_minimum = minimum;
    (*tool).wanted_pressure_range_maximum = maximum;
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_pressure_range_get_minimum(
    tool: *const LibinputTabletTool,
) -> f64 {
    if tool.is_null() {
        0.0
    } else {
        (*tool).wanted_pressure_range_minimum
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_pressure_range_get_maximum(
    tool: *const LibinputTabletTool,
) -> f64 {
    if tool.is_null() {
        1.0
    } else {
        (*tool).wanted_pressure_range_maximum
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_pressure_range_get_default_minimum(
    _tool: *const libc::c_void,
) -> f64 {
    0.0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_pressure_range_get_default_maximum(
    _tool: *const libc::c_void,
) -> f64 {
    1.0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_eraser_button_get_modes(
    tool: *const libc::c_void,
) -> u32 {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() {
        0
    } else {
        (*tool).eraser_button_modes
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_eraser_button_set_mode(
    tool: *mut libc::c_void,
    mode: u32,
) -> u32 {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() || (mode != 0 && ((*tool).eraser_button_modes & mode) == 0) {
        return 1;
    }
    if !matches!(mode, 0 | 1) {
        return 2;
    }
    (*tool).wanted_eraser_button_mode = mode;
    if !(*tool).in_proximity {
        (*tool).eraser_button_mode = mode;
    }
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_eraser_button_get_mode(
    tool: *const libc::c_void,
) -> u32 {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() || (*tool).eraser_button_modes == 0 {
        0
    } else {
        (*tool).wanted_eraser_button_mode
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_eraser_button_get_default_mode(
    _tool: *const libc::c_void,
) -> u32 {
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_eraser_button_set_button(
    tool: *mut libc::c_void,
    button: u32,
) -> u32 {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() || (*tool).eraser_button_modes == 0 {
        return 1;
    }
    let is_button = matches!(button, 0x149 | 0x14b | 0x14c)
        || (0x100..0x140).contains(&button)
        || (0x150..=0x151).contains(&button)
        || (0x220..=0x223).contains(&button)
        || (0x2c0..=0x2e7).contains(&button);
    if !is_button {
        return 2;
    }
    (*tool).wanted_eraser_button = button;
    if !(*tool).in_proximity {
        (*tool).eraser_button = button;
    }
    0
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_eraser_button_get_button(
    tool: *const libc::c_void,
) -> u32 {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() || (*tool).eraser_button_modes == 0 {
        0
    } else {
        (*tool).wanted_eraser_button
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_config_eraser_button_get_default_button(
    tool: *const libc::c_void,
) -> u32 {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() || (*tool).eraser_button_modes == 0 {
        0
    } else {
        (*tool).default_eraser_button
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_get_name(
    tool: *const libc::c_void,
) -> *const libc::c_char {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() {
        return std::ptr::null();
    }
    let tool = tool.cast::<LibinputTabletTool>();
    let tool = tool as *mut LibinputTabletTool;
    if let Some(name) = (*tool).name.as_ref() {
        return name.as_ptr();
    }
    if let Some(name) = crate::backend::tablet_tool_name_for_id((*tool).tool_id) {
        (*tool).name = Some(name);
        (*tool)
            .name
            .as_ref()
            .map_or(std::ptr::null(), |name| name.as_ptr())
    } else {
        std::ptr::null()
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_get_serial(tool: *const libc::c_void) -> u64 {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() {
        0
    } else {
        (*tool).serial
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_get_tool_id(tool: *const libc::c_void) -> u64 {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() {
        0
    } else {
        (*tool).tool_id
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_get_type(tool: *const libc::c_void) -> u32 {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() {
        0
    } else {
        (*tool).tool_type
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_has_distance(
    tool: *const libc::c_void,
) -> libc::c_int {
    let tool = tool.cast::<LibinputTabletTool>();
    (!tool.is_null() && (*tool).has_distance) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_has_button(
    tool: *const libc::c_void,
    button: u32,
) -> libc::c_int {
    let tool = tool.cast::<LibinputTabletTool>();
    (!tool.is_null() && (*tool).buttons.contains(&button)) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_has_size(tool: *const libc::c_void) -> libc::c_int {
    let tool = tool.cast::<LibinputTabletTool>();
    (!tool.is_null() && (*tool).has_size) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_is_unique(tool: *const libc::c_void) -> libc::c_int {
    let tool = tool.cast::<LibinputTabletTool>();
    (!tool.is_null() && (*tool).serial != 0) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_set_user_data(
    tool: *mut libc::c_void,
    data: *mut libc::c_void,
) {
    let tool = tool.cast::<LibinputTabletTool>();
    if !tool.is_null() {
        (*tool).user_data = data;
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_get_user_data(
    tool: *const libc::c_void,
) -> *mut libc::c_void {
    let tool = tool.cast::<LibinputTabletTool>();
    if tool.is_null() {
        std::ptr::null_mut()
    } else {
        (*tool).user_data
    }
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_has_pressure(
    tool: *const libc::c_void,
) -> libc::c_int {
    let tool = tool.cast::<LibinputTabletTool>();
    (!tool.is_null() && (*tool).has_pressure) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_has_rotation(
    tool: *const libc::c_void,
) -> libc::c_int {
    let tool = tool.cast::<LibinputTabletTool>();
    (!tool.is_null() && (*tool).has_rotation) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_has_slider(tool: *const libc::c_void) -> libc::c_int {
    let tool = tool.cast::<LibinputTabletTool>();
    (!tool.is_null() && (*tool).has_slider) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_has_tilt(tool: *const libc::c_void) -> libc::c_int {
    let tool = tool.cast::<LibinputTabletTool>();
    (!tool.is_null() && (*tool).has_tilt) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_has_wheel(tool: *const libc::c_void) -> libc::c_int {
    let tool = tool.cast::<LibinputTabletTool>();
    (!tool.is_null() && (*tool).has_wheel) as libc::c_int
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_ref(tool: *mut libc::c_void) -> *mut libc::c_void {
    let tablet_tool = tool.cast::<LibinputTabletTool>();
    if !tablet_tool.is_null() {
        (*tablet_tool)
            .refcount
            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    }
    tool
}

#[no_mangle]
pub unsafe extern "C" fn libinput_tablet_tool_unref(tool: *mut libc::c_void) -> *mut libc::c_void {
    let tablet_tool = tool.cast::<LibinputTabletTool>();
    if tablet_tool.is_null() {
        return std::ptr::null_mut();
    }
    if (*tablet_tool)
        .refcount
        .fetch_sub(1, std::sync::atomic::Ordering::AcqRel)
        == 1
    {
        drop(Box::from_raw(tablet_tool));
        std::ptr::null_mut()
    } else {
        tool
    }
}

// ---------------------------------------------------------------------------
// Suspend / resume
// ---------------------------------------------------------------------------

#[no_mangle]
pub unsafe extern "C" fn libinput_suspend(ctx: *mut LibinputContext) {
    if ctx.is_null() {
        return;
    }
    let mut events = std::collections::VecDeque::new();
    if let Ok(mut backend) = (*ctx).backend.lock() {
        backend.suspend(ctx, &mut events);
    }
    (*ctx).event_queue.extend(events);
}

#[no_mangle]
pub unsafe extern "C" fn libinput_resume(ctx: *mut LibinputContext) -> libc::c_int {
    if ctx.is_null() {
        return -1;
    }
    let mut events = std::collections::VecDeque::new();
    let status = if let Ok(mut backend) = (*ctx).backend.lock() {
        backend.resume(ctx, &mut events)
    } else {
        return -1;
    };
    (*ctx).event_queue.extend(events);
    if !(*ctx).event_queue.is_empty() {
        (*ctx).signal_fd();
    }
    status
}

#[cfg(test)]
mod tests {
    use super::*;

    unsafe extern "C" fn deny_open(
        _path: *const libc::c_char,
        _flags: libc::c_int,
        _user_data: *mut libc::c_void,
    ) -> libc::c_int {
        -libc::EACCES
    }

    unsafe extern "C" fn close_fd(_fd: libc::c_int, _user_data: *mut libc::c_void) {}

    static INTERFACE: LibinputInterface = LibinputInterface {
        open_restricted: Some(deny_open),
        close_restricted: Some(close_fd),
    };

    #[test]
    fn udev_context_requires_interface_and_udev() {
        unsafe {
            let fake_udev = 1usize as *mut libc::c_void;
            assert!(libinput_udev_create_context(
                std::ptr::null(),
                std::ptr::null_mut(),
                fake_udev,
            )
            .is_null());
            assert!(libinput_udev_create_context(
                &INTERFACE,
                std::ptr::null_mut(),
                std::ptr::null_mut(),
            )
            .is_null());
        }
    }

    #[test]
    fn seat_assignment_is_udev_only_and_happens_once() {
        unsafe {
            let fake_udev = 1usize as *mut libc::c_void;
            let seat = std::ffi::CString::new("seat0").unwrap();
            let udev_ctx =
                libinput_udev_create_context(&INTERFACE, std::ptr::null_mut(), fake_udev);
            assert!(!udev_ctx.is_null());
            assert_eq!(libinput_udev_assign_seat(udev_ctx, seat.as_ptr()), 0);
            assert_eq!(libinput_udev_assign_seat(udev_ctx, seat.as_ptr()), -1);
            libinput_unref(udev_ctx);

            let path_ctx = libinput_path_create_context(&INTERFACE, std::ptr::null_mut());
            assert!(!path_ctx.is_null());
            assert_eq!(libinput_udev_assign_seat(path_ctx, seat.as_ptr()), -1);
            libinput_unref(path_ctx);
        }
    }

    #[test]
    fn suspend_and_resume_are_null_safe() {
        unsafe {
            libinput_suspend(std::ptr::null_mut());
            assert_eq!(libinput_resume(std::ptr::null_mut()), -1);
        }
    }
}