Struct I3EventListener

pub struct I3EventListener { /* private fields */ }

Abstraction over an ipc socket to i3. Handles events.

Implementations

impl I3EventListener

pub fn connect() -> Result<I3EventListener, EstablishError>

Establishes the IPC connection.

Examples found in repository

examples/event_printer.rs (line 10)

fn main() {
    let mut listener = I3EventListener::connect().expect("failed to connect");
    let subs = [
        Subscription::Workspace,
        Subscription::Output,
        Subscription::Mode,
        Subscription::Window,
        Subscription::BarConfig,
        Subscription::Binding,
    ];
    listener.subscribe(&subs).expect("failed to subscribe");
    for event in listener.listen() {
        println!("{:?}\n", event.expect("failed to get event"))
    }
}

examples/hovered_window.rs (line 10)

fn main() {
    let mut listener = I3EventListener::connect().expect("failed to connect");
    listener
        .subscribe(&[Subscription::Window])
        .expect("failed to subscribe");
    for event in listener.listen() {
        match event {
            Ok(Event::WindowEvent(w)) => {
                println!("{}", w.container.name.unwrap_or("unnamed".to_owned()))
            }
            Err(e) => println!("Error: {}", e),
            _ => unreachable!(),
        }
    }
}

pub fn subscribe( &mut self, events: &[Subscription], ) -> Result<Subscribe, MessageError>

Subscribes your connection to certain events.

Examples found in repository

examples/event_printer.rs (line 19)

fn main() {
    let mut listener = I3EventListener::connect().expect("failed to connect");
    let subs = [
        Subscription::Workspace,
        Subscription::Output,
        Subscription::Mode,
        Subscription::Window,
        Subscription::BarConfig,
        Subscription::Binding,
    ];
    listener.subscribe(&subs).expect("failed to subscribe");
    for event in listener.listen() {
        println!("{:?}\n", event.expect("failed to get event"))
    }
}

examples/hovered_window.rs (line 12)

fn main() {
    let mut listener = I3EventListener::connect().expect("failed to connect");
    listener
        .subscribe(&[Subscription::Window])
        .expect("failed to subscribe");
    for event in listener.listen() {
        match event {
            Ok(Event::WindowEvent(w)) => {
                println!("{}", w.container.name.unwrap_or("unnamed".to_owned()))
            }
            Err(e) => println!("Error: {}", e),
            _ => unreachable!(),
        }
    }
}

pub fn listen(&mut self) -> EventIterator<'_>

Iterate over subscribed events forever.

Examples found in repository

examples/event_printer.rs (line 20)

fn main() {
    let mut listener = I3EventListener::connect().expect("failed to connect");
    let subs = [
        Subscription::Workspace,
        Subscription::Output,
        Subscription::Mode,
        Subscription::Window,
        Subscription::BarConfig,
        Subscription::Binding,
    ];
    listener.subscribe(&subs).expect("failed to subscribe");
    for event in listener.listen() {
        println!("{:?}\n", event.expect("failed to get event"))
    }
}

examples/hovered_window.rs (line 14)

fn main() {
    let mut listener = I3EventListener::connect().expect("failed to connect");
    listener
        .subscribe(&[Subscription::Window])
        .expect("failed to subscribe");
    for event in listener.listen() {
        match event {
            Ok(Event::WindowEvent(w)) => {
                println!("{}", w.container.name.unwrap_or("unnamed".to_owned()))
            }
            Err(e) => println!("Error: {}", e),
            _ => unreachable!(),
        }
    }
}

Trait Implementations

impl Debug for I3EventListener

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

Formats the value using the given formatter.