Struct libseat::Seat

source ·

pub struct Seat { /* private fields */ }

Implementations§

source §

impl Seat

source

pub fn open<C>(callback: C) -> Result<Self, Errno>where C: FnMut(&mut SeatRef, SeatEvent) + 'static,

Opens a seat, taking control of it if possible and returning a pointer to the libseat instance. If LIBSEAT_BACKEND is set, the specified backend is used. Otherwise, the first successful backend will be used.

Examples found in repository ?

examples/simple.rs (lines 10-23)

fn main() {
    let active = Rc::new(RefCell::new(false));

    let seat = {
        let active = active.clone();
        Seat::open(move |seat, event| match event {
            SeatEvent::Enable => {
                println!("Enable");
                println!("Name: {}", seat.name());

                *active.borrow_mut() = true;
            }
            SeatEvent::Disable => {
                println!("Disable");

                *active.borrow_mut() = false;
                seat.disable().unwrap();
            }
        })
    };

    if let Ok(mut seat) = seat {
        while !(*active.borrow()) {
            println!("waiting for activation...n");
            seat.dispatch(-1).unwrap();
        }

        // Close seat
        drop(seat);
    }
}

Methods from Deref<Target = SeatRef>§

source

pub fn disable(&mut self) -> Result<(), Errno>

Disables a seat, used in response to a disable_seat event. After disabling the seat, the seat devices must not be used until enable_seat is received, and all requests on the seat will fail during this period.

Examples found in repository ?

examples/simple.rs (line 21)

fn main() {
    let active = Rc::new(RefCell::new(false));

    let seat = {
        let active = active.clone();
        Seat::open(move |seat, event| match event {
            SeatEvent::Enable => {
                println!("Enable");
                println!("Name: {}", seat.name());

                *active.borrow_mut() = true;
            }
            SeatEvent::Disable => {
                println!("Disable");

                *active.borrow_mut() = false;
                seat.disable().unwrap();
            }
        })
    };

    if let Ok(mut seat) = seat {
        while !(*active.borrow()) {
            println!("waiting for activation...n");
            seat.dispatch(-1).unwrap();
        }

        // Close seat
        drop(seat);
    }
}

source

pub fn open_device<P: AsRef<Path>>(&mut self, path: &P) -> Result<Device, Errno>

Opens a device on the seat, returning its device ID and fd

This will only succeed if the seat is active and the device is of a type permitted for opening on the backend, such as drm and evdev.

The device may be revoked in some situations, such as in situations where a seat session switch is being forced.

source

pub fn close_device(&mut self, device: Device) -> Result<(), Errno>

Closes a device that has been opened on the seat using the device_id from libseat_open_device.

source

pub fn name(&mut self) -> &str

Retrieves the name of the seat that is currently made available through the provided libseat instance.

Examples found in repository ?

examples/simple.rs (line 13)

fn main() {
    let active = Rc::new(RefCell::new(false));

    let seat = {
        let active = active.clone();
        Seat::open(move |seat, event| match event {
            SeatEvent::Enable => {
                println!("Enable");
                println!("Name: {}", seat.name());

                *active.borrow_mut() = true;
            }
            SeatEvent::Disable => {
                println!("Disable");

                *active.borrow_mut() = false;
                seat.disable().unwrap();
            }
        })
    };

    if let Ok(mut seat) = seat {
        while !(*active.borrow()) {
            println!("waiting for activation...n");
            seat.dispatch(-1).unwrap();
        }

        // Close seat
        drop(seat);
    }
}

source

pub fn switch_session(&mut self, session: i32) -> Result<(), Errno>

Requests that the seat switches session to the specified session number. For seats that are VT-bound, the session number matches the VT number, and switching session results in a VT switch.

A call to libseat_switch_session does not imply that a switch will occur, and the caller should assume that the session continues unaffected.

source

pub fn get_fd(&mut self) -> Result<BorrowedFd<'_>, Errno>

Retrieve the pollable connection fd for a given libseat instance. Used to poll the libseat connection for events that need to be dispatched.

Returns a pollable fd on success.

source

pub fn dispatch(&mut self, timeout: i32) -> Result<i32, Errno>

Reads and dispatches events on the libseat connection fd.

The specified timeout dictates how long libseat might wait for data if none is available: 0 means that no wait will occur, -1 means that libseat might wait indefinitely for data to arrive, while > 0 is the maximum wait in milliseconds that might occur.

Returns a positive number signifying processed internal messages on success. Returns 0 if no messages were processed. Returns -1 and sets errno on error.

Examples found in repository ?

examples/simple.rs (line 29)

fn main() {
    let active = Rc::new(RefCell::new(false));

    let seat = {
        let active = active.clone();
        Seat::open(move |seat, event| match event {
            SeatEvent::Enable => {
                println!("Enable");
                println!("Name: {}", seat.name());

                *active.borrow_mut() = true;
            }
            SeatEvent::Disable => {
                println!("Disable");

                *active.borrow_mut() = false;
                seat.disable().unwrap();
            }
        })
    };

    if let Ok(mut seat) = seat {
        while !(*active.borrow()) {
            println!("waiting for activation...n");
            seat.dispatch(-1).unwrap();
        }

        // Close seat
        drop(seat);
    }
}