sm: save and restore window positions

mahkoh · mahkoh · commit 3e720a52367b · 2026-04-07T20:24:09.000+02:00
diff --git a/src/control_center/cc_window.rs b/src/control_center/cc_window.rs
@@ -358,7 +358,7 @@ pub fn show_window(behavior: &mut CcBehavior<'_>, ui: &mut Ui, window: &dyn Topl
         label(ui, "ID", &*data.identifier.get().to_string());
         label(ui, "Title", &*data.title.borrow());
         if let Some(w) = data.workspace.get() {
-            label(ui, "Workspace", &w.name);
+            label(ui, "Workspace", &*w.name);
         }
         match &data.kind {
             ToplevelType::Container => {
diff --git a/src/ifs/wl_surface/xdg_surface/xdg_toplevel.rs b/src/ifs/wl_surface/xdg_surface/xdg_toplevel.rs
@@ -407,6 +407,13 @@ impl XdgToplevel {
         parent: Option<&XdgToplevel>,
         pos: Option<(&Rc<OutputNode>, i32, i32)>,
     ) {
+        if let Some(session) = self.toplevel_data.session.get()
+            && self
+                .state
+                .map_restore(self.clone(), &session, parent.is_some())
+        {
+            return;
+        }
         if let Some(state) = self.state.initial_tile_state(&self.toplevel_data) {
             match state {
                 TileState::Floating => {
diff --git a/src/it/tests/t0018_click_to_active_ws.rs b/src/it/tests/t0018_click_to_active_ws.rs
@@ -28,7 +28,7 @@ async fn test(run: Rc<TestRun>) -> TestResult {
     client.sync().await;
 
     let name = ds.output.workspace.get().map(|ws| ws.name.clone());
-    tassert_eq!(name.as_deref(), Some("1"));
+    tassert_eq!(name.as_deref().map(String::as_str), Some("1"));
 
     let pos = {
         let rd = ds.output.render_data.borrow_mut();
@@ -40,7 +40,7 @@ async fn test(run: Rc<TestRun>) -> TestResult {
     client.sync().await;
 
     let name = ds.output.workspace.get().map(|ws| ws.name.clone());
-    tassert_eq!(name.as_deref(), Some("2"));
+    tassert_eq!(name.as_deref().map(String::as_str), Some("2"));
 
     Ok(())
 }
diff --git a/src/sm.rs b/src/sm.rs
@@ -1,6 +1,8 @@
 use {
     crate::{
         client::Client,
+        ifs::wl_output::OutputIdHash,
+        rect::Rect,
         sm::{
             sm_jobs::{
                 SmPending, SmScheduled,
@@ -21,6 +23,7 @@ use {
         },
         sqlite::Sqlite,
         state::State,
+        tree::{Node, OutputNode, ToplevelData, WorkspaceHash, WorkspaceNode},
         utils::{
             asyncevent::AsyncEvent,
             cell_ext::CellExt,
@@ -112,7 +115,6 @@ pub struct ToplevelSession {
     restore: bool,
     id: Cell<Option<ToplevelSessionId>>,
     owner: CloneCell<Option<Rc<dyn ToplevelSessionOwner>>>,
-    #[expect(dead_code)]
     pub state: ToplevelSessionState,
     job: Cell<Option<ToplevelJob>>,
 }
@@ -400,12 +402,53 @@ impl Session {
 }
 
 impl ToplevelSession {
-    #[expect(dead_code)]
     fn state_changed(self: &Rc<Self>) {
         self.changed.set(true);
         self.schedule_job(false);
     }
 
+    pub fn set_workspace(self: &Rc<Self>, ws: &WorkspaceNode) {
+        let hash = (!ws.is_dummy).then_some(ws.hash);
+        if hash == self.state.workspace_hash.get() {
+            return;
+        }
+        self.state.workspace_hash.set(hash);
+        self.state
+            .workspace
+            .set((!ws.is_dummy).then_some(ws.name.clone()));
+        self.state_changed();
+        self.set_output(&ws.output.get());
+    }
+
+    pub fn set_output(self: &Rc<Self>, on: &OutputNode) {
+        let hash = (!on.is_dummy).then_some(on.global.output_id.hash);
+        if hash == self.state.output.get() {
+            return;
+        }
+        self.state.output.set(hash);
+        self.state_changed();
+    }
+
+    pub fn set_float_pos(self: &Rc<Self>, data: &ToplevelData) {
+        let rect = if data.parent_is_float.get() {
+            let on = data.output();
+            if on.is_dummy {
+                None
+            } else {
+                let on = on.node_absolute_position();
+                let rect = data.desired_extents.get().move_(-on.x1(), -on.y1());
+                Some(rect)
+            }
+        } else {
+            None
+        };
+        if rect == self.state.floating_pos.get() {
+            return;
+        }
+        self.state.floating_pos.set(rect);
+        self.state_changed();
+    }
+
     fn schedule_job(self: &Rc<Self>, allow_changed: bool) {
         if self.job.is_some() {
             return;
@@ -451,13 +494,19 @@ impl ToplevelSession {
                 return;
             }
             self.changed.take();
+            let s = &self.state;
+            let tid = &self.session.manager.thread_id;
             let job = self
                 .session
                 .manager
                 .add_job(self, |job: &mut ToplevelUpdateJob| {
                     job.work.session_id = session_id;
                     job.work.id = id;
-                    job.work.data = SmToplevelIn {};
+                    job.work.data = SmToplevelIn {
+                        output: s.output.get(),
+                        workspace: s.workspace.get().map(|v| SendSyncRc::new(tid, &v)),
+                        floating_pos: s.floating_pos.get(),
+                    };
                 });
             self.job.set(Some(ToplevelJob::Update(job)));
             return;
@@ -511,7 +560,12 @@ impl ToplevelSession {
 }
 
 #[derive(Default, Clone)]
-pub struct ToplevelSessionState {}
+pub struct ToplevelSessionState {
+    pub output: Cell<Option<OutputIdHash>>,
+    pub floating_pos: Cell<Option<Rect>>,
+    pub workspace: CloneCell<Option<Rc<String>>>,
+    workspace_hash: Cell<Option<WorkspaceHash>>,
+}
 
 impl Drop for Session {
     fn drop(&mut self) {
diff --git a/src/sm/sm_jobs/sm_toplevel_acquire.rs b/src/sm/sm_jobs/sm_toplevel_acquire.rs
@@ -93,7 +93,9 @@ impl SqliteJob for ToplevelAcquireJob {
                 cb.id.set(Some(o.id));
                 let restored = o.restored.is_some();
                 if let Some(v) = o.restored {
-                    let _ = v;
+                    cb.state.output.set(v.output);
+                    cb.state.workspace.set(v.workspace.map(Rc::new));
+                    cb.state.floating_pos.set(v.floating_pos);
                 }
                 if let Some(owner) = cb.owner.get() {
                     owner.loaded(SessionGetStatus::from_restored(restored));
diff --git a/src/sm/sm_wire/sm_wire_toplevel.rs b/src/sm/sm_wire/sm_wire_toplevel.rs
@@ -1,4 +1,8 @@
 use {
+    crate::{
+        ifs::wl_output::OutputIdHash, rect::Rect, sm::sm_wire::WireRect,
+        utils::send_sync_rc::SendSyncRc,
+    },
     bincode::{Deserializer, Options},
     jay_config::_private::bincode_ops,
     serde::{Deserialize, Serialize},
@@ -10,6 +14,8 @@ use {
 pub enum DeserializeToplevelError {
     #[error("Could not deserialize the V0 component")]
     DeserializeV0(#[source] bincode::Error),
+    #[error("Could not deserialize the V1 component")]
+    DeserializeV1(#[source] bincode::Error),
 }
 
 pub fn deserialize_toplevel(data: &[u8]) -> Result<SmToplevelOut, DeserializeToplevelError> {
@@ -21,6 +27,9 @@ pub fn deserialize_toplevel(data: &[u8]) -> Result<SmToplevelOut, DeserializeTop
     }
     let mut wire = WireToplevel::default();
     wire.v0 = des!(DeserializeV0)?;
+    if wire.v0.version >= 1 {
+        wire.v1 = des!(DeserializeV1)?;
+    }
     Ok(wire.into())
 }
 
@@ -31,13 +40,23 @@ pub fn serialize_toplevel(data: &mut Vec<u8>, tl: &SmToplevelIn) {
 }
 
 #[derive(Default)]
-pub struct SmToplevelIn {}
+pub struct SmToplevelIn {
+    pub output: Option<OutputIdHash>,
+    pub workspace: Option<SendSyncRc<String>>,
+    pub floating_pos: Option<Rect>,
+}
 
-pub struct SmToplevelOut {}
+#[derive(Default)]
+pub struct SmToplevelOut {
+    pub output: Option<OutputIdHash>,
+    pub workspace: Option<String>,
+    pub floating_pos: Option<Rect>,
+}
 
 #[derive(Default, Serialize)]
 struct WireToplevel<'a> {
     v0: WireToplevelV0<'a>,
+    v1: WireToplevelV1<'a>,
 }
 
 #[derive(Default, Serialize, Deserialize)]
@@ -46,19 +65,42 @@ struct WireToplevelV0<'a> {
     _phantom: PhantomData<&'a ()>,
 }
 
+#[derive(Default, Serialize, Deserialize)]
+struct WireToplevelV1<'a> {
+    output: Option<OutputIdHash>,
+    #[serde(borrow)]
+    workspace: Option<&'a str>,
+    floating_pos: Option<WireRect>,
+}
+
 impl<'a> From<&'a SmToplevelIn> for WireToplevel<'a> {
-    fn from(_value: &'a SmToplevelIn) -> Self {
+    fn from(value: &'a SmToplevelIn) -> Self {
         Self {
             v0: WireToplevelV0 {
-                version: 0,
+                version: 1,
                 _phantom: Default::default(),
             },
+            v1: value.into(),
+        }
+    }
+}
+
+impl<'a> From<&'a SmToplevelIn> for WireToplevelV1<'a> {
+    fn from(value: &'a SmToplevelIn) -> Self {
+        Self {
+            output: value.output,
+            workspace: value.workspace.as_deref().map(|v| &**v),
+            floating_pos: value.floating_pos.map(Into::into),
         }
     }
 }
 
 impl From<WireToplevel<'_>> for SmToplevelOut {
-    fn from(_value: WireToplevel<'_>) -> Self {
-        Self {}
+    fn from(value: WireToplevel<'_>) -> Self {
+        Self {
+            output: value.v1.output,
+            workspace: value.v1.workspace.map(Into::into),
+            floating_pos: value.v1.floating_pos.map(Into::into),
+        }
     }
 }
diff --git a/src/state.rs b/src/state.rs
@@ -102,7 +102,7 @@ use {
         renderer::Renderer,
         scale::Scale,
         security_context_acceptor::SecurityContextAcceptors,
-        sm::SessionManager,
+        sm::{SessionManager, ToplevelSession},
         sqlite::Sqlite,
         tagged_acceptor::TaggedAcceptors,
         theme::{BarPosition, Color, Theme, ThemeColor, ThemeSized},
@@ -118,6 +118,7 @@ use {
         utils::{
             asyncevent::AsyncEvent,
             bindings::Bindings,
+            cell_ext::CellExt,
             clonecell::CloneCell,
             copyhashmap::CopyHashMap,
             errorfmt::ErrorFmt,
@@ -832,14 +833,67 @@ impl State {
         }
     }
 
-    pub fn ensure_map_workspace(&self, seat: Option<&Rc<WlSeatGlobal>>) -> Rc<WorkspaceNode> {
+    pub fn get_map_output(&self, seat: Option<&Rc<WlSeatGlobal>>) -> Rc<OutputNode> {
         seat.cloned()
             .or_else(|| self.seat_queue.last().map(|s| s.deref().clone()))
             .map(|s| s.get_fallback_output())
             .or_else(|| self.root.outputs.lock().values().next().cloned())
             .or_else(|| self.dummy_output.get())
             .unwrap()
-            .ensure_workspace()
+    }
+
+    pub fn ensure_map_workspace(&self, seat: Option<&Rc<WlSeatGlobal>>) -> Rc<WorkspaceNode> {
+        self.get_map_output(seat).ensure_workspace()
+    }
+
+    pub fn map_restore(
+        self: &Rc<Self>,
+        node: Rc<dyn ToplevelNode>,
+        session: &Rc<ToplevelSession>,
+        has_parent: bool,
+    ) -> bool {
+        let s = &session.state;
+        let on = || {
+            if let Some(o) = s.output.get() {
+                for on in self.root.outputs.lock().values() {
+                    if on.global.output_id.hash == o {
+                        return on.clone();
+                    }
+                }
+            }
+            self.get_map_output(None)
+        };
+        let ws = || {
+            let Some(name) = s.workspace.get() else {
+                return on().ensure_workspace();
+            };
+            if let Some(w) = self.workspaces.get(&*name) {
+                return w;
+            }
+            on().create_workspace(&name)
+        };
+        let ws = if let Some(pos) = session.state.floating_pos.get() {
+            let ws = ws();
+            let op = ws.output.get().node_absolute_position();
+            self.map_floating(
+                node.clone(),
+                pos.width(),
+                pos.height(),
+                &ws,
+                Some((pos.x1() + op.x1(), pos.y1() + op.y1())),
+            );
+            ws
+        } else if !has_parent && (s.workspace.is_some() || s.output.is_some()) {
+            let ws = ws();
+            self.map_tiled_on(node.clone(), &ws);
+            ws
+        } else {
+            return false;
+        };
+        if ws.output.get().workspace.get().map(|w| w.id) != Some(ws.id) {
+            node.tl_data().request_attention(&*node);
+        }
+        true
     }
 
     pub fn map_tiled(self: &Rc<Self>, node: Rc<dyn ToplevelNode>) {
diff --git a/src/tree/output.rs b/src/tree/output.rs
@@ -707,7 +707,7 @@ impl OutputNode {
                     wh.handle_destroyed();
                 }
                 old.clear();
-                self.state.workspaces.remove(&old.name);
+                self.state.workspaces.remove(&*old.name);
             } else {
                 old.set_visible(false);
                 old.flush_jay_workspaces();
diff --git a/src/tree/toplevel.rs b/src/tree/toplevel.rs
diff --git a/src/tree/workspace.rs b/src/tree/workspace.rs

Original file line number	Diff line number	Diff line change
`@@ -358,7 +358,7 @@ pub fn show_window(behavior: &mut CcBehavior<'_>, ui: &mut Ui, window: &dyn Topl`
`358`	`358`	`label(ui, "ID", &*data.identifier.get().to_string());`
`359`	`359`	`label(ui, "Title", &*data.title.borrow());`
`360`	`360`	`if let Some(w) = data.workspace.get() {`
`361`		`- label(ui, "Workspace", &w.name);`
	`361`	`+ label(ui, "Workspace", &*w.name);`
`362`	`362`	`}`
`363`	`363`	`match &data.kind {`
`364`	`364`	`ToplevelType::Container => {`
Original file line number	Diff line number	Diff line change
`@@ -707,7 +707,7 @@ impl OutputNode {`
`707`	`707`	`wh.handle_destroyed();`
`708`	`708`	`}`
`709`	`709`	`old.clear();`
`710`		`- self.state.workspaces.remove(&old.name);`
	`710`	`+ self.state.workspaces.remove(&*old.name);`
`711`	`711`	`} else {`
`712`	`712`	`old.set_visible(false);`
`713`	`713`	`old.flush_jay_workspaces();`