autocommit 2022-02-21 23:21:13 CET

src/tree/container.rs

@@ -345,7 +345,13 @@ impl ContainerNode {
                     }
                     _ => {
                         let height = body.height() + add;
-                        (0, pos + title_height + 1, other_content_size, height, height)
+                        (
+                            0,
+                            pos + title_height + 1,
+                            other_content_size,
+                            height,
+                            height,
+                        )
                     }
                 };
                 body = Rect::new_sized(x1, y1, width, height).unwrap();

src/tree/mod.rs

@@ -2,13 +2,11 @@ use crate::backend::{KeyState, OutputId, ScrollAxis};
 use crate::client::{Client, ClientId};
 use crate::cursor::KnownCursor;
 use crate::fixed::Fixed;
-use crate::ifs::wl_output::WlOutputGlobal;
 use crate::ifs::wl_seat::{Dnd, NodeSeatState, WlSeatGlobal};
 use crate::ifs::wl_surface::WlSurface;
 use crate::rect::Rect;
 use crate::render::Renderer;
 use crate::tree::walker::NodeVisitor;
-use crate::utils::clonecell::CloneCell;
 use crate::utils::copyhashmap::CopyHashMap;
 use crate::utils::linkedlist::LinkedList;
 use crate::xkbcommon::ModifierState;
@@ -16,16 +14,17 @@ use crate::NumCell;
 pub use container::*;
 pub use float::*;
 use i4config::Direction;
-use std::cell::{Cell, RefCell};
-use std::fmt::{Debug, Display, Formatter};
+use std::fmt::{Debug, Display};
 use std::ops::Deref;
 use std::rc::Rc;
 pub use workspace::*;
+pub use output::*;
 
 mod container;
 mod float;
 pub mod walker;
 mod workspace;
+mod output;
 
 pub struct NodeIds {
     next: NumCell<u32>,
@@ -254,6 +253,14 @@ pub trait Node {
         false
     }
 
+    fn is_output(&self) -> bool {
+        false
+    }
+
+    fn into_output(self: Rc<Self>) -> Option<Rc<OutputNode>> {
+        None
+    }
+
     fn accepts_child(&self, node: &dyn Node) -> bool {
         let _ = node;
         false
@@ -422,87 +429,3 @@ impl Node for DisplayNode {
         seat.set_known_cursor(KnownCursor::Default);
     }
 }
-
-tree_id!(OutputNodeId);
-pub struct OutputNode {
-    pub display: Rc<DisplayNode>,
-    pub id: OutputNodeId,
-    pub position: Cell<Rect>,
-    pub global: Rc<WlOutputGlobal>,
-    pub workspaces: RefCell<Vec<Rc<WorkspaceNode>>>,
-    pub workspace: CloneCell<Option<Rc<WorkspaceNode>>>,
-    pub seat_state: NodeSeatState,
-}
-
-impl Debug for OutputNode {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("OutputNode").finish_non_exhaustive()
-    }
-}
-
-impl Node for OutputNode {
-    fn id(&self) -> NodeId {
-        self.id.into()
-    }
-
-    fn seat_state(&self) -> &NodeSeatState {
-        &self.seat_state
-    }
-
-    fn destroy_node(&self, detach: bool) {
-        if detach {
-            self.display.clone().remove_child(self);
-        }
-        let mut workspaces = self.workspaces.borrow_mut();
-        for workspace in workspaces.drain(..) {
-            workspace.destroy_node(false);
-        }
-        self.seat_state.destroy_node(self);
-    }
-
-    fn visit(self: Rc<Self>, visitor: &mut dyn NodeVisitor) {
-        visitor.visit_output(&self);
-    }
-
-    fn visit_children(&self, visitor: &mut dyn NodeVisitor) {
-        let ws = self.workspaces.borrow_mut();
-        for ws in ws.deref() {
-            visitor.visit_workspace(ws);
-        }
-    }
-
-    fn absolute_position(&self) -> Rect {
-        self.position.get()
-    }
-
-    fn find_tree_at(&self, x: i32, y: i32, tree: &mut Vec<FoundNode>) -> FindTreeResult {
-        if let Some(ws) = self.workspace.get() {
-            tree.push(FoundNode {
-                node: ws.clone(),
-                x,
-                y,
-            });
-            ws.find_tree_at(x, y, tree);
-        }
-        FindTreeResult::AcceptsInput
-    }
-
-    fn remove_child(self: Rc<Self>, _child: &dyn Node) {
-        self.workspace.set(None);
-    }
-
-    fn pointer_focus(&self, seat: &Rc<WlSeatGlobal>) {
-        seat.set_known_cursor(KnownCursor::Default);
-    }
-
-    fn render(&self, renderer: &mut Renderer, x: i32, y: i32) {
-        renderer.render_output(self, x, y);
-    }
-
-    fn change_extents(self: Rc<Self>, rect: &Rect) {
-        self.position.set(*rect);
-        if let Some(c) = self.workspace.get() {
-            c.change_extents(rect);
-        }
-    }
-}

src/tree/output.rs

@@ -0,0 +1,117 @@
+use std::cell::{Cell, RefCell};
+use std::fmt::{Debug, Formatter};
+use std::ops::Deref;
+use std::rc::Rc;
+use crate::{CloneCell, DisplayNode};
+use crate::cursor::KnownCursor;
+use crate::ifs::wl_output::WlOutputGlobal;
+use crate::ifs::wl_seat::{NodeSeatState, WlSeatGlobal};
+use crate::ifs::wl_surface::zwlr_layer_surface_v1::ZwlrLayerSurfaceV1;
+use crate::rect::Rect;
+use crate::render::Renderer;
+use crate::tree::{FindTreeResult, FoundNode, Node, NodeId, WorkspaceNode};
+use crate::tree::walker::NodeVisitor;
+use crate::utils::linkedlist::LinkedList;
+
+tree_id!(OutputNodeId);
+pub struct OutputNode {
+    pub display: Rc<DisplayNode>,
+    pub id: OutputNodeId,
+    pub position: Cell<Rect>,
+    pub global: Rc<WlOutputGlobal>,
+    pub workspaces: RefCell<Vec<Rc<WorkspaceNode>>>,
+    pub workspace: CloneCell<Option<Rc<WorkspaceNode>>>,
+    pub seat_state: NodeSeatState,
+    pub layers: [LinkedList<Rc<ZwlrLayerSurfaceV1>>; 4],
+}
+
+impl Debug for OutputNode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("OutputNode").finish_non_exhaustive()
+    }
+}
+
+impl Node for OutputNode {
+    fn id(&self) -> NodeId {
+        self.id.into()
+    }
+
+    fn seat_state(&self) -> &NodeSeatState {
+        &self.seat_state
+    }
+
+    fn destroy_node(&self, detach: bool) {
+        if detach {
+            self.display.clone().remove_child(self);
+        }
+        let mut workspaces = self.workspaces.borrow_mut();
+        for workspace in workspaces.drain(..) {
+            workspace.destroy_node(false);
+        }
+        self.seat_state.destroy_node(self);
+    }
+
+    fn visit(self: Rc<Self>, visitor: &mut dyn NodeVisitor) {
+        visitor.visit_output(&self);
+    }
+
+    fn visit_children(&self, visitor: &mut dyn NodeVisitor) {
+        let ws = self.workspaces.borrow_mut();
+        for ws in ws.deref() {
+            visitor.visit_workspace(ws);
+        }
+        for layers in &self.layers {
+            for surface in layers.iter() {
+                visitor.visit_layer_surface(surface.deref());
+            }
+        }
+    }
+
+    fn absolute_position(&self) -> Rect {
+        self.position.get()
+    }
+
+    fn find_tree_at(&self, x: i32, y: i32, tree: &mut Vec<FoundNode>) -> FindTreeResult {
+        if let Some(ws) = self.workspace.get() {
+            tree.push(FoundNode {
+                node: ws.clone(),
+                x,
+                y,
+            });
+            ws.find_tree_at(x, y, tree);
+        }
+        FindTreeResult::AcceptsInput
+    }
+
+    fn remove_child(self: Rc<Self>, _child: &dyn Node) {
+        self.workspace.set(None);
+    }
+
+    fn pointer_focus(&self, seat: &Rc<WlSeatGlobal>) {
+        seat.set_known_cursor(KnownCursor::Default);
+    }
+
+    fn render(&self, renderer: &mut Renderer, x: i32, y: i32) {
+        renderer.render_output(self, x, y);
+    }
+
+    fn is_output(&self) -> bool {
+        true
+    }
+
+    fn into_output(self: Rc<Self>) -> Option<Rc<OutputNode>> {
+        Some(self)
+    }
+
+    fn change_extents(self: Rc<Self>, rect: &Rect) {
+        self.position.set(*rect);
+        if let Some(c) = self.workspace.get() {
+            c.change_extents(rect);
+        }
+        for layer in &self.layers {
+            for surface in layer.iter() {
+                surface.deref().clone().change_extents(rect);
+            }
+        }
+    }
+}

src/tree/walker.rs

@@ -4,6 +4,7 @@ use crate::ifs::wl_surface::WlSurface;
 use crate::tree::{ContainerNode, FloatNode, Node, OutputNode, WorkspaceNode};
 use crate::DisplayNode;
 use std::rc::Rc;
+use crate::ifs::wl_surface::zwlr_layer_surface_v1::ZwlrLayerSurfaceV1;
 
 pub trait NodeVisitorBase: Sized {
     fn visit_surface(&mut self, node: &Rc<WlSurface>) {
@@ -37,6 +38,10 @@ pub trait NodeVisitorBase: Sized {
     fn visit_workspace(&mut self, node: &Rc<WorkspaceNode>) {
         node.visit_children(self);
     }
+
+    fn visit_layer_surface(&mut self, node: &Rc<ZwlrLayerSurfaceV1>) {
+        node.visit_children(self);
+    }
 }
 
 pub trait NodeVisitor {
@@ -48,6 +53,7 @@ pub trait NodeVisitor {
     fn visit_output(&mut self, node: &Rc<OutputNode>);
     fn visit_float(&mut self, node: &Rc<FloatNode>);
     fn visit_workspace(&mut self, node: &Rc<WorkspaceNode>);
+    fn visit_layer_surface(&mut self, node: &Rc<ZwlrLayerSurfaceV1>);
 }
 
 impl<T: NodeVisitorBase> NodeVisitor for T {
@@ -82,6 +88,10 @@ impl<T: NodeVisitorBase> NodeVisitor for T {
     fn visit_workspace(&mut self, node: &Rc<WorkspaceNode>) {
         <T as NodeVisitorBase>::visit_workspace(self, node)
     }
+
+    fn visit_layer_surface(&mut self, node: &Rc<ZwlrLayerSurfaceV1>) {
+        <T as NodeVisitorBase>::visit_layer_surface(self, node)
+    }
 }
 
 // pub fn visit_containers<F: FnMut(&Rc<ContainerNode>)>(f: F) -> impl NodeVisitor {