Crate layershellev 

Handle the layer_shell in a winit way

Min example is under

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();
}

Re-exports

pub use calloop;

Modules

dpi

id

keyboard

Types related to the keyboard.

reexport

xkb_keyboard

Structs

AxisScroll

Describes a scroll along one axis

DisplayWrapper

NewInputPanelSettings

input panel settings to create a new input panel surface

NewLayerShellSettings

layershell settings to create a new layershell surface

NewPopUpSettings

be used to create a new popup

NewXdgWindowSettings

Settings used to create a new xdg toplevel window.

TextInputData

TextInputDataInner

VirtualKeyRelease

WindowState

main state, store the main information

WindowStateUnit

WindowWrapper

ZxdgOutputInfo

this struct store the xdg_output information

Enums

DispatchMessage

This tell the DispatchMessage by dispatch

Ime

ImePurpose

LayerEventError

LayerShellEvent

tell program what event is happened

OutputOption

Define the output for new layershell

PopupPlacement

How a popup is positioned relative to its parent surface

RefreshRequest

ReturnData

the return data Note: when event is RequestBuffer, you must return WlBuffer Note: when receive InitRequest, you can request to bind extra wayland-protocols. this time you can bind virtual-keyboard. you can take startcolorkeyboard as reference, or the simple.rs. Also, it should can bind with text-input, but I am not fully understand about this, maybe someone familiar with it can do

StartMode

Define the way layershell program is start

WithConnection

a wrapper for implement Debug, so we don’t need to implement Debug for WindowState

XdgInfoChangedType

this tell the what kind of information passed by LayerShellEvent::XdgInfoChanged

Traits

ZwpTextInputV3Ext

Type Aliases

WindowStateSimple

Simple WindowState, without any data binding or info