Struct WindowStateUnit

pub struct WindowStateUnit<T> { /* private fields */ }

Implementations

impl<T> WindowStateUnit<T>

pub fn id(&self) -> Id

get the WindowState id

pub fn try_set_viewport_destination( &self, width: i32, height: i32, ) -> Option<()>

pub fn try_set_viewport_source( &self, x: f64, y: f64, width: f64, height: f64, ) -> Option<()>

pub fn gen_wrapper(&self) -> WindowWrapper

gen the WindowState WindowWrapper

impl<T> WindowStateUnit<T>

pub fn raw_window_handle_rwh_06(&self) -> Result<RawWindowHandle, HandleError>

pub fn raw_display_handle_rwh_06(&self) -> Result<RawDisplayHandle, HandleError>

impl<T> WindowStateUnit<T>

pub fn get_wlsurface(&self) -> &WlSurface

get the wl surface from WindowState

Examples found in repository

examples/simplelayer.rs (line 46)

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_exclusize_zone(-1)
        .build()
        .unwrap();

    let mut virtual_keyboard_manager = None;
    ev.running(|event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerEvent::InitRequest => ReturnData::RequestBind,
            LayerEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                virtual_keyboard_manager = Some(
                    globals
                        .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                            qh,
                            1..=1,
                            (),
                        )
                        .unwrap(),
                );
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::RequestCompositor
            }
            LayerEvent::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
            }
            LayerEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerEvent::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,
                    (),
                ))
            }
            LayerEvent::RequestMessages(DispatchMessage::RequestRefresh {
                width, height, ..
            }) => {
                println!("{width}, {height}");
                ReturnData::None
            }
            LayerEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => ReturnData::None,
            LayerEvent::RequestMessages(DispatchMessage::MouseEnter {
                serial, pointer, ..
            }) => ReturnData::RequestSetCursorShape((
                "crosshair".to_owned(),
                pointer.clone(),
                *serial,
            )),
            LayerEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{time}, {surface_x}, {surface_y}");
                ReturnData::None
            }
            LayerEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
                if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                    ReturnData::RequestExit
                } else {
                    ReturnData::None
                }
            }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}

pub fn get_xdgoutput_info(&self) -> Option<&ZxdgOutputInfo>

get the xdg_output info related to this unit

Examples found in repository

examples/simplelayer.rs (line 53)

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_exclusize_zone(-1)
        .build()
        .unwrap();

    let mut virtual_keyboard_manager = None;
    ev.running(|event, ev, index| {
        match event {
            // NOTE: this will send when init, you can request bind extra object from here
            LayerEvent::InitRequest => ReturnData::RequestBind,
            LayerEvent::BindProvide(globals, qh) => {
                // NOTE: you can get implied wayland object from here
                virtual_keyboard_manager = Some(
                    globals
                        .bind::<zwp_virtual_keyboard_v1::ZwpVirtualKeyboardManagerV1, _, _>(
                            qh,
                            1..=1,
                            (),
                        )
                        .unwrap(),
                );
                println!("{:?}", virtual_keyboard_manager);
                ReturnData::RequestCompositor
            }
            LayerEvent::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
            }
            LayerEvent::XdgInfoChanged(_) => {
                let index = index.unwrap();
                let unit = ev.get_unit_with_id(index).unwrap();
                println!("{:?}", unit.get_xdgoutput_info());
                ReturnData::None
            }
            LayerEvent::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,
                    (),
                ))
            }
            LayerEvent::RequestMessages(DispatchMessage::RequestRefresh {
                width, height, ..
            }) => {
                println!("{width}, {height}");
                ReturnData::None
            }
            LayerEvent::RequestMessages(DispatchMessage::MouseButton { .. }) => ReturnData::None,
            LayerEvent::RequestMessages(DispatchMessage::MouseEnter {
                serial, pointer, ..
            }) => ReturnData::RequestSetCursorShape((
                "crosshair".to_owned(),
                pointer.clone(),
                *serial,
            )),
            LayerEvent::RequestMessages(DispatchMessage::MouseMotion {
                time,
                surface_x,
                surface_y,
            }) => {
                println!("{time}, {surface_x}, {surface_y}");
                ReturnData::None
            }
            LayerEvent::RequestMessages(DispatchMessage::KeyboardInput { event, .. }) => {
                if let PhysicalKey::Code(KeyCode::Escape) = event.physical_key {
                    ReturnData::RequestExit
                } else {
                    ReturnData::None
                }
            }
            _ => ReturnData::None,
        }
    })
    .unwrap();
}

pub fn set_anchor(&self, anchor: Anchor)

set the anchor of the current unit. please take the simple.rs as reference

pub fn set_margin(&self, (top, right, bottom, left): (i32, i32, i32, i32))

you can reset the margin which bind to the surface

pub fn set_layer(&self, layer: Layer)

set the layer

pub fn set_anchor_with_size(&self, anchor: Anchor, (width, height): (u32, u32))

set the anchor and set the size together When you want to change layer from LEFT|RIGHT|BOTTOM to TOP|LEFT|BOTTOM, use it

pub fn set_size(&self, (width, height): (u32, u32))

set the layer size of current unit

pub fn set_exclusive_zone(&self, zone: i32)

set current exclusive_zone

pub fn set_binding(&mut self, binding: T)

you can use this function to set a binding data. the message passed back contain a index, you can use that to get the unit. It will be very useful, because you can use the binding data to operate the file binding to the buffer. you can take startcolorkeyboard as reference.

pub fn get_binding_mut(&mut self) -> Option<&mut T>

return the binding data, with mut reference

pub fn get_binding(&self) -> Option<&T>

get the binding data

pub fn get_size(&self) -> (u32, u32)

get the size of the surface

pub fn request_refresh(&self, (width, height): (i32, i32))

this function will refresh whole surface. it will reattach the buffer, and damage whole, and final commit

pub fn scale_u32(&self) -> u32

pub fn scale_float(&self) -> f64

Trait Implementations

impl<T: Debug> Debug for WindowStateUnit<T>

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

Formats the value using the given formatter.

impl<T> HasDisplayHandle for WindowStateUnit<T>

fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>

Get a handle to the display controller of the windowing system.

impl<T> HasWindowHandle for WindowStateUnit<T>

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

Get a handle to the window.