Struct InputDevice 

pub struct InputDevice { /* private fields */ }

One open input device, with its own translation state.

Implementations

impl InputDevice

pub fn path(&self) -> &Path

Where the device node lives.

Examples found in repository

examples/input.rs (line 40)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::time::{Duration, Instant};

    use denise::{InputSource, Size};
    use denise_evdev::InputBackend;

    let seconds: u64 = std::env::args()
        .nth(1)
        .and_then(|a| a.parse().ok())
        .unwrap_or(5)
        .clamp(1, 120);

    // Pretend a panel, so absolute devices have something to map onto.
    let surface = Size::new(1280, 800);
    let mut input = InputBackend::open_all(surface)?;

    eprintln!("surface {}x{}", surface.width, surface.height);
    for device in input.devices() {
        let (ax, ay) = device.abs_ranges();
        let calibration = match (ax, ay) {
            (Some(x), Some(y)) => {
                format!("  abs x {}..{}, y {}..{}", x.min, x.max, y.min, y.max)
            }
            _ => String::new(),
        };
        eprintln!(
            "  {}: {} ({}){calibration}",
            device.capabilities(),
            device.name(),
            device.path().display()
        );
    }
    eprintln!("\nlistening for {seconds}s — move the mouse, type, click\n");

    let deadline = Instant::now() + Duration::from_secs(seconds);
    let mut events = Vec::new();
    let mut total = 0usize;

    while Instant::now() < deadline {
        events.clear();
        input.poll(&mut events);
        for event in &events {
            total += 1;
            eprintln!("  {event:?}");
        }
        if events.is_empty() {
            // A real loop waits on the descriptors instead. This is a probe.
            std::thread::sleep(Duration::from_millis(4));
        }
    }

    eprintln!("\n{total} events, pointer ended at {:?}", input.pointer());
    Ok(())
}

pub fn name(&self) -> &str

The device’s self-reported name.

Examples found in repository

examples/input.rs (line 39)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::time::{Duration, Instant};

    use denise::{InputSource, Size};
    use denise_evdev::InputBackend;

    let seconds: u64 = std::env::args()
        .nth(1)
        .and_then(|a| a.parse().ok())
        .unwrap_or(5)
        .clamp(1, 120);

    // Pretend a panel, so absolute devices have something to map onto.
    let surface = Size::new(1280, 800);
    let mut input = InputBackend::open_all(surface)?;

    eprintln!("surface {}x{}", surface.width, surface.height);
    for device in input.devices() {
        let (ax, ay) = device.abs_ranges();
        let calibration = match (ax, ay) {
            (Some(x), Some(y)) => {
                format!("  abs x {}..{}, y {}..{}", x.min, x.max, y.min, y.max)
            }
            _ => String::new(),
        };
        eprintln!(
            "  {}: {} ({}){calibration}",
            device.capabilities(),
            device.name(),
            device.path().display()
        );
    }
    eprintln!("\nlistening for {seconds}s — move the mouse, type, click\n");

    let deadline = Instant::now() + Duration::from_secs(seconds);
    let mut events = Vec::new();
    let mut total = 0usize;

    while Instant::now() < deadline {
        events.clear();
        input.poll(&mut events);
        for event in &events {
            total += 1;
            eprintln!("  {event:?}");
        }
        if events.is_empty() {
            // A real loop waits on the descriptors instead. This is a probe.
            std::thread::sleep(Duration::from_millis(4));
        }
    }

    eprintln!("\n{total} events, pointer ended at {:?}", input.pointer());
    Ok(())
}

examples/keys.rs (line 55)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::time::{Duration, Instant};

    use denise::{ElementState, InputEvent, InputSource, KeyCode, Modifiers, Size};
    use denise_evdev::{InputBackend, layout};

    let seconds: u64 = std::env::args()
        .nth(1)
        .and_then(|a| a.parse().ok())
        .unwrap_or(30)
        .clamp(1, 600);

    let mut input = InputBackend::open_all(Size::new(1280, 800))?;
    let (chosen, source) = match std::env::args().nth(2) {
        Some(name) => match layout::by_name(layout::normalise_name(&name)) {
            Some(layout) => {
                input.set_layout(layout);
                (layout, layout::LayoutSource::Denise)
            }
            None => {
                eprintln!("no layout called {name:?}; falling back to the system's");
                input.set_layout_from_system()
            }
        },
        None => input.set_layout_from_system(),
    };

    for device in input.devices() {
        eprintln!("input   {}: {}", device.capabilities(), device.name());
    }
    eprintln!(
        "keymap  {} (from {source})   (available: {})",
        chosen.name,
        layout::BUILT_IN
            .iter()
            .map(|l| l.name)
            .collect::<Vec<_>>()
            .join(", ")
    );
    eprintln!("\npress keys — Escape quits\n");

    let deadline = Instant::now() + Duration::from_secs(seconds);
    let mut events = Vec::new();
    let mut keys = 0u32;
    let mut characters = 0u32;
    let mut quit = false;

    while !quit && Instant::now() < deadline {
        events.clear();
        input.poll(&mut events);

        for event in &events {
            match event {
                InputEvent::Key {
                    code,
                    state: ElementState::Down,
                    modifiers,
                    repeat,
                } => {
                    keys += 1;
                    let mut held = String::new();
                    for (bit, name) in [
                        (Modifiers::SHIFT, "shift"),
                        (Modifiers::CTRL, "ctrl"),
                        (Modifiers::ALT, "alt"),
                        (Modifiers::SUPER, "super"),
                    ] {
                        if modifiers.contains(bit) {
                            held.push(' ');
                            held.push_str(name);
                        }
                    }
                    let repeat = if *repeat { " (repeat)" } else { "" };
                    eprintln!("key   {code:?}{held}{repeat}");
                    if *code == KeyCode::Escape {
                        quit = true;
                    }
                }
                InputEvent::Text { ch } => {
                    characters += 1;
                    eprintln!("  --> text {ch:?}  U+{:04X}", *ch as u32);
                }
                _ => {}
            }
        }
        std::thread::sleep(Duration::from_millis(8));
    }

    eprintln!("\n{keys} key presses produced {characters} characters");
    if keys > 0 && characters == 0 {
        eprintln!("nothing typed: either the keys pressed are not text keys, or");
        eprintln!("the layout above is not the one on the keyboard");
    }
    Ok(())
}

pub fn capabilities(&self) -> Capabilities

What the device can report.

Examples found in repository

examples/input.rs (line 38)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::time::{Duration, Instant};

    use denise::{InputSource, Size};
    use denise_evdev::InputBackend;

    let seconds: u64 = std::env::args()
        .nth(1)
        .and_then(|a| a.parse().ok())
        .unwrap_or(5)
        .clamp(1, 120);

    // Pretend a panel, so absolute devices have something to map onto.
    let surface = Size::new(1280, 800);
    let mut input = InputBackend::open_all(surface)?;

    eprintln!("surface {}x{}", surface.width, surface.height);
    for device in input.devices() {
        let (ax, ay) = device.abs_ranges();
        let calibration = match (ax, ay) {
            (Some(x), Some(y)) => {
                format!("  abs x {}..{}, y {}..{}", x.min, x.max, y.min, y.max)
            }
            _ => String::new(),
        };
        eprintln!(
            "  {}: {} ({}){calibration}",
            device.capabilities(),
            device.name(),
            device.path().display()
        );
    }
    eprintln!("\nlistening for {seconds}s — move the mouse, type, click\n");

    let deadline = Instant::now() + Duration::from_secs(seconds);
    let mut events = Vec::new();
    let mut total = 0usize;

    while Instant::now() < deadline {
        events.clear();
        input.poll(&mut events);
        for event in &events {
            total += 1;
            eprintln!("  {event:?}");
        }
        if events.is_empty() {
            // A real loop waits on the descriptors instead. This is a probe.
            std::thread::sleep(Duration::from_millis(4));
        }
    }

    eprintln!("\n{total} events, pointer ended at {:?}", input.pointer());
    Ok(())
}

examples/keys.rs (line 55)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::time::{Duration, Instant};

    use denise::{ElementState, InputEvent, InputSource, KeyCode, Modifiers, Size};
    use denise_evdev::{InputBackend, layout};

    let seconds: u64 = std::env::args()
        .nth(1)
        .and_then(|a| a.parse().ok())
        .unwrap_or(30)
        .clamp(1, 600);

    let mut input = InputBackend::open_all(Size::new(1280, 800))?;
    let (chosen, source) = match std::env::args().nth(2) {
        Some(name) => match layout::by_name(layout::normalise_name(&name)) {
            Some(layout) => {
                input.set_layout(layout);
                (layout, layout::LayoutSource::Denise)
            }
            None => {
                eprintln!("no layout called {name:?}; falling back to the system's");
                input.set_layout_from_system()
            }
        },
        None => input.set_layout_from_system(),
    };

    for device in input.devices() {
        eprintln!("input   {}: {}", device.capabilities(), device.name());
    }
    eprintln!(
        "keymap  {} (from {source})   (available: {})",
        chosen.name,
        layout::BUILT_IN
            .iter()
            .map(|l| l.name)
            .collect::<Vec<_>>()
            .join(", ")
    );
    eprintln!("\npress keys — Escape quits\n");

    let deadline = Instant::now() + Duration::from_secs(seconds);
    let mut events = Vec::new();
    let mut keys = 0u32;
    let mut characters = 0u32;
    let mut quit = false;

    while !quit && Instant::now() < deadline {
        events.clear();
        input.poll(&mut events);

        for event in &events {
            match event {
                InputEvent::Key {
                    code,
                    state: ElementState::Down,
                    modifiers,
                    repeat,
                } => {
                    keys += 1;
                    let mut held = String::new();
                    for (bit, name) in [
                        (Modifiers::SHIFT, "shift"),
                        (Modifiers::CTRL, "ctrl"),
                        (Modifiers::ALT, "alt"),
                        (Modifiers::SUPER, "super"),
                    ] {
                        if modifiers.contains(bit) {
                            held.push(' ');
                            held.push_str(name);
                        }
                    }
                    let repeat = if *repeat { " (repeat)" } else { "" };
                    eprintln!("key   {code:?}{held}{repeat}");
                    if *code == KeyCode::Escape {
                        quit = true;
                    }
                }
                InputEvent::Text { ch } => {
                    characters += 1;
                    eprintln!("  --> text {ch:?}  U+{:04X}", *ch as u32);
                }
                _ => {}
            }
        }
        std::thread::sleep(Duration::from_millis(8));
    }

    eprintln!("\n{keys} key presses produced {characters} characters");
    if keys > 0 && characters == 0 {
        eprintln!("nothing typed: either the keys pressed are not text keys, or");
        eprintln!("the layout above is not the one on the keyboard");
    }
    Ok(())
}

pub fn abs_ranges(&self) -> (Option<AbsAxis>, Option<AbsAxis>)

The absolute-axis calibration read from the device, as (x, y).

None for a relative device. An absolute device reporting None here would be unmappable, so this is worth looking at when a touchscreen lands in the wrong place.

Examples found in repository

examples/input.rs (line 29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::time::{Duration, Instant};

    use denise::{InputSource, Size};
    use denise_evdev::InputBackend;

    let seconds: u64 = std::env::args()
        .nth(1)
        .and_then(|a| a.parse().ok())
        .unwrap_or(5)
        .clamp(1, 120);

    // Pretend a panel, so absolute devices have something to map onto.
    let surface = Size::new(1280, 800);
    let mut input = InputBackend::open_all(surface)?;

    eprintln!("surface {}x{}", surface.width, surface.height);
    for device in input.devices() {
        let (ax, ay) = device.abs_ranges();
        let calibration = match (ax, ay) {
            (Some(x), Some(y)) => {
                format!("  abs x {}..{}, y {}..{}", x.min, x.max, y.min, y.max)
            }
            _ => String::new(),
        };
        eprintln!(
            "  {}: {} ({}){calibration}",
            device.capabilities(),
            device.name(),
            device.path().display()
        );
    }
    eprintln!("\nlistening for {seconds}s — move the mouse, type, click\n");

    let deadline = Instant::now() + Duration::from_secs(seconds);
    let mut events = Vec::new();
    let mut total = 0usize;

    while Instant::now() < deadline {
        events.clear();
        input.poll(&mut events);
        for event in &events {
            total += 1;
            eprintln!("  {event:?}");
        }
        if events.is_empty() {
            // A real loop waits on the descriptors instead. This is a probe.
            std::thread::sleep(Duration::from_millis(4));
        }
    }

    eprintln!("\n{total} events, pointer ended at {:?}", input.pointer());
    Ok(())
}

Trait Implementations

impl AsRawFd for InputDevice

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for InputDevice

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.