catppuccin/samples/rust/1.rs

use crate::context::DrawContext;
use crate::controller::Controller;
use crate::font::FontCache;
use crate::scene::*;
use crate::wayland::*;
use crate::*;
use smithay_client_toolkit::reexports::calloop::{EventLoop, LoopHandle, RegistrationToken};
use smithay_client_toolkit::seat::keyboard::ModifiersState;
use smithay_client_toolkit::shm::AutoMemPool;
use smithay_client_toolkit::WaylandSource;

use std::cell::RefCell;
use std::ops::{Deref, DerefMut};
use std::rc::Rc;

use smithay_client_toolkit::reexports::client::{
    global_filter,
    protocol::wl_buffer::WlBuffer,
    protocol::wl_callback,
    protocol::wl_compositor::WlCompositor,
    protocol::wl_output::{self, WlOutput},
    protocol::wl_pointer::{self, WlPointer},
    protocol::wl_region::WlRegion,
    protocol::wl_seat::{self, Capability, WlSeat},
    protocol::wl_shm::WlShm,
    protocol::wl_surface::WlSurface,
    Attached, Display, GlobalError, GlobalManager, Interface, Main, Proxy,
};
use smithay_client_toolkit::reexports::protocols::wlr::unstable::layer_shell::v1::client::{
    zwlr_layer_shell_v1::ZwlrLayerShellV1, zwlr_layer_surface_v1,
    zwlr_layer_surface_v1::ZwlrLayerSurfaceV1,
};

pub struct Application<M, C>
where
    C: Controller<M> + Clone + 'static,
{
    display: Display,
    globals: Rc<RefCell<Globals>>,
    global_manager: GlobalManager,
    pub inner: Vec<InnerApplication<M, C>>,
    token: RegistrationToken,
}

struct Context {
    pending_cb: bool,
    time: Option<u32>,
    render_node: Option<RenderNode>,
    font_cache: FontCache,
}

pub struct CoreApplication<M, C>
where
    C: Controller<M> + Clone,
{
    pub controller: C,
    ctx: Context,
    globals: Rc<RefCell<Globals>>,
    mempool: AutoMemPool,
    widget: Box<dyn Widget<M>>,
    surface: Option<Surface>,
}

pub struct InnerApplication<M, C>
where
    C: Controller<M> + Clone,
{
    core: CoreApplication<M, C>,
    cb: Box<dyn FnMut(&mut CoreApplication<M, C>, Event<M>)>,
}

impl Surface {
    fn new(
        surface: Main<WlSurface>,
        shell: Shell,
        region: Main<WlRegion>,
        previous: Option<Surface>,
    ) -> Self {
        Surface {
            alive: true,
            surface,
            shell,
            region,
            previous: if let Some(surface) = previous {
                Some(Box::new(surface))
            } else {
                None
            },
            buffer: None,
        }
    }
    fn commit(&mut self) {
        self.surface.commit();
        std::mem::drop(&mut self.previous);
        self.previous = None;
    }
    fn destroy(&mut self) {
        self.alive = false;
        self.surface.destroy();
        self.region.destroy();
        self.shell.destroy();
        if let Some(buffer) = self.buffer.as_ref() {
            buffer.destroy();
        }
        self.buffer = None;
    }
    fn destroy_previous(&mut self) {
        if let Some(surface) = self.previous.as_mut() {
            surface.destroy();
        }
        self.previous = None;
    }
    fn set_size(&self, width: u32, height: u32) {
        self.shell.set_size(width, height);
    }
    fn damage(&self, report: &[Region]) {
        self.surface.attach(self.buffer.as_ref(), 0, 0);
        for d in report {
            self.surface
                .damage(d.x as i32, d.y as i32, d.width as i32, d.height as i32);
        }
    }
    fn attach_buffer(&mut self, buffer: WlBuffer) {
        self.buffer = Some(buffer);
    }
}

impl Globals {
    fn new() -> Self {
        Self {
            outputs: Vec::new(),
            seats: Vec::new(),
            shm: None,
            compositor: None,
            shell: None,
        }
    }
    pub fn create_shell_surface_from<M, C>(
        &self,
        geometry: &dyn Widget<M>,
        config: ShellConfig,
        previous: Option<Surface>,
    ) -> Option<Surface>
    where
        M: 'static,
        C: Controller<M> + Clone + 'static,
    {
        if self.compositor.is_some() {
            match config {
                ShellConfig::LayerShell(config) => {
                    if let Some(layer_shell) = self.shell.as_ref() {
                        let region = self.compositor.as_ref().unwrap().create_region();
                        let wl_surface = self.compositor.as_ref().unwrap().create_surface();
                        let layer_surface = layer_shell.get_layer_surface(
                            &wl_surface,
                            config.output.as_ref(),
                            config.layer,
                            config.namespace.clone(),
                        );
                        if let Some(anchor) = &config.anchor {
                            layer_surface.set_anchor(*anchor);
                        }
                        wl_surface.quick_assign(|_, _, _| {});
                        layer_surface.set_exclusive_zone(config.exclusive);
                        layer_surface.set_keyboard_interactivity(config.interactivity);
                        layer_surface.set_size(geometry.width() as u32, geometry.height() as u32);
                        layer_surface.set_margin(
                            config.margin[0],
                            config.margin[1],
                            config.margin[2],
                            config.margin[3],
                        );
                        wl_surface.commit();
                        assign_surface::<M, C>(&layer_surface);
                        return Some(Surface::new(
                            wl_surface,
                            Shell::LayerShell {
                                surface: layer_surface,
                                config,
                            },
                            region,
                            previous,
                        ));
                    }
                }
            }
        }
        None
    }
    pub fn create_mempool(&self) -> AutoMemPool {
        let attached = Attached::from(self.shm.clone().unwrap());
        AutoMemPool::new(attached).unwrap()
    }
    pub fn get_outputs(&self) -> Vec<Output> {
        self.outputs.clone()
    }
    pub fn get_seats(&self) -> &[Seat] {
        &self.seats
    }
}

impl Output {
    fn new(output: Main<WlOutput>) -> Self {
        Output {
            width: 0,
            height: 0,
            scale: 1,
            name: String::new(),
            output,
        }
    }
}

impl<M, C> Application<M, C>
where
    M: 'static,
    C: Controller<M> + Clone + 'static,
{
    pub fn new(pointer: bool) -> (Self, EventLoop<'static, Self>) {
        let display = Display::connect_to_env().unwrap();
        let event_queue = display.create_event_queue();
        let attached_display = (*display).clone().attach(event_queue.token());

        let display_handle = display.clone();

        let globals = Globals::new();

        let global_manager = GlobalManager::new_with_cb(
            &attached_display,
            global_filter!(
                [
                    ZwlrLayerShellV1,
                    1,
                    |layer_shell: Main<ZwlrLayerShellV1>, mut application: DispatchData| {
                        if let Some(application) = application.get::<Application<M, C>>() {
                            if let Ok(mut globals) = application.globals.try_borrow_mut() {
                                globals.shell = Some(layer_shell);
                            }
                        }
                    }
                ],
                [
                    WlShm,
                    1,
                    |shm: Main<WlShm>, mut application: DispatchData| {
                        shm.quick_assign(|_, _, _| {});
                        if let Some(application) = application.get::<Application<M, C>>() {
                            if let Ok(mut globals) = application.globals.try_borrow_mut() {
                                globals.shm = Some(shm);
                            }
                        }
                    }
                ],
                [
                    WlCompositor,
                    4,
                    |compositor: Main<WlCompositor>, mut application: DispatchData| {
                        if let Some(application) = application.get::<Application<M, C>>() {
                            if let Ok(mut globals) = application.globals.try_borrow_mut() {
                                globals.compositor = Some(compositor);
                            }
                        }
                    }
                ],
                [WlSeat, 7, move |seat: Main<WlSeat>, _: DispatchData| {
                    seat.quick_assign(move |wl_seat, event, mut application| match event {
                        wl_seat::Event::Capabilities { capabilities } => {
                            if let Some(application) = application.get::<Application<M, C>>() {
                                if pointer
                                    && capabilities & Capability::Pointer == Capability::Pointer
                                {
                                    let pointer = wl_seat.get_pointer();
                                    assign_pointer::<M, C>(&pointer);
                                }
                                if let Ok(mut globals) = application.globals.try_borrow_mut() {
                                    let mut found = None;
                                    for seat in &mut globals.seats {
                                        if wl_seat.eq(&seat.seat) {
                                            found = Some(());
                                            seat.capabilities = capabilities;
                                        }
                                    }
                                    if found.is_none() {
                                        globals.seats.push(Seat {
                                            capabilities,
                                            seat: wl_seat,
                                        });
                                    }
                                }
                            }
                        }
                        _ => {}
                    });
                }],
                [
                    WlOutput,
                    3,
                    |output: Main<WlOutput>, _application: DispatchData| {
                        output.quick_assign(move |wl_output, event, mut application| match event {
                            wl_output::Event::Geometry {
                                x: _,
                                y: _,
                                physical_width: _,
                                physical_height: _,
                                subpixel: _,
                                make,
                                model: _,
                                transform: _,
                            } => {
                                if let Some(application) = application.get::<Application<M, C>>() {
                                    if let Ok(mut globals) = application.globals.try_borrow_mut() {
                                        let mut found = None;
                                        for output in &mut globals.outputs {
                                            if wl_output.eq(&output.output) {
                                                found = Some(());
                                                output.name = make.clone();
                                            }
                                        }
                                        if found.is_none() {
                                            let mut output = Output::new(wl_output);
                                            output.name = make;
                                            globals.outputs.push(output);
                                        }
                                    }
                                }
                            }
                            wl_output::Event::Mode {
                                flags: _,
                                width,
                                height,
                                refresh: _,
                            } => {
                                if let Some(application) = application.get::<Application<M, C>>() {
                                    if let Ok(mut globals) = application.globals.try_borrow_mut() {
                                        let mut found = None;
                                        for output in &mut globals.outputs {
                                            if wl_output.eq(&output.output) {
                                                found = Some(());
                                                output.width = width;
                                                output.height = height;
                                            }
                                        }
                                        if found.is_none() {
                                            let mut output = Output::new(wl_output);
                                            output.width = width;
                                            output.height = height;
                                            globals.outputs.push(output);
                                        }
                                    }
                                }
                            }
                            wl_output::Event::Scale { factor } => {
                                if let Some(application) = application.get::<Application<M, C>>() {
                                    if let Ok(mut globals) = application.globals.try_borrow_mut() {
                                        let mut found = None;
                                        for output in &mut globals.outputs {
                                            if wl_output.eq(&output.output) {
                                                found = Some(());
                                                output.scale = factor;
                                            }
                                        }
                                        if found.is_none() {
                                            let mut output = Output::new(wl_output);
                                            output.scale = factor;
                                            globals.outputs.push(output);
                                        }
                                    }
                                }
                            }
                            wl_output::Event::Done => {}
                            _ => {}
                        });
                    }
                ]
            ),
        );

        let event_loop = EventLoop::try_new().expect("Failed to initialize the event loop!");
        let token = WaylandSource::new(event_queue)
            .quick_insert(event_loop.handle())
            .unwrap();

        let (mut application, mut event_loop) = (
            Application {
                display,
                globals: Rc::new(RefCell::new(globals)),
                global_manager,
                inner: Vec::new(),
                token,
            },
            event_loop,
        );

        for _ in 0..2 {
            display_handle.flush().unwrap();
            event_loop.dispatch(None, &mut application).unwrap();
        }

        (application, event_loop)
    }
    fn get_index(&self, surface: &WlSurface) -> usize {
        for i in 0..self.inner.len() {
            if self.inner[i].eq(surface) {
                return i;
            }
        }
        0
    }
    fn get_application(&mut self, surface: &WlSurface) -> Option<&mut InnerApplication<M, C>> {
        for inner in &mut self.inner {
            if inner.eq(surface) {
                return Some(inner);
            }
        }
        None
    }
    pub fn get_global<I>(&self) -> Result<Main<I>, GlobalError>
    where
        I: Interface + AsRef<Proxy<I>> + From<Proxy<I>>,
    {
        self.global_manager.instantiate_range::<I>(0, 1 << 8)
    }
    pub fn create_empty_inner_application<Data: 'static>(
        &mut self,
        controller: C,
        widget: impl Widget<M> + 'static,
        handle: LoopHandle<'_, Data>,
        cb: impl FnMut(&mut CoreApplication<M, C>, Event<M>) + 'static,
    ) {
        let inner_application =
            InnerApplication::empty(controller, widget, self.globals.clone(), cb);
        self.inner.push(inner_application);
        handle.update(&self.token).unwrap();
    }
    pub fn create_inner_application_from<Data: 'static>(
        &mut self,
        controller: C,
        config: ShellConfig,
        widget: impl Widget<M> + 'static,
        handle: LoopHandle<'_, Data>,
        cb: impl FnMut(&mut CoreApplication<M, C>, Event<M>) + 'static,
    ) {
        let inner_application =
            InnerApplication::new(controller, widget, config, self.globals.clone(), cb);
        self.inner.push(inner_application);
        handle.update(&self.token).unwrap();
    }
    pub fn create_inner_application<Data: 'static>(
        &mut self,
        controller: C,
        widget: impl Widget<M> + 'static,
        handle: LoopHandle<'_, Data>,
        cb: impl FnMut(&mut CoreApplication<M, C>, Event<M>) + 'static,
    ) {
        let inner_application =
            InnerApplication::normal(controller, widget, self.globals.clone(), cb);
        self.inner.push(inner_application);
        handle.update(&self.token).unwrap();
    }
    pub fn run(mut self, event_loop: &mut EventLoop<'static, Self>) {
        loop {
            self.display.flush().unwrap();
            event_loop.dispatch(None, &mut self).unwrap();
        }
    }
}

impl<M, C> Deref for InnerApplication<M, C>
where
    C: Controller<M> + Clone + 'static,
{
    type Target = CoreApplication<M, C>;
    fn deref(&self) -> &Self::Target {
        &self.core
    }
}

impl<M, C> DerefMut for InnerApplication<M, C>
where
    C: Controller<M> + Clone + 'static,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.core
    }
}

impl<M, C> CoreApplication<M, C>
where
    M: 'static,
    C: Controller<M> + Clone + 'static,
{
    pub fn poll(&mut self, ev: Event<M>) -> C {
        let mut ctl = self.controller.clone();
        let mut sync_ctx = SyncContext::new(&mut ctl, &mut self.ctx.font_cache);
        self.widget.sync(&mut sync_ctx, ev);
        ctl
    }
    pub fn sync(&mut self, ev: Event<M>) -> bool {
        let mut sync_ctx = SyncContext::new(&mut self.controller, &mut self.ctx.font_cache);
        let mut damage = self.widget.sync(&mut sync_ctx, ev);
        while let Ok(msg) = sync_ctx.sync() {
            damage = damage.max(self.widget.sync(&mut sync_ctx, Event::Message(&msg)));
        }
        if damage == Damage::Frame {
            if self.ctx.time.is_none() {
                self.ctx.time = Some(0);
            }
        }
        damage.is_some() && !self.ctx.pending_cb
    }
    pub fn destroy(&mut self) {
        if let Some(surface) = self.surface.as_mut() {
            surface.destroy();
        }
    }
    pub fn get_layer_surface(&self) -> ZwlrLayerSurfaceV1 {
        match &self.surface.as_ref().unwrap().shell {
            Shell::LayerShell { config: _, surface } => surface.detach(),
        }
    }
    pub fn is_hidden(&self) -> bool {
        if let Some(surface) = self.surface.as_ref() {
            return !surface.alive;
        } else {
            true
        }
    }
    pub fn replace_surface(&mut self) {
        if let Some(surface) = self.surface.as_mut() {
            surface.destroy();
            surface.alive = true;
            match &surface.shell {
                Shell::LayerShell { config, surface: _ } => {
                    self.surface = self.globals.borrow().create_shell_surface_from::<M, C>(
                        self.widget.deref(),
                        ShellConfig::LayerShell(config.clone()),
                        Some(surface.clone()),
                    );
                }
            }
        } else {
            self.surface = self.globals.borrow().create_shell_surface_from::<M, C>(
                self.widget.deref(),
                ShellConfig::LayerShell(LayerShellConfig::default()),
                None,
            );
        }
    }
    pub fn replace_surface_by(&mut self, config: ShellConfig) {
        if let Some(surface) = self.surface.as_mut() {
            surface.destroy();
            surface.alive = true;
            self.surface = self.globals.borrow().create_shell_surface_from::<M, C>(
                self.widget.deref(),
                config,
                Some(surface.clone()),
            );
        } else {
            self.surface = self.globals.borrow().create_shell_surface_from::<M, C>(
                self.widget.deref(),
                config,
                None,
            );
        }
    }
}

impl<M, C> Geometry for InnerApplication<M, C>
where
    C: Controller<M> + Clone + 'static,
{
    fn width(&self) -> f32 {
        self.widget.width()
    }
    fn height(&self) -> f32 {
        self.widget.height()
    }
    fn set_size(&mut self, width: f32, height: f32) -> Result<(), (f32, f32)> {
        if let Some(surface) = self.surface.as_ref() {
            surface.set_size(width as u32, height as u32);
            surface.surface.commit();
        }
        Ok(())
    }
}

impl<M, C> InnerApplication<M, C>
where
    M: 'static,
    C: Controller<M> + Clone + 'static,
{
    pub fn empty(
        controller: C,
        widget: impl Widget<M> + 'static,
        globals: Rc<RefCell<Globals>>,
        cb: impl FnMut(&mut CoreApplication<M, C>, Event<M>) + 'static,
    ) -> Self {
        let mempool = globals.borrow().create_mempool();
        let mut default = InnerApplication {
            core: CoreApplication {
                controller,
                ctx: Context {
                    pending_cb: false,
                    time: None,
                    font_cache: FontCache::new(),
                    render_node: None,
                },
                surface: None,
                widget: Box::new(widget),
                mempool,
                globals,
            },
            cb: Box::new(cb),
        };
        default.sync(Event::Prepare);
        default
    }
    pub fn normal(
        controller: C,
        widget: impl Widget<M> + 'static,
        globals: Rc<RefCell<Globals>>,
        cb: impl FnMut(&mut CoreApplication<M, C>, Event<M>) + 'static,
    ) -> Self {
        let mempool = globals.borrow().create_mempool();
        let mut default = InnerApplication {
            core: CoreApplication {
                controller,
                ctx: Context {
                    pending_cb: false,
                    time: None,
                    font_cache: FontCache::new(),
                    render_node: None,
                },
                surface: None,
                widget: Box::new(widget),
                mempool,
                globals,
            },
            cb: Box::new(cb),
        };
        default.sync(Event::Prepare);
        default.replace_surface();
        default
    }
    pub fn new(
        controller: C,
        widget: impl Widget<M> + 'static,
        config: ShellConfig,
        globals: Rc<RefCell<Globals>>,
        cb: impl FnMut(&mut CoreApplication<M, C>, Event<M>) + 'static,
    ) -> Self {
        let mempool = globals.borrow().create_mempool();
        let mut new = InnerApplication {
            core: CoreApplication {
                controller,
                ctx: Context {
                    pending_cb: false,
                    time: None,
                    font_cache: FontCache::new(),
                    render_node: None,
                },
                surface: None,
                widget: Box::new(widget),
                mempool,
                globals,
            },
            cb: Box::new(cb),
        };
        new.sync(Event::Prepare);
        new.replace_surface_by(config);
        new
    }
    fn eq(&self, wl_surface: &WlSurface) -> bool {
        if let Some(surface) = &self.surface {
            return surface.surface.detach().eq(wl_surface);
        }
        false
    }
    pub fn roundtrip(&mut self, ev: Event<M>) -> Result<RenderNode, ()> {
        let width = self.width();
        let height = self.height();

        // Sending the event to the widget tree
        if self.sync(ev) || ev.is_frame() {
            // Calling the application´s closure
            (self.cb)(&mut self.core, ev);

            if !self.is_hidden() {
                let current_width = self.width();
                let current_height = self.height();

                // Resizing the surface in case the widget changed size
                if ev.is_frame() {
                    self.ctx.render_node = None;
                } else if width != current_width || height != current_height {
                    let _ = self.set_size(current_width, current_height);
                    return Err(());
                }

                // Creating the render node
                let render_node = self.core.widget.create_node(0., 0.);

                self.ctx.pending_cb = true;

                return Ok(render_node);
            }
        } else {
            // Calling the application´s closure
            (self.cb)(&mut self.core, ev);
        }

        Err(())
    }
    fn render(&mut self, time: u32, recent_node: RenderNode) {
        let width = recent_node.width();
        let height = recent_node.height();
        if Some(time).ne(&self.core.ctx.time) || time == 0 {
            if let Ok((buffer, wl_buffer)) =
                Buffer::new(&mut self.core.mempool, width as i32, height as i32)
            {
                let mut v = Vec::new();
                let mut ctx =
                    DrawContext::new(buffer.backend, &mut self.core.ctx.font_cache, &mut v);
                if let Some(render_node) = self.core.ctx.render_node.as_mut() {
                    if let Err(region) = render_node.draw_merge(
                        recent_node,
                        &mut ctx,
                        &Instruction::empty(0., 0., width, height),
                        None,
                    ) {
                        ctx.damage_region(&Background::Transparent, region, false);
                    }
                } else {
                    ctx.damage_region(
                        &Background::Transparent,
                        Region::new(0., 0., width, height),
                        false,
                    );
                    recent_node.render(&mut ctx, None);
                    self.core.ctx.render_node = Some(recent_node);
                }
                self.core.ctx.pending_cb = false;
                if let Some(surface) = self.core.surface.as_mut() {
                    surface.attach_buffer(wl_buffer);
                    surface.damage(&v);
                    surface.commit();
                    if let Some(_) = self.core.ctx.time {
                        self.core.ctx.time = Some(time);
                        frame_callback::<M, C>(time, surface.surface.clone());
                    }
                }
            }
        }
    }
    pub fn callback(&mut self, ev: Event<M>) {
        if self.ctx.time.is_none() || ev.is_cb() {
            if let Ok(render_node) = self.roundtrip(ev) {
                if let Some(surface) = self.surface.as_ref() {
                    draw_callback::<M, C>(&surface.surface, render_node);
                }
            }
        } else {
            let width = self.width();
            let height = self.height();

            self.sync(ev);

            let current_width = self.width();
            let current_height = self.height();

            // Resizing the surface in case the widget changed size
            if width != current_width || height != current_height {
                let _ = self.set_size(current_width, current_height);
            }
        }
    }
}

fn frame_callback<M, C>(time: u32, surface: Main<WlSurface>)
where
    M: 'static,
    C: Controller<M> + Clone + 'static,
{
    let h = surface.detach();
    surface
        .frame()
        .quick_assign(move |_, event, mut application| match event {
            wl_callback::Event::Done { callback_data } => {
                let timeout = (callback_data - time).min(50);
                if let Some(application) = application.get::<Application<M, C>>() {
                    if let Some(inner_application) = application.get_application(&h) {
                        inner_application.ctx.time = None;
                        inner_application.callback(Event::Callback(timeout));
                    }
                }
            }
            _ => {}
        });
    surface.commit();
}

fn draw_callback<M, C>(surface: &Main<WlSurface>, mut recent_node: RenderNode)
where
    M: 'static,
    C: Controller<M> + Clone + 'static,
{
    let h = surface.detach();
    surface
        .frame()
        .quick_assign(move |_, event, mut application| match event {
            wl_callback::Event::Done { callback_data } => {
                if let Some(application) = application.get::<Application<M, C>>() {
                    let inner_application = application.get_application(&h).unwrap();
                    inner_application.render(callback_data, std::mem::take(&mut recent_node));
                }
            }
            _ => {}
        });
    surface.commit();
}

impl From<ModifiersState> for Modifiers {
    fn from(modifer_state: ModifiersState) -> Modifiers {
        Modifiers {
            ctrl: modifer_state.ctrl,
            alt: modifer_state.alt,
            shift: modifer_state.shift,
            caps_lock: modifer_state.caps_lock,
            logo: modifer_state.logo,
            num_lock: modifer_state.num_lock,
        }
    }
}

fn assign_pointer<M, C>(pointer: &Main<WlPointer>)
where
    M: 'static,
    C: Controller<M> + Clone + 'static,
{
    let mut index = 0;
    let mut input = Pointer::Enter;
    let (mut x, mut y) = (0., 0.);
    pointer.quick_assign(move |_, event, mut inner| match event {
        wl_pointer::Event::Leave { serial: _, surface } => {
            input = Pointer::Leave;
            if let Some(application) = inner.get::<Application<M, C>>() {
                if let Some(inner_application) = application.get_application(&surface) {
                    inner_application.callback(Event::Pointer(x as f32, y as f32, input));
                }
            }
        }
        wl_pointer::Event::Button {
            serial: _,
            time,
            button,
            state,
        } => {
            input = Pointer::MouseClick {
                time,
                button: MouseButton::new(button),
                pressed: state == wl_pointer::ButtonState::Pressed,
            };
        }
        wl_pointer::Event::Frame => {
            if let Some(application) = inner.get::<Application<M, C>>() {
                let inner_application = application.inner.get_mut(index).unwrap();
                inner_application.callback(Event::Pointer(x as f32, y as f32, input));
            }
        }
        wl_pointer::Event::Axis {
            time: _,
            axis,
            value,
        } => {
            input = Pointer::Scroll {
                orientation: match axis {
                    wl_pointer::Axis::VerticalScroll => Orientation::Vertical,
                    wl_pointer::Axis::HorizontalScroll => Orientation::Horizontal,
                    _ => Orientation::Vertical,
                },
                value: value as f32,
            }
        }
        wl_pointer::Event::Enter {
            serial: _,
            surface,
            surface_x,
            surface_y,
        } => {
            if let Some(application) = inner.get::<Application<M, C>>() {
                x = surface_x;
                y = surface_y;
                index = application.get_index(&surface);
            }
        }
        wl_pointer::Event::Motion {
            time: _,
            surface_x,
            surface_y,
        } => {
            x = surface_x;
            y = surface_y;
            input = Pointer::Hover;
        }
        _ => {}
    });
}

fn assign_surface<M, C>(shell: &Main<ZwlrLayerSurfaceV1>)
where
    M: 'static,
    C: Controller<M> + Clone + 'static,
{
    shell.quick_assign(move |shell, event, mut inner| match event {
        zwlr_layer_surface_v1::Event::Configure {
            serial,
            width,
            height,
        } => {
            shell.ack_configure(serial);
            println!("\nCONFIGURE - {} : {} X {}\n", serial, width, height);
            if let Some(application) = inner.get::<Application<M, C>>() {
                for inner_application in &mut application.inner {
                    if let Some(app_surface) = inner_application.surface.as_mut() {
                        match &app_surface.shell {
                            Shell::LayerShell { config: _, surface } => {
                                if shell.eq(surface) {
                                    app_surface.destroy_previous();
                                    let _ = inner_application
                                        .widget
                                        .set_size(width as f32, height as f32);
                                    if inner_application.ctx.pending_cb {
                                        if let Ok(render_node) =
                                            inner_application.roundtrip(Event::Frame)
                                        {
                                            draw_callback::<M, C>(
                                                &inner_application
                                                    .surface
                                                    .as_ref()
                                                    .unwrap()
                                                    .surface,
                                                render_node,
                                            );
                                        }
                                    } else {
                                        if let Ok(render_node) =
                                            inner_application.roundtrip(Event::Frame)
                                        {
                                            inner_application.render(0, render_node);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        _ => unreachable!(),
    });
}