cosmic-comp/src/shell/handler.rs

// SPDX-License-Identifier: GPL-3.0-only

use crate::{config::Config, input::active_output, state::State, utils::SurfaceDropNotifier};
use smithay::{
    backend::renderer::utils::on_commit_buffer_handler,
    desktop::{
        layer_map_for_output, Kind, LayerSurface, PopupKeyboardGrab, PopupKind, PopupPointerGrab,
        PopupUngrabStrategy, Window,
    },
    reexports::{
        wayland_protocols::xdg_shell::server::xdg_toplevel,
        wayland_server::{protocol::wl_surface::WlSurface, Display},
    },
    wayland::{
        compositor::{compositor_init, with_states},
        output::Output,
        seat::{PointerGrabStartData, Seat},
        shell::{
            wlr_layer::{wlr_layer_shell_init, LayerShellRequest, LayerSurfaceAttributes},
            xdg::{
                xdg_shell_init, Configure, XdgPopupSurfaceRoleAttributes, XdgRequest,
                XdgToplevelSurfaceRoleAttributes,
            },
        },
        Serial,
    },
};
use std::{cell::Cell, rc::Rc, sync::Mutex};

pub fn init_shell(config: &Config, display: &mut Display) -> super::Shell {
    compositor_init(
        display,
        move |surface, mut ddata| {
            on_commit_buffer_handler(&surface);
            let state = ddata.get::<State>().unwrap();
            state.common.shell.commit(&surface);
            commit(&surface, state)
        },
        None,
    );

    let popup_grab = Rc::new(Cell::new(None));
    let popup_grab_clone = popup_grab.clone();
    let (_xdg_shell_state, _xdg_global) = xdg_shell_init(
        display,
        move |event, mut ddata| {
            let state = &mut ddata.get::<State>().unwrap().common;

            match event {
                XdgRequest::NewToplevel { surface } => {
                    state.pending_toplevels.push(surface.clone());

                    let seat = &state.last_active_seat;
                    let output = active_output(seat, &*state);
                    let space = state.shell.active_space_mut(&output);
                    let window = Window::new(Kind::Xdg(surface));
                    space.pending_window(window, seat);
                    // We will position the window after the first commit, when we know its size
                }
                XdgRequest::NewPopup { surface, .. } => {
                    state
                        .shell
                        .popups
                        .track_popup(PopupKind::from(surface))
                        .unwrap();
                }
                XdgRequest::RePosition {
                    surface,
                    positioner,
                    token,
                } => {
                    let result = surface.with_pending_state(|state| {
                        // TODO: This is a simplification, a proper compositor would
                        // calculate the geometry of the popup here.
                        // For now 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();
                    if let Some(start_data) =
                        check_grab_preconditions(&seat, surface.get_surface(), serial)
                    {
                        let workspace = state
                            .shell
                            .space_for_surface_mut(surface.get_surface().unwrap())
                            .unwrap();
                        let window = workspace
                            .space
                            .window_for_surface(surface.get_surface().unwrap())
                            .unwrap()
                            .clone();

                        workspace.move_request(&window, &seat, serial, start_data);
                    }
                }

                XdgRequest::Resize {
                    surface,
                    seat,
                    serial,
                    edges,
                } => {
                    let seat = Seat::from_resource(&seat).unwrap();
                    if let Some(start_data) =
                        check_grab_preconditions(&seat, surface.get_surface(), serial)
                    {
                        let workspace = state
                            .shell
                            .space_for_surface_mut(surface.get_surface().unwrap())
                            .unwrap();
                        let window = workspace
                            .space
                            .window_for_surface(surface.get_surface().unwrap())
                            .unwrap()
                            .clone();

                        workspace.resize_request(&window, &seat, serial, start_data, edges);
                    }
                }
                XdgRequest::AckConfigure {
                    surface,
                    configure: Configure::Toplevel(configure),
                } => {
                    // TODO: This is way to hardcoded and hacky,  but wayland-rs 0.30 will make this unnecessary so don't bother.
                    if let Some(window) = state
                        .shell
                        .space_for_surface(&surface)
                        .and_then(|workspace| workspace.space.window_for_surface(&surface))
                    {
                        crate::shell::layout::floating::ResizeSurfaceGrab::ack_configure(
                            window, configure,
                        )
                    }
                }
                XdgRequest::Maximize { surface } => {
                    if let Some(surface) = surface.get_surface() {
                        let seat = &state.last_active_seat;
                        let output = active_output(seat, &*state);

                        if let Some(workspace) = state.shell.space_for_surface_mut(surface) {
                            let window =
                                workspace.space.window_for_surface(surface).unwrap().clone();
                            workspace.maximize_request(&window, &output)
                        }
                    }
                }
                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();
                    }
                }
                XdgRequest::Grab {
                    serial,
                    surface,
                    seat,
                } => {
                    let seat = Seat::from_resource(&seat).unwrap();
                    let ret = state.shell.popups.grab_popup(surface.into(), &seat, serial);

                    if let Ok(mut grab) = ret {
                        if let Some(keyboard) = seat.get_keyboard() {
                            if keyboard.is_grabbed()
                                && !(keyboard.has_grab(serial)
                                    || keyboard.has_grab(grab.previous_serial().unwrap_or(serial)))
                            {
                                grab.ungrab(PopupUngrabStrategy::All);
                                return;
                            }
                            keyboard.set_focus(grab.current_grab().as_ref(), serial);
                            keyboard.set_grab(PopupKeyboardGrab::new(&grab), serial);
                        }

                        if let Some(pointer) = seat.get_pointer() {
                            if pointer.is_grabbed()
                                && !(pointer.has_grab(serial)
                                    || pointer.has_grab(
                                        grab.previous_serial().unwrap_or_else(|| grab.serial()),
                                    ))
                            {
                                grab.ungrab(PopupUngrabStrategy::All);
                                return;
                            }
                            pointer.set_grab(PopupPointerGrab::new(&grab), serial, 0);
                        }

                        popup_grab_clone.set(Some(grab));
                    }
                }
                _ => { /*TODO*/ }
            }
        },
        None,
    );

    let (_layer_shell_state, _layer_global) = wlr_layer_shell_init(
        display,
        |event, mut ddata| match event {
            LayerShellRequest::NewLayerSurface {
                surface,
                output: wl_output,
                namespace,
                ..
            } => {
                let state = &mut ddata.get::<State>().unwrap().common;
                let seat = &state.last_active_seat;
                let output = wl_output
                    .as_ref()
                    .and_then(Output::from_resource)
                    .unwrap_or_else(|| active_output(seat, &*state));

                let mut map = layer_map_for_output(&output);
                map.map_layer(&LayerSurface::new(surface, namespace))
                    .unwrap();
            }
            _ => {}
        },
        None,
    );

    super::Shell::new(config, popup_grab)
}

fn check_grab_preconditions(
    seat: &Seat,
    surface: Option<&WlSurface>,
    serial: Serial,
) -> Option<PointerGrabStartData> {
    let surface = if let Some(surface) = surface {
        surface
    } else {
        return None;
    };

    // TODO: touch resize.
    let pointer = seat.get_pointer().unwrap();

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

    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.as_ref())
    {
        return None;
    }

    Some(start_data)
}

fn commit(surface: &WlSurface, state: &mut State) {
    // TODO figure out which output the surface is on.
    for output in state.common.shell.outputs() {
        //.cloned().collect::<Vec<_>>().into_iter() {
        state.backend.schedule_render(output);
        // let space = state.common.spaces.active_space(output);
        // get output for surface
    }

    let state = &mut state.common;
    let _ = with_states(surface, |states| {
        states
            .data_map
            .insert_if_missing(|| SurfaceDropNotifier::from(&*state));
    });

    if let Some(toplevel) = state.pending_toplevels.iter().find(|toplevel| {
        toplevel
            .get_surface()
            .map(|s| s == surface)
            .unwrap_or(false)
    }) {
        // send the initial configure if relevant
        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();
        }

        return;
    }

    // TODO: This is way to hardcoded and hacky,  but wayland-rs 0.30 will make this unnecessary so don't bother.
    if let Some((space, window)) =
        state
            .shell
            .space_for_surface_mut(surface)
            .and_then(|workspace| {
                workspace
                    .space
                    .window_for_surface(surface)
                    .cloned()
                    .map(|window| (&mut workspace.space, window))
            })
    {
        let new_location = crate::shell::layout::floating::ResizeSurfaceGrab::apply_resize_state(
            &window,
            space.window_location(&window).unwrap(),
            window.geometry().size,
        );
        if let Some(location) = new_location {
            space.map_window(&window, location, true);
        }

        return;
    }

    if let Some(popup) = state.shell.popups.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");
        }

        return;
    }

    if let Some(output) = state.shell.outputs().find(|o| {
        let map = layer_map_for_output(o);
        map.layer_for_surface(surface).is_some()
    }) {
        let mut map = layer_map_for_output(output);
        let layer = map.layer_for_surface(surface).unwrap();

        // 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.layer_surface().send_configure();
        }

        map.arrange();

        return;
    };
}