tree: add Node::node_location

src/compositor.rs

@@ -752,6 +752,7 @@ fn create_dummy_output(state: &Rc<State>) {
         state: state.clone(),
         is_dummy: true,
         output: CloneCell::new(dummy_output.clone()),
+        output_id: Cell::new(dummy_output.id),
         position: Default::default(),
         container: Default::default(),
         stacked: Default::default(),

src/ifs/ext_session_lock_v1.rs

@@ -6,6 +6,7 @@ use {
         },
         leaks::Tracker,
         object::{Object, Version},
+        tree::NodeLocation,
         wire::{ExtSessionLockV1Id, ext_session_lock_v1::*},
     },
     std::{cell::Cell, rc::Rc},
@@ -87,7 +88,7 @@ impl ExtSessionLockV1RequestHandler for ExtSessionLockV1 {
             node.set_lock_surface(Some(new.clone()));
             let pos = node.global.pos.get();
             new.change_extents(pos);
-            new.surface.set_output(&node);
+            new.surface.set_output(&node, NodeLocation::Output(node.id));
             self.client.state.tree_changed();
         }
         Ok(())

src/ifs/wl_seat.rs

@@ -79,8 +79,8 @@ use {
         rect::Rect,
         state::{DeviceHandlerData, State},
         tree::{
-            ContainerNode, ContainerSplit, Direction, FoundNode, Node, NodeId, OutputNode,
+            ContainerNode, ContainerSplit, Direction, FoundNode, Node, NodeId, NodeLocation,
-            ToplevelNode, WorkspaceNode, generic_node_visitor, toplevel_create_split,
+            OutputNode, ToplevelNode, WorkspaceNode, generic_node_visitor, toplevel_create_split,
             toplevel_parent_container, toplevel_set_floating, toplevel_set_workspace,
         },
         utils::{
@@ -717,7 +717,9 @@ impl WlSeatGlobal {
         serial: u64,
     ) -> Result<(), WlSeatError> {
         if let Some(icon) = &icon {
-            icon.surface().set_output(&self.pointer_cursor.output());
+            let output = self.pointer_cursor.output();
+            icon.surface()
+                .set_output(&output, NodeLocation::Output(output.id));
         }
         self.pointer_owner
             .start_drag(self, origin, source, icon, serial)
@@ -1082,7 +1084,8 @@ impl WlSeatGlobal {
 impl CursorUserOwner for WlSeatGlobal {
     fn output_changed(&self, output: &Rc<OutputNode>) {
         if let Some(dnd) = self.pointer_owner.dnd_icon() {
-            dnd.surface().set_output(output);
+            dnd.surface()
+                .set_output(output, NodeLocation::Output(output.id));
         }
         if let Some(drag) = self.pointer_owner.toplevel_drag()
             && let Some(tl) = drag.toplevel.get()

src/ifs/wl_surface.rs

@@ -76,8 +76,8 @@ use {
         renderer::Renderer,
         tree::{
             BeforeLatchListener, BeforeLatchResult, ContainerNode, FindTreeResult, FoundNode,
-            LatchListener, Node, NodeId, NodeVisitor, NodeVisitorBase, OutputNode, PlaceholderNode,
+            LatchListener, Node, NodeId, NodeLocation, NodeVisitor, NodeVisitorBase, OutputNode,
-            PresentationListener, ToplevelNode, VblankListener,
+            PlaceholderNode, PresentationListener, ToplevelNode, VblankListener,
         },
         utils::{
             cell_ext::CellExt, clonecell::CloneCell, copyhashmap::CopyHashMap,
@@ -319,6 +319,7 @@ pub struct WlSurface {
     idle_inhibitors: SmallMap<ZwpIdleInhibitorV1Id, Rc<ZwpIdleInhibitorV1>, 1>,
     viewporter: CloneCell<Option<Rc<WpViewport>>>,
     output: CloneCell<Rc<OutputNode>>,
+    location: Cell<NodeLocation>,
     fractional_scale: CloneCell<Option<Rc<WpFractionalScaleV1>>>,
     pub constraints: SmallMap<SeatId, Rc<SeatConstraint>, 1>,
     xwayland_serial: Cell<Option<u64>>,
@@ -623,6 +624,7 @@ pub struct StackElement {
 
 impl WlSurface {
     pub fn new(id: WlSurfaceId, client: &Rc<Client>, version: Version, slf: &Weak<Self>) -> Self {
+        let dummy_output = client.state.dummy_output.get().unwrap();
         Self {
             id,
             node_id: client.state.node_ids.next(),
@@ -662,7 +664,8 @@ impl WlSurface {
             tracker: Default::default(),
             idle_inhibitors: Default::default(),
             viewporter: Default::default(),
-            output: CloneCell::new(client.state.dummy_output.get().unwrap()),
+            location: Cell::new(NodeLocation::Output(dummy_output.id)),
+            output: CloneCell::new(dummy_output),
             fractional_scale: Default::default(),
             constraints: Default::default(),
             xwayland_serial: Default::default(),
@@ -715,7 +718,8 @@ impl WlSurface {
         self.output.get()
     }
 
-    pub fn set_output(&self, output: &Rc<OutputNode>) {
+    pub fn set_output(&self, output: &Rc<OutputNode>, location: NodeLocation) {
+        self.location.set(location);
         let old = self.output.set(output.clone());
         if old.id == output.id {
             return;
@@ -737,7 +741,7 @@ impl WlSurface {
         let children = self.children.borrow_mut();
         if let Some(children) = &*children {
             for ss in children.subsurfaces.values() {
-                ss.surface.set_output(output);
+                ss.surface.set_output(output, location);
             }
         }
     }
@@ -1788,6 +1792,10 @@ impl Node for WlSurface {
         Some(self.output.get())
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        Some(self.location.get())
+    }
+
     fn node_active_changed(&self, active: bool) {
         if let Some(tl) = self.toplevel.get() {
             tl.tl_surface_active_changed(active);

src/ifs/wl_surface/cursor.rs

@@ -8,7 +8,7 @@ use {
         rect::Rect,
         renderer::Renderer,
         scale::Scale,
-        tree::{Node, NodeVisitorBase, OutputNode},
+        tree::{Node, NodeLocation, NodeVisitorBase, OutputNode},
     },
     std::{cell::Cell, ops::Deref, rc::Rc},
 };
@@ -133,7 +133,8 @@ impl Cursor for CursorSurface {
     }
 
     fn set_output(&self, output: &Rc<OutputNode>) {
-        self.surface.set_output(output);
+        self.surface
+            .set_output(output, NodeLocation::Output(output.id));
     }
 
     fn handle_set(self: Rc<Self>) {

src/ifs/wl_surface/ext_session_lock_surface_v1.rs

@@ -10,7 +10,10 @@ use {
         leaks::Tracker,
         object::{Object, Version},
         rect::Rect,
-        tree::{FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeVisitor, OutputNode},
+        tree::{
+            FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeLocation, NodeVisitor,
+            OutputNode,
+        },
         utils::numcell::NumCell,
         wire::{ExtSessionLockSurfaceV1Id, WlSurfaceId, ext_session_lock_surface_v1::*},
     },
@@ -131,6 +134,10 @@ impl Node for ExtSessionLockSurfaceV1 {
         self.output.node()
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        self.surface.node_location()
+    }
+
     fn node_find_tree_at(
         &self,
         x: i32,

src/ifs/wl_surface/tray.rs

@@ -11,8 +11,8 @@ use {
         },
         rect::Rect,
         tree::{
-            FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeVisitor, OutputNode,
+            FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeLocation, NodeVisitor,
-            StackedNode,
+            OutputNode, StackedNode,
         },
         utils::{
             copyhashmap::CopyHashMap,
@@ -300,6 +300,10 @@ impl<T: TrayItem> Node for T {
         self.data().output.node()
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        self.data().surface.node_location()
+    }
+
     fn node_find_tree_at(
         &self,
         x: i32,
@@ -328,7 +332,8 @@ fn install<T: TrayItem>(item: &Rc<T>) -> Result<(), TrayItemError> {
     data.surface.ext.set(item.clone());
     data.surface.set_visible(false);
     if let Some(node) = data.output.node() {
-        data.surface.set_output(&node);
+        data.surface
+            .set_output(&node, NodeLocation::Output(node.id));
         item.send_initial_configure();
     }
     Ok(())

src/ifs/wl_surface/wl_subsurface.rs

@@ -186,7 +186,8 @@ impl WlSubsurface {
         update_children_attach(self)?;
         let (x, y) = self.parent.buffer_abs_pos.get().position();
         self.surface.set_absolute_position(x, y);
-        self.surface.set_output(&self.parent.output.get());
+        self.surface
+            .set_output(&self.parent.output.get(), self.parent.location.get());
         Ok(())
     }
 

src/ifs/wl_surface/x_surface/xwindow.rs

@@ -12,8 +12,9 @@ use {
         state::State,
         tree::{
             ContainerSplit, Direction, FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId,
-            NodeVisitor, OutputNode, StackedNode, TileDragDestination, ToplevelData, ToplevelNode,
+            NodeLocation, NodeVisitor, OutputNode, StackedNode, TileDragDestination, ToplevelData,
-            ToplevelNodeBase, ToplevelType, WorkspaceNode, default_tile_drag_destination,
+            ToplevelNode, ToplevelNodeBase, ToplevelType, WorkspaceNode,
+            default_tile_drag_destination,
         },
         utils::{clonecell::CloneCell, copyhashmap::CopyHashMap, linkedlist::LinkedNode},
         wire::WlSurfaceId,
@@ -370,6 +371,10 @@ impl Node for Xwindow {
         self.toplevel_data.output_opt()
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        self.x.surface.node_location()
+    }
+
     fn node_do_focus(self: Rc<Self>, seat: &Rc<WlSeatGlobal>, _direction: Direction) {
         seat.focus_toplevel(self.clone());
     }
@@ -446,7 +451,7 @@ impl ToplevelNodeBase for Xwindow {
     }
 
     fn tl_set_workspace_ext(&self, ws: &Rc<WorkspaceNode>) {
-        self.x.surface.set_output(&ws.output.get());
+        self.x.surface.set_output(&ws.output.get(), ws.location());
     }
 
     fn tl_change_extents_impl(self: Rc<Self>, rect: &Rect) {
@@ -456,7 +461,9 @@ impl ToplevelNodeBase for Xwindow {
             if self.data.info.override_redirect.get() {
                 let (x, y) = rect.center();
                 let output = self.data.state.find_closest_output(x, y).0;
-                self.x.surface.set_output(&output);
+                self.x
+                    .surface
+                    .set_output(&output, NodeLocation::Output(output.id));
             } else {
                 self.data
                     .state

src/ifs/wl_surface/xdg_surface.rs

@@ -18,7 +18,9 @@ use {
         leaks::Tracker,
         object::Object,
         rect::Rect,
-        tree::{FindTreeResult, FoundNode, Node, OutputNode, StackedNode, WorkspaceNode},
+        tree::{
+            FindTreeResult, FoundNode, Node, NodeLocation, OutputNode, StackedNode, WorkspaceNode,
+        },
         utils::{
             clonecell::CloneCell,
             copyhashmap::CopyHashMap,
@@ -233,7 +235,7 @@ impl XdgSurface {
 
     fn set_workspace(&self, ws: &Rc<WorkspaceNode>) {
         self.workspace.set(Some(ws.clone()));
-        self.surface.set_output(&ws.output.get());
+        self.surface.set_output(&ws.output.get(), ws.location());
         let pu = self.popups.lock();
         for pu in pu.values() {
             pu.popup.xdg.set_workspace(ws);
@@ -241,7 +243,8 @@ impl XdgSurface {
     }
 
     pub fn set_output(&self, output: &Rc<OutputNode>) {
-        self.surface.set_output(output);
+        self.surface
+            .set_output(output, NodeLocation::Output(output.id));
         let pu = self.popups.lock();
         for pu in pu.values() {
             pu.popup.xdg.set_output(output);

src/ifs/wl_surface/xdg_surface/xdg_popup.rs

@@ -19,8 +19,8 @@ use {
         rect::Rect,
         renderer::Renderer,
         tree::{
-            FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeVisitor, OutputNode,
+            FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeLocation, NodeVisitor,
-            StackedNode,
+            OutputNode, StackedNode,
         },
         utils::clonecell::CloneCell,
         wire::{XdgPopupId, xdg_popup::*},
@@ -319,6 +319,10 @@ impl Node for XdgPopup {
         self.xdg.workspace.get().map(|w| w.output.get())
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        self.xdg.surface.node_location()
+    }
+
     fn node_find_tree_at(
         &self,
         x: i32,

src/ifs/wl_surface/xdg_surface/xdg_toplevel.rs

@@ -27,7 +27,7 @@ use {
         state::State,
         tree::{
             ContainerSplit, Direction, FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId,
-            NodeVisitor, OutputNode, TileDragDestination, ToplevelData, ToplevelNode,
+            NodeLocation, NodeVisitor, OutputNode, TileDragDestination, ToplevelData, ToplevelNode,
             ToplevelNodeBase, ToplevelNodeId, ToplevelType, WorkspaceNode,
             default_tile_drag_destination,
         },
@@ -512,7 +512,7 @@ impl XdgToplevel {
             self.extents_changed();
             if let Some(workspace) = self.xdg.workspace.get() {
                 let output = workspace.output.get();
-                surface.set_output(&output);
+                surface.set_output(&output, workspace.location());
             }
             // {
             //     let seats = surface.client.state.globals.lock_seats();
@@ -573,6 +573,10 @@ impl Node for XdgToplevel {
         self.toplevel_data.output_opt()
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        self.xdg.surface.node_location()
+    }
+
     fn node_do_focus(self: Rc<Self>, seat: &Rc<WlSeatGlobal>, _direction: Direction) {
         seat.focus_toplevel(self.clone());
     }

src/ifs/wl_surface/zwlr_layer_surface_v1.rs

@@ -15,8 +15,8 @@ use {
         rect::Rect,
         renderer::Renderer,
         tree::{
-            FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeVisitor, OutputNode,
+            FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeLocation, NodeVisitor,
-            StackedNode,
+            OutputNode, StackedNode,
         },
         utils::{
             bitflags::BitflagsExt,
@@ -187,7 +187,8 @@ impl ZwlrLayerSurfaceV1 {
         }
         self.surface.ext.set(self.clone());
         if let Some(output) = self.output.node() {
-            self.surface.set_output(&output);
+            self.surface
+                .set_output(&output, NodeLocation::Output(output.id));
         }
         Ok(())
     }
@@ -658,6 +659,10 @@ impl Node for ZwlrLayerSurfaceV1 {
         self.output.node()
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        self.surface.node_location()
+    }
+
     fn node_find_tree_at(
         &self,
         x: i32,

src/tree.rs

@@ -115,6 +115,15 @@ pub enum FindTreeUsecase {
     SelectWorkspace,
 }
 
+#[derive(Copy, Clone)]
+pub enum NodeLocation {
+    Workspace(
+        #[expect(dead_code)] OutputNodeId,
+        #[expect(dead_code)] WorkspaceNodeId,
+    ),
+    Output(#[expect(dead_code)] OutputNodeId),
+}
+
 pub trait Node: 'static {
     fn node_id(&self) -> NodeId;
     fn node_seat_state(&self) -> &NodeSeatState;
@@ -123,6 +132,7 @@ pub trait Node: 'static {
     fn node_visible(&self) -> bool;
     fn node_absolute_position(&self) -> Rect;
     fn node_output(&self) -> Option<Rc<OutputNode>>;
+    fn node_location(&self) -> Option<NodeLocation>;
 
     fn node_child_title_changed(self: Rc<Self>, child: &dyn Node, title: &str) {
         let _ = child;

src/tree/container.rs

@@ -18,8 +18,8 @@ use {
         text::TextTexture,
         tree::{
             ContainingNode, Direction, FindTreeResult, FindTreeUsecase, FloatNode, FoundNode, Node,
-            NodeId, OutputNode, TddType, TileDragDestination, ToplevelData, ToplevelNode,
+            NodeId, NodeLocation, OutputNode, TddType, TileDragDestination, ToplevelData,
-            ToplevelNodeBase, ToplevelType, WorkspaceNode, default_tile_drag_bounds,
+            ToplevelNode, ToplevelNodeBase, ToplevelType, WorkspaceNode, default_tile_drag_bounds,
             toplevel_set_floating, walker::NodeVisitor,
         },
         utils::{
@@ -129,6 +129,7 @@ pub struct ContainerNode {
     focus_history: LinkedList<NodeRef<ContainerChild>>,
     child_nodes: RefCell<AHashMap<NodeId, LinkedNode<ContainerChild>>>,
     workspace: CloneCell<Rc<WorkspaceNode>>,
+    location: Cell<NodeLocation>,
     cursors: RefCell<AHashMap<CursorType, CursorState>>,
     state: Rc<State>,
     pub render_data: RefCell<ContainerRenderData>,
@@ -235,6 +236,7 @@ impl ContainerNode {
             focus_history: Default::default(),
             child_nodes: RefCell::new(child_nodes),
             workspace: CloneCell::new(workspace.clone()),
+            location: Cell::new(workspace.location()),
             cursors: RefCell::new(Default::default()),
             state: state.clone(),
             render_data: Default::default(),
@@ -1547,6 +1549,10 @@ impl Node for ContainerNode {
         self.toplevel_data.output_opt()
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        Some(self.location.get())
+    }
+
     fn node_child_title_changed(self: Rc<Self>, child: &dyn Node, title: &str) {
         if let Some(child) = self.child_nodes.borrow().get(&child.node_id()) {
             self.update_child_title(child, title);
@@ -2085,6 +2091,7 @@ impl ToplevelNodeBase for ContainerNode {
 
     fn tl_set_workspace_ext(&self, ws: &Rc<WorkspaceNode>) {
         self.workspace.set(ws.clone());
+        self.location.set(ws.location());
         for child in self.children.iter() {
             child.node.clone().tl_set_workspace(ws);
         }

src/tree/display.rs

@@ -8,8 +8,9 @@ use {
         renderer::Renderer,
         state::State,
         tree::{
-            FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, OutputNode, StackedNode,
+            FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeLocation, OutputNode,
-            TileDragDestination, WorkspaceDragDestination, WorkspaceNodeId, walker::NodeVisitor,
+            StackedNode, TileDragDestination, WorkspaceDragDestination, WorkspaceNodeId,
+            walker::NodeVisitor,
         },
         utils::{copyhashmap::CopyHashMap, linkedlist::LinkedList},
     },
@@ -150,6 +151,10 @@ impl Node for DisplayNode {
         None
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        None
+    }
+
     fn node_find_tree_at(
         &self,
         x: i32,

src/tree/float.rs

@@ -15,8 +15,8 @@ use {
         text::TextTexture,
         tree::{
             ContainingNode, Direction, FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId,
-            OutputNode, PinnedNode, StackedNode, TileDragDestination, ToplevelNode, WorkspaceNode,
+            NodeLocation, OutputNode, PinnedNode, StackedNode, TileDragDestination, ToplevelNode,
-            toplevel_set_floating, walker::NodeVisitor,
+            WorkspaceNode, toplevel_set_floating, walker::NodeVisitor,
         },
         utils::{
             asyncevent::AsyncEvent, clonecell::CloneCell, double_click_state::DoubleClickState,
@@ -45,6 +45,7 @@ pub struct FloatNode {
     pub workspace_link: Cell<Option<LinkedNode<Rc<dyn StackedNode>>>>,
     pub pinned_link: RefCell<Option<LinkedNode<Rc<dyn PinnedNode>>>>,
     pub workspace: CloneCell<Rc<WorkspaceNode>>,
+    pub location: Cell<NodeLocation>,
     pub child: CloneCell<Option<Rc<dyn ToplevelNode>>>,
     pub active: Cell<bool>,
     pub seat_state: NodeSeatState,
@@ -124,6 +125,7 @@ impl FloatNode {
             workspace_link: Cell::new(None),
             pinned_link: RefCell::new(None),
             workspace: CloneCell::new(ws.clone()),
+            location: Cell::new(ws.location()),
             child: CloneCell::new(Some(child.clone())),
             active: Cell::new(false),
             seat_state: Default::default(),
@@ -423,6 +425,7 @@ impl FloatNode {
         self.workspace_link
             .set(Some(ws.stacked.add_last(self.clone())));
         self.workspace.set(ws.clone());
+        self.location.set(ws.location());
         if update_visible {
             self.stacked_set_visible(ws.float_visible());
         }
@@ -702,6 +705,10 @@ impl Node for FloatNode {
         Some(self.workspace.get().output.get())
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        Some(self.location.get())
+    }
+
     fn node_child_title_changed(self: Rc<Self>, _child: &dyn Node, title: &str) {
         self.update_child_title(title);
     }

src/tree/output.rs

@@ -43,9 +43,9 @@ use {
         state::State,
         text::TextTexture,
         tree::{
-            Direction, FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, PinnedNode,
+            Direction, FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId, NodeLocation,
-            StackedNode, TddType, TileDragDestination, WorkspaceDragDestination, WorkspaceNode,
+            PinnedNode, StackedNode, TddType, TileDragDestination, WorkspaceDragDestination,
-            WorkspaceNodeId, walker::NodeVisitor,
+            WorkspaceNode, WorkspaceNodeId, walker::NodeVisitor,
         },
         utils::{
             asyncevent::AsyncEvent, bitflags::BitflagsExt, clonecell::CloneCell,
@@ -718,6 +718,7 @@ impl OutputNode {
             state: self.state.clone(),
             is_dummy: false,
             output: CloneCell::new(self.clone()),
+            output_id: Cell::new(self.id),
             position: Cell::new(Default::default()),
             container: Default::default(),
             stacked: Default::default(),
@@ -1476,6 +1477,10 @@ impl Node for OutputNode {
         self.global.opt.node()
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        Some(NodeLocation::Output(self.id))
+    }
+
     fn node_do_focus(self: Rc<Self>, seat: &Rc<WlSeatGlobal>, direction: Direction) {
         if self.state.lock.locked.get() {
             if let Some(lock) = self.lock_surface.get() {

src/tree/placeholder.rs

@@ -11,8 +11,8 @@ use {
         text::TextTexture,
         tree::{
             ContainerSplit, Direction, FindTreeResult, FindTreeUsecase, FoundNode, Node, NodeId,
-            NodeVisitor, OutputNode, TileDragDestination, ToplevelData, ToplevelNode,
+            NodeLocation, NodeVisitor, OutputNode, TileDragDestination, ToplevelData, ToplevelNode,
-            ToplevelNodeBase, ToplevelType, default_tile_drag_destination,
+            ToplevelNodeBase, ToplevelType, WorkspaceNode, default_tile_drag_destination,
         },
         utils::{
             asyncevent::AsyncEvent, errorfmt::ErrorFmt, on_drop_event::OnDropEvent,
@@ -35,6 +35,7 @@ pub struct PlaceholderNode {
     destroyed: Cell<bool>,
     update_textures_scheduled: Cell<bool>,
     state: Rc<State>,
+    location: Cell<Option<NodeLocation>>,
     pub textures: RefCell<SmallMapMut<Scale, TextTexture, 2>>,
 }
 
@@ -63,6 +64,7 @@ impl PlaceholderNode {
             destroyed: Default::default(),
             update_textures_scheduled: Cell::new(false),
             state: state.clone(),
+            location: Cell::new(node.node_location()),
             textures: Default::default(),
         }
     }
@@ -82,6 +84,7 @@ impl PlaceholderNode {
             destroyed: Default::default(),
             update_textures_scheduled: Default::default(),
             state: state.clone(),
+            location: Default::default(),
             textures: Default::default(),
         }
     }
@@ -174,6 +177,10 @@ impl Node for PlaceholderNode {
         self.toplevel.output_opt()
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        self.location.get()
+    }
+
     fn node_do_focus(self: Rc<Self>, seat: &Rc<WlSeatGlobal>, _direction: Direction) {
         seat.focus_toplevel(self.clone());
     }
@@ -223,6 +230,10 @@ impl ToplevelNodeBase for PlaceholderNode {
         &self.toplevel
     }
 
+    fn tl_set_workspace_ext(&self, ws: &Rc<WorkspaceNode>) {
+        self.location.set(ws.node_location());
+    }
+
     fn tl_change_extents_impl(self: Rc<Self>, rect: &Rect) {
         self.toplevel.pos.set(*rect);
         if let Some(p) = self.toplevel.parent.get() {

src/tree/workspace.rs

@@ -21,8 +21,8 @@ use {
         text::TextTexture,
         tree::{
             ContainingNode, Direction, FindTreeResult, FindTreeUsecase, FloatNode, FoundNode, Node,
-            NodeId, NodeVisitorBase, OutputNode, PlaceholderNode, StackedNode, ToplevelNode,
+            NodeId, NodeLocation, NodeVisitorBase, OutputNode, OutputNodeId, PlaceholderNode,
-            container::ContainerNode, walker::NodeVisitor,
+            StackedNode, ToplevelNode, container::ContainerNode, walker::NodeVisitor,
         },
         utils::{
             clonecell::CloneCell,
@@ -49,6 +49,7 @@ pub struct WorkspaceNode {
     pub state: Rc<State>,
     pub is_dummy: bool,
     pub output: CloneCell<Rc<OutputNode>>,
+    pub output_id: Cell<OutputNodeId>,
     pub position: Cell<Rect>,
     pub container: CloneCell<Option<Rc<ContainerNode>>>,
     pub stacked: LinkedList<Rc<dyn StackedNode>>,
@@ -104,6 +105,7 @@ impl WorkspaceNode {
     }
 
     pub fn set_output(&self, output: &Rc<OutputNode>) {
+        self.output_id.set(output.id);
         let old = self.output.set(output.clone());
         for wh in self.ext_workspaces.lock().values() {
             wh.handle_new_output(output);
@@ -113,12 +115,13 @@ impl WorkspaceNode {
         }
         self.update_has_captures();
         struct OutputSetter<'a> {
+            ws: &'a WorkspaceNode,
             old: &'a Rc<OutputNode>,
             new: &'a Rc<OutputNode>,
         }
         impl NodeVisitorBase for OutputSetter<'_> {
             fn visit_surface(&mut self, node: &Rc<WlSurface>) {
-                node.set_output(self.new);
+                node.set_output(self.new, self.ws.location());
             }
 
             fn visit_container(&mut self, node: &Rc<ContainerNode>) {
@@ -147,6 +150,7 @@ impl WorkspaceNode {
             }
         }
         let mut visitor = OutputSetter {
+            ws: self,
             old: &old,
             new: output,
         };
@@ -273,6 +277,10 @@ impl WorkspaceNode {
             self.output.get().schedule_update_render_data();
         }
     }
+
+    pub fn location(&self) -> NodeLocation {
+        NodeLocation::Workspace(self.output_id.get(), self.id)
+    }
 }
 
 impl Node for WorkspaceNode {
@@ -309,6 +317,10 @@ impl Node for WorkspaceNode {
         Some(self.output.get())
     }
 
+    fn node_location(&self) -> Option<NodeLocation> {
+        Some(self.location())
+    }
+
     fn node_do_focus(self: Rc<Self>, seat: &Rc<WlSeatGlobal>, direction: Direction) {
         if let Some(fs) = self.fullscreen.get() {
             fs.node_do_focus(seat, direction);