smithay/anvil/src/shell.rs

use std::{
    cell::RefCell,
    rc::Rc,
    sync::{Arc, Mutex},
};

use smithay::{
    backend::renderer::buffer_dimensions,
    reexports::{
        wayland_protocols::xdg_shell::server::xdg_toplevel,
        wayland_server::{
            protocol::{wl_buffer, wl_output, wl_pointer::ButtonState, wl_shell_surface, wl_surface},
            Display,
        },
    },
    utils::{Logical, Physical, Point, Rectangle, Size},
    wayland::{
        compositor::{
            compositor_init, is_sync_subsurface, with_states, with_surface_tree_upward, BufferAssignment,
            SurfaceAttributes, TraversalAction,
        },
        seat::{AxisFrame, GrabStartData, PointerGrab, PointerInnerHandle, Seat},
        shell::{
            legacy::{wl_shell_init, ShellRequest, ShellState as WlShellState, ShellSurfaceKind},
            wlr_layer::{LayerShellRequest, LayerSurfaceAttributes},
            xdg::{
                xdg_shell_init, Configure, ShellState as XdgShellState, SurfaceCachedState,
                XdgPopupSurfaceRoleAttributes, XdgRequest, XdgToplevelSurfaceRoleAttributes,
            },
        },
        Serial,
    },
};

use crate::{
    output_map::OutputMap,
    state::AnvilState,
    window_map::{Kind as SurfaceKind, PopupKind, WindowMap},
};

struct MoveSurfaceGrab {
    start_data: GrabStartData,
    window_map: Rc<RefCell<WindowMap>>,
    toplevel: SurfaceKind,
    initial_window_location: Point<i32, Logical>,
}

impl PointerGrab for MoveSurfaceGrab {
    fn motion(
        &mut self,
        _handle: &mut PointerInnerHandle<'_>,
        location: Point<f64, Logical>,
        _focus: Option<(wl_surface::WlSurface, Point<i32, Logical>)>,
        _serial: Serial,
        _time: u32,
    ) {
        let delta = location - self.start_data.location;
        let new_location = self.initial_window_location.to_f64() + delta;

        self.window_map.borrow_mut().set_location(
            &self.toplevel,
            (new_location.x as i32, new_location.y as i32).into(),
        );
    }

    fn button(
        &mut self,
        handle: &mut PointerInnerHandle<'_>,
        button: u32,
        state: ButtonState,
        serial: Serial,
        time: u32,
    ) {
        handle.button(button, state, serial, time);
        if handle.current_pressed().is_empty() {
            // No more buttons are pressed, release the grab.
            handle.unset_grab(serial, time);
        }
    }

    fn axis(&mut self, handle: &mut PointerInnerHandle<'_>, details: AxisFrame) {
        handle.axis(details)
    }

    fn start_data(&self) -> &GrabStartData {
        &self.start_data
    }
}

bitflags::bitflags! {
    struct ResizeEdge: u32 {
        const NONE = 0;
        const TOP = 1;
        const BOTTOM = 2;
        const LEFT = 4;
        const TOP_LEFT = 5;
        const BOTTOM_LEFT = 6;
        const RIGHT = 8;
        const TOP_RIGHT = 9;
        const BOTTOM_RIGHT = 10;
    }
}

impl From<wl_shell_surface::Resize> for ResizeEdge {
    #[inline]
    fn from(x: wl_shell_surface::Resize) -> Self {
        Self::from_bits(x.bits()).unwrap()
    }
}

impl From<ResizeEdge> for wl_shell_surface::Resize {
    #[inline]
    fn from(x: ResizeEdge) -> Self {
        Self::from_bits(x.bits()).unwrap()
    }
}

impl From<xdg_toplevel::ResizeEdge> for ResizeEdge {
    #[inline]
    fn from(x: xdg_toplevel::ResizeEdge) -> Self {
        Self::from_bits(x.to_raw()).unwrap()
    }
}

impl From<ResizeEdge> for xdg_toplevel::ResizeEdge {
    #[inline]
    fn from(x: ResizeEdge) -> Self {
        Self::from_raw(x.bits()).unwrap()
    }
}

struct ResizeSurfaceGrab {
    start_data: GrabStartData,
    toplevel: SurfaceKind,
    edges: ResizeEdge,
    initial_window_size: Size<i32, Logical>,
    last_window_size: Size<i32, Logical>,
}

impl PointerGrab for ResizeSurfaceGrab {
    fn motion(
        &mut self,
        handle: &mut PointerInnerHandle<'_>,
        location: Point<f64, Logical>,
        _focus: Option<(wl_surface::WlSurface, Point<i32, Logical>)>,
        serial: Serial,
        time: u32,
    ) {
        // It is impossible to get `min_size` and `max_size` of dead toplevel, so we return early.
        if !self.toplevel.alive() | self.toplevel.get_surface().is_none() {
            handle.unset_grab(serial, time);
            return;
        }

        let (mut dx, mut dy) = (location - self.start_data.location).into();

        let mut new_window_width = self.initial_window_size.w;
        let mut new_window_height = self.initial_window_size.h;

        let left_right = ResizeEdge::LEFT | ResizeEdge::RIGHT;
        let top_bottom = ResizeEdge::TOP | ResizeEdge::BOTTOM;

        if self.edges.intersects(left_right) {
            if self.edges.intersects(ResizeEdge::LEFT) {
                dx = -dx;
            }

            new_window_width = (self.initial_window_size.w as f64 + dx) as i32;
        }

        if self.edges.intersects(top_bottom) {
            if self.edges.intersects(ResizeEdge::TOP) {
                dy = -dy;
            }

            new_window_height = (self.initial_window_size.h as f64 + dy) as i32;
        }

        let (min_size, max_size) = with_states(self.toplevel.get_surface().unwrap(), |states| {
            let data = states.cached_state.current::<SurfaceCachedState>();
            (data.min_size, data.max_size)
        })
        .unwrap();

        let min_width = min_size.w.max(1);
        let min_height = min_size.h.max(1);
        let max_width = if max_size.w == 0 {
            i32::max_value()
        } else {
            max_size.w
        };
        let max_height = if max_size.h == 0 {
            i32::max_value()
        } else {
            max_size.h
        };

        new_window_width = new_window_width.max(min_width).min(max_width);
        new_window_height = new_window_height.max(min_height).min(max_height);

        self.last_window_size = (new_window_width, new_window_height).into();

        match &self.toplevel {
            SurfaceKind::Xdg(xdg) => {
                let ret = xdg.with_pending_state(|state| {
                    state.states.set(xdg_toplevel::State::Resizing);
                    state.size = Some(self.last_window_size);
                });
                if ret.is_ok() {
                    xdg.send_configure();
                }
            }
            SurfaceKind::Wl(wl) => wl.send_configure(self.last_window_size, self.edges.into()),
            #[cfg(feature = "xwayland")]
            SurfaceKind::X11(_) => {
                // TODO: What to do here? Send the update via X11?
            }
        }
    }

    fn button(
        &mut self,
        handle: &mut PointerInnerHandle<'_>,
        button: u32,
        state: ButtonState,
        serial: Serial,
        time: u32,
    ) {
        handle.button(button, state, serial, time);
        if handle.current_pressed().is_empty() {
            // No more buttons are pressed, release the grab.
            handle.unset_grab(serial, time);

            // If toplevel is dead, we can't resize it, so we return early.
            if !self.toplevel.alive() | self.toplevel.get_surface().is_none() {
                return;
            }

            if let SurfaceKind::Xdg(xdg) = &self.toplevel {
                let ret = xdg.with_pending_state(|state| {
                    state.states.unset(xdg_toplevel::State::Resizing);
                    state.size = Some(self.last_window_size);
                });
                if ret.is_ok() {
                    xdg.send_configure();
                }

                with_states(self.toplevel.get_surface().unwrap(), |states| {
                    let mut data = states
                        .data_map
                        .get::<RefCell<SurfaceData>>()
                        .unwrap()
                        .borrow_mut();
                    if let ResizeState::Resizing(resize_data) = data.resize_state {
                        data.resize_state = ResizeState::WaitingForFinalAck(resize_data, serial);
                    } else {
                        panic!("invalid resize state: {:?}", data.resize_state);
                    }
                })
                .unwrap();
            } else {
                with_states(self.toplevel.get_surface().unwrap(), |states| {
                    let mut data = states
                        .data_map
                        .get::<RefCell<SurfaceData>>()
                        .unwrap()
                        .borrow_mut();
                    if let ResizeState::Resizing(resize_data) = data.resize_state {
                        data.resize_state = ResizeState::WaitingForCommit(resize_data);
                    } else {
                        panic!("invalid resize state: {:?}", data.resize_state);
                    }
                })
                .unwrap();
            }
        }
    }

    fn axis(&mut self, handle: &mut PointerInnerHandle<'_>, details: AxisFrame) {
        handle.axis(details)
    }

    fn start_data(&self) -> &GrabStartData {
        &self.start_data
    }
}

#[derive(Clone)]
pub struct ShellHandles {
    pub xdg_state: Arc<Mutex<XdgShellState>>,
    pub wl_state: Arc<Mutex<WlShellState>>,
}

fn fullscreen_output_geometry(
    wl_surface: &wl_surface::WlSurface,
    wl_output: Option<&wl_output::WlOutput>,
    window_map: &WindowMap,
    output_map: &OutputMap,
) -> Option<Rectangle<i32, Logical>> {
    // First test if a specific output has been requested
    // if the requested output is not found ignore the request
    if let Some(wl_output) = wl_output {
        return output_map.find_by_output(wl_output).map(|o| o.geometry());
    }

    // There is no output preference, try to find the output
    // where the window is currently active
    let window_location = window_map
        .find(wl_surface)
        .and_then(|kind| window_map.location(&kind));

    if let Some(location) = window_location {
        let window_output = output_map.find_by_position(location).map(|o| o.geometry());

        if let Some(result) = window_output {
            return Some(result);
        }
    }

    // Fallback to primary output
    output_map.with_primary().map(|o| o.geometry())
}

pub fn init_shell<BackendData: 'static>(display: Rc<RefCell<Display>>, log: ::slog::Logger) -> ShellHandles {
    // Create the compositor
    compositor_init(
        &mut *display.borrow_mut(),
        move |surface, mut ddata| {
            let anvil_state = ddata.get::<AnvilState<BackendData>>().unwrap();
            let window_map = anvil_state.window_map.as_ref();
            let output_map = anvil_state.output_map.as_ref();
            surface_commit(&surface, &*window_map, &*output_map)
        },
        log.clone(),
    );

    // init the xdg_shell
    let (xdg_shell_state, _) = xdg_shell_init(
        &mut *display.borrow_mut(),
        move |shell_event, mut ddata| {
            let state = ddata.get::<AnvilState<BackendData>>().unwrap();

            match shell_event {
                XdgRequest::NewToplevel { surface } => {
                    // place the window at a random location on the primary output
                    // or if there is not output in a [0;800]x[0;800] square
                    use rand::distributions::{Distribution, Uniform};

                    let output_geometry = state
                        .output_map
                        .borrow()
                        .with_primary()
                        .map(|o| o.geometry())
                        .unwrap_or_else(|| Rectangle::from_loc_and_size((0, 0), (800, 800)));

                    let max_x =
                        output_geometry.loc.x + (((output_geometry.size.w as f32) / 3.0) * 2.0) as i32;
                    let max_y =
                        output_geometry.loc.y + (((output_geometry.size.h as f32) / 3.0) * 2.0) as i32;
                    let x_range = Uniform::new(output_geometry.loc.x, max_x);
                    let y_range = Uniform::new(output_geometry.loc.y, max_y);
                    let mut rng = rand::thread_rng();
                    let x = x_range.sample(&mut rng);
                    let y = y_range.sample(&mut rng);
                    // Do not send a configure here, the initial configure
                    // of a xdg_surface has to be sent during the commit if
                    // the surface is not already configured
                    state
                        .window_map
                        .borrow_mut()
                        .insert(SurfaceKind::Xdg(surface), (x, y).into());
                }

                XdgRequest::NewPopup { surface, positioner } => {
                    // Do not send a configure here, the initial configure
                    // of a xdg_surface has to be sent during the commit if
                    // the surface is not already configured

                    // TODO: properly recompute the geometry with the whole of positioner state
                    surface
                        .with_pending_state(|state| {
                            // NOTE: This is not really necessary as the default geometry
                            // is already set the same way, but for demonstrating how
                            // to set the initial popup geometry this code is left as
                            // an example
                            state.geometry = positioner.get_geometry();
                        })
                        .unwrap();
                    state
                        .window_map
                        .borrow_mut()
                        .insert_popup(PopupKind::Xdg(surface));
                }

                XdgRequest::RePosition {
                    surface,
                    positioner,
                    token,
                } => {
                    let result = surface.with_pending_state(|state| {
                        // NOTE: This is again a simplification, a proper compositor would
                        // calculate the geometry of the popup here. For simplicity we just
                        // use the default implementation here that does not take the
                        // window position and output constraints into account.
                        let geometry = positioner.get_geometry();
                        state.geometry = geometry;
                        state.positioner = positioner;
                    });

                    if result.is_ok() {
                        surface.send_repositioned(token);
                    }
                }

                XdgRequest::Move {
                    surface,
                    seat,
                    serial,
                } => {
                    let seat = Seat::from_resource(&seat).unwrap();
                    // TODO: touch move.
                    let pointer = seat.get_pointer().unwrap();

                    // Check that this surface has a click grab.
                    if !pointer.has_grab(serial) {
                        return;
                    }

                    let start_data = pointer.grab_start_data().unwrap();

                    // If the focus was for a different surface, ignore the request.
                    if start_data.focus.is_none()
                        || !start_data
                            .focus
                            .as_ref()
                            .unwrap()
                            .0
                            .as_ref()
                            .same_client_as(surface.get_surface().unwrap().as_ref())
                    {
                        return;
                    }

                    let toplevel = SurfaceKind::Xdg(surface.clone());
                    let mut initial_window_location = state.window_map.borrow().location(&toplevel).unwrap();

                    // If surface is maximized then unmaximize it
                    if let Some(current_state) = surface.current_state() {
                        if current_state.states.contains(xdg_toplevel::State::Maximized) {
                            let fs_changed = surface.with_pending_state(|state| {
                                state.states.unset(xdg_toplevel::State::Maximized);
                                state.size = None;
                            });

                            if fs_changed.is_ok() {
                                surface.send_configure();

                                // NOTE: In real compositor mouse location should be mapped to a new window size
                                // For example, you could:
                                // 1) transform mouse pointer position from compositor space to window space (location relative)
                                // 2) divide the x coordinate by width of the window to get the percentage
                                //   - 0.0 would be on the far left of the window
                                //   - 0.5 would be in middle of the window
                                //   - 1.0 would be on the far right of the window
                                // 3) multiply the percentage by new window width
                                // 4) by doing that, drag will look a lot more natural
                                //
                                // but for anvil needs setting location to pointer location is fine
                                let pos = pointer.current_location();
                                initial_window_location = (pos.x as i32, pos.y as i32).into();
                            }
                        }
                    }

                    let grab = MoveSurfaceGrab {
                        start_data,
                        window_map: state.window_map.clone(),
                        toplevel,
                        initial_window_location,
                    };

                    pointer.set_grab(grab, serial);
                }

                XdgRequest::Resize {
                    surface,
                    seat,
                    serial,
                    edges,
                } => {
                    let seat = Seat::from_resource(&seat).unwrap();
                    // TODO: touch resize.
                    let pointer = seat.get_pointer().unwrap();

                    // Check that this surface has a click grab.
                    if !pointer.has_grab(serial) {
                        return;
                    }

                    let start_data = pointer.grab_start_data().unwrap();

                    // If the focus was for a different surface, ignore the request.
                    if start_data.focus.is_none()
                        || !start_data
                            .focus
                            .as_ref()
                            .unwrap()
                            .0
                            .as_ref()
                            .same_client_as(surface.get_surface().unwrap().as_ref())
                    {
                        return;
                    }

                    let toplevel = SurfaceKind::Xdg(surface.clone());
                    let initial_window_location = state.window_map.borrow().location(&toplevel).unwrap();
                    let geometry = state.window_map.borrow().geometry(&toplevel).unwrap();
                    let initial_window_size = geometry.size;

                    with_states(surface.get_surface().unwrap(), move |states| {
                        states
                            .data_map
                            .get::<RefCell<SurfaceData>>()
                            .unwrap()
                            .borrow_mut()
                            .resize_state = ResizeState::Resizing(ResizeData {
                            edges: edges.into(),
                            initial_window_location,
                            initial_window_size,
                        });
                    })
                    .unwrap();

                    let grab = ResizeSurfaceGrab {
                        start_data,
                        toplevel,
                        edges: edges.into(),
                        initial_window_size,
                        last_window_size: initial_window_size,
                    };

                    pointer.set_grab(grab, serial);
                }

                XdgRequest::AckConfigure {
                    surface,
                    configure: Configure::Toplevel(configure),
                    ..
                } => {
                    let waiting_for_serial = with_states(&surface, |states| {
                        if let Some(data) = states.data_map.get::<RefCell<SurfaceData>>() {
                            if let ResizeState::WaitingForFinalAck(_, serial) = data.borrow().resize_state {
                                return Some(serial);
                            }
                        }

                        None
                    })
                    .unwrap();

                    if let Some(serial) = waiting_for_serial {
                        // When the resize grab is released the surface
                        // resize state will be set to WaitingForFinalAck
                        // and the client will receive a configure request
                        // without the resize state to inform the client
                        // resizing has finished. Here we will wait for
                        // the client to acknowledge the end of the
                        // resizing. To check if the surface was resizing
                        // before sending the configure we need to use
                        // the current state as the received acknowledge
                        // will no longer have the resize state set
                        let is_resizing = with_states(&surface, |states| {
                            states
                                .data_map
                                .get::<Mutex<XdgToplevelSurfaceRoleAttributes>>()
                                .unwrap()
                                .lock()
                                .unwrap()
                                .current
                                .states
                                .contains(xdg_toplevel::State::Resizing)
                        })
                        .unwrap();

                        if configure.serial >= serial && is_resizing {
                            with_states(&surface, |states| {
                                let mut data = states
                                    .data_map
                                    .get::<RefCell<SurfaceData>>()
                                    .unwrap()
                                    .borrow_mut();
                                if let ResizeState::WaitingForFinalAck(resize_data, _) = data.resize_state {
                                    data.resize_state = ResizeState::WaitingForCommit(resize_data);
                                } else {
                                    unreachable!()
                                }
                            })
                            .unwrap();
                        }
                    }
                }

                XdgRequest::Fullscreen { surface, output, .. } => {
                    // NOTE: This is only one part of the solution. We can set the
                    // location and configure size here, but the surface should be rendered fullscreen
                    // independently from its buffer size
                    let wl_surface = if let Some(surface) = surface.get_surface() {
                        surface
                    } else {
                        // If there is no underlying surface just ignore the request
                        return;
                    };

                    let output_geometry = fullscreen_output_geometry(
                        wl_surface,
                        output.as_ref(),
                        &state.window_map.borrow(),
                        &state.output_map.borrow(),
                    );

                    if let Some(geometry) = output_geometry {
                        if let Some(surface) = surface.get_surface() {
                            let mut xdg_window_map = state.window_map.borrow_mut();

                            if let Some(kind) = xdg_window_map.find(surface) {
                                xdg_window_map.set_location(&kind, geometry.loc);
                            }
                        }

                        let ret = surface.with_pending_state(|state| {
                            state.states.set(xdg_toplevel::State::Fullscreen);
                            state.size = Some(geometry.size);
                            state.fullscreen_output = output;
                        });
                        if ret.is_ok() {
                            surface.send_configure();
                        }
                    }
                }

                XdgRequest::UnFullscreen { surface } => {
                    let ret = surface.with_pending_state(|state| {
                        state.states.unset(xdg_toplevel::State::Fullscreen);
                        state.size = None;
                        state.fullscreen_output = None;
                    });
                    if ret.is_ok() {
                        surface.send_configure();
                    }
                }

                XdgRequest::Maximize { surface } => {
                    // NOTE: This should use layer-shell when it is implemented to
                    // get the correct maximum size
                    let output_geometry = {
                        let xdg_window_map = state.window_map.borrow();
                        surface
                            .get_surface()
                            .and_then(|s| xdg_window_map.find(s))
                            .and_then(|k| xdg_window_map.location(&k))
                            .and_then(|position| {
                                state
                                    .output_map
                                    .borrow()
                                    .find_by_position(position)
                                    .map(|o| o.geometry())
                            })
                    };

                    if let Some(geometry) = output_geometry {
                        if let Some(surface) = surface.get_surface() {
                            let mut xdg_window_map = state.window_map.borrow_mut();

                            if let Some(kind) = xdg_window_map.find(surface) {
                                xdg_window_map.set_location(&kind, geometry.loc);
                            }
                        }

                        let ret = surface.with_pending_state(|state| {
                            state.states.set(xdg_toplevel::State::Maximized);
                            state.size = Some(geometry.size);
                        });

                        if ret.is_ok() {
                            surface.send_configure();
                        }
                    }
                }
                XdgRequest::UnMaximize { surface } => {
                    let ret = surface.with_pending_state(|state| {
                        state.states.unset(xdg_toplevel::State::Maximized);
                        state.size = None;
                    });

                    if ret.is_ok() {
                        surface.send_configure();
                    }
                }
                _ => (),
            }
        },
        log.clone(),
    );

    // init the wl_shell
    let (wl_shell_state, _) = wl_shell_init(
        &mut *display.borrow_mut(),
        move |req: ShellRequest, mut ddata| {
            let state = ddata.get::<AnvilState<BackendData>>().unwrap();

            match req {
                ShellRequest::SetKind {
                    surface,
                    kind: ShellSurfaceKind::Toplevel,
                } => {
                    // place the window at a random location on the primary output
                    // or if there is not output in a [0;800]x[0;800] square
                    use rand::distributions::{Distribution, Uniform};

                    let output_geometry = state
                        .output_map
                        .borrow()
                        .with_primary()
                        .map(|o| o.geometry())
                        .unwrap_or_else(|| Rectangle::from_loc_and_size((0, 0), (800, 800)));
                    let max_x =
                        output_geometry.loc.x + (((output_geometry.size.w as f32) / 3.0) * 2.0) as i32;
                    let max_y =
                        output_geometry.loc.y + (((output_geometry.size.h as f32) / 3.0) * 2.0) as i32;
                    let x_range = Uniform::new(output_geometry.loc.x, max_x);
                    let y_range = Uniform::new(output_geometry.loc.y, max_y);
                    let mut rng = rand::thread_rng();
                    let x = x_range.sample(&mut rng);
                    let y = y_range.sample(&mut rng);
                    state
                        .window_map
                        .borrow_mut()
                        .insert(SurfaceKind::Wl(surface), (x, y).into());
                }

                ShellRequest::SetKind {
                    surface,
                    kind: ShellSurfaceKind::Fullscreen { output, .. },
                } => {
                    // NOTE: This is only one part of the solution. We can set the
                    // location and configure size here, but the surface should be rendered fullscreen
                    // independently from its buffer size
                    let wl_surface = if let Some(surface) = surface.get_surface() {
                        surface
                    } else {
                        // If there is no underlying surface just ignore the request
                        return;
                    };

                    let output_geometry = fullscreen_output_geometry(
                        wl_surface,
                        output.as_ref(),
                        &state.window_map.borrow(),
                        &state.output_map.borrow(),
                    );

                    if let Some(geometry) = output_geometry {
                        state
                            .window_map
                            .borrow_mut()
                            .insert(SurfaceKind::Wl(surface), geometry.loc);
                    }
                }

                ShellRequest::Move {
                    surface,
                    seat,
                    serial,
                } => {
                    let seat = Seat::from_resource(&seat).unwrap();
                    // TODO: touch move.
                    let pointer = seat.get_pointer().unwrap();

                    // Check that this surface has a click grab.
                    if !pointer.has_grab(serial) {
                        return;
                    }

                    let start_data = pointer.grab_start_data().unwrap();

                    // If the focus was for a different surface, ignore the request.
                    if start_data.focus.is_none()
                        || !start_data
                            .focus
                            .as_ref()
                            .unwrap()
                            .0
                            .as_ref()
                            .same_client_as(surface.get_surface().unwrap().as_ref())
                    {
                        return;
                    }

                    let toplevel = SurfaceKind::Wl(surface);
                    let initial_window_location = state.window_map.borrow().location(&toplevel).unwrap();

                    let grab = MoveSurfaceGrab {
                        start_data,
                        window_map: state.window_map.clone(),
                        toplevel,
                        initial_window_location,
                    };

                    pointer.set_grab(grab, serial);
                }

                ShellRequest::Resize {
                    surface,
                    seat,
                    serial,
                    edges,
                } => {
                    let seat = Seat::from_resource(&seat).unwrap();
                    // TODO: touch resize.
                    let pointer = seat.get_pointer().unwrap();

                    // Check that this surface has a click grab.
                    if !pointer.has_grab(serial) {
                        return;
                    }

                    let start_data = pointer.grab_start_data().unwrap();

                    // If the focus was for a different surface, ignore the request.
                    if start_data.focus.is_none()
                        || !start_data
                            .focus
                            .as_ref()
                            .unwrap()
                            .0
                            .as_ref()
                            .same_client_as(surface.get_surface().unwrap().as_ref())
                    {
                        return;
                    }

                    let toplevel = SurfaceKind::Wl(surface.clone());
                    let initial_window_location = state.window_map.borrow().location(&toplevel).unwrap();
                    let geometry = state.window_map.borrow().geometry(&toplevel).unwrap();
                    let initial_window_size = geometry.size;

                    with_states(surface.get_surface().unwrap(), move |states| {
                        states
                            .data_map
                            .get::<RefCell<SurfaceData>>()
                            .unwrap()
                            .borrow_mut()
                            .resize_state = ResizeState::Resizing(ResizeData {
                            edges: edges.into(),
                            initial_window_location,
                            initial_window_size,
                        });
                    })
                    .unwrap();

                    let grab = ResizeSurfaceGrab {
                        start_data,
                        toplevel,
                        edges: edges.into(),
                        initial_window_size,
                        last_window_size: initial_window_size,
                    };

                    pointer.set_grab(grab, serial);
                }
                _ => (),
            }
        },
        log.clone(),
    );

    smithay::wayland::shell::wlr_layer::wlr_layer_shell_init(
        &mut *display.borrow_mut(),
        move |event, mut ddata| match event {
            LayerShellRequest::NewLayerSurface {
                surface,
                output,
                layer,
                ..
            } => {
                let anvil_state = ddata.get::<AnvilState<BackendData>>().unwrap();
                let output_map = anvil_state.output_map.borrow();

                let output = output.and_then(|output| output_map.find_by_output(&output));
                let output = output.unwrap_or_else(|| {
                    output_map
                        .find_by_position(anvil_state.pointer_location.to_i32_round())
                        .unwrap_or_else(|| output_map.with_primary().unwrap())
                });

                if let Some(wl_surface) = surface.get_surface() {
                    output.add_layer_surface(wl_surface.clone());

                    anvil_state.window_map.borrow_mut().layers.insert(surface, layer);
                }
            }

            LayerShellRequest::AckConfigure { .. } => {}
        },
        log.clone(),
    );

    ShellHandles {
        xdg_state: xdg_shell_state,
        wl_state: wl_shell_state,
    }
}

/// Information about the resize operation.
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct ResizeData {
    /// The edges the surface is being resized with.
    edges: ResizeEdge,
    /// The initial window location.
    initial_window_location: Point<i32, Logical>,
    /// The initial window size (geometry width and height).
    initial_window_size: Size<i32, Logical>,
}

/// State of the resize operation.
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum ResizeState {
    /// The surface is not being resized.
    NotResizing,
    /// The surface is currently being resized.
    Resizing(ResizeData),
    /// The resize has finished, and the surface needs to ack the final configure.
    WaitingForFinalAck(ResizeData, Serial),
    /// The resize has finished, and the surface needs to commit its final state.
    WaitingForCommit(ResizeData),
}

impl Default for ResizeState {
    fn default() -> Self {
        ResizeState::NotResizing
    }
}

#[derive(Default)]
pub struct SurfaceData {
    pub buffer: Option<wl_buffer::WlBuffer>,
    pub texture: Option<Box<dyn std::any::Any + 'static>>,
    pub geometry: Option<Rectangle<i32, Logical>>,
    pub resize_state: ResizeState,
    pub buffer_dimensions: Option<Size<i32, Physical>>,
    pub buffer_scale: i32,
}

impl SurfaceData {
    pub fn update_buffer(&mut self, attrs: &mut SurfaceAttributes) {
        match attrs.buffer.take() {
            Some(BufferAssignment::NewBuffer { buffer, .. }) => {
                // new contents
                self.buffer_dimensions = buffer_dimensions(&buffer);
                self.buffer_scale = attrs.buffer_scale;
                if let Some(old_buffer) = std::mem::replace(&mut self.buffer, Some(buffer)) {
                    old_buffer.release();
                }
                self.texture = None;
            }
            Some(BufferAssignment::Removed) => {
                // remove the contents
                self.buffer = None;
                self.buffer_dimensions = None;
                self.texture = None;
            }
            None => {}
        }
    }

    /// Returns the size of the surface.
    pub fn size(&self) -> Option<Size<i32, Logical>> {
        self.buffer_dimensions
            .map(|dims| dims.to_logical(self.buffer_scale))
    }

    /// Checks if the surface's input region contains the point.
    pub fn contains_point(&self, attrs: &SurfaceAttributes, point: Point<f64, Logical>) -> bool {
        let size = match self.size() {
            None => return false, // If the surface has no size, it can't have an input region.
            Some(size) => size,
        };

        let rect = Rectangle {
            loc: (0, 0).into(),
            size,
        }
        .to_f64();

        // The input region is always within the surface itself, so if the surface itself doesn't contain the
        // point we can return false.
        if !rect.contains(point) {
            return false;
        }

        // If there's no input region, we're done.
        if attrs.input_region.is_none() {
            return true;
        }

        attrs
            .input_region
            .as_ref()
            .unwrap()
            .contains(point.to_i32_floor())
    }

    /// Send the frame callback if it had been requested
    pub fn send_frame(attrs: &mut SurfaceAttributes, time: u32) {
        for callback in attrs.frame_callbacks.drain(..) {
            callback.done(time);
        }
    }
}

fn surface_commit(
    surface: &wl_surface::WlSurface,
    window_map: &RefCell<WindowMap>,
    output_map: &RefCell<OutputMap>,
) {
    #[cfg(feature = "xwayland")]
    super::xwayland::commit_hook(surface);

    let mut window_map = window_map.borrow_mut();

    if !is_sync_subsurface(surface) {
        // Update the buffer of all child surfaces
        with_surface_tree_upward(
            surface,
            (),
            |_, _, _| TraversalAction::DoChildren(()),
            |_, states, _| {
                states
                    .data_map
                    .insert_if_missing(|| RefCell::new(SurfaceData::default()));
                let mut data = states
                    .data_map
                    .get::<RefCell<SurfaceData>>()
                    .unwrap()
                    .borrow_mut();
                data.update_buffer(&mut *states.cached_state.current::<SurfaceAttributes>());
            },
            |_, _, _| true,
        );
    }

    if let Some(toplevel) = window_map.find(surface) {
        // send the initial configure if relevant
        if let SurfaceKind::Xdg(ref toplevel) = toplevel {
            let initial_configure_sent = with_states(surface, |states| {
                states
                    .data_map
                    .get::<Mutex<XdgToplevelSurfaceRoleAttributes>>()
                    .unwrap()
                    .lock()
                    .unwrap()
                    .initial_configure_sent
            })
            .unwrap();
            if !initial_configure_sent {
                toplevel.send_configure();
            }
        }

        window_map.refresh_toplevel(&toplevel);

        let geometry = window_map.geometry(&toplevel).unwrap();
        let new_location = with_states(surface, |states| {
            let mut data = states
                .data_map
                .get::<RefCell<SurfaceData>>()
                .unwrap()
                .borrow_mut();

            let mut new_location = None;

            // If the window is being resized by top or left, its location must be adjusted
            // accordingly.
            match data.resize_state {
                ResizeState::Resizing(resize_data)
                | ResizeState::WaitingForFinalAck(resize_data, _)
                | ResizeState::WaitingForCommit(resize_data) => {
                    let ResizeData {
                        edges,
                        initial_window_location,
                        initial_window_size,
                    } = resize_data;

                    if edges.intersects(ResizeEdge::TOP_LEFT) {
                        let mut location = window_map.location(&toplevel).unwrap();

                        if edges.intersects(ResizeEdge::LEFT) {
                            location.x =
                                initial_window_location.x + (initial_window_size.w - geometry.size.w);
                        }
                        if edges.intersects(ResizeEdge::TOP) {
                            location.y =
                                initial_window_location.y + (initial_window_size.h - geometry.size.h);
                        }

                        new_location = Some(location);
                    }
                }
                ResizeState::NotResizing => (),
            }

            // Finish resizing.
            if let ResizeState::WaitingForCommit(_) = data.resize_state {
                data.resize_state = ResizeState::NotResizing;
            }

            new_location
        })
        .unwrap();

        if let Some(location) = new_location {
            window_map.set_location(&toplevel, location);
        }
    }

    if let Some(popup) = window_map.find_popup(surface) {
        let PopupKind::Xdg(ref popup) = popup;
        let initial_configure_sent = with_states(surface, |states| {
            states
                .data_map
                .get::<Mutex<XdgPopupSurfaceRoleAttributes>>()
                .unwrap()
                .lock()
                .unwrap()
                .initial_configure_sent
        })
        .unwrap();
        if !initial_configure_sent {
            // NOTE: This should never fail as the initial configure is always
            // allowed.
            popup.send_configure().expect("initial configure failed");
        }
    }

    if let Some(layer) = window_map.layers.find(surface) {
        // send the initial configure if relevant
        let initial_configure_sent = with_states(surface, |states| {
            states
                .data_map
                .get::<Mutex<LayerSurfaceAttributes>>()
                .unwrap()
                .lock()
                .unwrap()
                .initial_configure_sent
        })
        .unwrap();
        if !initial_configure_sent {
            layer.surface.send_configure();
        }

        if let Some(output) = output_map.borrow().find_by_layer_surface(surface) {
            window_map.layers.arange_layers(output);
        }
    }
}