Crate exwlshellev 

Handle the layer_shell in a winit way

Min example is under

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

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

fn main() {
    let mut ev: WindowState<()> = WindowState::new("Hello")
        .with_allscreens()
        .with_size(LayerSize::fill_width(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
            ExWlShellEvent::InitRequest => ReturnData::RequestBind,
            ExWlShellEvent::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
            }
            ExWlShellEvent::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,
                    (),
                ))
            }
            ExWlShellEvent::RequestMessages(DispatchMessage::RequestRefresh { width, height, .. }) => {
                println!("{width}, {height}");
                ReturnData::None
            }
            ExWlShellEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => ReturnData::None,
            ExWlShellEvent::RequestMessages(DispatchMessage::MouseEnter {
                pointer, ..
            }) => ReturnData::RequestSetCursorShape((
                "crosshair".to_owned(),
                pointer.clone(),
            )),
            ExWlShellEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{time}, {surface_x}, {surface_y}");
                ReturnData::None
            }
            ExWlShellEvent::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

blur

dpi

id

keyboard

Types related to the keyboard.

reexport

xkb_keyboard

Structs

AxisScroll

Describes a scroll along one axis

DisplayWrapper

LayerSize

size requested for layer surface

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.

OutputInfo

Information about an output.

PixelSize

Exact, non-zero size in surface-local pixels, for sizes no protocol lets you ask the compositor to choose.

PopUpRepositionSettings

be used to move and resize a mapped popup

TextInputData

TextInputDataInner

VirtualKeyRelease

WindowState

main state, store the main information

WindowStateUnit

WindowWrapper

Enums

DispatchMessage

This tell the DispatchMessage by dispatch

ExShellEventError

ExWlShellEvent

tell program what event is happened

Extent

The extent requested for a layer surface along one axis.

Ime

ImePurpose

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

WlShellType

Traits

ZwpTextInputV3Ext

Type Aliases

WindowStateSimple

Simple WindowState, without any data binding or info