autocommit 2022-01-25 16:45:44 CET

src/tree.rs

@@ -1,222 +0,0 @@
-use crate::backend::{Output, OutputId};
-use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::XdgToplevel;
-use crate::utils::clonecell::CloneCell;
-use crate::utils::copyhashmap::CopyHashMap;
-use crate::utils::linkedlist::{LinkedList, Node as LinkedNode};
-use ahash::AHashMap;
-use std::cell::{Cell, RefCell};
-use std::mem;
-use std::rc::Rc;
-
-linear_ids!(NodeIds, NodeId);
-
-pub trait NodeBase {
-    fn id(&self) -> NodeId;
-    fn parent(&self) -> Option<Rc<dyn Node>>;
-    fn extents(&self) -> NodeExtents;
-}
-
-macro_rules! base {
-    ($name:ident) => {
-        impl NodeBase for $name {
-            fn id(&self) -> NodeId {
-                self.common.id
-            }
-
-            fn parent(&self) -> Option<Rc<dyn Node>> {
-                self.common.parent.clone()
-            }
-
-            fn extents(&self) -> NodeExtents {
-                self.common.extents.get()
-            }
-        }
-    };
-}
-
-pub trait Node: NodeBase {
-    fn into_kind(self: Rc<Self>) -> NodeKind;
-    fn clear(&self);
-    fn find_node_at(self: Rc<Self>, x: i32, y: i32) -> (Rc<dyn Node>, i32, i32);
-}
-
-pub enum NodeKind {
-    Display(Rc<DisplayNode>),
-    Output(Rc<OutputNode>),
-    Toplevel(Rc<ToplevelNode>),
-    Container(Rc<ContainerNode>),
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
-pub struct NodeExtents {
-    pub x: i32,
-    pub y: i32,
-    pub width: u32,
-    pub height: u32,
-}
-
-impl NodeExtents {
-    pub fn contains(&self, x: i32, y: i32) -> bool {
-        self.x <= x
-            && self.y <= y
-            && (x - self.x) as u32 <= self.width
-            && (y - self.y) as u32 <= self.height
-    }
-
-    pub fn translate(&self, x: i32, y: i32) -> Option<(i32, i32)> {
-        if self.contains(x, y) {
-            Some((x - self.x, y - self.y))
-        } else {
-            None
-        }
-    }
-}
-
-pub struct NodeCommon {
-    pub extents: Cell<NodeExtents>,
-    pub id: NodeId,
-    pub parent: Option<Rc<dyn Node>>,
-    pub floating_outputs: RefCell<AHashMap<NodeId, LinkedNode<Rc<dyn Node>>>>,
-}
-
-impl NodeCommon {
-    fn clear(&self) {
-        mem::take(&mut *self.floating_outputs.borrow_mut());
-    }
-}
-
-pub struct DisplayNode {
-    pub common: NodeCommon,
-    pub outputs: CopyHashMap<OutputId, Rc<OutputNode>>,
-}
-
-impl DisplayNode {
-    pub fn new(id: NodeId) -> Self {
-        Self {
-            common: NodeCommon {
-                extents: Default::default(),
-                id,
-                parent: None,
-                floating_outputs: Default::default(),
-            },
-            outputs: Default::default(),
-        }
-    }
-}
-
-base!(DisplayNode);
-
-impl Node for DisplayNode {
-    fn into_kind(self: Rc<Self>) -> NodeKind {
-        NodeKind::Display(self)
-    }
-
-    fn clear(&self) {
-        self.common.clear();
-        let mut outputs = self.outputs.lock();
-        for output in outputs.values() {
-            output.clear();
-        }
-        outputs.clear();
-    }
-
-    fn find_node_at(self: Rc<Self>, x: i32, y: i32) -> (Rc<dyn Node>, i32, i32) {
-        {
-            let outputs = self.outputs.lock();
-            for output in outputs.values() {
-                if let Some((x, y)) = output.common.extents.get().translate(x, y) {
-                    return output.clone().find_node_at(x, y);
-                }
-            }
-        }
-        (self, x, y)
-    }
-}
-
-pub struct OutputNode {
-    pub common: NodeCommon,
-    pub backend: Rc<dyn Output>,
-    pub child: CloneCell<Option<Rc<dyn Node>>>,
-    pub floating: LinkedList<Rc<dyn Node>>,
-}
-
-base!(OutputNode);
-
-impl Node for OutputNode {
-    fn into_kind(self: Rc<Self>) -> NodeKind {
-        NodeKind::Output(self)
-    }
-
-    fn clear(&self) {
-        self.common.clear();
-        for floating in self.floating.iter() {
-            floating.clear();
-        }
-        if let Some(child) = self.child.take() {
-            child.clear();
-        }
-    }
-
-    fn find_node_at(self: Rc<Self>, x: i32, y: i32) -> (Rc<dyn Node>, i32, i32) {
-        for f in self.floating.rev_iter() {
-            let e = f.extents();
-            if let Some((x, y)) = e.translate(x, y) {
-                return f.clone().find_node_at(x, y);
-            }
-        }
-        (self, x, y)
-    }
-}
-
-pub struct ToplevelNode {
-    pub common: NodeCommon,
-    pub surface: Rc<XdgToplevel>,
-}
-
-base!(ToplevelNode);
-
-impl Node for ToplevelNode {
-    fn into_kind(self: Rc<Self>) -> NodeKind {
-        NodeKind::Toplevel(self)
-    }
-
-    fn clear(&self) {
-        self.common.clear();
-    }
-
-    fn find_node_at(self: Rc<Self>, x: i32, y: i32) -> (Rc<dyn Node>, i32, i32) {
-        (self, x, y)
-    }
-}
-
-#[allow(dead_code)]
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum ContainerSplit {
-    Horizontal,
-    Vertical,
-}
-
-pub struct ContainerNode {
-    pub common: NodeCommon,
-    pub split: Cell<ContainerSplit>,
-    pub children: LinkedList<Rc<dyn Node>>,
-}
-
-base!(ContainerNode);
-
-impl Node for ContainerNode {
-    fn into_kind(self: Rc<Self>) -> NodeKind {
-        NodeKind::Container(self)
-    }
-
-    fn clear(&self) {
-        for child in self.children.iter() {
-            child.clear();
-        }
-    }
-
-    fn find_node_at(self: Rc<Self>, x: i32, y: i32) -> (Rc<dyn Node>, i32, i32) {
-        (self, x, y)
-        // todo
-    }
-}