jay-compositor 1.15.0

use crate::libinput::consts::ButtonState;
use crate::libinput::consts::EventType;
use crate::libinput::consts::KeyState;
use crate::libinput::consts::PointerAxis;
use crate::libinput::consts::Switch;
use crate::libinput::consts::SwitchState;
use crate::libinput::consts::TabletPadRingAxisSource;
use crate::libinput::consts::TabletPadStripAxisSource;
use crate::libinput::consts::TabletToolProximityState;
use crate::libinput::consts::TabletToolTipState;
use crate::libinput::consts::TabletToolType;
use crate::libinput::device::LibInputDevice;
use crate::libinput::device::LibInputTabletPadModeGroup;
use crate::libinput::sys::libinput_event;
use crate::libinput::sys::libinput_event_destroy;
use crate::libinput::sys::libinput_event_gesture;
use crate::libinput::sys::libinput_event_gesture_get_angle_delta;
use crate::libinput::sys::libinput_event_gesture_get_cancelled;
use crate::libinput::sys::libinput_event_gesture_get_dx;
use crate::libinput::sys::libinput_event_gesture_get_dx_unaccelerated;
use crate::libinput::sys::libinput_event_gesture_get_dy;
use crate::libinput::sys::libinput_event_gesture_get_dy_unaccelerated;
use crate::libinput::sys::libinput_event_gesture_get_finger_count;
use crate::libinput::sys::libinput_event_gesture_get_scale;
use crate::libinput::sys::libinput_event_gesture_get_time_usec;
use crate::libinput::sys::libinput_event_get_device;
use crate::libinput::sys::libinput_event_get_gesture_event;
use crate::libinput::sys::libinput_event_get_keyboard_event;
use crate::libinput::sys::libinput_event_get_pointer_event;
use crate::libinput::sys::libinput_event_get_switch_event;
use crate::libinput::sys::libinput_event_get_tablet_pad_event;
use crate::libinput::sys::libinput_event_get_tablet_tool_event;
use crate::libinput::sys::libinput_event_get_touch_event;
use crate::libinput::sys::libinput_event_get_type;
use crate::libinput::sys::libinput_event_keyboard;
use crate::libinput::sys::libinput_event_keyboard_get_key;
use crate::libinput::sys::libinput_event_keyboard_get_key_state;
use crate::libinput::sys::libinput_event_keyboard_get_time_usec;
use crate::libinput::sys::libinput_event_pointer;
use crate::libinput::sys::libinput_event_pointer_get_absolute_x_transformed;
use crate::libinput::sys::libinput_event_pointer_get_absolute_y_transformed;
use crate::libinput::sys::libinput_event_pointer_get_button;
use crate::libinput::sys::libinput_event_pointer_get_button_state;
use crate::libinput::sys::libinput_event_pointer_get_dx;
use crate::libinput::sys::libinput_event_pointer_get_dx_unaccelerated;
use crate::libinput::sys::libinput_event_pointer_get_dy;
use crate::libinput::sys::libinput_event_pointer_get_dy_unaccelerated;
use crate::libinput::sys::libinput_event_pointer_get_scroll_value;
use crate::libinput::sys::libinput_event_pointer_get_scroll_value_v120;
use crate::libinput::sys::libinput_event_pointer_get_time_usec;
use crate::libinput::sys::libinput_event_pointer_has_axis;
use crate::libinput::sys::libinput_event_switch;
use crate::libinput::sys::libinput_event_switch_get_switch;
use crate::libinput::sys::libinput_event_switch_get_switch_state;
use crate::libinput::sys::libinput_event_switch_get_time_usec;
use crate::libinput::sys::libinput_event_tablet_pad;
use crate::libinput::sys::libinput_event_tablet_pad_get_button_number;
use crate::libinput::sys::libinput_event_tablet_pad_get_button_state;
use crate::libinput::sys::libinput_event_tablet_pad_get_dial_delta_v120;
use crate::libinput::sys::libinput_event_tablet_pad_get_dial_number;
use crate::libinput::sys::libinput_event_tablet_pad_get_mode;
use crate::libinput::sys::libinput_event_tablet_pad_get_mode_group;
use crate::libinput::sys::libinput_event_tablet_pad_get_ring_number;
use crate::libinput::sys::libinput_event_tablet_pad_get_ring_position;
use crate::libinput::sys::libinput_event_tablet_pad_get_ring_source;
use crate::libinput::sys::libinput_event_tablet_pad_get_strip_number;
use crate::libinput::sys::libinput_event_tablet_pad_get_strip_position;
use crate::libinput::sys::libinput_event_tablet_pad_get_strip_source;
use crate::libinput::sys::libinput_event_tablet_pad_get_time_usec;
use crate::libinput::sys::libinput_event_tablet_tool;
use crate::libinput::sys::libinput_event_tablet_tool_get_button;
use crate::libinput::sys::libinput_event_tablet_tool_get_button_state;
use crate::libinput::sys::libinput_event_tablet_tool_get_proximity_state;
use crate::libinput::sys::libinput_event_tablet_tool_get_time_usec;
use crate::libinput::sys::libinput_event_tablet_tool_get_tip_state;
use crate::libinput::sys::libinput_event_tablet_tool_get_tool;
use crate::libinput::sys::libinput_event_tablet_tool_get_wheel_delta_discrete;
use crate::libinput::sys::libinput_event_tablet_tool_get_x_transformed;
use crate::libinput::sys::libinput_event_tablet_tool_get_y_transformed;
use crate::libinput::sys::libinput_event_touch;
use crate::libinput::sys::libinput_event_touch_get_seat_slot;
use crate::libinput::sys::libinput_event_touch_get_time_usec;
use crate::libinput::sys::libinput_event_touch_get_x_transformed;
use crate::libinput::sys::libinput_event_touch_get_y_transformed;
use crate::libinput::sys::libinput_tablet_tool;
use crate::libinput::sys::libinput_tablet_tool_get_serial;
use crate::libinput::sys::libinput_tablet_tool_get_tool_id;
use crate::libinput::sys::libinput_tablet_tool_get_type;
use crate::libinput::sys::libinput_tablet_tool_get_user_data;
use crate::libinput::sys::libinput_tablet_tool_set_user_data;
use std::marker::PhantomData;

pub struct LibInputEvent<'a> {
    pub(super) event: *mut libinput_event,
    pub(super) _phantom: PhantomData<&'a ()>,
}

pub struct LibInputEventKeyboard<'a> {
    event: *mut libinput_event_keyboard,
    _phantom: PhantomData<&'a ()>,
}

pub struct LibInputEventPointer<'a> {
    event: *mut libinput_event_pointer,
    _phantom: PhantomData<&'a ()>,
}

pub struct LibInputEventGesture<'a> {
    event: *mut libinput_event_gesture,
    _phantom: PhantomData<&'a ()>,
}

pub struct LibInputEventSwitch<'a> {
    event: *mut libinput_event_switch,
    _phantom: PhantomData<&'a ()>,
}

pub struct LibInputEventTabletTool<'a> {
    event: *mut libinput_event_tablet_tool,
    _phantom: PhantomData<&'a ()>,
}

pub struct LibInputEventTabletPad<'a> {
    event: *mut libinput_event_tablet_pad,
    _phantom: PhantomData<&'a ()>,
}

pub struct LibInputTabletTool<'a> {
    tool: *mut libinput_tablet_tool,
    _phantom: PhantomData<&'a ()>,
}

pub struct LibInputEventTouch<'a> {
    event: *mut libinput_event_touch,
    _phantom: PhantomData<&'a ()>,
}

impl Drop for LibInputEvent<'_> {
    fn drop(&mut self) {
        unsafe {
            libinput_event_destroy(self.event);
        }
    }
}

macro_rules! converter {
    ($name:ident, $out:ident, $f:ident) => {
        pub fn $name(&self) -> Option<$out<'_>> {
            let res = unsafe { $f(self.event) };
            if res.is_null() {
                None
            } else {
                Some($out {
                    event: res,
                    _phantom: Default::default(),
                })
            }
        }
    };
}

impl LibInputEvent<'_> {
    pub fn ty(&self) -> EventType {
        unsafe { EventType(libinput_event_get_type(self.event)) }
    }

    pub fn device(&self) -> LibInputDevice<'_> {
        LibInputDevice {
            dev: unsafe { libinput_event_get_device(self.event) },
            _phantom: Default::default(),
        }
    }

    converter!(
        keyboard_event,
        LibInputEventKeyboard,
        libinput_event_get_keyboard_event
    );
    converter!(
        pointer_event,
        LibInputEventPointer,
        libinput_event_get_pointer_event
    );
    converter!(
        gesture_event,
        LibInputEventGesture,
        libinput_event_get_gesture_event
    );
    converter!(
        switch_event,
        LibInputEventSwitch,
        libinput_event_get_switch_event
    );
    converter!(
        tablet_tool_event,
        LibInputEventTabletTool,
        libinput_event_get_tablet_tool_event
    );
    converter!(
        tablet_pad_event,
        LibInputEventTabletPad,
        libinput_event_get_tablet_pad_event
    );
    converter!(
        touch_event,
        LibInputEventTouch,
        libinput_event_get_touch_event
    );
}

impl LibInputEventKeyboard<'_> {
    pub fn key(&self) -> u32 {
        unsafe { libinput_event_keyboard_get_key(self.event) }
    }

    pub fn key_state(&self) -> KeyState {
        unsafe { KeyState(libinput_event_keyboard_get_key_state(self.event)) }
    }

    pub fn time_usec(&self) -> u64 {
        unsafe { libinput_event_keyboard_get_time_usec(self.event) }
    }
}

impl LibInputEventPointer<'_> {
    pub fn x_transformed(&self, width: u32) -> f64 {
        unsafe { libinput_event_pointer_get_absolute_x_transformed(self.event, width) }
    }

    pub fn y_transformed(&self, height: u32) -> f64 {
        unsafe { libinput_event_pointer_get_absolute_y_transformed(self.event, height) }
    }

    pub fn dx(&self) -> f64 {
        unsafe { libinput_event_pointer_get_dx(self.event) }
    }

    pub fn dy(&self) -> f64 {
        unsafe { libinput_event_pointer_get_dy(self.event) }
    }

    pub fn dx_unaccelerated(&self) -> f64 {
        unsafe { libinput_event_pointer_get_dx_unaccelerated(self.event) }
    }

    pub fn dy_unaccelerated(&self) -> f64 {
        unsafe { libinput_event_pointer_get_dy_unaccelerated(self.event) }
    }

    pub fn button(&self) -> u32 {
        unsafe { libinput_event_pointer_get_button(self.event) }
    }

    pub fn button_state(&self) -> ButtonState {
        unsafe { ButtonState(libinput_event_pointer_get_button_state(self.event)) }
    }

    pub fn scroll_value(&self, axis: PointerAxis) -> f64 {
        unsafe { libinput_event_pointer_get_scroll_value(self.event, axis.raw() as _) }
    }

    pub fn scroll_value_v120(&self, axis: PointerAxis) -> f64 {
        unsafe { libinput_event_pointer_get_scroll_value_v120(self.event, axis.raw() as _) }
    }

    pub fn has_axis(&self, axis: PointerAxis) -> bool {
        unsafe { libinput_event_pointer_has_axis(self.event, axis.raw() as _) != 0 }
    }

    pub fn time_usec(&self) -> u64 {
        unsafe { libinput_event_pointer_get_time_usec(self.event) }
    }
}

impl LibInputEventGesture<'_> {
    pub fn time_usec(&self) -> u64 {
        unsafe { libinput_event_gesture_get_time_usec(self.event) }
    }

    pub fn finger_count(&self) -> u32 {
        unsafe { libinput_event_gesture_get_finger_count(self.event) as u32 }
    }

    pub fn cancelled(&self) -> bool {
        unsafe { libinput_event_gesture_get_cancelled(self.event) != 0 }
    }

    pub fn dx(&self) -> f64 {
        unsafe { libinput_event_gesture_get_dx(self.event) }
    }

    pub fn dy(&self) -> f64 {
        unsafe { libinput_event_gesture_get_dy(self.event) }
    }

    pub fn dx_unaccelerated(&self) -> f64 {
        unsafe { libinput_event_gesture_get_dx_unaccelerated(self.event) }
    }

    pub fn dy_unaccelerated(&self) -> f64 {
        unsafe { libinput_event_gesture_get_dy_unaccelerated(self.event) }
    }

    pub fn scale(&self) -> f64 {
        unsafe { libinput_event_gesture_get_scale(self.event) }
    }

    pub fn angle_delta(&self) -> f64 {
        unsafe { libinput_event_gesture_get_angle_delta(self.event) }
    }
}

impl LibInputEventSwitch<'_> {
    pub fn time_usec(&self) -> u64 {
        unsafe { libinput_event_switch_get_time_usec(self.event) }
    }

    pub fn switch(&self) -> Switch {
        unsafe { Switch(libinput_event_switch_get_switch(self.event)) }
    }

    pub fn switch_state(&self) -> SwitchState {
        unsafe { SwitchState(libinput_event_switch_get_switch_state(self.event)) }
    }
}

macro_rules! has_changed {
    ($name:ident, $f:ident) => {
        pub fn $name(&self) -> bool {
            unsafe { crate::libinput::sys::$f(self.event) != 0 }
        }
    };
}

macro_rules! get_double {
    ($name:ident, $f:ident) => {
        pub fn $name(&self) -> f64 {
            unsafe { crate::libinput::sys::$f(self.event) }
        }
    };
}

macro_rules! has_capability {
    ($name:ident, $f:ident) => {
        pub fn $name(&self) -> bool {
            unsafe { crate::libinput::sys::$f(self.tool) != 0 }
        }
    };
}

impl LibInputTabletTool<'_> {
    pub fn user_data(&self) -> usize {
        unsafe { libinput_tablet_tool_get_user_data(self.tool) }
    }

    pub fn set_user_data(&self, user_data: usize) {
        unsafe { libinput_tablet_tool_set_user_data(self.tool, user_data) }
    }

    pub fn type_(&self) -> TabletToolType {
        unsafe { TabletToolType(libinput_tablet_tool_get_type(self.tool)) }
    }

    pub fn tool_id(&self) -> u64 {
        unsafe { libinput_tablet_tool_get_tool_id(self.tool) }
    }

    pub fn serial(&self) -> u64 {
        unsafe { libinput_tablet_tool_get_serial(self.tool) }
    }

    has_capability!(has_pressure, libinput_tablet_tool_has_pressure);
    has_capability!(has_distance, libinput_tablet_tool_has_distance);
    has_capability!(has_tilt, libinput_tablet_tool_has_tilt);
    has_capability!(has_rotation, libinput_tablet_tool_has_rotation);
    has_capability!(has_slider, libinput_tablet_tool_has_slider);
    // has_capability!(has_size, libinput_tablet_tool_has_size);
    has_capability!(has_wheel, libinput_tablet_tool_has_wheel);
}

impl LibInputEventTabletTool<'_> {
    pub fn tool(&self) -> LibInputTabletTool<'_> {
        LibInputTabletTool {
            tool: unsafe { libinput_event_tablet_tool_get_tool(self.event) },
            _phantom: Default::default(),
        }
    }

    pub fn time_usec(&self) -> u64 {
        unsafe { libinput_event_tablet_tool_get_time_usec(self.event) }
    }

    has_changed!(x_has_changed, libinput_event_tablet_tool_x_has_changed);
    has_changed!(y_has_changed, libinput_event_tablet_tool_y_has_changed);
    has_changed!(
        pressure_has_changed,
        libinput_event_tablet_tool_pressure_has_changed
    );
    has_changed!(
        distance_has_changed,
        libinput_event_tablet_tool_distance_has_changed
    );
    has_changed!(
        tilt_x_has_changed,
        libinput_event_tablet_tool_tilt_x_has_changed
    );
    has_changed!(
        tilt_y_has_changed,
        libinput_event_tablet_tool_tilt_y_has_changed
    );
    has_changed!(
        rotation_has_changed,
        libinput_event_tablet_tool_rotation_has_changed
    );
    has_changed!(
        slider_has_changed,
        libinput_event_tablet_tool_slider_has_changed
    );
    // has_changed!(
    //     size_major_has_changed,
    //     libinput_event_tablet_tool_size_major_has_changed
    // );
    // has_changed!(
    //     size_minor_has_changed,
    //     libinput_event_tablet_tool_size_minor_has_changed
    // );
    has_changed!(
        wheel_has_changed,
        libinput_event_tablet_tool_wheel_has_changed
    );

    // get_double!(x, libinput_event_tablet_tool_get_x);
    // get_double!(y, libinput_event_tablet_tool_get_y);
    get_double!(dx, libinput_event_tablet_tool_get_dx);
    get_double!(dy, libinput_event_tablet_tool_get_dy);
    get_double!(pressure, libinput_event_tablet_tool_get_pressure);
    get_double!(distance, libinput_event_tablet_tool_get_distance);
    get_double!(tilt_x, libinput_event_tablet_tool_get_tilt_x);
    get_double!(tilt_y, libinput_event_tablet_tool_get_tilt_y);
    get_double!(rotation, libinput_event_tablet_tool_get_rotation);
    get_double!(
        slider_position,
        libinput_event_tablet_tool_get_slider_position
    );
    // get_double!(size_major, libinput_event_tablet_tool_get_size_major);
    // get_double!(size_minor, libinput_event_tablet_tool_get_size_minor);
    get_double!(wheel_delta, libinput_event_tablet_tool_get_wheel_delta);

    pub fn wheel_delta_discrete(&self) -> i32 {
        unsafe { libinput_event_tablet_tool_get_wheel_delta_discrete(self.event) as _ }
    }

    pub fn x_transformed(&self, width: u32) -> f64 {
        unsafe { libinput_event_tablet_tool_get_x_transformed(self.event, width) }
    }

    pub fn y_transformed(&self, width: u32) -> f64 {
        unsafe { libinput_event_tablet_tool_get_y_transformed(self.event, width) }
    }

    pub fn proximity_state(&self) -> TabletToolProximityState {
        unsafe {
            TabletToolProximityState(libinput_event_tablet_tool_get_proximity_state(self.event))
        }
    }

    pub fn tip_state(&self) -> TabletToolTipState {
        unsafe { TabletToolTipState(libinput_event_tablet_tool_get_tip_state(self.event)) }
    }

    pub fn button(&self) -> u32 {
        unsafe { libinput_event_tablet_tool_get_button(self.event) }
    }

    pub fn button_state(&self) -> ButtonState {
        unsafe { ButtonState(libinput_event_tablet_tool_get_button_state(self.event)) }
    }
}

impl LibInputEventTabletPad<'_> {
    pub fn time_usec(&self) -> u64 {
        unsafe { libinput_event_tablet_pad_get_time_usec(self.event) }
    }

    pub fn ring_position(&self) -> f64 {
        unsafe { libinput_event_tablet_pad_get_ring_position(self.event) }
    }

    pub fn ring_number(&self) -> u32 {
        unsafe { libinput_event_tablet_pad_get_ring_number(self.event) as u32 }
    }

    pub fn ring_source(&self) -> TabletPadRingAxisSource {
        unsafe { TabletPadRingAxisSource(libinput_event_tablet_pad_get_ring_source(self.event)) }
    }

    pub fn strip_position(&self) -> f64 {
        unsafe { libinput_event_tablet_pad_get_strip_position(self.event) }
    }

    pub fn strip_number(&self) -> u32 {
        unsafe { libinput_event_tablet_pad_get_strip_number(self.event) as u32 }
    }

    pub fn strip_source(&self) -> TabletPadStripAxisSource {
        unsafe { TabletPadStripAxisSource(libinput_event_tablet_pad_get_strip_source(self.event)) }
    }

    pub fn dial_number(&self) -> Option<u32> {
        libinput_event_tablet_pad_get_dial_number.map(|f| unsafe { f(self.event) as u32 })
    }

    pub fn dial_delta_v120(&self) -> Option<f64> {
        libinput_event_tablet_pad_get_dial_delta_v120.map(|f| unsafe { f(self.event) })
    }

    pub fn button_number(&self) -> u32 {
        unsafe { libinput_event_tablet_pad_get_button_number(self.event) }
    }

    pub fn button_state(&self) -> ButtonState {
        unsafe { ButtonState(libinput_event_tablet_pad_get_button_state(self.event)) }
    }

    pub fn mode(&self) -> u32 {
        unsafe { libinput_event_tablet_pad_get_mode(self.event) as u32 }
    }

    pub fn mode_group(&self) -> LibInputTabletPadModeGroup<'_> {
        LibInputTabletPadModeGroup {
            group: unsafe { libinput_event_tablet_pad_get_mode_group(self.event) },
            _phantom: Default::default(),
        }
    }
}

impl LibInputEventTouch<'_> {
    pub fn seat_slot(&self) -> i32 {
        unsafe { libinput_event_touch_get_seat_slot(self.event) }
    }

    // pub fn x(&self) -> f64 {
    //     unsafe { libinput_event_touch_get_x(self.event) }
    // }
    //
    // pub fn y(&self) -> f64 {
    //     unsafe { libinput_event_touch_get_y(self.event) }
    // }

    pub fn x_transformed(&self, width: u32) -> f64 {
        unsafe { libinput_event_touch_get_x_transformed(self.event, width) }
    }

    pub fn y_transformed(&self, height: u32) -> f64 {
        unsafe { libinput_event_touch_get_y_transformed(self.event, height) }
    }

    pub fn time_usec(&self) -> u64 {
        unsafe { libinput_event_touch_get_time_usec(self.event) }
    }
}