fix(wm): make drag-to-resize follow the dragged edge

Dragging a tile's edge was unreliable: long drags were dropped, the
divider next to a different window drifted by a few points, and in
recordings made with komorebi-recorder a drag to the left shrank the tile
instead of growing it. This fixes the causes that were found there.

Resize bounds: bump komorebi-layouts and komorebi-themes to
LGUG2Z/komorebi@f08aa55, where DefaultLayout::resize only accumulates and
no longer refuses any adjustment larger than half of the container's own
size. resize_window now grants the largest amount that keeps every tile
at least a tenth of the work area (or as large as it already is), found
by bisection, instead of all or nothing. Keyboard resizing goes through
the same path. RUSTSEC-2024-0449 is ignored in deny.toml, as upstream
does in the same bump.

The dragged container: ResizeStart records the rect of the dragged window
once, since AXWindowResized fires again all through a drag, and ResizeEnd
hands it to the new WindowManager::resize_by_drag along with the rect the
window ended in. That resizes the container of the dragged window instead
of the focused one, for each edge that moved, instead of guessing the
edges from the difference to latest_layout (which made apps that snap to
a grid of cells resize edges that nobody touched).

Where the drag began: AXWindowResized is first reported after the edge
has moved, and handlers run one at a time, so the rect recorded as the
start can already be 22 points into the drag, or be the rect the drag
ended in. An edge that ended up more than 32 points from its tile is
measured from its tile edge; every other edge from the recorded start.

The reaper: it re-tiled the focused workspace on every mouse-up and
key-up to find windows that had gone away. That ran as soon as the button
went up, ahead of the ResizeEnd queued behind slower handlers, so the
window was back on its tile when ResizeEnd read where it had been dropped
and the drag was measured backwards. It now only looks for windows that
no longer exist and reaps them, without moving any window.

The tests reproduce each of these, including the numbers from the
recordings: a first step of 22 points, a drag already over when it was
first seen, and a mouse-up that must leave the layout alone.
This commit is contained in:
LGUG2Z committed 2026-10-27 12:27:40 -07:00
1 parent bdf10452f1
commit db1c18b5b6
6 files changed
+672 -136

No files matched your search

Generated
+4 -4
View File
@@ -3158,8 +3158,8 @@ dependencies = [
[[package]]
name = "komorebi-layouts"
version = "0.1.41"
source = "git+https://github.com/LGUG2Z/komorebi?rev=24c0ce0b1df1b5d7d62c682a7e28b32980293883#24c0ce0b1df1b5d7d62c682a7e28b32980293883"
version = "0.1.42"
source = "git+https://github.com/LGUG2Z/komorebi?rev=f08aa55511d77ca56ab0e789efabeb0a237a463e#f08aa55511d77ca56ab0e789efabeb0a237a463e"
dependencies = [
"clap",
"color-eyre",
@@ -3174,8 +3174,8 @@ dependencies = [
[[package]]
name = "komorebi-themes"
version = "0.1.41"
source = "git+https://github.com/LGUG2Z/komorebi?rev=24c0ce0b1df1b5d7d62c682a7e28b32980293883#24c0ce0b1df1b5d7d62c682a7e28b32980293883"
version = "0.1.42"
source = "git+https://github.com/LGUG2Z/komorebi?rev=f08aa55511d77ca56ab0e789efabeb0a237a463e#f08aa55511d77ca56ab0e789efabeb0a237a463e"
dependencies = [
"base16-egui-themes",
"catppuccin-egui",
+2 -2
View File
@@ -13,8 +13,8 @@ members = [
version = "0.1.0"
[workspace.dependencies]
komorebi-themes = { git = "https://github.com/LGUG2Z/komorebi", rev = "24c0ce0b1df1b5d7d62c682a7e28b32980293883" }
komorebi-layouts = { git = "https://github.com/LGUG2Z/komorebi", rev = "24c0ce0b1df1b5d7d62c682a7e28b32980293883", features = [
komorebi-themes = { git = "https://github.com/LGUG2Z/komorebi", rev = "f08aa55511d77ca56ab0e789efabeb0a237a463e" }
komorebi-layouts = { git = "https://github.com/LGUG2Z/komorebi", rev = "f08aa55511d77ca56ab0e789efabeb0a237a463e", features = [
"darwin",
"schemars",
] }
+1
View File
@@ -11,6 +11,7 @@ ignore = [
{ id = "RUSTSEC-2024-0436", reason = "paste is fine" },
{ id = "RUSTSEC-2024-0320", reason = "not using any yaml features from this library" },
{ id = "RUSTSEC-2025-0056", reason = "only used for colour palette generation" },
{ id = "RUSTSEC-2024-0449", reason = "unsafe-libyaml is only pulled in via serde_yaml, and there is no safe upgrade available" },
]
[licenses]
+24 -67
View File
@@ -13,9 +13,7 @@ use crate::accessibility::notification_constants::AccessibilityNotification;
use crate::border_manager;
use crate::core::DefaultLayout;
use crate::core::Layout;
use crate::core::OperationDirection;
use crate::core::Rect;
use crate::core::Sizing;
use crate::core::WindowContainerBehaviour;
use crate::core::WindowHidingPosition;
use crate::core::config_generation::MatchingRule;
@@ -977,15 +975,23 @@ impl WindowManager {
}
}
WindowManagerEvent::ResizeStart(_, _, window_id) => {
let workspace = self.focused_workspace_mut()?;
if let Some(container) = workspace.focused_container()
&& let Some(window) = container.focused_window()
{
let window = window.clone();
let new_position = Rect::from(MacosApi::window_rect(&window.element)?);
// AXWindowResized fires again and again through a drag; only the first frame is
// the one the drag started from
let already_recorded = matches!(
*self.pending_resize_op,
Some((wid, Some(_))) if wid == window_id
);
let pending_resize_op = Arc::make_mut(&mut self.pending_resize_op);
*pending_resize_op = Option::from((window_id, Some(new_position)));
if !already_recorded {
let workspace = self.focused_workspace()?;
if let Some(container) = workspace.container_for_window(window_id)
&& let Some(window) = container.windows().iter().find(|w| w.id == window_id)
{
let started_from = Rect::from(MacosApi::window_rect(&window.element)?);
let pending_resize_op = Arc::make_mut(&mut self.pending_resize_op);
*pending_resize_op = Option::from((window_id, Some(started_from)));
}
}
}
WindowManagerEvent::ResizeEnd(_, _, window_id) => {
@@ -994,7 +1000,7 @@ impl WindowManager {
let pending_resize_op = Arc::make_mut(&mut self.pending_resize_op);
*pending_resize_op = None;
if let Some((wid, Some(new_position))) = pending {
if let Some((wid, Some(started_from))) = pending {
// If the window handles don't match then something went wrong and the pending resize
// is not related to this current resize, if so abort this operation.
if wid != window_id {
@@ -1005,64 +1011,15 @@ impl WindowManager {
);
}
let workspace = self.focused_workspace_mut()?;
let focused_container_idx = workspace.focused_container_idx();
if let Some(container) = workspace.focused_container()
&& let Some(window) = container.focused_window()
let workspace = self.focused_workspace()?;
if workspace.tile
&& let Some(container) = workspace.container_for_window(window_id)
&& let Some(window) = container.windows().iter().find(|w| w.id == window_id)
{
let window = window.clone();
let old_position = *workspace
.latest_layout
.get(focused_container_idx)
.unwrap_or(&Rect::default());
let workspace = self.focused_workspace_mut()?;
if workspace.tile && workspace.contains_managed_window(window.id) {
let resize = Rect {
left: new_position.left - old_position.left,
top: new_position.top - old_position.top,
right: new_position.right - old_position.right,
bottom: new_position.bottom - old_position.bottom,
};
tracing::info!("resizing with mouse");
let mut ops = vec![];
macro_rules! resize_op {
($coordinate:expr, $comparator:tt, $direction:expr) => {{
let adjusted = $coordinate * 2;
let sizing = if adjusted $comparator 0 {
Sizing::Decrease
} else {
Sizing::Increase
};
($direction, sizing, adjusted.abs())
}};
}
if resize.left != 0 {
ops.push(resize_op!(resize.left, >, OperationDirection::Left));
}
if resize.top != 0 {
ops.push(resize_op!(resize.top, >, OperationDirection::Up));
}
if resize.right != 0 && (resize.left == 0) {
ops.push(resize_op!(resize.right, <, OperationDirection::Right));
}
if resize.bottom != 0 && (resize.top == 0) {
ops.push(resize_op!(resize.bottom, <, OperationDirection::Down));
}
for (edge, sizing, delta) in ops {
self.resize_window(edge, sizing, delta, true)?;
}
let ended_at = Rect::from(MacosApi::window_rect(&window.element)?);
tracing::info!("resizing with mouse");
if self.resize_by_drag(window_id, started_from, ended_at)? {
self.update_focused_workspace(false, false)?;
}
}
+88 -54
View File
@@ -64,62 +64,25 @@ fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()>
continue 'notification;
}
match notification {
ReaperNotification::InvalidWindow(window_id) => {
let mut should_update = false;
for monitor in wm.monitors_mut() {
for workspace in monitor.workspaces_mut() {
for container in workspace.containers_mut() {
container.windows_mut().retain(|w| {
if w.id == window_id {
should_update = true;
tracing::info!("reaping window: {window_id}");
}
handle_notification(&mut wm, notification, Window::is_valid)?;
}
w.id != window_id
});
}
Ok(())
}
if let Some(container) = &mut workspace.monocle_container {
container.windows_mut().retain(|w| {
if w.id == window_id {
should_update = true;
tracing::info!("reaping window: {window_id}");
}
w.id != window_id
});
if container.windows().is_empty() {
workspace.monocle_container = None;
workspace.monocle_container_restore_idx = None;
}
}
workspace.floating_windows_mut().retain(|w| {
if w.id == window_id {
should_update = true;
tracing::info!("reaping window: {window_id}");
}
w.id != window_id
});
}
}
// If an invalid window was cleaned up, we update the workspace
if should_update {
// If an invalid window was cleaned up, we update the workspace
wm.update_focused_workspace(false, false)?;
border_manager::send_notification(None, Some(window_id), true);
}
}
ReaperNotification::MouseUpKeyUp => {
// this first one will do a "nothing" update to check if any windows failed
// to have their positions set - the failures will trigger an InvalidWindow
// notification
// TODO: maybe replace this with something a bit more lightweight
wm.update_focused_workspace(false, false)?;
pub(crate) fn handle_notification(
wm: &mut WindowManager,
notification: ReaperNotification,
is_valid: impl Fn(&Window) -> bool,
) -> color_eyre::Result<()> {
match notification {
ReaperNotification::InvalidWindow(window_id) => reap_window(wm, window_id)?,
ReaperNotification::MouseUpKeyUp => {
// This must not move any window: it is handled as soon as the button goes up, ahead
// of the events queued for the end of a drag, and a window put back on its tile
// would be measured against where it was dragged from, which is backwards
for window_id in invalid_window_ids(wm, is_valid)? {
reap_window(wm, window_id)?;
}
}
}
@@ -127,6 +90,77 @@ fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()>
Ok(())
}
/// The windows of the focused workspace that no longer exist
fn invalid_window_ids(
wm: &WindowManager,
is_valid: impl Fn(&Window) -> bool,
) -> color_eyre::Result<Vec<u32>> {
let workspace = wm.focused_workspace()?;
let windows = workspace
.containers()
.iter()
.chain(workspace.monocle_container.iter())
.flat_map(|container| container.windows().iter())
.chain(workspace.floating_windows().iter());
Ok(windows
.filter(|window| !is_valid(window))
.map(|window| window.id)
.collect())
}
fn reap_window(wm: &mut WindowManager, window_id: u32) -> color_eyre::Result<()> {
let mut should_update = false;
for monitor in wm.monitors_mut() {
for workspace in monitor.workspaces_mut() {
for container in workspace.containers_mut() {
container.windows_mut().retain(|w| {
if w.id == window_id {
should_update = true;
tracing::info!("reaping window: {window_id}");
}
w.id != window_id
});
}
if let Some(container) = &mut workspace.monocle_container {
container.windows_mut().retain(|w| {
if w.id == window_id {
should_update = true;
tracing::info!("reaping window: {window_id}");
}
w.id != window_id
});
if container.windows().is_empty() {
workspace.monocle_container = None;
workspace.monocle_container_restore_idx = None;
}
}
workspace.floating_windows_mut().retain(|w| {
if w.id == window_id {
should_update = true;
tracing::info!("reaping window: {window_id}");
}
w.id != window_id
});
}
}
// If an invalid window was cleaned up, we update the workspace
if should_update {
wm.update_focused_workspace(false, false)?;
border_manager::send_notification(None, Some(window_id), true);
}
Ok(())
}
pub fn notify_on_error(
window: &Window,
result: Result<(), AccessibilityError>,
+553 -9
View File
@@ -1616,15 +1616,67 @@ impl WindowManager {
}
}
let resize = layout.resize(
unaltered
.get(focused_idx)
.ok_or_eyre("there is no last layout")?,
focused_idx_resize,
direction,
sizing,
delta,
);
let min_width = focused_monitor_work_area.right / 10;
let min_height = focused_monitor_work_area.bottom / 10;
let unaltered_rect = *unaltered
.get(focused_idx)
.ok_or_eyre("there is no last layout")?;
let candidate = |amount: i32| {
layout.resize(
&unaltered_rect,
focused_idx_resize,
direction,
sizing,
amount,
)
};
let calculate = |dimensions: &[Option<Rect>]| {
layout.calculate(
&focused_monitor_work_area,
len,
workspace.container_padding,
workspace.layout_flip,
dimensions,
workspace.focused_container_idx(),
workspace.layout_options,
&workspace.latest_layout,
)
};
// No tile may end up smaller than a tenth of the work area, or
// smaller than it already is
let now = calculate(&workspace.resize_dimensions);
let fits = |amount: i32| {
let mut dimensions = workspace.resize_dimensions.clone();
dimensions[focused_idx] = candidate(amount);
calculate(&dimensions).iter().zip(now.iter()).all(
|(tile, before)| {
tile.right >= min_width.min(before.right)
&& tile.bottom >= min_height.min(before.bottom)
},
)
};
// Grant as much of the request as fits; tiles only get smaller as
// the amount grows, so bisect
let granted = if fits(delta) {
delta
} else {
let (mut fits_at, mut fails_at) = (0, delta);
while fails_at - fits_at > 1 {
let middle = fits_at + (fails_at - fits_at) / 2;
if fits(middle) {
fits_at = middle;
} else {
fails_at = middle;
}
}
fits_at
};
let resize = candidate(granted);
workspace.resize_dimensions[focused_idx] = resize;
@@ -1644,6 +1696,82 @@ impl WindowManager {
Ok(())
}
/// How far an edge can be from its tile without having been dragged there: an app that snaps
/// its size to a grid of cells, or keeps to a minimum size, is never quite on its tile
const DRAG_SNAP_TOLERANCE: i32 = 32;
/// Applies a mouse drag of the edge(s) of `window_id`'s tile, given the frame the window was
/// first seen in once the drag was going on and the frame it ended in. Returns whether the
/// workspace needs to be re-tiled, which also puts back a window dragged by an edge with no
/// neighbour.
#[tracing::instrument(skip(self))]
pub fn resize_by_drag(
&mut self,
window_id: u32,
started_from: Rect,
ended_at: Rect,
) -> eyre::Result<bool> {
let workspace = self.focused_workspace()?;
let Some(idx) = workspace.container_idx_for_window(window_id) else {
tracing::warn!("the dragged window is not in a container on the focused workspace");
return Ok(false);
};
// A Rect is (left, top, width, height); work in edges instead
let edges = |r: &Rect| [r.left, r.top, r.left + r.right, r.top + r.bottom];
let started = edges(&started_from);
let ended = edges(&ended_at);
let tile = workspace.latest_layout.get(idx).map(edges);
// The first AXWindowResized is reported after the edge has already moved, and handlers
// run one at a time, so the frame a drag is first seen in is not the one it began from,
// and can even be the one it ended in. An edge that ended up further from its tile than
// an app strays from its tile on its own was dragged, and began on its tile. Any other
// edge was not moved, and the offset of the app from its tile is not part of the drag.
let moved: Vec<(OperationDirection, i32)> = [
OperationDirection::Left,
OperationDirection::Up,
OperationDirection::Right,
OperationDirection::Down,
]
.into_iter()
.enumerate()
.filter_map(|(i, edge)| {
let from = match tile {
Some(tile) if (ended[i] - tile[i]).abs() > Self::DRAG_SNAP_TOLERANCE => tile[i],
_ => started[i],
};
(ended[i] != from).then_some((edge, ended[i] - from))
})
.collect();
if moved.is_empty() {
return Ok(false);
}
// Resize the container of the dragged window, which is not necessarily the focused one
self.focused_workspace_mut()?.focus_container(idx);
for (edge, by) in moved {
let outward = match edge {
OperationDirection::Left | OperationDirection::Up => by < 0,
OperationDirection::Right | OperationDirection::Down => by > 0,
};
let sizing = if outward {
Sizing::Increase
} else {
Sizing::Decrease
};
// A shared edge is moved by half of what the layout is given
self.resize_window(edge, sizing, by.abs() * 2, false)?;
}
Ok(true)
}
#[tracing::instrument(skip(self))]
pub fn retile_all(&mut self, preserve_resize_dimensions: bool) -> eyre::Result<()> {
let offset = self.work_area_offset;
@@ -3384,6 +3512,8 @@ impl WindowManager {
mod tests {
use super::*;
use crate::monitor;
use crate::reaper;
use crate::reaper::ReaperNotification;
use crossbeam_channel::Sender;
use crossbeam_channel::bounded;
use std::path::PathBuf;
@@ -5335,4 +5465,418 @@ mod tests {
assert_eq!(op.target_workspace_idx, target_workspace_idx); // 3
assert_eq!(op.floating, floating); // false
}
// Resizing a tile by dragging an edge. A Rect is `left, top, width, height` (`right` and
// `bottom` are the size), and the work area of the monitor is 1920x1050, which makes the
// right-hand stack of an UltrawideVerticalStack layout narrow enough to expose the old guard.
const WORK_AREA: Rect = Rect {
left: 0,
top: 0,
right: 1920,
bottom: 1050,
};
/// A monitor with one workspace in `layout`, with a container per window id, the last of
/// them focused, and the tiles komorebi would have given them recorded as the latest layout
fn tiled(layout: DefaultLayout, ids: &[u32]) -> (WindowManager, TestContext) {
let (mut wm, context) = setup_window_manager();
let m = monitor::new(
0,
WORK_AREA,
WORK_AREA,
"TestMonitor".to_string(),
"TestDeviceID".to_string(),
);
wm.monitors_mut().push_back(m);
let workspace = wm.focused_workspace_mut().unwrap();
workspace.layout = Layout::Default(layout);
for id in ids {
workspace
.new_container_for_window(&Window::from(*id))
.unwrap();
}
let latest_layout = tiles(&wm);
wm.focused_workspace_mut().unwrap().latest_layout = latest_layout;
(wm, context)
}
/// The tile of each container, as the layout calculates them with the current resizes
fn tiles(wm: &WindowManager) -> Vec<Rect> {
let workspace = wm.focused_workspace().unwrap();
let Layout::Default(layout) = workspace.layout;
layout.calculate(
&WORK_AREA,
NonZeroUsize::new(workspace.containers().len()).unwrap(),
workspace.container_padding,
workspace.layout_flip,
&workspace.resize_dimensions,
workspace.focused_container_idx(),
workspace.layout_options,
&workspace.latest_layout,
)
}
fn grown_left(r: Rect, by: i32) -> Rect {
Rect {
left: r.left - by,
right: r.right + by,
..r
}
}
fn overlap(a: &Rect, b: &Rect) -> bool {
a.left < b.left + b.right
&& b.left < a.left + a.right
&& a.top < b.top + b.bottom
&& b.top < a.top + a.bottom
}
fn assert_tiling(tiles: &[Rect]) {
for (i, a) in tiles.iter().enumerate() {
assert!(
a.left >= 0
&& a.top >= 0
&& a.left + a.right <= WORK_AREA.right
&& a.top + a.bottom <= WORK_AREA.bottom,
"{a:?} is outside the work area"
);
for b in &tiles[i + 1..] {
assert!(!overlap(a, b), "{a:?} and {b:?} overlap");
}
}
}
fn no_resizes(wm: &WindowManager) -> bool {
wm.focused_workspace()
.unwrap()
.resize_dimensions
.iter()
.all(|r| r.is_none())
}
#[test]
fn test_a_long_drag_of_a_narrow_tile_is_not_dropped() {
// the right-hand stack of an ultrawide layout is the narrowest thing there is, and the
// layout used to refuse any drag of more than half of a tile's own width, without a word
let (mut wm, _context) = tiled(DefaultLayout::UltrawideVerticalStack, &[1, 2, 3, 4, 5]);
// 1 is the centre, 2 the left column, 3..5 the stack on the right
let before = tiles(&wm);
assert!(before[2].left > WORK_AREA.right / 2, "{:?}", before[2]);
// 5 has focus, not the window being dragged
let redraw = wm
.resize_by_drag(3, before[2], grown_left(before[2], 300))
.unwrap();
assert!(redraw);
let after = tiles(&wm);
assert!(
after[2].right >= before[2].right + 290,
"dragged by 300 and got {:?} -> {:?}",
before[2],
after[2]
);
assert!(after[0].right > 0 && after[0].left + after[0].right <= after[2].left);
assert_tiling(&after);
// and the whole stack moved with it: they share the edge
for idx in [3, 4] {
assert_eq!(after[idx].left, after[2].left, "tile {idx}");
}
}
#[test]
fn test_a_drag_further_than_the_neighbour_can_give_goes_as_far_as_it_can() {
let (mut wm, _context) = tiled(DefaultLayout::UltrawideVerticalStack, &[1, 2, 3, 4, 5]);
let before = tiles(&wm);
// far past the centre tile's whole width
wm.resize_by_drag(3, before[2], grown_left(before[2], 1000))
.unwrap();
let after = tiles(&wm);
assert!(
after[2].right > before[2].right + 400,
"it grew: {:?} -> {:?}",
before[2],
after[2]
);
// no tile is smaller than a tenth of the work area, or than it was
let tenth = WORK_AREA.right / 10;
for (idx, (tile, was)) in after.iter().zip(before.iter()).enumerate() {
assert!(tile.right >= tenth.min(was.right), "tile {idx}: {tile:?}");
}
// and the centre tile was squeezed to the floor, not left where it was
assert!(
after[0].right < tenth + 10,
"the neighbour was not given all it could give: {:?}",
after[0]
);
assert_tiling(&after);
}
#[test]
fn test_shrinking_a_tile_by_more_than_it_can_is_granted_as_far_as_it_goes() {
let (mut wm, _context) = tiled(DefaultLayout::UltrawideVerticalStack, &[1, 2, 3, 4, 5]);
let before = tiles(&wm);
let tile = before[2];
// the user pulls the left edge inward by more than the tile is wide
wm.resize_by_drag(
3,
tile,
Rect {
left: tile.left + tile.right - 20,
right: 20,
..tile
},
)
.unwrap();
let after = tiles(&wm);
let tenth = WORK_AREA.right / 10;
assert!(
after[2].right < tile.right,
"it shrank: {tile:?} -> {:?}",
after[2]
);
assert!(after[2].right >= tenth, "but not too far: {:?}", after[2]);
assert!(
after[2].right < tenth + 10,
"as far as it goes: {:?}",
after[2]
);
assert_tiling(&after);
}
#[test]
fn test_a_drag_is_measured_from_where_the_window_was_not_from_its_tile() {
// a terminal snaps its size to its cells, so it never quite fills its tile; the horizontal
// split between the two windows on the right must stay where it is when the *left* edge
// is dragged
let (mut wm, _context) = tiled(DefaultLayout::BSP, &[1, 2, 3]);
let before = tiles(&wm);
let (top_right, split_before) = (before[1], before[2].top);
let snapped = Rect {
right: top_right.right - 1,
bottom: top_right.bottom - 8,
..top_right
};
wm.resize_by_drag(2, snapped, grown_left(snapped, 100))
.unwrap();
let after = tiles(&wm);
assert!(
after[1].left <= top_right.left - 90,
"{top_right:?} -> {:?}",
after[1]
);
assert_eq!(
after[2].top, split_before,
"the split between the two on the right moved, though only a left edge was dragged"
);
assert_eq!(after[1].bottom, top_right.bottom);
assert_tiling(&after);
}
#[test]
fn test_the_window_that_was_dragged_is_the_one_resized_not_the_focused_one() {
let (mut wm, _context) = tiled(DefaultLayout::BSP, &[1, 2, 3]);
// 3 (the bottom right tile) has focus; 2 (top right) is dragged by its bottom edge
assert_eq!(wm.focused_workspace().unwrap().focused_container_idx(), 2);
let before = tiles(&wm);
let (top_right, bottom_right) = (before[1], before[2]);
wm.resize_by_drag(
2,
top_right,
Rect {
bottom: top_right.bottom + 100,
..top_right
},
)
.unwrap();
let after = tiles(&wm);
assert!(
after[1].bottom >= top_right.bottom + 90,
"{top_right:?} -> {:?}",
after[1]
);
assert!(
after[2].bottom <= bottom_right.bottom - 90,
"{bottom_right:?} -> {:?}",
after[2]
);
assert_tiling(&after);
// the dragged one is the focused one now
assert_eq!(wm.focused_workspace().unwrap().focused_container_idx(), 1);
}
#[test]
fn test_dragging_an_edge_that_has_no_neighbour_changes_nothing_but_puts_the_window_back() {
let (mut wm, _context) = tiled(DefaultLayout::BSP, &[1, 2]);
let before = tiles(&wm);
// the outer left edge of the left tile has nothing to take room from
let redraw = wm
.resize_by_drag(1, before[0], grown_left(before[0], 80))
.unwrap();
assert!(
redraw,
"the window is not where its tile is, so it needs to be put back"
);
assert!(no_resizes(&wm));
assert_eq!(tiles(&wm), before);
}
#[test]
fn test_a_drag_that_changed_nothing_changes_nothing() {
let (mut wm, _context) = tiled(DefaultLayout::BSP, &[1, 2, 3]);
let before = tiles(&wm);
// a click on an edge: started, finished, nowhere
let redraw = wm.resize_by_drag(2, before[1], before[1]).unwrap();
assert!(!redraw);
assert!(no_resizes(&wm));
assert_eq!(tiles(&wm), before);
assert_eq!(wm.focused_workspace().unwrap().focused_container_idx(), 2);
}
#[test]
fn test_a_corner_resizes_both_of_its_edges() {
let (mut wm, _context) = tiled(DefaultLayout::BSP, &[1, 2, 3]);
// the bottom right tile, by its top left corner: up into the tile above, left into the
// one beside
let before = tiles(&wm);
let (beside, above, tile) = (before[0], before[1], before[2]);
wm.resize_by_drag(
3,
tile,
Rect {
left: tile.left - 100,
top: tile.top - 100,
right: tile.right + 100,
bottom: tile.bottom + 100,
},
)
.unwrap();
let after = tiles(&wm);
assert!(
after[2].left <= tile.left - 90 && after[2].top <= tile.top - 90,
"{tile:?} -> {:?}",
after[2]
);
assert!(after[1].bottom < above.bottom);
assert!(after[0].right < beside.right);
assert_tiling(&after);
}
#[test]
fn test_a_window_that_is_in_no_container_is_ignored() {
let (mut wm, _context) = tiled(DefaultLayout::BSP, &[1, 2, 3]);
let before = tiles(&wm);
let redraw = wm
.resize_by_drag(99, before[1], grown_left(before[1], 100))
.unwrap();
assert!(!redraw);
assert!(no_resizes(&wm));
assert_eq!(wm.focused_workspace().unwrap().focused_container_idx(), 2);
}
// The two recordings of a left-hand drag of the right-hand tile of an UltrawideVerticalStack
// that "doesn't resize properly" (docs/drag-resize.md). Both end with the tile narrower
// instead of wider, and in both the log shows the same thing: a workspace update on the
// reaper's thread, between the button going up and the handler for the end of the drag
// reading where the window is.
#[test]
fn test_a_mouse_up_does_not_re_tile_the_workspace() {
// The reaper looks for windows that went away on every mouse-up and key-up. It did that
// by re-tiling the workspace, which put the window being dragged back on its tile
// before ResizeEnd was handled, so the drag was measured from the dragged frame to the
// tile: backwards. A re-tile replaces the latest layout, so a marker in it shows one.
let (mut wm, _context) = tiled(DefaultLayout::UltrawideVerticalStack, &[1, 2, 3]);
let marker = vec![Rect::default(); 3];
wm.focused_workspace_mut().unwrap().latest_layout = marker.clone();
reaper::handle_notification(&mut wm, ReaperNotification::MouseUpKeyUp, |_| true).unwrap();
assert_eq!(
wm.focused_workspace().unwrap().latest_layout,
marker,
"the mouse-up re-tiled the workspace"
);
}
#[test]
fn test_a_mouse_up_still_reaps_the_windows_that_went_away() {
// what the re-tile on mouse-up was for: a window closed with a click or a key press
let (mut wm, _context) = tiled(DefaultLayout::UltrawideVerticalStack, &[1, 2, 3]);
reaper::handle_notification(&mut wm, ReaperNotification::MouseUpKeyUp, |w| w.id != 2)
.unwrap();
let ids: Vec<u32> = wm
.focused_workspace()
.unwrap()
.containers()
.iter()
.flat_map(|c| c.windows().iter().map(|w| w.id))
.collect();
assert_eq!(ids, vec![1, 3]);
}
#[test]
fn test_the_first_step_of_a_drag_is_part_of_the_drag() {
// AXWindowResized is reported after the edge has already moved, so the frame recorded as
// the start of the drag is not the one it started from: in the second recording the edge
// was 22 points out when first seen and 107 when the button went up, and the divider
// ended 22 points short of the pointer. The edge began on its tile.
let (mut wm, _context) = tiled(DefaultLayout::UltrawideVerticalStack, &[1, 2, 3]);
let tile = tiles(&wm)[2];
let redraw = wm
.resize_by_drag(3, grown_left(tile, 22), grown_left(tile, 107))
.unwrap();
assert!(redraw);
let after = tiles(&wm);
assert_eq!(after[2].left, tile.left - 107, "{tile:?} -> {:?}", after[2]);
assert_tiling(&after);
}
#[test]
fn test_a_drag_that_was_over_before_it_was_first_seen_is_still_applied() {
// Handlers run one at a time and can be slow (432 ms in the first recording, before the
// handler for the first AXWindowResized even logged its header), so the frame recorded as
// the start of the drag can already be the frame the drag ended in
let (mut wm, _context) = tiled(DefaultLayout::UltrawideVerticalStack, &[1, 2, 3]);
let tile = tiles(&wm)[2];
let dragged = grown_left(tile, 211);
let redraw = wm.resize_by_drag(3, dragged, dragged).unwrap();
assert!(redraw);
let after = tiles(&wm);
assert_eq!(after[2].left, tile.left - 211, "{tile:?} -> {:?}", after[2]);
assert_tiling(&after);
}
}