Struct Libwayland 

pub struct Libwayland { /* private fields */ }

A reference to the libwayland-client.so dynamic library.

You can obtain a reference by calling Self::open.

Implementations

impl Libwayland

pub fn connect_to_default_display(&'static self) -> Result<Connection>

Connects to the default display.

The default display is usually identified by the WAYLAND_DISPLAY environment variable but falls back to wayland-0 if the environment variable is not set.

Example

let lib = Libwayland::open().unwrap();
let _con = lib.connect_to_default_display().unwrap();

Examples found in repository

examples/get-registry/main.rs (line 12)

fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_queue(c"get-registry");

    let (_, snapshot) = get_registry_snapshot(&queue);
    println!("{:#?}", snapshot);
}

examples/async-wait/main.rs (line 12)

async fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"async-wait");

    create_sync(&queue, 1);

    loop {
        queue.wait_for_events().await.unwrap();
        queue.dispatch_pending().unwrap();
    }
}

examples/simple-window/main.rs (line 8)

fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"simple-window");
    let singletons = get_singletons(&queue.display());
    let simple_window = simple_window::prepare(singletons);
    while !simple_window.exit.get() {
        queue.dispatch_blocking().unwrap();
    }
}

examples/async-window/main.rs (line 11)

async fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"async-window");
    let singletons = get_singletons_async(&queue.display()).await;
    let simple_window = simple_window::prepare(singletons);
    while !simple_window.exit.get() {
        queue.dispatch_async().await.unwrap();
    }
}

examples/keyboard-events/main.rs (line 28)

fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"keyboard-events");
    let singletons = get_singletons(&queue.display());
    let simple_window = simple_window::prepare(singletons);

    let wl_registry = queue.display::<WlDisplay>().get_registry();
    proxy::set_event_handler_local(
        &wl_registry,
        RegistryEventHandler {
            wl_registry: wl_registry.clone(),
            seats: Default::default(),
        },
    );

    while !simple_window.exit.get() {
        queue.dispatch_blocking().unwrap();
    }
}

examples/async-roundtrip/main.rs (line 13)

async fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"async-roundtrip");
    let registry = queue.display::<WlDisplay>().get_registry();
    let num_globals = Cell::new(0);
    queue
        .dispatch_scope_async(async |scope| {
            scope.set_event_handler_local(
                &registry,
                WlRegistry::on_global(|_, _, _, _| {
                    num_globals.set(num_globals.get() + 1);
                }),
            );
            // This function can be used to perform an async roundtrip. It is
            // compatible with any async runtime. This example also demonstrates
            // that this works in combination with scoped event handlers.
            queue.dispatch_roundtrip_async().await.unwrap();
        })
        .await;
    println!("number of globals: {}", num_globals.get());
}

Additional examples can be found in:

• examples/get-registry-with-data/main.rs
• examples/poll-integration/main.rs
• examples/hello-wayland/main.rs
• examples/async-window/../common/simple_window.rs

pub fn connect_to_named_display( &'static self, display: &CStr, ) -> Result<Connection>

Connects to a display with a given name.

The name of the display should usually be of the form wayland-N or it should be the absolute path of a display socket.

Example

let lib = Libwayland::open().unwrap();
let _con = lib.connect_to_named_display(c"wayland-1").unwrap();

pub fn connect_to_fd(&'static self, fd: OwnedFd) -> Result<Connection>

Consumes an existing socket connected to a wayland compositor.

Unlike Libwayland::connect_to_default_display, this function does not perform any blocking IO.

pub unsafe fn wrap_owned_pointer( &'static self, wl_display: NonNull<wl_display>, ) -> Result<Connection>

Takes ownership of an existing wl_display.

If the display is owned when the last clone of the Connection is dropped, the display will be destroyed. All proxies and queues created from the Connection will contain a clone of the connection to keep the connection alive.

For proxies and queues that already exist at the time this function is called, you must manage the lifetime requirements manually.

Safety

• wl_display must be valid and must stay valid for the lifetime of this object and its clones.
• The display file descriptor must be open and owned by the wl_display.
• If the display is owned by the time the connection is dropped, all proxies and queues created from this object must have been destroyed before then.

Example

let lib = Libwayland::open().unwrap();
let wl_display = {
    let con = lib.connect_to_default_display().unwrap();
    con.take_ownership().unwrap()
};
// SAFETY: We took the display from a freshly created Connection so it is valid
//         and has no queues or proxies attached.
let _con = unsafe { lib.wrap_owned_pointer(wl_display) };

pub unsafe fn wrap_borrowed_pointer( &'static self, wl_display: NonNull<wl_display>, ) -> Result<Connection>

Borrows an existing wl_display.

Safety

• wl_display must be valid and must stay valid for the lifetime of this object and its clones.
• The display file descriptor must be open and owned by the wl_display.

Example

let lib = Libwayland::open().unwrap();
let con = lib.connect_to_default_display().unwrap();
let wl_display = con.wl_display();
{
    // SAFETY: - We took the display from a freshly created Connection so it is valid.
    //         - We drop the connection before dropping the outer connection that
    //           owns the wl_display.
    let _con = unsafe { lib.wrap_borrowed_pointer(wl_display) };
}

impl Libwayland

pub fn open() -> Result<&'static Self>

Obtains a reference to libwayland-client.so.

Examples found in repository

examples/get-registry/main.rs (line 11)

fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_queue(c"get-registry");

    let (_, snapshot) = get_registry_snapshot(&queue);
    println!("{:#?}", snapshot);
}

examples/async-wait/main.rs (line 11)

async fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"async-wait");

    create_sync(&queue, 1);

    loop {
        queue.wait_for_events().await.unwrap();
        queue.dispatch_pending().unwrap();
    }
}

examples/simple-window/main.rs (line 7)

fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"simple-window");
    let singletons = get_singletons(&queue.display());
    let simple_window = simple_window::prepare(singletons);
    while !simple_window.exit.get() {
        queue.dispatch_blocking().unwrap();
    }
}

examples/async-window/main.rs (line 10)

async fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"async-window");
    let singletons = get_singletons_async(&queue.display()).await;
    let simple_window = simple_window::prepare(singletons);
    while !simple_window.exit.get() {
        queue.dispatch_async().await.unwrap();
    }
}

examples/keyboard-events/main.rs (line 27)

fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"keyboard-events");
    let singletons = get_singletons(&queue.display());
    let simple_window = simple_window::prepare(singletons);

    let wl_registry = queue.display::<WlDisplay>().get_registry();
    proxy::set_event_handler_local(
        &wl_registry,
        RegistryEventHandler {
            wl_registry: wl_registry.clone(),
            seats: Default::default(),
        },
    );

    while !simple_window.exit.get() {
        queue.dispatch_blocking().unwrap();
    }
}

examples/async-roundtrip/main.rs (line 12)

async fn main() {
    let lib = Libwayland::open().unwrap();
    let con = lib.connect_to_default_display().unwrap();
    let queue = con.create_local_queue(c"async-roundtrip");
    let registry = queue.display::<WlDisplay>().get_registry();
    let num_globals = Cell::new(0);
    queue
        .dispatch_scope_async(async |scope| {
            scope.set_event_handler_local(
                &registry,
                WlRegistry::on_global(|_, _, _, _| {
                    num_globals.set(num_globals.get() + 1);
                }),
            );
            // This function can be used to perform an async roundtrip. It is
            // compatible with any async runtime. This example also demonstrates
            // that this works in combination with scoped event handlers.
            queue.dispatch_roundtrip_async().await.unwrap();
        })
        .await;
    println!("number of globals: {}", num_globals.get());
}

Additional examples can be found in:

• examples/get-registry-with-data/main.rs
• examples/poll-integration/main.rs
• examples/hello-wayland/main.rs
• examples/async-window/../common/simple_window.rs