screencast: schedule toplevel screencasts with other screencasts

src/compositor.rs

@@ -494,6 +494,7 @@ fn create_dummy_output(state: &Rc<State>) {
         screencopies: Default::default(),
         title_visible: Cell::new(false),
         schedule,
+        latch_event: Default::default(),
     });
     let dummy_workspace = Rc::new(WorkspaceNode {
         id: state.node_ids.next(),

src/ifs/jay_compositor.rs

@@ -325,7 +325,7 @@ impl JayCompositorRequestHandler for JayCompositor {
     }
 
     fn create_screencast(&self, req: CreateScreencast, _slf: &Rc<Self>) -> Result<(), Self::Error> {
-        let sc = Rc::new(JayScreencast::new(req.id, &self.client));
+        let sc = Rc::new_cyclic(|slf| JayScreencast::new(req.id, &self.client, slf));
         track!(self.client, sc);
         self.client.add_client_obj(&sc)?;
         Ok(())

src/ifs/jay_screencast.rs

@@ -8,10 +8,11 @@ use {
         object::{Object, Version},
         scale::Scale,
         state::State,
-        tree::{OutputNode, ToplevelNode, WorkspaceNode, WorkspaceNodeId},
+        tree::{LatchListener, OutputNode, ToplevelNode, WorkspaceNode, WorkspaceNodeId},
         utils::{
             clonecell::{CloneCell, UnsafeCellCloneSafe},
             errorfmt::ErrorFmt,
+            event_listener::EventListener,
             numcell::NumCell,
             option_ext::OptionExt,
         },
@@ -29,7 +30,7 @@ use {
     std::{
         cell::{Cell, RefCell},
         ops::DerefMut,
-        rc::Rc,
+        rc::{Rc, Weak},
     },
     thiserror::Error,
 };
@@ -75,6 +76,7 @@ pub struct JayScreencast {
     pending: Pending,
     need_realloc: Cell<bool>,
     realloc_scheduled: Cell<bool>,
+    latch_listener: EventListener<dyn LatchListener>,
 }
 
 #[derive(Clone)]
@@ -83,6 +85,12 @@ enum Target {
     Toplevel(Rc<dyn ToplevelNode>),
 }
 
+impl LatchListener for JayScreencast {
+    fn after_latch(self: Rc<Self>) {
+        self.schedule_toplevel_screencast();
+    }
+}
+
 unsafe impl UnsafeCellCloneSafe for Target {}
 
 enum PendingTarget {
@@ -119,7 +127,7 @@ impl JayScreencast {
         false
     }
 
-    pub fn new(id: JayScreencastId, client: &Rc<Client>) -> Self {
+    pub fn new(id: JayScreencastId, client: &Rc<Client>, slf: &Weak<Self>) -> Self {
         Self {
             id,
             client: client.clone(),
@@ -139,10 +147,11 @@ impl JayScreencast {
             pending: Default::default(),
             need_realloc: Cell::new(false),
             realloc_scheduled: Cell::new(false),
+            latch_listener: EventListener::new(slf.clone()),
         }
     }
 
-    pub fn schedule_toplevel_screencast(self: &Rc<Self>) {
+    fn schedule_toplevel_screencast(self: &Rc<Self>) {
         if !self.running.get() {
             return;
         }
@@ -319,6 +328,7 @@ impl JayScreencast {
     }
 
     fn detach(&self) {
+        self.latch_listener.detach();
         if let Some(target) = self.target.take() {
             match target {
                 Target::Output(output) => {
@@ -427,6 +437,18 @@ impl JayScreencast {
             self.client.state.damage(rect);
         }
     }
+
+    pub fn update_latch_listener(&self) {
+        let Some(Target::Toplevel(tl)) = self.target.get() else {
+            return;
+        };
+        let data = tl.tl_data();
+        if data.visible.get() {
+            self.latch_listener.attach(&data.output().latch_event);
+        } else {
+            self.latch_listener.detach();
+        }
+    }
 }
 
 impl JayScreencastRequestHandler for JayScreencast {
@@ -540,6 +562,9 @@ impl JayScreencastRequestHandler for JayScreencast {
                         let data = t.tl_data();
                         data.jay_screencasts
                             .set((self.client.id, self.id), slf.clone());
+                        if data.visible.get() {
+                            self.latch_listener.attach(&data.output().latch_event);
+                        }
                         new_target = Some(Target::Toplevel(t));
                     }
                 }

src/renderer.rs

@@ -360,11 +360,6 @@ impl Renderer<'_> {
         bounds: Option<&Rect>,
         render_highlight: bool,
     ) {
-        if self.result.is_some() {
-            for screencast in tl_data.jay_screencasts.lock().values() {
-                screencast.schedule_toplevel_screencast();
-            }
-        }
         if render_highlight {
             self.render_highlight(tl_data, bounds);
         }

src/tasks/connector.rs

@@ -185,6 +185,7 @@ impl ConnectorHandler {
             screencopies: Default::default(),
             title_visible: Default::default(),
             schedule,
+            latch_event: Default::default(),
         });
         on.update_visible();
         on.update_rects();

src/tree/output.rs

@@ -37,8 +37,8 @@ use {
         },
         utils::{
             clonecell::CloneCell, copyhashmap::CopyHashMap, errorfmt::ErrorFmt,
-            hash_map_ext::HashMapExt, linkedlist::LinkedList, scroller::Scroller,
+            event_listener::EventSource, hash_map_ext::HashMapExt, linkedlist::LinkedList,
-            transform_ext::TransformExt,
+            scroller::Scroller, transform_ext::TransformExt,
         },
         wire::{JayOutputId, JayScreencastId, ZwlrScreencopyFrameV1Id},
     },
@@ -80,6 +80,11 @@ pub struct OutputNode {
     pub screencopies: CopyHashMap<(ClientId, ZwlrScreencopyFrameV1Id), Rc<ZwlrScreencopyFrameV1>>,
     pub title_visible: Cell<bool>,
     pub schedule: Rc<OutputSchedule>,
+    pub latch_event: EventSource<dyn LatchListener>,
+}
+
+pub trait LatchListener {
+    fn after_latch(self: Rc<Self>);
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
@@ -148,6 +153,9 @@ impl OutputNode {
         y_off: i32,
         size: Option<(i32, i32)>,
     ) {
+        for listener in self.latch_event.iter() {
+            listener.after_latch();
+        }
         if let Some(workspace) = self.workspace.get() {
             if !workspace.may_capture.get() {
                 return;

src/tree/toplevel.rs

@@ -42,6 +42,7 @@ pub trait ToplevelNode: ToplevelNodeBase {
     fn tl_set_parent(&self, parent: Rc<dyn ContainingNode>);
     fn tl_extents_changed(&self);
     fn tl_set_workspace(&self, ws: &Rc<WorkspaceNode>);
+    fn tl_workspace_output_changed(&self);
     fn tl_change_extents(self: Rc<Self>, rect: &Rect);
     fn tl_set_visible(&self, visible: bool);
     fn tl_destroy(&self);
@@ -112,8 +113,20 @@ impl<T: ToplevelNodeBase> ToplevelNode for T {
 
     fn tl_set_workspace(&self, ws: &Rc<WorkspaceNode>) {
         let data = self.tl_data();
-        data.workspace.set(Some(ws.clone()));
+        let prev = data.workspace.set(Some(ws.clone()));
         self.tl_set_workspace_ext(ws);
+        let prev_id = prev.map(|p| p.output.get().id);
+        let new_id = Some(ws.output.get().id);
+        if prev_id != new_id {
+            self.tl_workspace_output_changed();
+        }
+    }
+
+    fn tl_workspace_output_changed(&self) {
+        let data = self.tl_data();
+        for sc in data.jay_screencasts.lock().values() {
+            sc.update_latch_listener();
+        }
     }
 
     fn tl_change_extents(self: Rc<Self>, rect: &Rect) {
@@ -484,6 +497,9 @@ impl ToplevelData {
     pub fn set_visible(&self, node: &dyn Node, visible: bool) {
         self.visible.set(visible);
         self.seat_state.set_visible(node, visible);
+        for sc in self.jay_screencasts.lock().values() {
+            sc.update_latch_listener();
+        }
         if !visible {
             return;
         }
@@ -508,4 +524,11 @@ impl ToplevelData {
             parent.cnode_child_attention_request_changed(node, true);
         }
     }
+
+    pub fn output(&self) -> Rc<OutputNode> {
+        match self.workspace.get() {
+            None => self.state.dummy_output.get().unwrap(),
+            Some(ws) => ws.output.get(),
+        }
+    }
 }

src/tree/workspace.rs

@@ -7,7 +7,9 @@ use {
             jay_workspace::JayWorkspace,
             wl_output::OutputId,
             wl_seat::{tablet::TabletTool, NodeSeatState, WlSeatGlobal},
-            wl_surface::WlSurface,
+            wl_surface::{
+                x_surface::xwindow::Xwindow, xdg_surface::xdg_toplevel::XdgToplevel, WlSurface,
+            },
         },
         rect::Rect,
         renderer::Renderer,
@@ -16,7 +18,7 @@ use {
         tree::{
             container::ContainerNode, walker::NodeVisitor, ContainingNode, Direction,
             FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeVisitorBase, OutputNode,
-            StackedNode, ToplevelNode,
+            PlaceholderNode, StackedNode, ToplevelNode,
         },
         utils::{
             clonecell::CloneCell,
@@ -102,6 +104,26 @@ impl WorkspaceNode {
             fn visit_surface(&mut self, node: &Rc<WlSurface>) {
                 node.set_output(self.0);
             }
+
+            fn visit_container(&mut self, node: &Rc<ContainerNode>) {
+                node.tl_workspace_output_changed();
+                node.node_visit_children(self);
+            }
+
+            fn visit_toplevel(&mut self, node: &Rc<XdgToplevel>) {
+                node.tl_workspace_output_changed();
+                node.node_visit_children(self);
+            }
+
+            fn visit_xwindow(&mut self, node: &Rc<Xwindow>) {
+                node.tl_workspace_output_changed();
+                node.node_visit_children(self);
+            }
+
+            fn visit_placeholder(&mut self, node: &Rc<PlaceholderNode>) {
+                node.tl_workspace_output_changed();
+                node.node_visit_children(self);
+            }
         }
         let mut visitor = OutputSetter(output);
         self.node_visit_children(&mut visitor);