win32_synthetic_pointer/

lib.rs

use enumflags2::{bitflags, BitFlags};
use thiserror::Error;
use windows::Win32::{
    Foundation::{GetLastError, POINT, RECT},
    UI::{
        Controls::{
            CreateSyntheticPointerDevice, DestroySyntheticPointerDevice, HSYNTHETICPOINTERDEVICE,
            POINTER_FEEDBACK_INDIRECT, POINTER_TYPE_INFO,
        },
        Input::Pointer::{
            InitializeTouchInjection, InjectSyntheticPointerInput, POINTER_FLAG_DOWN,
            POINTER_FLAG_FIRSTBUTTON, POINTER_FLAG_HASTRANSFORM, POINTER_FLAG_INCONTACT,
            POINTER_FLAG_INRANGE, POINTER_FLAG_NEW, POINTER_FLAG_NONE, POINTER_FLAG_PRIMARY,
            POINTER_FLAG_UP, POINTER_FLAG_UPDATE, POINTER_INFO, POINTER_PEN_INFO,
            POINTER_TOUCH_INFO, TOUCH_FEEDBACK_DEFAULT,
        },
        WindowsAndMessaging::POINTER_INPUT_TYPE,
    },
};

const MAX_POINTERS: u32 = 10;
const MAX_POINTERS_USIZE: usize = 10;

pub struct SyntheticPointer {
    pub pointer_type: PointerType,
    pub pointer_count: u32,
    pointer_type_info: [POINTER_TYPE_INFO; MAX_POINTERS_USIZE],
    synthetic_pointer_device: HSYNTHETICPOINTERDEVICE,
    last_contact: [bool; MAX_POINTERS_USIZE],
}

impl SyntheticPointer {
    /// Creates a new synthetic pointer of the type specified.
    /// The maximum working number of pointers is [MAX_POINTERS]
    pub fn new(
        pointer_type: PointerType,
        pointer_count: u32,
    ) -> Result<Self, SyntheticPointerError> {
        if pointer_count == 0 || pointer_count > MAX_POINTERS {
            return Err(SyntheticPointerError::InvalidPointerCount {
                count: pointer_count,
            });
        }

        match pointer_type {
            PointerType::Pointer => return Err(SyntheticPointerError::InvalidPointerType),
            PointerType::Touchpad => {
                // TODO: fail with an InvalidPointerType if windows < 8.1
            }
            _ => {}
        }

        let pointer_input_type = POINTER_INPUT_TYPE(pointer_type.get_value());

        if let PointerType::Touch(_) = pointer_type {
            unsafe {
                if (!InitializeTouchInjection(pointer_count, TOUCH_FEEDBACK_DEFAULT)).into() {
                    return Err(SyntheticPointerError::InputInjectionError(
                        GetLastError().into(),
                    ));
                }
            }
        }

        let device = unsafe {
            CreateSyntheticPointerDevice(
                pointer_input_type,
                pointer_count,
                POINTER_FEEDBACK_INDIRECT,
            )
        }?;

        let mut s = Self {
            pointer_type,
            pointer_count,
            synthetic_pointer_device: device,

            // fills with zeroes
            pointer_type_info: [POINTER_TYPE_INFO::default(); MAX_POINTERS_USIZE],
            last_contact: [false; MAX_POINTERS_USIZE],
        };

        // initialize pointers

        match pointer_type {
            PointerType::Touch(properties) => {
                for i in 0..pointer_count as usize {
                    let mut touch_info = POINTER_TOUCH_INFO {
                        pointerInfo: POINTER_INFO::default(),
                        ..Default::default()
                    };

                    touch_info.pointerInfo.pointerType = pointer_input_type;
                    touch_info.pointerInfo.pointerId = i as u32 + 1;
                    touch_info.pointerInfo.pointerFlags = POINTER_FLAG_NEW;
                    touch_info.touchMask = properties.bits();

                    s.pointer_type_info[i].r#type = pointer_input_type;
                    s.pointer_type_info[i].Anonymous.touchInfo = touch_info;
                }
            }
            PointerType::Pen(properties) => {
                let mut pen_info = POINTER_PEN_INFO {
                    pointerInfo: POINTER_INFO::default(),
                    ..Default::default()
                };

                pen_info.pointerInfo.pointerType = pointer_input_type;
                pen_info.pointerInfo.pointerFlags = POINTER_FLAG_NEW;
                pen_info.penMask = properties.bits();

                s.pointer_type_info[0].r#type = pointer_input_type;
                s.pointer_type_info[0].Anonymous.penInfo = pen_info;
            }

            _ => {
                todo!()
            }
        }

        // inject once so windows knows about the new pointers
        s.inject()?;

        Ok(s)
    }

    /// Schedules pen input for injection.
    /// If None, the pen is outside the detection range.
    /// After this, you need to call inject()
    pub fn pen_input(&mut self, input: &Option<PenInput>) -> Result<(), SyntheticPointerError> {
        match self.pointer_type {
            PointerType::Pen(_) => {
                // nothing
            }
            _ => {
                return Err(SyntheticPointerError::InvalidPointerType);
            }
        }

        let union = &mut self.pointer_type_info[0].Anonymous;

        // if none, it's out of range
        if let Some(data) = input {
            let mut flags = POINTER_FLAG_INRANGE
                | POINTER_FLAG_HASTRANSFORM
                | POINTER_FLAG_PRIMARY
                | POINTER_FLAG_UPDATE;

            // set position

            union.penInfo.pointerInfo.ptPixelLocation = POINT {
                x: data.x,
                y: data.y,
            };

            if let Some(tilt_x) = data.tilt_x {
                union.penInfo.tiltX = tilt_x;
            }

            if let Some(tilt_y) = data.tilt_y {
                union.penInfo.tiltY = tilt_y;
            }

            if let Some(rotation) = data.rotation {
                union.penInfo.rotation = rotation;
            }

            union.penInfo.pressure = data.pressure;
            let contact = data.pressure > 0;

            if contact && !self.last_contact[0] {
                flags |= POINTER_FLAG_DOWN;
            } else if !contact && self.last_contact[0] {
                flags |= POINTER_FLAG_UP;
            }

            if data.bind_active && contact {
                flags |= POINTER_FLAG_INCONTACT | POINTER_FLAG_FIRSTBUTTON;
            }

            union.penInfo.pointerInfo.pointerFlags = flags;
            self.last_contact[0] = data.pressure > 0;
        } else {
            // mark as out of range
            union.penInfo.pointerInfo.pointerFlags = POINTER_FLAG_NONE;
            self.last_contact[0] = false;
        }

        Ok(())
    }

    /// Schedules touch input for injection.
    /// If None, the finger is outside of the detection range.
    /// Set all the disabled fingers to None.
    /// After this, you need to call inject()
    pub fn touch_input(
        &mut self,
        input: &[Option<TouchInput>; MAX_POINTERS_USIZE],
    ) -> Result<(), SyntheticPointerError> {
        match self.pointer_type {
            PointerType::Touch(_) => {
                // nothing
            }
            _ => {
                return Err(SyntheticPointerError::InvalidPointerType);
            }
        }

        for (i, pt_info) in self.pointer_type_info[0..self.pointer_count as usize]
            .iter_mut()
            .enumerate()
        {
            let union = &mut pt_info.Anonymous;

            // if none, it's out of range
            if let Some(data) = &input[i] {
                let mut flags =
                    POINTER_FLAG_INRANGE | POINTER_FLAG_HASTRANSFORM | POINTER_FLAG_UPDATE;

                // the first touch is always the primary one
                if i == 0 {
                    flags |= POINTER_FLAG_PRIMARY;
                }

                // set position
                union.touchInfo.pointerInfo.ptPixelLocation = POINT {
                    x: data.x,
                    y: data.y,
                };

                if let Some(area) = data.contact_area {
                    union.touchInfo.rcContact = RECT {
                        top: area.top,
                        bottom: area.bottom,
                        left: area.left,
                        right: area.right,
                    };
                }

                if let Some(orientation) = data.orientation {
                    union.touchInfo.orientation = orientation;
                }

                union.touchInfo.pressure = data.pressure;
                let contact = data.pressure > 0;

                if contact && !self.last_contact[i] {
                    flags |= POINTER_FLAG_DOWN;
                } else if !contact && self.last_contact[i] {
                    flags |= POINTER_FLAG_UP;
                }

                if data.bind_active && contact {
                    flags |= POINTER_FLAG_INCONTACT | POINTER_FLAG_FIRSTBUTTON;
                }

                union.touchInfo.pointerInfo.pointerFlags = flags;
                self.last_contact[i] = data.pressure > 0;
            } else {
                // mark as out of range
                union.touchInfo.pointerInfo.pointerFlags = POINTER_FLAG_NONE;
                self.last_contact[i] = false;
            }
        }

        Ok(())
    }

    /// Sends the scheduled input data to windows.
    pub fn inject(&mut self) -> Result<(), SyntheticPointerError> {
        unsafe {
            if (!InjectSyntheticPointerInput(
                self.synthetic_pointer_device,
                &self.pointer_type_info[0..self.pointer_count as usize],
            ))
            .into()
            {
                return Err(SyntheticPointerError::InputInjectionError(
                    GetLastError().into(),
                ));
            }
        }
        Ok(())
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PenInput {
    /// The X screen coordinate
    pub x: i32,
    /// The Y screen coordinate
    pub y: i32,
    /// The pressure value, if enabled
    pub pressure: u32,
    /// The tilt value on the X axis, if enabled
    pub tilt_x: Option<i32>,
    /// The tilt value on the Y axis, if enabled
    pub tilt_y: Option<i32>,
    /// The rotation value, if enabled
    pub rotation: Option<u32>,
    /// Whether or not to bind pressure to contact
    pub bind_active: bool,
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct TouchInput {
    /// The X screen coordinate
    pub x: i32,
    /// The Y screen coordinate
    pub y: i32,
    /// The pressure value, if enabled
    pub pressure: u32,
    /// The orientation of the touch, if enabled
    pub orientation: Option<u32>,
    /// The contact area of the touch, if enabled.
    /// This is a rectangle with the X and Y coordinates as its center.
    pub contact_area: Option<Rectangle>,
    /// Whether or not to bind pressure to contact
    pub bind_active: bool,
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Rectangle {
    top: i32,
    bottom: i32,
    left: i32,
    right: i32,
}

#[bitflags]
#[repr(u32)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum PenProperties {
    TiltX = 4,
    TiltY = 8,
    Pressure = 1,
    Rotation = 2,
}

#[bitflags]
#[repr(u32)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum TouchProperties {
    Pressure = 4,
    ContactArea = 1,
    Orientation = 2,
}

impl Drop for SyntheticPointer {
    fn drop(&mut self) {
        unsafe { DestroySyntheticPointerDevice(self.synthetic_pointer_device) };
    }
}

#[derive(Debug, PartialEq, Copy, Clone)]
pub enum PointerType {
    /// Generic pointer. This never appears in messages or pointer data.
    /// Don't use this.
    Pointer,
    Touch(BitFlags<TouchProperties>),
    Pen(BitFlags<PenProperties>),
    Mouse,

    /// Windows 8.1 and later
    Touchpad,
}

impl PointerType {
    pub fn get_value(&self) -> i32 {
        match self {
            PointerType::Pointer => 1,
            PointerType::Touch(_) => 2,
            PointerType::Pen(_) => 3,
            PointerType::Mouse => 4,
            PointerType::Touchpad => 5,
        }
    }
}

#[derive(Error, Debug)]
pub enum SyntheticPointerError {
    #[error("The selected pointer type is invalid or not supported on the current OS version.")]
    InvalidPointerType,

    #[error("The number of pointers must be between 0 and {MAX_POINTERS}, but it was {count}.")]
    InvalidPointerCount { count: u32 },

    #[error("Failed to inject input.")]
    InputInjectionError(#[from] windows::core::Error),
}