layout: Extract ScrollingSpace

Leave the Workspace to do the workspace parts, and extract the scrolling parts
into a new file. This is a pre-requisite for things like the floating layer
(which will live in a workspace alongside the scrolling layer).

As part of this huge refactor, I found and fixed at least these issues:
- Wrong horizontal popup unconstraining for a smaller window in an
  always-centered column.
- Wrong workspace switch in focus_up_or_right().

10 files changed, 4458 insertions, 4084 deletions

diff --git a/niri-visual-tests/src/cases/layout.rs b/niri-visual-tests/src/cases/layout.rs
index 8d365645..c2aee7fd 100644
--- a/niri-visual-tests/src/cases/layout.rs
+++ b/niri-visual-tests/src/cases/layout.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::time::Duration;
 
 use niri::animation::Clock;
-use niri::layout::workspace::ColumnWidth;
+use niri::layout::scrolling::ColumnWidth;
 use niri::layout::{ActivateWindow, LayoutElement as _, Options};
 use niri::render_helpers::RenderTarget;
 use niri_config::{Color, FloatOrInt, OutputName};
diff --git a/src/handlers/compositor.rs b/src/handlers/compositor.rs
index ae53bfc8..fe9f8839 100644
--- a/src/handlers/compositor.rs
+++ b/src/handlers/compositor.rs
@@ -189,9 +189,8 @@ impl CompositorHandler for State {
                     if let Some(output) = output.cloned() {
                         self.niri.layout.start_open_animation_for_window(&window);
 
-                        let new_active_window =
-                            self.niri.layout.active_window().map(|(m, _)| &m.window);
-                        if new_active_window == Some(&window) {
+                        let new_focus = self.niri.layout.focus().map(|m| &m.window);
+                        if new_focus == Some(&window) {
                             self.maybe_warp_cursor_to_focus();
                         }
 
@@ -242,7 +241,7 @@ impl CompositorHandler for State {
                     // The toplevel got unmapped.
                     //
                     // Test client: wleird-unmap.
-                    let active_window = self.niri.layout.active_window().map(|(m, _)| &m.window);
+                    let active_window = self.niri.layout.focus().map(|m| &m.window);
                     let was_active = active_window == Some(&window);
 
                     #[cfg(feature = "xdp-gnome-screencast")]
@@ -290,7 +289,7 @@ impl CompositorHandler for State {
                 self.niri.layout.update_window(&window, serial);
 
                 // Popup placement depends on window size which might have changed.
-                self.update_reactive_popups(&window, &output);
+                self.update_reactive_popups(&window);
 
                 self.niri.queue_redraw(&output);
                 return;
diff --git a/src/handlers/xdg_shell.rs b/src/handlers/xdg_shell.rs
index 834bbf64..ae860e4a 100644
--- a/src/handlers/xdg_shell.rs
+++ b/src/handlers/xdg_shell.rs
@@ -42,7 +42,7 @@ use crate::input::resize_grab::ResizeGrab;
 use crate::input::touch_move_grab::TouchMoveGrab;
 use crate::input::touch_resize_grab::TouchResizeGrab;
 use crate::input::{PointerOrTouchStartData, DOUBLE_CLICK_TIME};
-use crate::layout::workspace::ColumnWidth;
+use crate::layout::scrolling::ColumnWidth;
 use crate::niri::{PopupGrabState, State};
 use crate::utils::transaction::Transaction;
 use crate::utils::{get_monotonic_time, output_matches_name, send_scale_transform, ResizeEdge};
@@ -609,7 +609,7 @@ impl XdgShellHandler for State {
                 .start_close_animation_for_window(renderer, &window, blocker);
         });
 
-        let active_window = self.niri.layout.active_window().map(|(m, _)| &m.window);
+        let active_window = self.niri.layout.focus().map(|m| &m.window);
         let was_active = active_window == Some(&window);
 
         self.niri.layout.remove_window(&window, transaction.clone());
@@ -928,8 +928,8 @@ impl State {
         };
 
         // Figure out if the root is a window or a layer surface.
-        if let Some((mapped, output)) = self.niri.layout.find_window_and_output(&root) {
-            self.unconstrain_window_popup(popup, &mapped.window, output);
+        if let Some((mapped, _)) = self.niri.layout.find_window_and_output(&root) {
+            self.unconstrain_window_popup(popup, &mapped.window);
         } else if let Some((layer_surface, output)) = self.niri.layout.outputs().find_map(|o| {
             let map = layer_map_for_output(o);
             let layer_surface = map.layer_for_surface(&root, WindowSurfaceType::TOPLEVEL)?;
@@ -939,19 +939,10 @@ impl State {
         }
     }
 
-    fn unconstrain_window_popup(&self, popup: &PopupKind, window: &Window, output: &Output) {
-        let window_geo = window.geometry();
-        let output_geo = self.niri.global_space.output_geometry(output).unwrap();
-
+    fn unconstrain_window_popup(&self, popup: &PopupKind, window: &Window) {
         // The target geometry for the positioner should be relative to its parent's geometry, so
         // we will compute that here.
-        //
-        // We try to keep regular window popups within the window itself horizontally (since the
-        // window can be scrolled to both edges of the screen), but within the whole monitor's
-        // height.
-        let mut target =
-            Rectangle::from_loc_and_size((0, 0), (window_geo.size.w, output_geo.size.h)).to_f64();
-        target.loc -= self.niri.layout.window_loc(window).unwrap();
+        let mut target = self.niri.layout.popup_target_rect(window);
         target.loc -= get_popup_toplevel_coords(popup).to_f64();
 
         self.position_popup_within_rect(popup, target);
@@ -1016,7 +1007,7 @@ impl State {
         }
     }
 
-    pub fn update_reactive_popups(&self, window: &Window, output: &Output) {
+    pub fn update_reactive_popups(&self, window: &Window) {
         let _span = tracy_client::span!("Niri::update_reactive_popups");
 
         for (popup, _) in PopupManager::popups_for_surface(
@@ -1025,7 +1016,7 @@ impl State {
             match &popup {
                 xdg_popup @ PopupKind::Xdg(popup) => {
                     if popup.with_pending_state(|state| state.positioner.reactive) {
-                        self.unconstrain_window_popup(xdg_popup, window, output);
+                        self.unconstrain_window_popup(xdg_popup, window);
                         if let Err(err) = popup.send_pending_configure() {
                             warn!("error re-configuring reactive popup: {err:?}");
                         }
diff --git a/src/input/mod.rs b/src/input/mod.rs
index 545c82d7..13ed6d7f 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -581,8 +581,8 @@ impl State {
                 self.open_screenshot_ui();
             }
             Action::ScreenshotWindow => {
-                let active = self.niri.layout.active_window();
-                if let Some((mapped, output)) = active {
+                let focus = self.niri.layout.focus_with_output();
+                if let Some((mapped, output)) = focus {
                     self.backend.with_primary_renderer(|renderer| {
                         if let Err(err) = self.niri.screenshot_window(renderer, output, mapped) {
                             warn!("error taking screenshot: {err:?}");
@@ -990,8 +990,8 @@ impl State {
                             self.niri.layout.move_to_workspace(Some(&window), index);
 
                             // If we focused the target window.
-                            let new_active_win = self.niri.layout.active_window();
-                            if new_active_win.map_or(false, |(win, _)| win.window == window) {
+                            let new_focus = self.niri.layout.focus();
+                            if new_focus.map_or(false, |win| win.window == window) {
                                 self.maybe_warp_cursor_to_focus();
                             }
                         }
diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index 6cb4dd44..53248d75 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -40,6 +40,7 @@ use niri_config::{
     Workspace as WorkspaceConfig,
 };
 use niri_ipc::SizeChange;
+use scrolling::{Column, ColumnWidth, InsertHint, InsertPosition};
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::element::Id;
 use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture};
@@ -51,9 +52,8 @@ use workspace::WorkspaceId;
 
 pub use self::monitor::MonitorRenderElement;
 use self::monitor::{Monitor, WorkspaceSwitch};
-use self::workspace::{compute_working_area, Column, ColumnWidth, InsertHint, OutputId, Workspace};
+use self::workspace::{OutputId, Workspace};
 use crate::animation::Clock;
-use crate::layout::workspace::InsertPosition;
 use crate::niri_render_elements;
 use crate::render_helpers::renderer::NiriRenderer;
 use crate::render_helpers::snapshot::RenderSnapshot;
@@ -70,6 +70,7 @@ pub mod focus_ring;
 pub mod insert_hint_element;
 pub mod monitor;
 pub mod opening_window;
+pub mod scrolling;
 pub mod tile;
 pub mod workspace;
 
@@ -801,10 +802,7 @@ impl<W: LayoutElement> Layout<W> {
                 let activate = activate.map_smart(|| {
                     // Don't steal focus from an active fullscreen window.
                     let ws = &mon.workspaces[ws_idx];
-                    if mon_idx == *active_monitor_idx
-                        && !ws.columns.is_empty()
-                        && ws.columns[ws.active_column_idx].is_fullscreen
-                    {
+                    if mon_idx == *active_monitor_idx && ws.is_active_fullscreen() {
                         return false;
                     }
 
@@ -829,7 +827,7 @@ impl<W: LayoutElement> Layout<W> {
                     })
                     .unwrap();
                 let activate = activate.map_smart(|| true);
-                ws.add_window(None, window, activate, width, is_full_width);
+                ws.add_window(window, activate, width, is_full_width);
                 None
             }
         }
@@ -881,7 +879,7 @@ impl<W: LayoutElement> Layout<W> {
                 let activate = activate.map_smart(|| {
                     // Don't steal focus from an active fullscreen window.
                     let ws = &mon.workspaces[mon.active_workspace_idx];
-                    ws.columns.is_empty() || !ws.columns[ws.active_column_idx].is_fullscreen
+                    !ws.is_active_fullscreen()
                 });
 
                 mon.add_window(
@@ -904,7 +902,7 @@ impl<W: LayoutElement> Layout<W> {
                     &mut workspaces[0]
                 };
                 let activate = activate.map_smart(|| true);
-                ws.add_window(None, window, activate, width, is_full_width);
+                ws.add_window(window, activate, width, is_full_width);
                 None
             }
         }
@@ -991,13 +989,7 @@ impl<W: LayoutElement> Layout<W> {
         let activate = activate.map_smart(|| {
             // Don't steal focus from an active fullscreen window.
             let ws = &mon.workspaces[mon.active_workspace_idx];
-            if mon_idx == *active_monitor_idx
-                && !ws.columns.is_empty()
-                && ws.columns[ws.active_column_idx].is_fullscreen
-            {
-                return false;
-            }
-            true
+            mon_idx != *active_monitor_idx || !ws.is_active_fullscreen()
         });
 
         mon.add_window(
@@ -1263,37 +1255,28 @@ impl<W: LayoutElement> Layout<W> {
         None
     }
 
-    pub fn window_loc(&self, window: &W::Id) -> Option<Point<f64, Logical>> {
+    /// Computes the window-geometry-relative target rect for popup unconstraining.
+    ///
+    /// We will try to fit popups inside this rect.
+    pub fn popup_target_rect(&self, window: &W::Id) -> Rectangle<f64, Logical> {
         if let Some(InteractiveMoveState::Moving(move_)) = &self.interactive_move {
             if move_.tile.window().id() == window {
-                return Some(move_.tile.window_loc());
-            }
-        }
-
-        match &self.monitor_set {
-            MonitorSet::Normal { monitors, .. } => {
-                for mon in monitors {
-                    for ws in &mon.workspaces {
-                        for col in &ws.columns {
-                            if let Some(idx) = col.position(window) {
-                                return Some(col.window_loc(idx));
-                            }
-                        }
-                    }
-                }
-            }
-            MonitorSet::NoOutputs { workspaces, .. } => {
-                for ws in workspaces {
-                    for col in &ws.columns {
-                        if let Some(idx) = col.position(window) {
-                            return Some(col.window_loc(idx));
-                        }
-                    }
-                }
+                // Follow the scrolling layout logic and fit the popup horizontally within the
+                // window geometry.
+                let width = move_.tile.window_size().w;
+                let height = output_size(&move_.output).h;
+                let mut target = Rectangle::from_loc_and_size((0., 0.), (width, height));
+                // FIXME: ideally this shouldn't include the tile render offset, but the code
+                // duplication would be a bit annoying for this edge case.
+                target.loc.y -= move_.tile_render_location().y;
+                target.loc.y -= move_.tile.window_loc().y;
+                return target;
             }
         }
 
-        None
+        self.workspaces()
+            .find_map(|(_, _, ws)| ws.popup_target_rect(window))
+            .unwrap()
     }
 
     pub fn update_output_size(&mut self, output: &Output) {
@@ -1305,13 +1288,8 @@ impl<W: LayoutElement> Layout<W> {
 
         for mon in monitors {
             if &mon.output == output {
-                let scale = output.current_scale();
-                let transform = output.current_transform();
-                let view_size = output_size(output);
-                let working_area = compute_working_area(output, self.options.struts);
-
                 for ws in &mut mon.workspaces {
-                    ws.set_view_size(scale, transform, view_size, working_area);
+                    ws.update_output_size();
                 }
 
                 break;
@@ -1471,31 +1449,6 @@ impl<W: LayoutElement> Layout<W> {
         Some(&mut mon.workspaces[mon.active_workspace_idx])
     }
 
-    pub fn active_window(&self) -> Option<(&W, &Output)> {
-        if let Some(InteractiveMoveState::Moving(move_)) = &self.interactive_move {
-            return Some((move_.tile.window(), &move_.output));
-        }
-
-        let MonitorSet::Normal {
-            monitors,
-            active_monitor_idx,
-            ..
-        } = &self.monitor_set
-        else {
-            return None;
-        };
-
-        let mon = &monitors[*active_monitor_idx];
-        let ws = &mon.workspaces[mon.active_workspace_idx];
-
-        if ws.columns.is_empty() {
-            return None;
-        }
-
-        let col = &ws.columns[ws.active_column_idx];
-        Some((col.tiles[col.active_tile_idx].window(), &mon.output))
-    }
-
     pub fn windows_for_output(&self, output: &Output) -> impl Iterator<Item = &W> + '_ {
         let MonitorSet::Normal { monitors, .. } = &self.monitor_set else {
             panic!()
@@ -1661,11 +1614,7 @@ impl<W: LayoutElement> Layout<W> {
 
     pub fn move_column_left_or_to_output(&mut self, output: &Output) -> bool {
         if let Some(monitor) = self.active_monitor() {
-            let workspace = monitor.active_workspace();
-            let curr_idx = workspace.active_column_idx;
-
-            if !workspace.columns.is_empty() && curr_idx != 0 {
-                monitor.move_left();
+            if monitor.move_left() {
                 return false;
             }
         }
@@ -1676,11 +1625,7 @@ impl<W: LayoutElement> Layout<W> {
 
     pub fn move_column_right_or_to_output(&mut self, output: &Output) -> bool {
         if let Some(monitor) = self.active_monitor() {
-            let workspace = monitor.active_workspace();
-            let curr_idx = workspace.active_column_idx;
-
-            if !workspace.columns.is_empty() && curr_idx != workspace.columns.len() - 1 {
-                monitor.move_right();
+            if monitor.move_right() {
                 return false;
             }
         }
@@ -1807,15 +1752,8 @@ impl<W: LayoutElement> Layout<W> {
 
     pub fn focus_window_up_or_output(&mut self, output: &Output) -> bool {
         if let Some(monitor) = self.active_monitor() {
-            let workspace = monitor.active_workspace();
-
-            if !workspace.columns.is_empty() {
-                let curr_idx = workspace.columns[workspace.active_column_idx].active_tile_idx;
-                let new_idx = curr_idx.saturating_sub(1);
-                if curr_idx != new_idx {
-                    workspace.focus_up();
-                    return false;
-                }
+            if monitor.focus_up() {
+                return false;
             }
         }
 
@@ -1825,16 +1763,8 @@ impl<W: LayoutElement> Layout<W> {
 
     pub fn focus_window_down_or_output(&mut self, output: &Output) -> bool {
         if let Some(monitor) = self.active_monitor() {
-            let workspace = monitor.active_workspace();
-
-            if !workspace.columns.is_empty() {
-                let column = &workspace.columns[workspace.active_column_idx];
-                let curr_idx = column.active_tile_idx;
-                let new_idx = min(column.active_tile_idx + 1, column.tiles.len() - 1);
-                if curr_idx != new_idx {
-                    workspace.focus_down();
-                    return false;
-                }
+            if monitor.focus_down() {
+                return false;
             }
         }
 
@@ -1844,11 +1774,7 @@ impl<W: LayoutElement> Layout<W> {
 
     pub fn focus_column_left_or_output(&mut self, output: &Output) -> bool {
         if let Some(monitor) = self.active_monitor() {
-            let workspace = monitor.active_workspace();
-            let curr_idx = workspace.active_column_idx;
-
-            if !workspace.columns.is_empty() && curr_idx != 0 {
-                monitor.focus_left();
+            if monitor.focus_left() {
                 return false;
             }
         }
@@ -1859,12 +1785,7 @@ impl<W: LayoutElement> Layout<W> {
 
     pub fn focus_column_right_or_output(&mut self, output: &Output) -> bool {
         if let Some(monitor) = self.active_monitor() {
-            let workspace = monitor.active_workspace();
-            let curr_idx = workspace.active_column_idx;
-            let columns = &workspace.columns;
-
-            if !workspace.columns.is_empty() && curr_idx != columns.len() - 1 {
-                monitor.focus_right();
+            if monitor.focus_right() {
                 return false;
             }
         }
@@ -2040,8 +1961,12 @@ impl<W: LayoutElement> Layout<W> {
     }
 
     pub fn focus(&self) -> Option<&W> {
+        self.focus_with_output().map(|(win, _out)| win)
+    }
+
+    pub fn focus_with_output(&self) -> Option<(&W, &Output)> {
         if let Some(InteractiveMoveState::Moving(move_)) = &self.interactive_move {
-            return Some(move_.tile.window());
+            return Some((move_.tile.window(), &move_.output));
         }
 
         let MonitorSet::Normal {
@@ -2053,7 +1978,8 @@ impl<W: LayoutElement> Layout<W> {
             return None;
         };
 
-        monitors[*active_monitor_idx].focus()
+        let mon = &monitors[*active_monitor_idx];
+        mon.active_window().map(|win| (win, &mon.output))
     }
 
     /// Returns the window under the cursor and the position of its toplevel surface within the
@@ -2248,12 +2174,12 @@ impl<W: LayoutElement> Layout<W> {
             }
 
             assert!(
-                monitor.workspaces.last().unwrap().columns.is_empty(),
+                !monitor.workspaces.last().unwrap().has_windows(),
                 "monitor must have an empty workspace in the end"
             );
             if monitor.options.empty_workspace_above_first {
                 assert!(
-                    monitor.workspaces.first().unwrap().columns.is_empty(),
+                    !monitor.workspaces.first().unwrap().has_windows(),
                     "first workspace must be empty when empty_workspace_above_first is set"
                 )
             }
@@ -2710,34 +2636,21 @@ impl<W: LayoutElement> Layout<W> {
                 .position(|mon| &mon.output == output)
                 .unwrap();
 
-            let (mon_idx, ws_idx, col_idx, tile_idx) = if let Some(window) = window {
+            let (mon_idx, ws_idx) = if let Some(window) = window {
                 monitors
                     .iter()
                     .enumerate()
                     .find_map(|(mon_idx, mon)| {
-                        mon.workspaces.iter().enumerate().find_map(|(ws_idx, ws)| {
-                            ws.columns.iter().enumerate().find_map(|(col_idx, col)| {
-                                col.tiles
-                                    .iter()
-                                    .position(|tile| tile.window().id() == window)
-                                    .map(|tile_idx| (mon_idx, ws_idx, col_idx, tile_idx))
-                            })
-                        })
+                        mon.workspaces
+                            .iter()
+                            .position(|ws| ws.has_window(window))
+                            .map(|ws_idx| (mon_idx, ws_idx))
                     })
                     .unwrap()
             } else {
                 let mon_idx = *active_monitor_idx;
                 let mon = &monitors[mon_idx];
-                let ws_idx = mon.active_workspace_idx;
-                let ws = &mon.workspaces[ws_idx];
-
-                if ws.columns.is_empty() {
-                    return;
-                }
-
-                let col_idx = ws.active_column_idx;
-                let tile_idx = ws.columns[col_idx].active_tile_idx;
-                (mon_idx, ws_idx, col_idx, tile_idx)
+                (mon_idx, mon.active_workspace_idx)
             };
 
             let workspace_idx = target_ws_idx.unwrap_or(monitors[new_idx].active_workspace_idx);
@@ -2746,14 +2659,20 @@ impl<W: LayoutElement> Layout<W> {
             }
 
             let mon = &mut monitors[mon_idx];
-            let ws = &mut mon.workspaces[ws_idx];
-            let column = &ws.columns[col_idx];
-            let activate = mon_idx == *active_monitor_idx
-                && ws_idx == mon.active_workspace_idx
-                && col_idx == ws.active_column_idx
-                && tile_idx == column.active_tile_idx;
+            let activate = window.map_or(true, |win| {
+                mon_idx == *active_monitor_idx
+                    && mon.active_window().map(|win| win.id()) == Some(win)
+            });
 
-            let removed = ws.remove_tile_by_idx(col_idx, tile_idx, Transaction::new(), None);
+            let ws = &mut mon.workspaces[ws_idx];
+            let transaction = Transaction::new();
+            let removed = if let Some(window) = window {
+                ws.remove_tile(window, transaction)
+            } else if let Some(removed) = ws.remove_active_tile(transaction) {
+                removed
+            } else {
+                return;
+            };
 
             self.add_window_by_idx(
                 new_idx,
@@ -2788,10 +2707,9 @@ impl<W: LayoutElement> Layout<W> {
 
             let current = &mut monitors[*active_monitor_idx];
             let ws = current.active_workspace();
-            if !ws.has_windows() {
+            let Some(column) = ws.remove_active_column() else {
                 return;
-            }
-            let column = ws.remove_column_by_idx(ws.active_column_idx, None);
+            };
 
             let workspace_idx = monitors[new_idx].active_workspace_idx;
             self.add_column_by_idx(new_idx, workspace_idx, column, true);
@@ -3373,14 +3291,7 @@ impl<W: LayoutElement> Layout<W> {
                 };
 
                 // No point in trying to use the pointer position without outputs.
-                ws.add_tile(
-                    None,
-                    move_.tile,
-                    true,
-                    move_.width,
-                    move_.is_full_width,
-                    None,
-                );
+                ws.add_tile(None, move_.tile, true, move_.width, move_.is_full_width);
             }
         }
     }
@@ -3491,31 +3402,11 @@ impl<W: LayoutElement> Layout<W> {
             }
         }
 
-        match &mut self.monitor_set {
-            MonitorSet::Normal { monitors, .. } => {
-                for mon in monitors {
-                    for ws in &mut mon.workspaces {
-                        for col in &mut ws.columns {
-                            for tile in &mut col.tiles {
-                                if tile.window().id() == window {
-                                    tile.start_open_animation();
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            MonitorSet::NoOutputs { workspaces, .. } => {
-                for ws in workspaces {
-                    for col in &mut ws.columns {
-                        for tile in &mut col.tiles {
-                            if tile.window().id() == window {
-                                tile.start_open_animation();
-                                return;
-                            }
-                        }
-                    }
+        for ws in self.workspaces_mut() {
+            for tile in ws.tiles_mut() {
+                if tile.window().id() == window {
+                    tile.start_open_animation();
+                    return;
                 }
             }
         }
@@ -3615,7 +3506,7 @@ impl<W: LayoutElement> Layout<W> {
                     .find(|ws| ws.id() == ws_id)
                     .unwrap();
 
-                let tile_pos = tile_pos + Point::from((ws.view_pos(), 0.)) - offset;
+                let tile_pos = tile_pos - offset;
                 ws.start_close_animation_for_tile(renderer, snapshot, tile_size, tile_pos, blocker);
                 return;
             }
@@ -3823,7 +3714,6 @@ mod tests {
     use smithay::utils::Rectangle;
 
     use super::*;
-    use crate::utils::round_logical_in_physical;
 
     impl<W: LayoutElement> Default for Layout<W> {
         fn default() -> Self {
@@ -5532,7 +5422,8 @@ mod tests {
             "the second workspace must remain active"
         );
         assert_eq!(
-            mon.workspaces[0].active_column_idx, 1,
+            mon.workspaces[0].scrolling().active_column_idx(),
+            1,
             "the new window must become active"
         );
     }
@@ -5577,7 +5468,8 @@ mod tests {
             "the second workspace must remain active"
         );
         assert_eq!(
-            mon.workspaces[1].active_column_idx, 1,
+            mon.workspaces[1].scrolling().active_column_idx(),
+            1,
             "the new window must become active"
         );
     }
@@ -5769,71 +5661,6 @@ mod tests {
     }
 
     #[test]
-    fn working_area_starts_at_physical_pixel() {
-        let struts = Struts {
-            left: FloatOrInt(0.5),
-            right: FloatOrInt(1.),
-            top: FloatOrInt(0.75),
-            bottom: FloatOrInt(1.),
-        };
-
-        let output = Output::new(
-            String::from("output"),
-            PhysicalProperties {
-                size: Size::from((1280, 720)),
-                subpixel: Subpixel::Unknown,
-                make: String::new(),
-                model: String::new(),
-            },
-        );
-        output.change_current_state(
-            Some(Mode {
-                size: Size::from((1280, 720)),
-                refresh: 60000,
-            }),
-            None,
-            None,
-            None,
-        );
-
-        let area = compute_working_area(&output, struts);
-
-        assert_eq!(round_logical_in_physical(1., area.loc.x), area.loc.x);
-        assert_eq!(round_logical_in_physical(1., area.loc.y), area.loc.y);
-    }
-
-    #[test]
-    fn large_fractional_strut() {
-        let struts = Struts {
-            left: FloatOrInt(0.),
-            right: FloatOrInt(0.),
-            top: FloatOrInt(50000.5),
-            bottom: FloatOrInt(0.),
-        };
-
-        let output = Output::new(
-            String::from("output"),
-            PhysicalProperties {
-                size: Size::from((1280, 720)),
-                subpixel: Subpixel::Unknown,
-                make: String::new(),
-                model: String::new(),
-            },
-        );
-        output.change_current_state(
-            Some(Mode {
-                size: Size::from((1280, 720)),
-                refresh: 60000,
-            }),
-            None,
-            None,
-            None,
-        );
-
-        compute_working_area(&output, struts);
-    }
-
-    #[test]
     fn set_window_height_recomputes_to_auto() {
         let ops = [
             Op::AddOutput(1),
diff --git a/src/layout/monitor.rs b/src/layout/monitor.rs
index 1ecd812c..67b09e20 100644
--- a/src/layout/monitor.rs
+++ b/src/layout/monitor.rs
@@ -9,11 +9,9 @@ use smithay::backend::renderer::element::utils::{
 use smithay::output::Output;
 use smithay::utils::{Logical, Point, Rectangle};
 
+use super::scrolling::{Column, ColumnWidth};
 use super::tile::Tile;
-use super::workspace::{
-    compute_working_area, Column, ColumnWidth, OutputId, Workspace, WorkspaceId,
-    WorkspaceRenderElement,
-};
+use super::workspace::{OutputId, Workspace, WorkspaceId, WorkspaceRenderElement};
 use super::{LayoutElement, Options};
 use crate::animation::{Animation, Clock};
 use crate::input::swipe_tracker::SwipeTracker;
@@ -230,7 +228,7 @@ impl<W: LayoutElement> Monitor<W> {
     ) {
         let workspace = &mut self.workspaces[workspace_idx];
 
-        workspace.add_window(None, window, activate, width, is_full_width);
+        workspace.add_window(window, activate, width, is_full_width);
 
         // After adding a new window, workspace becomes this output's own.
         workspace.original_output = OutputId::new(&self.output);
@@ -275,7 +273,7 @@ impl<W: LayoutElement> Monitor<W> {
     pub fn add_column(&mut self, mut workspace_idx: usize, column: Column<W>, activate: bool) {
         let workspace = &mut self.workspaces[workspace_idx];
 
-        workspace.add_column(None, column, activate, None);
+        workspace.add_column(column, activate);
 
         // After adding a new window, workspace becomes this output's own.
         workspace.original_output = OutputId::new(&self.output);
@@ -304,7 +302,7 @@ impl<W: LayoutElement> Monitor<W> {
     ) {
         let workspace = &mut self.workspaces[workspace_idx];
 
-        workspace.add_tile(column_idx, tile, activate, width, is_full_width, None);
+        workspace.add_tile(column_idx, tile, activate, width, is_full_width);
 
         // After adding a new window, workspace becomes this output's own.
         workspace.original_output = OutputId::new(&self.output);
@@ -392,12 +390,12 @@ impl<W: LayoutElement> Monitor<W> {
         false
     }
 
-    pub fn move_left(&mut self) {
-        self.active_workspace().move_left();
+    pub fn move_left(&mut self) -> bool {
+        self.active_workspace().move_left()
     }
 
-    pub fn move_right(&mut self) {
-        self.active_workspace().move_right();
+    pub fn move_right(&mut self) -> bool {
+        self.active_workspace().move_right()
     }
 
     pub fn move_column_to_first(&mut self) {
@@ -417,40 +415,23 @@ impl<W: LayoutElement> Monitor<W> {
     }
 
     pub fn move_down_or_to_workspace_down(&mut self) {
-        let workspace = self.active_workspace();
-        if workspace.columns.is_empty() {
-            return;
-        }
-        let column = &mut workspace.columns[workspace.active_column_idx];
-        let curr_idx = column.active_tile_idx;
-        let new_idx = min(column.active_tile_idx + 1, column.tiles.len() - 1);
-        if curr_idx == new_idx {
+        if !self.active_workspace().move_down() {
             self.move_to_workspace_down();
-        } else {
-            workspace.move_down();
         }
     }
 
     pub fn move_up_or_to_workspace_up(&mut self) {
-        let workspace = self.active_workspace();
-        if workspace.columns.is_empty() {
-            return;
-        }
-        let curr_idx = workspace.columns[workspace.active_column_idx].active_tile_idx;
-        let new_idx = curr_idx.saturating_sub(1);
-        if curr_idx == new_idx {
+        if !self.active_workspace().move_up() {
             self.move_to_workspace_up();
-        } else {
-            workspace.move_up();
         }
     }
 
-    pub fn focus_left(&mut self) {
-        self.active_workspace().focus_left();
+    pub fn focus_left(&mut self) -> bool {
+        self.active_workspace().focus_left()
     }
 
-    pub fn focus_right(&mut self) {
-        self.active_workspace().focus_right();
+    pub fn focus_right(&mut self) -> bool {
+        self.active_workspace().focus_right()
     }
 
     pub fn focus_column_first(&mut self) {
@@ -469,98 +450,39 @@ impl<W: LayoutElement> Monitor<W> {
         self.active_workspace().focus_column_left_or_last();
     }
 
-    pub fn focus_down(&mut self) {
-        self.active_workspace().focus_down();
+    pub fn focus_down(&mut self) -> bool {
+        self.active_workspace().focus_down()
     }
 
-    pub fn focus_up(&mut self) {
-        self.active_workspace().focus_up();
+    pub fn focus_up(&mut self) -> bool {
+        self.active_workspace().focus_up()
     }
 
     pub fn focus_down_or_left(&mut self) {
-        let workspace = self.active_workspace();
-        if !workspace.columns.is_empty() {
-            let column = &workspace.columns[workspace.active_column_idx];
-            let curr_idx = column.active_tile_idx;
-            let new_idx = min(column.active_tile_idx + 1, column.tiles.len() - 1);
-            if curr_idx == new_idx {
-                self.focus_left();
-            } else {
-                workspace.focus_down();
-            }
-        }
+        self.active_workspace().focus_down_or_left();
     }
 
     pub fn focus_down_or_right(&mut self) {
-        let workspace = self.active_workspace();
-        if !workspace.columns.is_empty() {
-            let column = &workspace.columns[workspace.active_column_idx];