feat(scrolling): put several windows in a column of the scrolling layout

The strip's tiles are the workspace's containers, in the order of the
list, so a column is a run of the list and every container still gets
one rectangle: the layout pass, latest_layout, drag and the borders are
as they were. Everything that changes the order of the containers does
it on the list, and the strip is made to match on the next pass.

- consume left|right and expel make and unmake columns of several
  windows, and only do anything in the Scrolling layout for now
- focus left and right go to the neighbouring column and to the window
  in it that had focus last, and up and down go between the windows of
  the column and carry on to another monitor at the ends, as before
- move left and right move the whole column, and up and down swap the
  window with the one above or below it, past which the list changes
- a new window goes after the last window of the focused column and
  not after the focused window, so that it is a column of its own and
  does not split the one it was opened next to
- the strip is no longer thrown away when the layout is not Scrolling,
  so that widths come back when it is again

Heights are equal and there is no command to change them yet. A window
that is moved to another workspace or monitor starts again with the
default width.
This commit is contained in:
LGUG2Z committed 2026-10-29 16:38:53 -07:00
1 parent ebc9d49d77
commit 5d78b22a8b
10 files changed
+494 -7

No files matched your search

+20
View File
@@ -0,0 +1,20 @@
# consume
```
Take the window on one side into the focused column
Left takes the last window of the column on the left to the top of the focused column, and right
takes the first window of the column on the right to the bottom of it. Up and down do nothing. Only
the Scrolling layout has columns of several windows, so this does nothing in the other layouts.
Usage: komorebic consume <OPERATION_DIRECTION>
Arguments:
<OPERATION_DIRECTION>
[possible values: left, right, up, down]
Options:
-h, --help
Print help (see a summary with '-h')
```
+14
View File
@@ -0,0 +1,14 @@
# expel
```
Take the focused window out of its column and into a column of its own
Only the Scrolling layout has columns of several windows, so this does nothing in the other layouts.
Usage: komorebic expel
Options:
-h, --help
Print help (see a summary with '-h')
```
+32
View File
@@ -51,6 +51,33 @@ screen wide, and is not stretched to fill it.
A lone window is a third of the screen wide, at the left edge. To have it fill the screen, or to take it out of the
layout for a while, use [`komorebic toggle-monocle`](../cli/toggle-monocle.md).
## Columns of several windows
A column can hold more than one window, one above the other, sharing the height of the screen. A new window is always a
column of its own, to the right of the column that has focus. To put windows in the same column:
- [`komorebic consume right`](../cli/consume.md) takes the first window of the column on the right and puts it at the
bottom of the focused column.
- [`komorebic consume left`](../cli/consume.md) takes the last window of the column on the left and puts it at the top of
the focused column.
- [`komorebic expel`](../cli/expel.md) takes the focused window out of its column and puts it in a column of its own on
the right.
These only do anything in the Scrolling layout, which is the only one with columns of several windows for now.
The focused window keeps focus, and stays where it is on screen, when you do any of these.
Focus and move commands know about columns:
- [`focus left` and `focus right`](../cli/focus.md) go to the neighbouring column, and to the window in it that had focus
last. `focus up` and `focus down` go to the windows of the focused column, and stop at the ends, where they carry on
to another monitor as they always did.
- [`move left` and `move right`](../cli/move.md) move the whole focused column. `move up` and `move down` move the
window up or down in its column.
- A column keeps its width, and a [stack](../cli/stack.md) is still one tile showing one of its windows, as in any layout.
A column that you resized, or made the full width of the screen, keeps that as windows are added to it or taken out.
## Full width and centring
- [`komorebic scrolling-layout-full-width`](../cli/scrolling-layout-full-width.md) makes the focused column as wide as the
@@ -116,5 +143,10 @@ arranged above and below each other rather than side by side, none of this appli
These are not done yet.
- The windows of a column share its height equally. There are no commands for giving a window more of it, and no minimum
height.
- Moving a window to another workspace or monitor makes it a column of its own with the default width.
- Switching to another layout and back keeps the widths, but a column whose windows were moved past each other in the
other layout is made again from the order that they are in.
- Every window has a border, including the windows resting at the edges, so you may see a thin line of one at the edge
of the screen.
+4
View File
@@ -336,6 +336,8 @@ pub enum SocketMessage {
ScrollingLayoutFullWidth,
CenterFocus,
Expand,
Consume(OperationDirection),
Expel,
LayoutRatios(Option<Vec<f32>>, Option<Vec<f32>>),
// ChangeLayoutCustom(#[serde_as(as = "ResolvedPathBuf")] PathBuf),
FlipLayout(Axis),
@@ -498,6 +500,8 @@ mod tests {
SocketMessage::ScrollingLayoutFullWidth,
SocketMessage::CenterFocus,
SocketMessage::Expand,
SocketMessage::Consume(OperationDirection::Left),
SocketMessage::Expel,
] {
let bytes = message.as_bytes().unwrap();
let read: SocketMessage = String::from_utf8(bytes.clone()).unwrap().parse().unwrap();
+8
View File
@@ -1508,6 +1508,14 @@ impl WindowManager {
self.focused_workspace_mut()?.expand_scrolling_column();
self.update_focused_workspace(false, false)?;
}
SocketMessage::Consume(direction) => {
self.focused_workspace_mut()?.consume_scrolling(direction);
self.update_focused_workspace(false, false)?;
}
SocketMessage::Expel => {
self.focused_workspace_mut()?.expel_scrolling();
self.update_focused_workspace(false, false)?;
}
SocketMessage::LayoutRatios(ref columns, ref rows) => {
use crate::core::validate_ratios;
+379
View File
@@ -290,6 +290,172 @@ impl Workspace {
Ok(())
}
/// Where the container that a new window gets goes, if the strip has a say: after the last
/// tile of the column that has focus.
///
/// A new window is a column of its own beside the focused one, and not a tile in the middle of
/// it, which is what the container after the focused one would be if the column has other
/// tiles below.
pub(crate) fn scrolling_insertion_idx(&self) -> Option<usize> {
if !self.is_scrolling() {
return None;
}
let space = self.scrolling.as_ref()?;
let focused = self.focused_container()?.id.clone();
let last = space.column_of(&focused)?.pop()?;
self.containers()
.iter()
.position(|container| container.id == last)
.map(|idx| idx + 1)
}
/// Where focus would go from the focused container in this direction, in the strip as it is
/// now, or `None` if it would not go anywhere.
///
/// Left and right are the neighbouring columns, and focus goes to the tile that had it last
/// in the one it arrives at. Up and down are the tiles of the focused column, and stop at
/// the ends.
pub(crate) fn scrolling_idx_for_direction(
&self,
direction: OperationDirection,
) -> Option<usize> {
// the strip may not have heard about everything that happened since the last layout, so
// this goes by a copy of it that has
let mut probe = self.scrolling.clone()?;
let ids: Vec<String> = self
.containers()
.iter()
.map(|container| container.id.clone())
.collect();
let focused = self
.focused_container()
.map(|container| container.id.clone());
probe.reconcile(&ids, focused.as_ref());
let moved = match direction {
OperationDirection::Left => probe.focus_left(),
OperationDirection::Right => probe.focus_right(),
OperationDirection::Up => probe.focus_up(),
OperationDirection::Down => probe.focus_down(),
};
if moved {
probe.active_tile_index()
} else {
None
}
}
/// Make the order of the containers the order of the tiles of the strip, and focus the tile
/// that the strip says has it.
///
/// Most of what the strip does leaves the order alone. What moves a tile past another does
/// not, and the list of containers is what is true, so it is made to match.
fn apply_scrolling_order(&mut self) {
let Some(space) = self.scrolling.as_ref() else {
return;
};
let order = space.ids();
let focused = space.active_tile_index();
let containers = self.containers_mut();
let mut containers_in_order: Vec<_> = containers.drain(..).collect();
containers_in_order.sort_by_key(|container| {
order
.iter()
.position(|id| *id == container.id)
.unwrap_or(usize::MAX)
});
containers.extend(containers_in_order);
if let Some(idx) = focused {
self.focus_container(idx);
}
}
/// Move the focused column one place to the left or right, or the focused tile one place up
/// or down in its column, and tell whether anything moved.
///
/// A column moves with all of its tiles.
pub(crate) fn move_scrolling(&mut self, direction: OperationDirection) -> bool {
let Some(id) = self.focused_scrolling_column() else {
return false;
};
let Some(space) = self.scrolling.as_mut() else {
return false;
};
let moved = match direction {
OperationDirection::Up => space.move_tile_up(),
OperationDirection::Down => space.move_tile_down(),
OperationDirection::Left | OperationDirection::Right => match space.position(&id) {
Some(at) => {
let to = match direction {
OperationDirection::Left => at.checked_sub(1),
_ => Some(at + 1).filter(|to| *to < space.len()),
};
match to {
Some(to) => {
space.move_column(&id, to);
true
}
None => false,
}
}
None => false,
},
};
if moved {
self.apply_scrolling_order();
}
moved
}
/// Take the neighbouring tile on one side into the focused column: the first tile of the
/// column on the right to the bottom of it, or the last tile of the column on the left to the
/// top of it. Up and down mean nothing here.
pub(crate) fn consume_scrolling(&mut self, direction: OperationDirection) {
if self.focused_scrolling_column().is_none() {
return;
}
let Some(space) = self.scrolling.as_mut() else {
return;
};
let changed = match direction {
OperationDirection::Left => space.consume_left(),
OperationDirection::Right => space.consume_right(),
OperationDirection::Up | OperationDirection::Down => false,
};
if changed {
self.apply_scrolling_order();
}
}
/// Take the focused tile out of its column and put it in a column of its own on the right.
pub(crate) fn expel_scrolling(&mut self) {
if self.focused_scrolling_column().is_none() {
return;
}
let Some(space) = self.scrolling.as_mut() else {
return;
};
if space.expel() {
self.apply_scrolling_order();
}
}
/// Put every column back to the width that the `columns` option gives, which forgets every
/// width that was set by resizing, by a preset, or by taking the full width.
///
@@ -948,6 +1114,219 @@ mod tests {
.unwrap()
}
/// The id of the window in every container, in the order of the containers.
fn window_ids(workspace: &Workspace) -> Vec<u32> {
workspace
.containers()
.iter()
.filter_map(|container| container.focused_window())
.map(|window| window.id)
.collect()
}
/// A workspace of four windows, 0 and 1 of which are in one column, with 0 in focus.
fn workspace_with_a_column(first: u32) -> Workspace {
let mut workspace = workspace_of_windows_from(3, first, 4);
workspace.focus_container(0);
workspace.layout_scrolling(&AREA, 0);
workspace.consume_scrolling(OperationDirection::Right);
workspace.layout_scrolling(&AREA, 0);
workspace
}
#[test]
fn consuming_puts_two_windows_in_one_column_and_leaves_the_order_of_the_containers() {
let mut workspace = workspace_with_a_column(0);
assert_eq!(window_ids(&workspace), [0, 1, 2, 3]);
let placements = workspace.layout_scrolling(&AREA, 0);
assert_eq!(placements[0].rect.left, placements[1].rect.left);
assert_eq!(placements[0].rect.right, placements[1].rect.right);
assert_eq!(
placements[0].rect.bottom + placements[1].rect.bottom,
AREA.bottom
);
assert_eq!(
placements[1].rect.top,
placements[0].rect.top + placements[0].rect.bottom
);
// the column that was next to the one that gave up its window moved up to it
assert_eq!(placements[2].rect.left, placements[0].rect.left + 400);
assert_eq!(focused_window(&workspace), 0);
}
#[test]
fn expelling_puts_the_focused_window_in_a_column_of_its_own() {
let mut workspace = workspace_with_a_column(0);
workspace.focus_container(1);
workspace.expel_scrolling();
let placements = workspace.layout_scrolling(&AREA, 0);
assert_eq!(widths(&placements), [400; 4]);
assert!(
placements
.iter()
.all(|placement| placement.rect.bottom == AREA.bottom)
);
assert_eq!(focused_window(&workspace), 1);
}
#[test]
fn expelling_a_window_that_has_others_below_it_moves_its_container_in_the_list() {
let mut workspace = workspace_of_windows_from(3, 10, 3);
workspace.focus_container(0);
workspace.layout_scrolling(&AREA, 0);
workspace.consume_scrolling(OperationDirection::Right);
workspace.layout_scrolling(&AREA, 0);
workspace.consume_scrolling(OperationDirection::Right);
assert_eq!(window_ids(&workspace), [10, 11, 12]);
workspace.expel_scrolling();
// 10 left the column, so it is after the windows that were below it
assert_eq!(window_ids(&workspace), [11, 12, 10]);
assert_eq!(focused_window(&workspace), 10);
assert_eq!(workspace.focused_container_idx(), 2);
}
#[test]
fn up_and_down_are_the_windows_of_a_column_and_left_and_right_are_the_columns() {
let mut workspace = workspace_with_a_column(0);
workspace.focus_container(1);
assert_eq!(
workspace.scrolling_idx_for_direction(OperationDirection::Up),
Some(0)
);
assert_eq!(
workspace.scrolling_idx_for_direction(OperationDirection::Down),
None
);
assert_eq!(
workspace.scrolling_idx_for_direction(OperationDirection::Right),
Some(2)
);
assert_eq!(
workspace.scrolling_idx_for_direction(OperationDirection::Left),
None
);
// the strip hears about focus at the next layout, which is made after every change of it
workspace.layout_scrolling(&AREA, 0);
workspace.focus_container(2);
// and left goes to the window that had focus in the column that it arrives at
assert_eq!(
workspace.scrolling_idx_for_direction(OperationDirection::Left),
Some(1)
);
}
#[test]
fn asking_where_focus_would_go_changes_nothing() {
let mut workspace = workspace_with_a_column(0);
workspace.focus_container(1);
let before = workspace.layout_scrolling(&AREA, 0);
let strip = workspace.scrolling.clone();
workspace.scrolling_idx_for_direction(OperationDirection::Right);
workspace.scrolling_idx_for_direction(OperationDirection::Up);
assert_eq!(workspace.scrolling, strip);
assert_eq!(workspace.layout_scrolling(&AREA, 0), before);
}
#[test]
fn moving_down_swaps_the_windows_of_a_column_and_focus_stays_with_the_window() {
let mut workspace = workspace_with_a_column(20);
assert_eq!(window_ids(&workspace), [20, 21, 22, 23]);
assert!(workspace.move_scrolling(OperationDirection::Down));
assert_eq!(window_ids(&workspace), [21, 20, 22, 23]);
assert_eq!(focused_window(&workspace), 20);
assert_eq!(workspace.focused_container_idx(), 1);
assert!(
!workspace.move_scrolling(OperationDirection::Down),
"it is the last"
);
}
#[test]
fn moving_right_moves_the_whole_column() {
let mut workspace = workspace_with_a_column(30);
assert!(workspace.move_scrolling(OperationDirection::Right));
assert_eq!(window_ids(&workspace), [32, 30, 31, 33]);
assert_eq!(focused_window(&workspace), 30);
assert!(workspace.move_scrolling(OperationDirection::Right));
assert_eq!(window_ids(&workspace), [32, 33, 30, 31]);
assert!(
!workspace.move_scrolling(OperationDirection::Right),
"it is the last column"
);
assert!(workspace.move_scrolling(OperationDirection::Left));
assert_eq!(window_ids(&workspace), [32, 30, 31, 33]);
}
#[test]
fn a_new_window_goes_after_the_whole_column_that_has_focus() {
let mut workspace = workspace_with_a_column(40);
// the top window of the column has focus, and there is another below it
workspace
.new_container_for_window(&Window::from(99))
.unwrap();
assert_eq!(window_ids(&workspace), [40, 41, 99, 42, 43]);
// and it is a column of its own
let placements = workspace.layout_scrolling(&AREA, 0);
assert_eq!(placements[2].rect.bottom, AREA.bottom);
assert_eq!(placements[2].rect.left, placements[0].rect.left + 400);
}
#[test]
fn consuming_to_the_left_is_the_other_way_round() {
let mut workspace = workspace_of_windows_from(3, 50, 3);
workspace.focus_container(1);
workspace.layout_scrolling(&AREA, 0);
workspace.consume_scrolling(OperationDirection::Left);
let placements = workspace.layout_scrolling(&AREA, 0);
assert_eq!(placements[0].rect.left, placements[1].rect.left);
assert_eq!(window_ids(&workspace), [50, 51, 52]);
assert_eq!(
focused_window(&workspace),
51,
"focus stays with the window"
);
// up and down mean nothing to it
workspace.consume_scrolling(OperationDirection::Up);
assert_eq!(workspace.layout_scrolling(&AREA, 0), placements);
}
#[test]
fn nothing_here_does_anything_before_there_is_a_strip() {
let mut workspace = workspace_of_windows_from(3, 60, 3);
workspace.consume_scrolling(OperationDirection::Right);
workspace.expel_scrolling();
assert!(!workspace.move_scrolling(OperationDirection::Down));
assert_eq!(window_ids(&workspace), [60, 61, 62]);
assert!(workspace.scrolling.is_none());
}
#[test]
fn closing_a_window_that_was_just_opened_goes_back_to_the_one_before_it() {
let mut workspace = workspace_of_windows(3, 8);
+7 -2
View File
@@ -907,8 +907,13 @@ impl WindowManager {
}
Some(new_idx) => {
let workspace = self.focused_workspace_mut()?;
workspace.swap_containers(origin_container_idx, new_idx);
workspace.focus_container(new_idx);
// a column of the Scrolling layout moves whole, and its tiles move within it,
// which is not a swap of two containers
if !(workspace.is_scrolling() && workspace.move_scrolling(direction)) {
workspace.swap_containers(origin_container_idx, new_idx);
workspace.focus_container(new_idx);
}
}
}
+8 -5
View File
@@ -377,6 +377,12 @@ impl Workspace {
}
pub fn new_idx_for_direction(&self, direction: OperationDirection) -> Option<usize> {
// in a strip, left and right are the neighbouring columns and up and down are the tiles of
// the column, which the strip is the one to say
if self.is_scrolling() && self.scrolling.is_some() {
return self.scrolling_idx_for_direction(direction);
}
let len = NonZeroUsize::new(self.containers().len())?;
direction.destination(
@@ -453,6 +459,8 @@ impl Workspace {
next
} else if self.containers().is_empty() {
0
} else if let Some(idx) = self.scrolling_insertion_idx() {
idx
} else {
self.focused_container_idx() + 1
};
@@ -1350,11 +1358,6 @@ impl Workspace {
}
pub fn update(&mut self) -> eyre::Result<()> {
// a strip of columns is only kept for as long as the workspace is laid out as one
if !self.is_scrolling() {
self.scrolling = None;
}
// make sure we are never holding on to empty containers
self.prune_duplicate_windows()?;
let focused_container_idx = self.focused_container_idx();
+20
View File
@@ -111,6 +111,7 @@ gen_enum_subcommand_args! {
FlipLayout: Axis,
ChangeLayout: DefaultLayout,
CycleLayout: CycleDirection,
Consume: OperationDirection,
// WatchConfiguration: BooleanState,
MouseFollowsFocus: BooleanState,
Query: StateQuery,
@@ -996,6 +997,19 @@ enum SubCommand {
/// Make the focused column of the Scrolling layout fill the room that the columns in view
/// leave on the screen, which does nothing in any other layout
Expand,
/// Take the window on one side into the focused column
///
/// Left takes the last window of the column on the left to the top of the focused column, and
/// right takes the first window of the column on the right to the bottom of it. Up and down do
/// nothing. Only the Scrolling layout has columns of several windows, so this does nothing in
/// the other layouts.
#[clap(arg_required_else_help = true)]
Consume(Consume),
/// Take the focused window out of its column and into a column of its own
///
/// Only the Scrolling layout has columns of several windows, so this does nothing in the other
/// layouts.
Expel,
/// Set the layout column and row ratios for the focused workspace
LayoutRatios(LayoutRatios),
// /// Load a custom layout from file for the focused workspace
@@ -2386,6 +2400,12 @@ exit 1
SubCommand::Expand => {
send_message(&SocketMessage::Expand)?;
}
SubCommand::Consume(args) => {
send_message(&SocketMessage::Consume(args.operation_direction))?;
}
SubCommand::Expel => {
send_message(&SocketMessage::Expel)?;
}
SubCommand::LayoutRatios(args) => {
if args.columns.is_none() && args.rows.is_none() {
println!(
+2
View File
@@ -97,6 +97,8 @@ nav:
- cli/eager-focus.md
- cli/stack.md
- cli/unstack.md
- cli/consume.md
- cli/expel.md
- cli/cycle-stack.md
- cli/cycle-stack-index.md
- cli/focus-stack-window.md