LayerShellEv

https://docs.rs/layershellev/0.18.1
Admin
LayerShellEv is a Rust library that handles Wayland layer shell surfaces in a winit-compatible way,...
Tokens:239,799
Snippets:2,412
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Minimal Example: Initialize and Run WindowState

Source: https://docs.rs/layershellev/0.18.1/src/layershellev/lib.rs.html

This example demonstrates the basic setup for creating a Wayland layer shell window. It shows how to initialize `WindowState` with various configurations like size, layer, margins, and keyboard interactivity, and then enters a running loop to handle events.

```rust
use std::fs::File;
use std::os::fd::AsFd;

use layershellev::keyboard::{KeyCode, PhysicalKey};
use layershellev::reexport::*;
use layershellev::*;

fn main() {
    let mut ev: WindowState<()> = WindowState::new("Hello")
        .with_allscreens()
        .with_size((0, 400))
        .with_layer(Layer::Top)
        .with_margin((20, 20, 100, 20))
        .with_anchor(Anchor::Bottom | Anchor::Left | Anchor::Right)
        .with_keyboard_interacivity(KeyboardInteractivity::Exclusive)
        .with_exclusive_zone(-1)
        .build()
        .unwrap();

    ev.running(|event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerShellEvent::InitRequest => ReturnData::RequestBind,
            LayerShellEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                let virtual_keyboard_manager = globals
                        .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                            qh,
                            1..=1,
                            (),
                        )
                        .unwrap();
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::None
            }
            LayerShellEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerShellEvent::RequestBuffer(file, shm, qh, init_w, init_h) => {
                draw(file, (init_w, init_h));
                let pool = shm.create_pool(file.as_fd(), (init_w * init_h * 4) as i32, qh, ());
                ReturnData::WlBuffer(pool.create_buffer(
                    0,
                    init_w as i32,
                    init_h as i32,
                    (init_w * 4) as i32,
                    wl_shm::Format::Argb8888,
                    qh,
                    (),
                ))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::RequestRefresh { width, height, .. }) => {
                println!("{width}, {height}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => ReturnData::None,
            LayerShellEvent::RequestMessages(DispatchMessage::MouseEnter {
                pointer, ..
            }) => ReturnData::RequestSetCursorShape((
                "crosshair".to_owned(),
                pointer.clone(),
            )),
            LayerShellEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{time}, {surface_x}, {surface_y}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
               if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                   ReturnData::RequestExit
               } else {
                   ReturnData::None
               }
           }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}

fn draw(tmp: &mut File, (buf_x, buf_y): (u32, u32)) {
    use std::{cmp::min, io::Write};
    let mut buf = std::io::BufWriter::new(tmp);
    for y in 0..buf_y {
        for x in 0..buf_x {
            let a = 0xFF;
            let r = min(((buf_x - x) * 0xFF) / buf_x, ((buf_y - y) * 0xFF) / buf_y);
            let g = min((x * 0xFF) / buf_x, ((buf_y - y) * 0xFF) / buf_y);
            let b = min(((buf_x - x) * 0xFF) / buf_x, (y * 0xFF) / buf_y);

            let color = (a << 24) + (r << 16) + (g << 8) + b;
            buf.write_all(&color.to_ne_bytes()).unwrap();
        }
    }
    buf.flush().unwrap();
}

```

--------------------------------

### Example Calling a Crate Function

Source: https://docs.rs/layershellev/0.18.1/scrape-examples-help.html

Shows an example in `examples/ex.rs` that calls a documented public function from a crate. This example will be scraped and included in the documentation.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### WindowState::with_start_mode

Source: https://docs.rs/layershellev/0.18.1/src/layershellev/lib.rs.html

Sets the start mode for the window.

```APIDOC
## WindowState::with_start_mode

### Description
Sets the start mode for the window.

### Signature
```rust
pub fn with_start_mode(mut self, mode: StartMode) -> Self
```

### Parameters
* **mode** (StartMode) - The desired start mode for the window.
```

--------------------------------

### Example: SimpleLayer Application with WlShm

Source: https://docs.rs/layershellev/0.18.1/layershellev/reexport/wl_shm/struct.WlShm.html

This example demonstrates a complete Wayland application using WlShm for buffer creation. It covers window initialization, event handling for various Wayland events like InitRequest, BindProvide, CompositorProvide, and RequestBuffer, and shows how to create a shared memory pool and buffer.

```rust
fn main() {
    let ev: WindowState<()> = WindowState::new("Hello")
        .with_allscreens()
        .with_size((0, 400))
        .with_layer(Layer::Top)
        .with_margin((20, 20, 100, 20))
        .with_anchor(Anchor::Bottom | Anchor::Left | Anchor::Right)
        .with_keyboard_interacivity(KeyboardInteractivity::Exclusive)
        .with_exclusive_zone(-1)
        .build()
        .unwrap();

    ev.running(move |event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerShellEvent::InitRequest => ReturnData::RequestBind,
            LayerShellEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                let virtual_keyboard_manager = globals
                    .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                        qh,
                        1..=1,
                        (),
                    )
                    .unwrap();
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::RequestCompositor
            }
            LayerShellEvent::CompositorProvide(compositor, qh) => {
                // NOTE: you can set input region to limit area which gets input events
                // surface outside region becomes transparent for input events
                // To ignore all input events use region with (0,0) size
                for x in ev.get_unit_iter() {
                    let region = compositor.create_region(qh, ());
                    region.add(0, 0, 0, 0);
                    x.get_wlsurface().set_input_region(Some(&region));
                }
                ReturnData::None
            }
            LayerShellEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerShellEvent::RequestBuffer(file, shm, qh, init_w, init_h) => {
                draw(file, (init_w, init_h));
                let pool = shm.create_pool(file.as_fd(), (init_w * init_h * 4) as i32, qh, ());
                ReturnData::WlBuffer(pool.create_buffer(
                    0,
                    init_w as i32,
                    init_h as i32,
                    (init_w * 4) as i32,
                    wl_shm::Format::Argb8888,
                    qh,
                    (),
                ))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::RequestRefresh {
                width,
                height,
                .. 
            }) => {
                println!("{{width}}, {{height}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => {
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseEnter { pointer, .. }) => {
                ReturnData::RequestSetCursorShape(("crosshair".to_owned(), pointer.clone()))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{{time}}, {{surface_x}}, {{surface_y}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
                if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                    ReturnData::RequestExit
                } else {
                    ReturnData::None
                }
            }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}
```

--------------------------------

### Simple Wayland Layer Application Example

Source: https://docs.rs/layershellev/0.18.1/layershellev/reexport/wayland_client/struct.WlCompositor.html

This example demonstrates a basic Wayland layer application using the layershellev library. It covers window creation, event handling, binding to Wayland globals, setting input regions, and requesting buffers for drawing. The application exits when the Escape key is pressed.

```rust
fn main() {
    let ev: WindowState<()> = WindowState::new("Hello")
        .with_allscreens()
        .with_size((0, 400))
        .with_layer(Layer::Top)
        .with_margin((20, 20, 100, 20))
        .with_anchor(Anchor::Bottom | Anchor::Left | Anchor::Right)
        .with_keyboard_interacivity(KeyboardInteractivity::Exclusive)
        .with_exclusive_zone(-1)
        .build()
        .unwrap();

    ev.running(move |event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerShellEvent::InitRequest => ReturnData::RequestBind,
            LayerShellEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                let virtual_keyboard_manager = globals
                    .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                        qh,
                        1..=1,
                        (),
                    )
                    .unwrap();
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::RequestCompositor
            }
            LayerShellEvent::CompositorProvide(compositor, qh) => {
                // NOTE: you can set input region to limit area which gets input events
                // surface outside region becomes transparent for input events
                // To ignore all input events use region with (0,0) size
                for x in ev.get_unit_iter() {
                    let region = compositor.create_region(qh, ());
                    region.add(0, 0, 0, 0);
                    x.get_wlsurface().set_input_region(Some(&region));
                }
                ReturnData::None
            }
            LayerShellEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerShellEvent::RequestBuffer(file, shm, qh, init_w, init_h) => {
                draw(file, (init_w, init_h));
                let pool = shm.create_pool(file.as_fd(), (init_w * init_h * 4) as i32, qh, ());
                ReturnData::WlBuffer(pool.create_buffer(
                    0,
                    init_w as i32,
                    init_h as i32,
                    (init_w * 4) as i32,
                    wl_shm::Format::Argb8888,
                    qh,
                    (),
                ))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::RequestRefresh {
                width,
                height,
                .. 
            }) => {
                println!("{{width}}, {{height}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => {
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseEnter { pointer, .. }) => {
                ReturnData::RequestSetCursorShape(("crosshair".to_owned(), pointer.clone()))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{{time}}, {{surface_x}}, {{surface_y}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
                if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                    ReturnData::RequestExit
                } else {
                    ReturnData::None
                }
            }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}

```

--------------------------------

### Get Keyboards from WindowState

Source: https://docs.rs/layershellev/0.18.1/layershellev/struct.WindowState.html

Returns a vector of all WlKeyboard devices managed by the WindowState. Use this to get a list of available keyboards.

```rust
pub fn get_keyboards(&self) -> Vec<WlKeyboard>
```

--------------------------------

### Get all WlPointer devices

Source: https://docs.rs/layershellev/0.18.1/src/layershellev/seat.rs.html

Collects and returns all WlPointer devices managed by the window state. This is useful for iterating over all available pointers.

```rust
pub fn get_pointers(&self) -> Vec<WlPointer> {
        self.seats
            .values()
            .flat_map(|seat| &seat.pointer)
            .cloned()
            .collect()
    }
```

--------------------------------

### Basic Window Setup and Event Handling

Source: https://docs.rs/layershellev/0.18.1/layershellev/reexport/wayland_client/struct.GlobalList.html

Demonstrates setting up a basic window with various properties and handling Wayland events. This includes initialization, binding Wayland objects, setting input regions, and responding to different event types like buffer requests and mouse/keyboard inputs.

```rust
fn main() {
    let ev: WindowState<()> = WindowState::new("Hello")
        .with_allscreens()
        .with_size((0, 400))
        .with_layer(Layer::Top)
        .with_margin((20, 20, 100, 20))
        .with_anchor(Anchor::Bottom | Anchor::Left | Anchor::Right)
        .with_keyboard_interacivity(KeyboardInteractivity::Exclusive)
        .with_exclusive_zone(-1)
        .build()
        .unwrap();

    ev.running(move |event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerShellEvent::InitRequest => ReturnData::RequestBind,
            LayerShellEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                let virtual_keyboard_manager = globals
                    .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                        qh,
                        1..=1,
                        (),
                    )
                    .unwrap();
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::RequestCompositor
            }
            LayerShellEvent::CompositorProvide(compositor, qh) => {
                // NOTE: you can set input region to limit area which gets input events
                // surface outside region becomes transparent for input events
                // To ignore all input events use region with (0,0) size
                for x in ev.get_unit_iter() {
                    let region = compositor.create_region(qh, ());
                    region.add(0, 0, 0, 0);
                    x.get_wlsurface().set_input_region(Some(&region));
                }
                ReturnData::None
            }
            LayerShellEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerShellEvent::RequestBuffer(file, shm, qh, init_w, init_h) => {
                draw(file, (init_w, init_h));
                let pool = shm.create_pool(file.as_fd(), (init_w * init_h * 4) as i32, qh, ());
                ReturnData::WlBuffer(pool.create_buffer(
                    0,
                    init_w as i32,
                    init_h as i32,
                    (init_w * 4) as i32,
                    wl_shm::Format::Argb8888,
                    qh,
                    (),
                ))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::RequestRefresh {
                width,
                height,
                ..
            }) => {
                println!("{{width}}, {{height}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => {
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseEnter { pointer, .. }) => {
                ReturnData::RequestSetCursorShape(("crosshair".to_owned(), pointer.clone()))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{{time}}, {{surface_x}}, {{surface_y}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
                if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                    ReturnData::RequestExit
                } else {
                    ReturnData::None
                }
            }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}

```

--------------------------------

### Initialize and Run SimpleLayer Window

Source: https://docs.rs/layershellev/0.18.1/src/simplelayer/simplelayer.rs.html

Sets up a new window with specified properties, including size, layer, margins, and keyboard interactivity. It then enters a running loop to handle various LayerShell events.

```rust
use std::fs::File;
use std::os::fd::AsFd;

use layershellev::keyboard::{KeyCode, PhysicalKey};
use layershellev::reexport::*
use layershellev::*;

fn main() {
    let ev: WindowState<()> = WindowState::new("Hello")
        .with_allscreens()
        .with_size((0, 400))
        .with_layer(Layer::Top)
        .with_margin((20, 20, 100, 20))
        .with_anchor(Anchor::Bottom | Anchor::Left | Anchor::Right)
        .with_keyboard_interacivity(KeyboardInteractivity::Exclusive)
        .with_exclusive_zone(-1)
        .build()
        .unwrap();

    ev.running(move |event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerShellEvent::InitRequest => ReturnData::RequestBind,
            LayerShellEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                let virtual_keyboard_manager = globals
                    .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                        qh,
                        1..=1,
                        (),
                    )
                    .unwrap();
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::RequestCompositor
            }
            LayerShellEvent::CompositorProvide(compositor, qh) => {
                // NOTE: you can set input region to limit area which gets input events
                // surface outside region becomes transparent for input events
                // To ignore all input events use region with (0,0) size
                for x in ev.get_unit_iter() {
                    let region = compositor.create_region(qh, ());
                    region.add(0, 0, 0, 0);
                    x.get_wlsurface().set_input_region(Some(&region));
                }
                ReturnData::None
            }
            LayerShellEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerShellEvent::RequestBuffer(file, shm, qh, init_w, init_h) => {
                draw(file, (init_w, init_h));
                let pool = shm.create_pool(file.as_fd(), (init_w * init_h * 4) as i32, qh, ());
                ReturnData::WlBuffer(pool.create_buffer(
                    0,
                    init_w as i32,
                    init_h as i32,
                    (init_w * 4) as i32,
                    wl_shm::Format::Argb8888,
                    qh,
                    (),
                ))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::RequestRefresh {
                width,
                height,
                .. 
            }) => {
                println!("{{width}}, {{height}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => {
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseEnter { pointer, .. }) => {
                ReturnData::RequestSetCursorShape(("crosshair".to_owned(), pointer.clone()))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{{time}}, {{surface_x}}, {{surface_y}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
                if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                    ReturnData::RequestExit
                } else {
                    ReturnData::None
                }
            }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}

```

--------------------------------

### Get Type ID

Source: https://docs.rs/layershellev/0.18.1/layershellev/dpi/enum.Position.html

Gets the TypeId of the current type. This is a blanket implementation for Any.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Initialize and Run WindowStateSimple

Source: https://docs.rs/layershellev/0.18.1/layershellev/type.WindowStateSimple.html

Demonstrates the initialization of a WindowStateSimple with various configurations like screen, size, layer, margin, anchor, and keyboard interactivity. It also shows the event loop for handling window events.

```rust
fn main() {
    let ev: WindowState<()> = WindowState::new("Hello")
        .with_allscreens()
        .with_size((0, 400))
        .with_layer(Layer::Top)
        .with_margin((20, 20, 100, 20))
        .with_anchor(Anchor::Bottom | Anchor::Left | Anchor::Right)
        .with_keyboard_interacivity(KeyboardInteractivity::Exclusive)
        .with_exclusive_zone(-1)
        .build()
        .unwrap();

    ev.running(move |event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerShellEvent::InitRequest => ReturnData::RequestBind,
            LayerShellEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                let virtual_keyboard_manager = globals
                    .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                        qh,
                        1..=1,
                        (),
                    )
                    .unwrap();
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::RequestCompositor
            }
            LayerShellEvent::CompositorProvide(compositor, qh) => {
                // NOTE: you can set input region to limit area which gets input events
                // surface outside region becomes transparent for input events
                // To ignore all input events use region with (0,0) size
                for x in ev.get_unit_iter() {
                    let region = compositor.create_region(qh, ());
                    region.add(0, 0, 0, 0);
                    x.get_wlsurface().set_input_region(Some(&region));
                }
                ReturnData::None
            }
            LayerShellEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerShellEvent::RequestBuffer(file, shm, qh, init_w, init_h) => {
                draw(file, (init_w, init_h));
                let pool = shm.create_pool(file.as_fd(), (init_w * init_h * 4) as i32, qh, ());
                ReturnData::WlBuffer(pool.create_buffer(
                    0,
                    init_w as i32,
                    init_h as i32,
                    (init_w * 4) as i32,
                    wl_shm::Format::Argb8888,
                    qh,
                    (),
                ))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::RequestRefresh {
                width,
                height,
                .. 
            }) => {
                println!("{{}}, {{}}", width, height);
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => {
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseEnter { pointer, .. }) => {
                ReturnData::RequestSetCursorShape(("crosshair".to_owned(), pointer.clone()))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{{}}, {{}}, {{}}", time, surface_x, surface_y);
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
                if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                    ReturnData::RequestExit
                } else {
                    ReturnData::None
                }
            }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}

```

--------------------------------

### Get Pointers from WindowState

Source: https://docs.rs/layershellev/0.18.1/layershellev/struct.WindowState.html

Returns a vector of all WlPointer devices managed by the WindowState. Use this to get a list of available pointers.

```rust
pub fn get_pointers(&self) -> Vec<WlPointer>
```

--------------------------------

### Get all WlKeyboard devices

Source: https://docs.rs/layershellev/0.18.1/src/layershellev/seat.rs.html

Collects and returns all WlKeyboard devices currently managed by the window state across all seats. This is useful for iterating over all available keyboards.

```rust
pub fn get_keyboards(&self) -> Vec<WlKeyboard> {
        self.seats
            .values()
            .flat_map(|seat| &seat.keyboard_state)
            .map(|keyboard_state| &keyboard_state.keyboard)
            .cloned()
            .collect()
    }
```

--------------------------------

### Constructor: new

Source: https://docs.rs/layershellev/0.18.1/layershellev/dpi/struct.LogicalSize.html

Creates a new LogicalSize instance with the specified width and height.

```APIDOC
## impl<P> LogicalSize<P>

### pub const fn new(width: P, height: P) -> Self

Creates a new LogicalSize instance with the specified width and height.
```

--------------------------------

### XkbContext::new

Source: https://docs.rs/layershellev/0.18.1/layershellev/xkb_keyboard/struct.XkbContext.html

Creates a new XkbContext. This is the primary way to instantiate an XkbContext.

```APIDOC
## pub fn new() -> Result<XkbContext, Error>

### Description
Creates a new XkbContext.

### Returns
A `Result` containing a new `XkbContext` on success, or an `Error` on failure.
```

--------------------------------

### Get Touchers from WindowState

Source: https://docs.rs/layershellev/0.18.1/layershellev/struct.WindowState.html

Returns a vector of all WlTouch devices managed by the WindowState. Use this to get a list of available touch devices.

```rust
pub fn get_touchers(&self) -> Vec<WlTouch>
```

--------------------------------

### Initialize and Run WindowState

Source: https://docs.rs/layershellev/0.18.1/index.html

This example demonstrates how to initialize a WindowState for a layer shell surface, configure its properties like size, layer, margins, and interactivity, and then run its event loop. It handles various LayerShellEvents including initialization requests, binding Wayland objects, XDG output changes, buffer requests, and message dispatching for input events like mouse and keyboard.

```rust
use std::fs::File;
use std::os::fd::AsFd;

use layershellev::keyboard::{KeyCode, PhysicalKey};
use layershellev::reexport::*
use layershellev::*;

fn main() {
    let mut ev: WindowState<()> = WindowState::new("Hello")
        .with_allscreens()
        .with_size((0, 400))
        .with_layer(Layer::Top)
        .with_margin((20, 20, 100, 20))
        .with_anchor(Anchor::Bottom | Anchor::Left | Anchor::Right)
        .with_keyboard_interacivity(KeyboardInteractivity::Exclusive)
        .with_exclusive_zone(-1)
        .build()
        .unwrap();

    ev.running(|event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerShellEvent::InitRequest => ReturnData::RequestBind,
            LayerShellEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                let virtual_keyboard_manager = globals
                        .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                            qh,
                            1..=1,
                            (),
                        )
                        .unwrap();
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::None
            }
            LayerShellEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerShellEvent::RequestBuffer(file, shm, qh, init_w, init_h) => {
                draw(file, (init_w, init_h));
                let pool = shm.create_pool(file.as_fd(), (init_w * init_h * 4) as i32, qh, ());
                ReturnData::WlBuffer(pool.create_buffer(
                    0,
                    init_w as i32,
                    init_h as i32,
                    (init_w * 4) as i32,
                    wl_shm::Format::Argb8888,
                    qh,
                    (),
                ))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::RequestRefresh { width, height, .. }) => {
                println!("{width}, {height}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => ReturnData::None,
            LayerShellEvent::RequestMessages(DispatchMessage::MouseEnter {
                pointer, ..
            }) => ReturnData::RequestSetCursorShape((
                "crosshair".to_owned(),
                pointer.clone(),
            )),
            LayerShellEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{time}, {surface_x}, {surface_y}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
               if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                   ReturnData::RequestExit
               } else {
                   ReturnData::None
               }
           }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}

fn draw(tmp: &mut File, (buf_x, buf_y): (u32, u32)) {
    use std::{cmp::min, io::Write};
    let mut buf = std::io::BufWriter::new(tmp);
    for y in 0..buf_y {
        for x in 0..buf_x {
            let a = 0xFF;
            let r = min(((buf_x - x) * 0xFF) / buf_x, ((buf_y - y) * 0xFF) / buf_y);
            let g = min((x * 0xFF) / buf_x, ((buf_y - y) * 0xFF) / buf_y);
            let b = min(((buf_x - x) * 0xFF) / buf_x, (y * 0xFF) / buf_y);

            let color = (a << 24) + (r << 16) + (g << 8) + b;
            buf.write_all(&color.to_ne_bytes()).unwrap();
        }
    }
    buf.flush().unwrap();
}

```

--------------------------------

### window_handle

Source: https://docs.rs/layershellev/0.18.1/layershellev/struct.WindowStateUnit.html

Gets a handle to the window.

```APIDOC
## window_handle

### Description
Gets a handle to the window.

### Method
`fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError>`

### Returns
- `Result<WindowHandle<'_>, HandleError>` - A handle to the window or an error.
```

--------------------------------

### type_id

Source: https://docs.rs/layershellev/0.18.1/layershellev/reexport/wayland_client/struct.GlobalList.html

Gets the TypeId of self.

```APIDOC
## type_id

### Description
Gets the `TypeId` of `self`.

### Signature
`fn type_id(&self) -> TypeId`
```

--------------------------------

### Create and Configure WindowStateSimple

Source: https://docs.rs/layershellev/0.18.1/layershellev/type.WindowStateSimple.html

Demonstrates the creation of a WindowStateSimple with various configurations including screen, size, layer, margin, keyboard interactivity, and exclusive zone. This is typically used for setting up the initial state of a window.

```rust
fn main() {
    let ev: WindowState<()> = WindowState::new("Hello")
        .with_allscreens()
        .with_size((0, 400))
        .with_layer(Layer::Top)
        .with_margin((20, 20, 100, 20))
        .with_keyboard_interacivity(KeyboardInteractivity::Exclusive)
        .with_exclusive_zone(-1)
        .build()
        .unwrap();

    ev.running(move |event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerShellEvent::InitRequest => ReturnData::RequestBind,
            LayerShellEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                let virtual_keyboard_manager = globals
                    .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                        qh,
                        1..=1,
                        (),
                    )
                    .unwrap();
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::RequestCompositor
            }
            LayerShellEvent::CompositorProvide(compositor, qh) => {
                // NOTE: you can set input region to limit area which gets input events
                // surface outside region becomes transparent for input events
                // To ignore all input events use region with (0,0) size
                for x in ev.get_unit_iter() {
                    let region = compositor.create_region(qh, ());
                    region.add(0, 0, 0, 0);
                    x.get_wlsurface().set_input_region(Some(&region));
                }
                ReturnData::None
            }
            LayerShellEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerShellEvent::RequestBuffer(file, shm, qh, init_w, init_h) => {
                draw(file, (init_w, init_h));
                let pool = shm.create_pool(file.as_fd(), (init_w * init_h * 4) as i32, qh, ());
                ReturnData::WlBuffer(pool.create_buffer(
                    0,
                    init_w as i32,
                    init_h as i32,
                    (init_w * 4) as i32,
                    wl_shm::Format::Argb8888,
                    qh,
                    (),
                ))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::RequestRefresh {
                width,
                height,
                .. 
            }) => {
                println!("{{width}}, {{height}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => {
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseEnter { pointer, .. }) => {
                ReturnData::RequestSetCursorShape(("crosshair".to_owned(), pointer.clone()))
            }
            LayerShellEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{{time}}, {{surface_x}}, {{surface_y}}");
                ReturnData::None
            }
            LayerShellEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
                if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                    ReturnData::RequestExit
                } else {
                    ReturnData::None
                }
            }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}
```

--------------------------------

### Get Seat

Source: https://docs.rs/layershellev/0.18.1/src/layershellev/seat.rs.html

Retrieves a reference to the WlSeat object.

```APIDOC
## get_seat

### Description
Retrieves a reference to the WlSeat object associated with the current state.

### Method Signature
`pub fn get_seat(&self) -> &WlSeat`
```

--------------------------------

### Get Window Handle

Source: https://docs.rs/layershellev/0.18.1/layershellev/struct.WindowWrapper.html

Retrieves a handle to the window itself.

```rust
fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError>
```

--------------------------------

### Event::opcode

Source: https://docs.rs/layershellev/0.18.1/layershellev/reexport/wayland_client/wl_pointer/enum.Event.html

Get the opcode number of this message.

```APIDOC
## Method: Event::opcode

### Description
Get the opcode number of this message.

### Signature
`pub fn opcode(&self) -> u16`
```

--------------------------------

### ZwpVirtualKeyboardV1 Methods

Source: https://docs.rs/layershellev/0.18.1/layershellev/reexport/zwp_virtual_keyboard_v1/struct.ZwpVirtualKeyboardV1.html

This section details the methods available on the ZwpVirtualKeyboardV1 interface for emulating keyboard input.

```APIDOC
## keymap

### Description
Provide a file descriptor to the compositor which can be memory-mapped to provide a keyboard mapping description. Format carries a value from the keymap_format enumeration.

### Parameters
- **format** (u32) - Description of the keymap format.
- **fd** (BorrowedFd<'_>) - File descriptor for the keymap.
- **size** (u32) - Size of the keymap data.

## key

### Description
A key was pressed or released. The time argument is a timestamp with millisecond granularity, with an undefined base. All requests regarding a single object must share the same clock. Keymap must be set before issuing this request. State carries a value from the key_state enumeration.

### Parameters
- **time** (u32) - Timestamp of the event in milliseconds.
- **key** (u32) - The key code.
- **state** (u32) - The state of the key (pressed or released).

## modifiers

### Description
Notifies the compositor that the modifier and/or group state has changed, and it should update state. The client should use wl_keyboard.modifiers event to synchronize its internal state with seat state. Keymap must be set before issuing this request.

### Parameters
- **mods_depressed** (u32) - Bitmask of depressed modifiers.
- **mods_latched** (u32) - Bitmask of latched modifiers.
- **mods_locked** (u32) - Bitmask of locked modifiers.
- **group** (u32) - The keyboard group.

## destroy

### Description
Destroy the virtual keyboard object.
```

--------------------------------

### Get all WlTouch devices

Source: https://docs.rs/layershellev/0.18.1/src/layershellev/seat.rs.html

Collects and returns all WlTouch devices managed by the window state. This is useful for iterating over all available touch devices.

```rust
pub fn get_touchers(&self) -> Vec<WlTouch> {
        self.seats
            .values()
            .flat_map(|seat| &seat.touch)
            .cloned()
            .collect()
    }
```

--------------------------------

### Get WlKeyboard object

Source: https://docs.rs/layershellev/0.18.1/layershellev/reexport/wayland_client/struct.WlSeat.html

Obtain a WlKeyboard object for the seat. This request is only valid if the seat has or had keyboard capability. The missing_capability error is sent otherwise.

```rust
pub fn get_keyboard<U, D>(&self, qh: &QueueHandle<D>, udata: U) -> WlKeyboard
where U: Send + Sync + 'static, D: Dispatch<WlKeyboard, U> + 'static,
```

--------------------------------

### Any

Source: https://docs.rs/layershellev/0.18.1/layershellev/dpi/struct.PhysicalPosition.html

Provides the `type_id` method to get the `TypeId` of the instance.

```APIDOC
## fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`.
```

--------------------------------

### Initialize WindowState and Wayland Connections

Source: https://docs.rs/layershellev/0.18.1/src/layershellev/lib.rs.html

Build a new WindowState instance, establishing Wayland connections and initializing necessary states like registry, output, and seat states. This involves binding to various Wayland protocols.

```rust
pub fn build(mut self) -> Result<Self, LayerEventError> {
        let connection = if let Some(with_connection) = self.with_connection.take() {
            with_connection.get_connection()? 
        } else {
            Connection::connect_to_env()? 
        };
        let (globals, mut event_queue) = registry_queue_init::<Self>(&connection)?;

        let qh = event_queue.handle();
        self.registry_state = Some(RegistryState::new(&globals));
        self.output_state = Some(OutputState::new(&globals, &qh));
        let seat_state = SeatState::new(&globals, &qh);
        for seat in seat_state.seats() {
            self.seats.insert(seat.id(), SeatStorage::new());
        }
        self.seat_state = Some(seat_state);

        self.display = Some(connection.display());

        let wmcompositer = globals.bind::<WlCompositor, _, _>(&qh, 1..=5, ())?;

        let shm = globals.bind::<WlShm, _, _>(&qh, 1..=1, ())?;
        self.shm = Some(shm);
        self.seat_back = Some(globals.bind::<WlSeat, _, _>(&qh, 1..=1, ())?);

        let wmbase = globals.bind::<XdgWmBase, _, _>(&qh, 2..=6, ())?;
        self.wmbase = Some(wmbase);

        let cursor_manager = globals
            .bind::<WpCursorShapeManagerV1, _, _>(&qh, 1..=1, ())
            .ok();
        let viewporter = globals.bind::<WpViewporter, _, _>(&qh, 1..=1, ()).ok();

        // register this

        let xdg_output_manager = globals.bind::<ZxdgOutputManagerV1, _, _>(&qh, 1..=3, ())?;
        // xdg_output_manager

        let decoration_manager = globals
            .bind::<ZxdgDecorationManagerV1, _, _>(&qh, 1..=1, ())
            .ok();

        self.xdg_decoration_manager = decoration_manager;

        let fractional_scale_manager = globals
            .bind::<WpFractionalScaleManagerV1, _, _>(&qh, 1..=1, ())
            .ok();
        let text_input_manager = globals
            .bind::<ZwpTextInputManagerV3, _, _>(&qh, 1..=1, ())
            .ok();

        self.text_input_manager = text_input_manager;
        event_queue.blocking_dispatch(&mut self)?;

        // do the step before, you get empty list

        for output_display in &self.outputs {
            let zxdgoutput = xdg_output_manager.get_xdg_output(output_display, &qh, ());
            self.xdg_info_cache
                .push((output_display.clone(), ZxdgOutputInfo::new(zxdgoutput)));
        }
        event_queue.blocking_dispatch(&mut self)?;
        // so it is the same way, to get surface detach to protocol, first get the shell, like wmbase
        // or layer_shell or session-shell, then get `surface` from the wl_surface you get before, and
        // set it
        // finally thing to remember is to commit the surface, make the shell to init.
        //let (init_w, init_h) = self.size;
        // this example is ok for both xdg_surface and layer_shell
        if self.is_background() {
            let background_surface = wmcompositer.create_surface(&qh, ());
            if self.events_transparent {
                let region = wmcompositer.create_region(&qh, ());
                background_surface.set_input_region(Some(&region));
                region.destroy();
            }
            self.background_surface = Some(background_surface);
        } else if !self.is_allscreens() {

```

--------------------------------

### XkbState::new_wayland

Source: https://docs.rs/layershellev/0.18.1/layershellev/xkb_keyboard/struct.XkbState.html

Creates a new XkbState for Wayland, initializing it with the provided XkbKeymap. Returns None if initialization fails.

```APIDOC
## XkbState::new_wayland

### Description
Creates a new XkbState for Wayland, initializing it with the provided XkbKeymap. Returns None if initialization fails.

### Signature
```rust
pub fn new_wayland(keymap: &XkbKeymap) -> Option<XkbState>
```

### Parameters
* `keymap` - A reference to an `XkbKeymap` to initialize the state with.

### Returns
An `Option<XkbState>` which is `Some(XkbState)` on success, or `None` if initialization failed.
```

--------------------------------

### Get WindowState ID

Source: https://docs.rs/layershellev/0.18.1/src/layershellev/lib.rs.html

Retrieves the unique identifier for the WindowState.

```rust
pub fn id(&self) -> id::Id {
        self.id
    }
```
Tokens:
Raw