autocommit 2022-04-20 18:33:59 CEST

src/ifs/wl_surface/xwindow.rs

@@ -31,6 +31,7 @@ use {
     },
     thiserror::Error,
 };
+use crate::tree::{FullscreenData, SizedFullscreenNode};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum XInputModel {
@@ -142,6 +143,7 @@ pub struct Xwindow {
     pub workspace: CloneCell<Option<Rc<WorkspaceNode>>>,
     pub display_link: RefCell<Option<LinkedNode<Rc<dyn Node>>>>,
     pub toplevel_data: ToplevelData,
+    pub fullscreen_data: FullscreenData,
 }
 
 impl XwindowData {
@@ -214,6 +216,7 @@ impl Xwindow {
             workspace: Default::default(),
             display_link: Default::default(),
             toplevel_data: Default::default(),
+            fullscreen_data: Default::default(),
         }
     }
 
@@ -502,12 +505,40 @@ impl SizedToplevelNode for Xwindow {
             .push(XWaylandEvent::Activate(self.data.clone()));
     }
 
-    fn set_fullscreen(self: &Rc<Self>, _fullscreen: bool) {
+    fn set_fullscreen(self: &Rc<Self>, fullscreen: bool) {
-        // nothing
+        if fullscreen {
+            if let Some(ws) = self.workspace.get() {
+                self.fullscreen_data.set_fullscreen(&self.data.state, self.clone(), &ws.output.get());
+            }
+        } else {
+            self.fullscreen_data.unset_fullscreen(&self.data.state, self.clone());
+        }
     }
 
     fn fullscreen(&self) -> bool {
-        false
+        self.fullscreen_data.is_fullscreen.get()
+    }
+}
+
+impl SizedFullscreenNode for Xwindow {
+    fn on_set_fullscreen(&self, _workspace: &Rc<WorkspaceNode>) {
+        self.data
+            .state
+            .xwayland
+            .queue
+            .push(XWaylandEvent::SetFullscreen(self.data.clone(), true));
+    }
+
+    fn on_unset_fullscreen(&self) {
+        self.data
+            .state
+            .xwayland
+            .queue
+            .push(XWaylandEvent::SetFullscreen(self.data.clone(), false));
+    }
+
+    fn title(&self) -> String {
+        self.data.info.title.borrow_mut().clone().unwrap_or_default()
     }
 }
 

src/rect/region.rs

@@ -69,6 +69,7 @@ impl Region {
         })
     }
 
+    #[allow(dead_code)]
     pub fn extents(&self) -> Rect {
         self.extents
     }
@@ -576,6 +577,7 @@ impl RegionBuilder {
         self.base.clone()
     }
 
+    #[allow(dead_code)]
     pub fn clear(&mut self) {
         self.pending.clear();
         self.base = Region::empty();

src/render/renderer/renderer.rs

@@ -177,7 +177,6 @@ impl Renderer<'_> {
         if let Some(tex) = placeholder.texture() {
             let x = x + (pos.width() - tex.width()) / 2;
             let y = y + (pos.height() - tex.height()) / 2;
-            log::info!("render at {}x{}", x, y);
             self.render_texture(&tex, x, y, &ARGB8888);
         }
     }

src/tree/fullscreen.rs

@@ -152,7 +152,7 @@ impl FullscreenData {
         }
         fd.workspace.fullscreen.take();
         if let Some(container) = fd.workspace.container.get() {
-            container.set_visible(true);
+            container.set_visible(node.as_node().node_visible());
         }
         if fd.placeholder.is_destroyed() {
             state.map_tiled(node.into_node());

src/tree/output.rs

@@ -160,6 +160,9 @@ impl OutputNode {
             old.node_set_visible(false);
         }
         ws.node_set_visible(true);
+        if let Some(fs) = ws.fullscreen.get() {
+            fs.into_node().node_change_extents(&self.global.pos.get());
+        }
         ws.change_extents(&self.workspace_rect());
         let node = ws.last_active_child();
         for seat in seats {
@@ -204,6 +207,9 @@ impl OutputNode {
         self.state.root.update_extents();
         self.update_render_data();
         if let Some(c) = self.workspace.get() {
+            if let Some(fs) = c.fullscreen.get() {
+                fs.into_node().node_change_extents(rect);
+            }
             c.node_change_extents(&self.workspace_rect());
         }
         for layer in &self.layers {

src/tree/placeholder.rs

@@ -16,7 +16,7 @@ use {
             FindTreeResult, FoundNode, FullscreenNode, Node, NodeId, NodeVisitor, SizedNode,
             SizedToplevelNode, ToplevelData, WorkspaceNode,
         },
-        utils::clonecell::CloneCell,
+        utils::{clonecell::CloneCell, errorfmt::ErrorFmt},
     },
     jay_config::Direction,
     std::{
@@ -25,7 +25,6 @@ use {
         rc::Rc,
     },
 };
-use crate::utils::errorfmt::ErrorFmt;
 
 tree_id!(DetachedNodeId);
 pub struct PlaceholderNode {
@@ -139,6 +138,18 @@ impl SizedNode for PlaceholderNode {
         });
     }
 
+    fn move_focus(self: &Rc<Self>, seat: &Rc<WlSeatGlobal>, direction: Direction) {
+        if let Some(parent) = self.parent.get() {
+            parent.node_move_focus_from_child(seat, self.deref(), direction);
+        }
+    }
+
+    fn move_self(self: &Rc<Self>, direction: Direction) {
+        if let Some(parent) = self.parent.get() {
+            parent.node_move_child(self.clone(), direction);
+        }
+    }
+
     fn absolute_position(&self) -> Rect {
         self.pos.get()
     }
@@ -159,8 +170,11 @@ impl SizedNode for PlaceholderNode {
         seat.enter_toplevel(self.clone());
     }
 
+    fn render(&self, renderer: &mut Renderer, x: i32, y: i32) {
+        renderer.render_placeholder(self, x, y);
+    }
+
     fn change_extents(self: &Rc<Self>, rect: &Rect) {
-        log::info!("{:?}", rect);
         self.pos.set(*rect);
         if let Some(p) = self.parent.get() {
             p.node_child_size_changed(self.deref(), rect.width(), rect.height());
@@ -179,7 +193,7 @@ impl SizedNode for PlaceholderNode {
                 ) {
                     Ok(t) => {
                         self.texture.set(Some(t));
-                    },
+                    }
                     Err(e) => {
                         log::warn!("Could not render fullscreen texture: {}", ErrorFmt(e));
                     }
@@ -200,10 +214,6 @@ impl SizedNode for PlaceholderNode {
     fn client(&self) -> Option<Rc<Client>> {
         self.client.clone()
     }
-
-    fn render(&self, renderer: &mut Renderer, x: i32, y: i32) {
-        renderer.render_placeholder(self, x, y);
-    }
 }
 
 impl SizedToplevelNode for PlaceholderNode {

src/tree/workspace.rs

@@ -56,6 +56,9 @@ impl SizedNode for WorkspaceNode {
             self.output.get().node_remove_child(self);
         }
         self.output_link.set(None);
+        if let Some(fs) = self.fullscreen.take() {
+            fs.into_node().node_destroy(false);
+        }
         if let Some(container) = self.container.take() {
             container.node_destroy(false);
         }
@@ -84,6 +87,9 @@ impl SizedNode for WorkspaceNode {
     }
 
     fn last_active_child(self: &Rc<Self>) -> Rc<dyn Node> {
+        if let Some(fs) = self.fullscreen.get() {
+            return fs.into_node().node_last_active_child();
+        }
         if let Some(c) = self.container.get() {
             return c.last_active_child();
         }
@@ -92,14 +98,18 @@ impl SizedNode for WorkspaceNode {
 
     fn set_visible(&self, visible: bool) {
         self.visible.set(visible);
-        if let Some(container) = self.container.get() {
+        if let Some(fs) = self.fullscreen.get() {
+            fs.as_node().node_set_visible(visible);
+        } else if let Some(container) = self.container.get() {
             container.node_set_visible(visible);
         }
         self.seat_state.set_visible(self, visible);
     }
 
     fn do_focus(self: &Rc<Self>, seat: &Rc<WlSeatGlobal>, direction: Direction) {
-        if let Some(container) = self.container.get() {
+        if let Some(fs) = self.fullscreen.get() {
+            fs.into_node().node_do_focus(seat, direction);
+        } else if let Some(container) = self.container.get() {
             container.do_focus(seat, direction);
         }
     }

src/xwayland.rs

@@ -274,4 +274,5 @@ pub enum XWaylandEvent {
     Activate(Rc<XwindowData>),
     ActivateRoot,
     Close(Rc<XwindowData>),
+    SetFullscreen(Rc<XwindowData>, bool),
 }

src/xwayland/xwm.rs

@@ -47,6 +47,7 @@ use {
     },
     uapi::OwnedFd,
 };
+use crate::tree::{ToplevelNode};
 
 atoms! {
     Atoms;
@@ -368,6 +369,7 @@ impl Wm {
             XWaylandEvent::Activate(window) => self.activate_window(Some(&window)).await,
             XWaylandEvent::ActivateRoot => self.activate_window(None).await,
             XWaylandEvent::Close(window) => self.close_window(&window).await,
+            XWaylandEvent::SetFullscreen(window, fullscreen) => self.set_fullscreen(&window, fullscreen).await,
         }
     }
 
@@ -407,6 +409,7 @@ impl Wm {
         self.set_net_wm_state(data).await;
     }
 
+    #[allow(dead_code)]
     async fn set_maximized(&self, data: &Rc<XwindowData>, maximized: bool) {
         data.info.maximized_vert.set(maximized);
         data.info.maximized_horz.set(maximized);
@@ -1550,6 +1553,11 @@ impl Wm {
                 minimized = self.handle_minimize_requested(data).await;
             }
         }
+        if fullscreen != data.info.fullscreen.get() {
+            if let Some(w) = data.window.get() {
+                w.set_fullscreen(fullscreen);
+            }
+        }
         data.info.fullscreen.set(fullscreen);
         data.info.maximized_horz.set(maximized_horz);
         data.info.maximized_vert.set(maximized_vert);