monolith

//! wlr-foreign-toplevel-management-v1, for taskbars and window titles in

//! bars. Like ext-workspace, the compositor publishes a snapshot of its

//! windows and each client is sent the difference from what it has seen.

use smithay::output::Output;

use smithay::reexports::wayland_protocols_wlr::foreign_toplevel::v1::server::{

    zwlr_foreign_toplevel_handle_v1::{self, ZwlrForeignToplevelHandleV1},

    zwlr_foreign_toplevel_manager_v1::{self, ZwlrForeignToplevelManagerV1},

};

use smithay::reexports::wayland_server::backend::{ClientId, GlobalId};

use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;

use smithay::reexports::wayland_server::{

    Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,

};

use smithay::wayland::{Dispatch2, GlobalDispatch2};

#[derive(Clone, Debug, Default, PartialEq)]

pub struct Snapshot {

    pub toplevels: Vec<Toplevel>,

}

#[derive(Clone, Debug, PartialEq)]

pub struct Toplevel {

    /// Stable for the window's lifetime.

    pub key: u64,

    pub title: String,

    pub app_id: String,

    pub outputs: Vec<Output>,

    pub activated: bool,

    pub maximized: bool,

    pub fullscreen: bool,

}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum Action {

    Activate(u64),

    Close(u64),

    Maximize(u64, bool),

    Fullscreen(u64, bool),

}

pub trait ForeignToplevelHandler {

    fn foreign_toplevel_state(&mut self) -> &mut ForeignToplevelState;

    fn foreign_toplevel_action(&mut self, action: Action);

}

struct Sent {

    handle: ZwlrForeignToplevelHandleV1,

    last: Toplevel,

    outputs: Vec<WlOutput>,

}

struct Manager {

    handle: ZwlrForeignToplevelManagerV1,

    toplevels: Vec<Sent>,

}

pub struct ForeignToplevelState {

    global: GlobalId,

    managers: Vec<Manager>,

    snapshot: Snapshot,

}

pub struct ManagerGlobal;

pub struct ManagerData;

pub struct HandleData {

    key: u64,

}

impl ForeignToplevelState {

    pub fn new<D>(dh: &DisplayHandle) -> Self

    where

        D: GlobalDispatch<ZwlrForeignToplevelManagerV1, ManagerGlobal> + 'static,

    {

        Self {

            global: dh.create_global::<D, ZwlrForeignToplevelManagerV1, _>(3, ManagerGlobal),

            managers: Vec::new(),

            snapshot: Snapshot::default(),

        }

    }

    pub fn global(&self) -> GlobalId {

        self.global.clone()

    }

    pub fn update<D>(&mut self, dh: &DisplayHandle, snapshot: Snapshot)

    where

        D: Dispatch<ZwlrForeignToplevelHandleV1, HandleData> + 'static,

    {

        self.snapshot = snapshot;

        self.managers.retain(|m| m.handle.is_alive());

        for m in &mut self.managers {

            sync::<D>(dh, m, &self.snapshot);

        }

    }

}

fn sync<D>(dh: &DisplayHandle, m: &mut Manager, snap: &Snapshot)

where

    D: Dispatch<ZwlrForeignToplevelHandleV1, HandleData> + 'static,

{

    let Ok(client) = dh.get_client(m.handle.id()) else {

        return;

    };

    m.toplevels.retain(|t| {

        let keep = snap.toplevels.iter().any(|s| s.key == t.last.key);

        if !keep {

            t.handle.closed();

        }

        keep

    });

    for top in &snap.toplevels {

        let i = match m.toplevels.iter().position(|t| t.last.key == top.key) {

            Some(i) => i,

            None => {

                let Ok(handle) = client.create_resource::<ZwlrForeignToplevelHandleV1, _, D>(

                    dh,

                    m.handle.version(),

                    HandleData { key: top.key },

                ) else {

                    continue;

                };

                m.handle.toplevel(&handle);

                send_props(&handle, None, top);

                m.toplevels.push(Sent {

                    handle,

                    last: top.clone(),

                    outputs: Vec::new(),

                });

                let sent = m.toplevels.last_mut().expect("just pushed");

                sync_outputs(&client, sent, top);

                sent.handle.done();

                continue;

            }

        };

        let sent = &mut m.toplevels[i];

        let mut changed = sync_outputs(&client, sent, top);

        if sent.last != *top {

            send_props(&sent.handle, Some(&sent.last), top);

            sent.last = top.clone();

            changed = true;

        }

        if changed {

            sent.handle.done();

        }

    }

}

/// Sends output enter and leave for the client's wl_outputs. Returns

/// whether anything was sent.

fn sync_outputs(client: &Client, sent: &mut Sent, top: &Toplevel) -> bool {

    let want: Vec<WlOutput> = top

        .outputs

        .iter()

        .flat_map(|o| o.client_outputs(client))

        .collect();

    let mut changed = false;

    sent.outputs.retain(|o| {

        let keep = o.is_alive() && want.contains(o);

        if !keep && o.is_alive() {

            sent.handle.output_leave(o);

            changed = true;

        }

        keep

    });

    for wl in want {

        if !sent.outputs.contains(&wl) {

            sent.handle.output_enter(&wl);

            sent.outputs.push(wl);

            changed = true;

        }

    }

    changed

}

fn send_props(h: &ZwlrForeignToplevelHandleV1, old: Option<&Toplevel>, new: &Toplevel) {

    if old.is_none_or(|o| o.title != new.title) {

        h.title(new.title.clone());

    }

    if old.is_none_or(|o| o.app_id != new.app_id) {

        h.app_id(new.app_id.clone());

    }

    let states = |t: &Toplevel| {

        let mut s: Vec<u32> = Vec::new();

        if t.maximized {

            s.push(zwlr_foreign_toplevel_handle_v1::State::Maximized as u32);

        }

        if t.activated {

            s.push(zwlr_foreign_toplevel_handle_v1::State::Activated as u32);

        }

        if t.fullscreen && h.version() >= 2 {

            s.push(zwlr_foreign_toplevel_handle_v1::State::Fullscreen as u32);

        }

        s

    };

    if old.is_none_or(|o| states(o) != states(new)) {

        h.state(states(new).iter().flat_map(|s| s.to_ne_bytes()).collect());

    }

}

impl<D> GlobalDispatch2<ZwlrForeignToplevelManagerV1, D> for ManagerGlobal

where

    D: ForeignToplevelHandler

        + Dispatch<ZwlrForeignToplevelManagerV1, ManagerData>

        + Dispatch<ZwlrForeignToplevelHandleV1, HandleData>

        + 'static,

{

    fn bind(

        &self,

        state: &mut D,

        dh: &DisplayHandle,

        _client: &Client,

        resource: New<ZwlrForeignToplevelManagerV1>,

        data_init: &mut DataInit<'_, D>,

    ) {

        let handle = data_init.init(resource, ManagerData);

        let s = state.foreign_toplevel_state();

        let mut m = Manager {

            handle,

            toplevels: Vec::new(),

        };

        sync::<D>(dh, &mut m, &s.snapshot);

        s.managers.push(m);

    }

}

impl<D: ForeignToplevelHandler> Dispatch2<ZwlrForeignToplevelManagerV1, D> for ManagerData {

    fn request(

        &self,

        state: &mut D,

        _client: &Client,

        resource: &ZwlrForeignToplevelManagerV1,

        request: zwlr_foreign_toplevel_manager_v1::Request,

        _dh: &DisplayHandle,

        _data_init: &mut DataInit<'_, D>,

    ) {

        if let zwlr_foreign_toplevel_manager_v1::Request::Stop = request {

            resource.finished();

            state

                .foreign_toplevel_state()

                .managers

                .retain(|m| m.handle != *resource);

        }

    }

    fn destroyed(&self, state: &mut D, _client: ClientId, resource: &ZwlrForeignToplevelManagerV1) {

        state

            .foreign_toplevel_state()

            .managers

            .retain(|m| m.handle != *resource);

    }

}

impl<D: ForeignToplevelHandler> Dispatch2<ZwlrForeignToplevelHandleV1, D> for HandleData {

    fn request(

        &self,

        state: &mut D,

        _client: &Client,

        _resource: &ZwlrForeignToplevelHandleV1,

        request: zwlr_foreign_toplevel_handle_v1::Request,

        _dh: &DisplayHandle,

        _data_init: &mut DataInit<'_, D>,

    ) {

        use zwlr_foreign_toplevel_handle_v1::Request;

        let action = match request {

            Request::Activate { .. } => Action::Activate(self.key),

            Request::Close => Action::Close(self.key),

            Request::SetMaximized => Action::Maximize(self.key, true),

            Request::UnsetMaximized => Action::Maximize(self.key, false),

            Request::SetFullscreen { .. } => Action::Fullscreen(self.key, true),

            Request::UnsetFullscreen => Action::Fullscreen(self.key, false),

            _ => return,

        };

        state.foreign_toplevel_action(action);

    }

    fn destroyed(&self, state: &mut D, _client: ClientId, resource: &ZwlrForeignToplevelHandleV1) {

        for m in &mut state.foreign_toplevel_state().managers {

            m.toplevels.retain(|t| t.handle != *resource);

        }

    }

}