wip: New shell logic

src/shell/element/stack.rs

@@ -0,0 +1,293 @@
+use crate::state::State;
+use smithay::{
+    backend::{
+        input::KeyState,
+        renderer::{
+            element::{surface::WaylandSurfaceRenderElement, AsRenderElements},
+            ImportAll, Renderer,
+        },
+    },
+    desktop::{space::SpaceElement, Kind, Window},
+    input::{
+        keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
+        pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget},
+        Seat,
+    },
+    output::Output,
+    render_elements,
+    utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size},
+};
+use std::{
+    hash::Hash,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc, Mutex,
+    },
+};
+
+#[derive(Debug, Clone)]
+pub struct CosmicStack {
+    windows: Arc<Mutex<Vec<Window>>>,
+    active: Arc<AtomicUsize>,
+    pub(super) header: Arc<Mutex<Option<HeaderBar>>>,
+}
+
+impl PartialEq for CosmicStack {
+    fn eq(&self, other: &Self) -> bool {
+        *self.windows.lock().unwrap() == *other.windows.lock().unwrap()
+    }
+}
+
+impl Eq for CosmicStack {}
+
+impl Hash for CosmicStack {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        Arc::as_ptr(&self.windows).hash(state)
+    }
+}
+
+#[derive(Debug)]
+pub struct HeaderBar {}
+
+impl HeaderBar {
+    pub fn height(&self) -> i32 {
+        0
+    }
+}
+
+impl CosmicStack {
+    pub fn active(&self) -> Window {
+        self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)].clone()
+    }
+
+    pub fn set_active(&self, window: &Window) {
+        if let Some(val) = self
+            .windows
+            .lock()
+            .unwrap()
+            .iter()
+            .position(|w| w == window)
+        {
+            self.active.store(val, Ordering::SeqCst)
+        }
+    }
+
+    pub fn set_size(&self, size: Size<i32, Logical>) {
+        let surface_size = (
+            size.w,
+            size.h
+                - self
+                    .header
+                    .lock()
+                    .unwrap()
+                    .as_ref()
+                    .map(|h| h.height())
+                    .unwrap_or(0),
+        )
+            .into();
+
+        for window in self.windows.lock().unwrap().iter() {
+            match window.toplevel() {
+                Kind::Xdg(xdg) => xdg.with_pending_state(|state| state.size = Some(surface_size)),
+            };
+        }
+    }
+}
+
+impl IsAlive for CosmicStack {
+    fn alive(&self) -> bool {
+        self.windows.lock().unwrap().iter().any(IsAlive::alive)
+    }
+}
+
+impl SpaceElement for CosmicStack {
+    fn bbox(&self) -> Rectangle<i32, Logical> {
+        SpaceElement::bbox(&self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)])
+    }
+    fn is_in_input_region(&self, point: &Point<f64, Logical>) -> bool {
+        SpaceElement::is_in_input_region(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            point,
+        )
+    }
+    fn set_activate(&self, activated: bool) {
+        self.windows
+            .lock()
+            .unwrap()
+            .iter()
+            .for_each(|w| SpaceElement::set_activate(w, activated))
+    }
+    fn output_enter(&self, output: &Output, overlap: Rectangle<i32, Logical>) {
+        self.windows
+            .lock()
+            .unwrap()
+            .iter()
+            .for_each(|w| SpaceElement::output_enter(w, output, overlap))
+    }
+    fn output_leave(&self, output: &Output) {
+        self.windows
+            .lock()
+            .unwrap()
+            .iter()
+            .for_each(|w| SpaceElement::output_leave(w, output))
+    }
+    fn geometry(&self) -> Rectangle<i32, Logical> {
+        SpaceElement::geometry(&self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)])
+    }
+    fn z_index(&self) -> u8 {
+        SpaceElement::z_index(&self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)])
+    }
+    fn refresh(&self) {
+        let mut windows = self.windows.lock().unwrap();
+        windows.retain(IsAlive::alive);
+        let len = windows.len();
+        let _ = self
+            .active
+            .fetch_update(Ordering::SeqCst, Ordering::SeqCst, |active| {
+                (active > len).then_some(len - 1)
+            });
+        windows.iter().for_each(|w| SpaceElement::refresh(w))
+    }
+}
+
+impl KeyboardTarget<State> for CosmicStack {
+    fn enter(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        keys: Vec<KeysymHandle<'_>>,
+        serial: Serial,
+    ) {
+        KeyboardTarget::enter(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            seat,
+            data,
+            keys,
+            serial,
+        )
+    }
+    fn leave(&self, seat: &Seat<State>, data: &mut State, serial: Serial) {
+        KeyboardTarget::leave(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            seat,
+            data,
+            serial,
+        )
+    }
+    fn key(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        key: KeysymHandle<'_>,
+        state: KeyState,
+        serial: Serial,
+        time: u32,
+    ) {
+        KeyboardTarget::key(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            seat,
+            data,
+            key,
+            state,
+            serial,
+            time,
+        )
+    }
+    fn modifiers(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        modifiers: ModifiersState,
+        serial: Serial,
+    ) {
+        KeyboardTarget::modifiers(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            seat,
+            data,
+            modifiers,
+            serial,
+        )
+    }
+}
+
+impl PointerTarget<State> for CosmicStack {
+    fn enter(&self, seat: &Seat<State>, data: &mut State, event: &MotionEvent) {
+        PointerTarget::enter(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            seat,
+            data,
+            event,
+        )
+    }
+    fn motion(&self, seat: &Seat<State>, data: &mut State, event: &MotionEvent) {
+        PointerTarget::motion(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            seat,
+            data,
+            event,
+        )
+    }
+    fn button(&self, seat: &Seat<State>, data: &mut State, event: &ButtonEvent) {
+        PointerTarget::button(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            seat,
+            data,
+            event,
+        )
+    }
+    fn axis(&self, seat: &Seat<State>, data: &mut State, frame: AxisFrame) {
+        PointerTarget::axis(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            seat,
+            data,
+            frame,
+        )
+    }
+    fn leave(&self, seat: &Seat<State>, data: &mut State, serial: Serial, time: u32) {
+        PointerTarget::leave(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            seat,
+            data,
+            serial,
+            time,
+        )
+    }
+}
+
+render_elements! {
+    pub CosmicStackRenderElement<R> where R: ImportAll;
+    Window=WaylandSurfaceRenderElement,
+}
+
+impl<R> AsRenderElements<R> for CosmicStack
+where
+    R: Renderer + ImportAll,
+    <R as Renderer>::TextureId: 'static,
+{
+    type RenderElement = CosmicStackRenderElement<R>;
+    fn render_elements<C: From<Self::RenderElement>>(
+        &self,
+        location: Point<i32, Physical>,
+        scale: Scale<f64>,
+    ) -> Vec<C> {
+        AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
+            &self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
+            location,
+            scale,
+        )
+        .into_iter()
+        .map(C::from)
+        .collect()
+    }
+}
+impl CosmicStack {
+    pub fn windows(&self) -> impl Iterator<Item = Window> {
+        self.windows
+            .lock()
+            .unwrap()
+            .iter()
+            .cloned()
+            .collect::<Vec<_>>()
+            .into_iter()
+    }
+}