Merge branch 'docking' into dock-windows

This commit is contained in:
aiongg committed 2026-10-24 03:13:34 +00:00
commit 1c24845a17
10 files changed
+348 -113

No files matched your search

+10
View File
@@ -415,6 +415,16 @@ fn column_and_group_dividers_resize_and_minimized_groups_keep_their_height() {
assert_eq!(d.tab(4).top(), 600.0 - 26.0);
}
#[test]
fn a_group_divider_dragged_past_the_lower_groups_minimum_shrinks_the_next_group() {
let mut d = Driver::new(docked(Side::Start, &[&[&[2], &[3], &[4]]]));
let divider = d.rect("group-resize", 2).center();
d.drag(divider, divider + vec2(0.0, 500.0));
// Groups 3 and 4 are at their minimum: a tab strip and a 40 pt body.
let heights = column(&d.layout, 0).groups.iter().map(|g| g.height).collect::<Vec<_>>();
assert_eq!(heights[1..], [Some(66.0), Some(66.0)], "{heights:?}");
}
#[test]
fn double_click_on_a_docked_tab_minimizes_and_clicking_another_tab_expands() {
let mut d = Driver::new(docked(Side::Start, &[&[&[2, 3], &[4]]]));
+30 -17
View File
@@ -8,7 +8,7 @@ use std::{fmt::Debug, hash::Hash};
use egui::{Context, Key, Pos2, Rect, Sense, Stroke, StrokeKind, Ui, UiBuilder, pos2, vec2};
use super::{GroupKind, Renderer};
use super::{GroupKind, Renderer, RowItem, row_drag, row_range};
use crate::docking::{
Action, Column, DockEvent, DockStyle, Group, GroupDrag, GroupGesture, Node, Placement, Side, Target,
dock_model::Unit,
@@ -144,7 +144,15 @@ pub(in crate::docking) fn fit_widths(columns: &[(f32, Option<f32>)], room: f32)
impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
/// A horizontal split with a dock child: the dock takes its columns' width on its physical
/// edge, the sibling the rest. False when neither child is a dock.
pub(super) fn dock_split(&mut self, ui: &mut Ui, first: &Node<P>, second: &Node<P>, rect: Rect, path: &mut Vec<bool>) -> bool {
pub(super) fn dock_split(
&mut self,
ui: &mut Ui,
first: &Node<P>,
second: &Node<P>,
rect: Rect,
path: &mut Vec<bool>,
root: (&Node<P>, Rect),
) -> bool {
let (dock_first, side, columns, other) = match (first, second) {
(Node::Dock { side, columns }, other) => (true, *side, columns, other),
(other, Node::Dock { side, columns }) => (false, *side, columns, other),
@@ -153,7 +161,7 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
let (dock, rest, room) = dock_rects(side, columns, other, rect, self.style, &*self.content);
self.dock(ui, side, columns, dock, room);
path.push(dock_first);
self.node(ui, other, rest, path);
self.node(ui, other, rest, path, root);
path.pop();
true
}
@@ -360,16 +368,18 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
push(&mut self.dock_targets, DockTarget::GroupBand { anchor: last.clone(), below: true }, band, horizontal_line(top, xs));
}
// Height dividers between an open group and the next open one, after the groups so
// their hit areas win at the boundary. Both groups' heights are saved.
// their hit areas win at the boundary. The heights of the groups a drag changes are
// saved: the upper group, and the lower groups that give way in turn, or the reverse.
let open: Vec<usize> = (0..column.groups.len()).filter(|i| column.groups.get(*i).is_some_and(|g| !g.minimized)).collect();
for pair in open.windows(2) {
let &[i, j] = pair else { continue };
let (Some(upper), Some(lower), Some(rect)) = (column.groups.get(i), column.groups.get(j), rects.get(i)) else { continue };
let (Some(a), Some(b), Some(first), Some(second)) = (heights.get(i), heights.get(j), upper.panels.first(), lower.panels.first()) else {
continue;
};
let (lo, hi) = (self.group_min(upper), a + b - self.group_min(lower));
let hi = hi.max(lo);
let row: Vec<RowItem> = open
.iter()
.filter_map(|i| Some(RowItem { size: *heights.get(*i)?, min: self.group_min(column.groups.get(*i)?), max: f32::INFINITY }))
.collect();
for (index, pair) in open.windows(2).enumerate() {
let &[i, _] = pair else { continue };
let (Some(upper), Some(rect), Some(a)) = (column.groups.get(i), rects.get(i), heights.get(i)) else { continue };
let Some(first) = upper.panels.first() else { continue };
let (lo, hi) = row_range(&row, index);
let divider = Rect::from_x_y_ranges(rect.x_range(), (rect.bottom() - 1.0)..=(rect.bottom() + 1.0));
let response = ResizeHandle::new(
self.id.with(("group-resize", Some(first))),
@@ -378,13 +388,16 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
&self.style.resize_label,
self.handle_style(),
)
.value(*a, lo..=hi)
.value(*a, (a + lo)..=(a + hi))
.show(ui);
self.register_interaction(ui.ctx(), response.response.id);
let next = (a + response.delta).clamp(lo, hi);
if response.delta != 0.0 && next != *a {
self.output.actions.push(Action::ResizeGroup { panel: first.clone(), height: Some(next) });
self.output.actions.push(Action::ResizeGroup { panel: second.clone(), height: Some(a + b - next) });
if response.delta == 0.0 {
continue;
}
for ((group, item), next) in open.iter().filter_map(|g| column.groups.get(*g)).zip(&row).zip(row_drag(&row, index, response.delta)) {
if let Some(panel) = group.panels.first().filter(|_| next != item.size) {
self.output.actions.push(Action::ResizeGroup { panel: panel.clone(), height: Some(next) });
}
}
}
}
+1 -1
View File
@@ -116,7 +116,7 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
(_, true) => {}
(root, false) => {
let outer = self.tree.replace((key, frame));
self.node(ui, root, body, &mut Vec::new());
self.node(ui, root, body, &mut Vec::new(), (root, body));
self.tree = outer;
}
}
+49 -38
View File
@@ -37,7 +37,7 @@ mod group;
mod preview;
mod sizes;
pub(in crate::docking) use sizes::{DROP_MARGIN, Drawn, Sizer};
pub(in crate::docking) use sizes::{DROP_MARGIN, Drawn, RowItem, Sizer, row_drag, row_range};
pub(super) struct Renderer<'a, P> {
pub(super) id: Id,
@@ -79,8 +79,6 @@ pub(super) struct Renderer<'a, P> {
pub(super) struct DrawnDivider {
path: Vec<bool>,
axis: SplitAxis,
/// The whole split's rect.
rect: Rect,
divider: Rect,
}
@@ -123,23 +121,25 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
});
}
pub(in crate::docking) fn node(&mut self, ui: &mut Ui, node: &Node<P>, rect: Rect, path: &mut Vec<bool>) {
/// Draws `node` at view path `path` in `rect`, in the tree `root` (its root node and rect),
/// which a dragged divider resizes beyond `node`.
pub(in crate::docking) fn node(&mut self, ui: &mut Ui, node: &Node<P>, rect: Rect, path: &mut Vec<bool>, root: (&Node<P>, Rect)) {
if !crate::docking::targets::usable(rect) {
return;
}
self.note_edge(path, rect);
match node {
Node::Split { axis: SplitAxis::Horizontal, first, second, .. } if self.dock_split(ui, first, second, rect, path) => {}
Node::Split { axis: SplitAxis::Horizontal, first, second, .. } if self.dock_split(ui, first, second, rect, path, root) => {}
Node::Split { axis, size, first, second } => {
let sizer = self.sizer();
let Some(split) = sizer.split(*axis, *size, first, second, rect) else { return };
let (lo, hi) = sizer.range(node, rect);
let (lo, hi) = sizer.range(root, path);
let mark = self.dividers.len();
path.push(false);
self.node(ui, first, split.first, path);
self.node(ui, first, split.first, path, root);
path.pop();
path.push(true);
self.node(ui, second, split.second, path);
self.node(ui, second, split.second, path, root);
path.pop();
// The divider's inner-edge hit margin must win over child scrollbars, just
// as accordion dividers win over the adjacent panel's content.
@@ -156,12 +156,12 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
.show(ui);
self.register_interaction(ui.ctx(), response.response.id);
if response.delta != 0.0 {
let actions = self.divider_actions(node, rect, path, response.delta);
let actions = self.divider_actions(root, path, response.delta);
self.output.actions.extend(actions);
}
self.intersections(ui, node, rect, path, split.divider, mark);
self.intersections(ui, (node, rect), path, split.divider, mark, root);
if self.dividers.len() < crate::docking::model::MAX_NODES {
self.dividers.push(DrawnDivider { path: path.clone(), axis: *axis, rect, divider: split.divider });
self.dividers.push(DrawnDivider { path: path.clone(), axis: *axis, divider: split.divider });
}
}
Node::Tabs { panels, active } => {
@@ -228,21 +228,30 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
}
// Register dividers after the headers so their narrow hit regions win at the
// shared boundary. Closed entries retain their saved sizes and are skipped.
let scale = if total_wanted > 0.0 { f64::from(remaining) / total_wanted } else { 0.0 };
let body_limits = |panel: &P| {
let mut limits = self.limits(panel);
limits.min.y = limits.min.y.max(self.style.min_pane);
limits.max = limits.max.max(limits.min);
limits
};
let open: Vec<&crate::docking::StackEntry<P>> = entries.iter().filter(|entry| entry.open).collect();
let row: Vec<RowItem> = open
.iter()
.map(|entry| {
let limits = body_limits(&entry.panel);
let size = (f64::from(entry.height.unwrap_or(self.style.min_pane).max(1.0)) * scale) as f32;
RowItem { size, min: limits.min.y, max: limits.max.y }
})
.collect();
for (index, divider) in dividers {
let Some(first) = entries.get(index) else { continue };
let Some(second) = entries.iter().skip(index.saturating_add(1)).find(|entry| entry.open) else { continue };
let a = f64::from(first.height.unwrap_or(self.style.min_pane).max(1.0));
let b = f64::from(second.height.unwrap_or(self.style.min_pane).max(1.0));
let scale = f64::from(remaining) / total_wanted;
let first_size = (a * scale) as f32;
let pair_size = ((a + b) * scale) as f32;
let body_limits = |panel: &P| {
let mut limits = self.limits(panel);
limits.min.y = limits.min.y.max(self.style.min_pane);
limits.max = limits.max.max(limits.min);
limits
};
let (lo, hi) = split_bounds(pair_size, SplitAxis::Vertical, body_limits(&first.panel), body_limits(&second.panel));
let Some(position) = open.iter().position(|entry| std::ptr::eq(*entry, first)) else { continue };
let Some(first_size) = row.get(position).map(|item| item.size) else { continue };
if position + 1 >= row.len() {
continue;
}
let (lo, hi) = row_range(&row, position);
let response = ResizeHandle::new(
self.id.with(("stack-resize", &first.panel)),
SplitAxis::Vertical,
@@ -250,14 +259,16 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
&self.style.resize_label,
ResizeHandleStyle { hovered: self.style.accent, dragged: self.style.accent, focused: self.style.accent },
)
.value(first_size, lo..=hi)
.value(first_size, (first_size + lo)..=(first_size + hi))
.show(ui);
self.register_interaction(ui.ctx(), response.response.id);
if response.delta != 0.0 && scale > 0.0 {
let delta = f64::from((first_size + response.delta).clamp(lo, hi) - first_size) / scale;
let next_a = (a + delta).clamp((a + b - 1_000_000.0).max(1.0), (a + b - 1.0).min(1_000_000.0));
self.output.actions.push(Action::ResizeStack { panel: first.panel.clone(), height: Some(next_a as f32) });
self.output.actions.push(Action::ResizeStack { panel: second.panel.clone(), height: Some((a + b - next_a) as f32) });
for ((entry, item), next) in open.iter().zip(&row).zip(row_drag(&row, position, response.delta)) {
if next != item.size {
let height = (f64::from(next) / scale).clamp(1.0, 1_000_000.0) as f32;
self.output.actions.push(Action::ResizeStack { panel: entry.panel.clone(), height: Some(height) });
}
}
}
}
}
@@ -268,10 +279,10 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
Sizer { style: self.style, content: &*self.content }
}
/// `ResizeSplit` actions that move the divider of the split `node`, drawn at view path
/// `path` in `rect`, by `delta` points.
fn divider_actions(&self, node: &Node<P>, rect: Rect, path: &[bool], delta: f32) -> Vec<Action<P>> {
let sizes = self.sizer().drag(node, rect, delta, &mut path.to_vec());
/// `ResizeSplit` actions that move the divider of the split at view path `path` in the
/// tree `root` by `delta` points.
fn divider_actions(&self, root: (&Node<P>, Rect), path: &[bool], delta: f32) -> Vec<Action<P>> {
let sizes = self.sizer().drag(root, path, delta);
let resize = |path: Vec<bool>, size| match &self.tree {
None => Action::ResizeSplit { path, size },
Some((panel, _)) => Action::ResizeWindowSplit { panel: panel.clone(), path, size },
@@ -290,7 +301,7 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
/// Four-way handles where a divider drawn inside the split `node` (since `mark`) ends on
/// the split's own divider: dragging one moves both dividers.
fn intersections(&mut self, ui: &mut Ui, node: &Node<P>, rect: Rect, path: &[bool], divider: Rect, mark: usize) {
fn intersections(&mut self, ui: &mut Ui, (node, rect): (&Node<P>, Rect), path: &[bool], divider: Rect, mark: usize, root: (&Node<P>, Rect)) {
let Node::Split { axis, .. } = node else { return };
let side = (self.style.gap * 3.0).max(12.0);
let mut found = Vec::new();
@@ -302,9 +313,9 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
SplitAxis::Horizontal => pos2(divider.center().x, inner.divider.center().y),
SplitAxis::Vertical => pos2(inner.divider.center().x, divider.center().y),
};
found.push((inner.path.clone(), inner.rect, Rect::from_center_size(center, Vec2::splat(side)).intersect(rect)));
found.push((inner.path.clone(), Rect::from_center_size(center, Vec2::splat(side)).intersect(rect)));
}
for (inner_path, inner_rect, hit) in found {
for (inner_path, hit) in found {
let Some(inner) = inner_path.get(path.len()..).and_then(|rest| crate::docking::dock_model::node_at(node, rest)) else { continue };
let (outer, inner_layout) = (self.original_path(path), self.original_path(&inner_path));
let id = match &self.tree {
@@ -321,8 +332,8 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Renderer<'_, P> {
if delta != Vec2::ZERO && delta.is_finite() {
let along = |axis: SplitAxis| if axis == SplitAxis::Horizontal { delta.x } else { delta.y };
let Node::Split { axis: inner_axis, .. } = inner else { continue };
let mut actions = self.divider_actions(node, rect, path, along(*axis));
actions.extend(self.divider_actions(inner, inner_rect, &inner_path, along(*inner_axis)));
let mut actions = self.divider_actions(root, path, along(*axis));
actions.extend(self.divider_actions(root, &inner_path, along(*inner_axis)));
self.output.actions.extend(actions);
}
}
+184 -29
View File
@@ -1,5 +1,13 @@
//! Split-tree geometry: where each split draws its children, how far a divider can travel,
//! and the sizes that move a divider while every group away from it keeps its size.
//! and the sizes that move a divider.
//!
//! A dragged divider grows the groups touching it on one side, up to their maximums, and
//! shrinks the groups on the other side in turn: the group touching the divider gives way
//! down to its minimum, then the next group along the axis, and so on, until every group on
//! that side is at its minimum. Groups side by side across the axis shrink together, and the
//! line goes on past them once one is at its minimum. The line follows splits of the drag's
//! axis up the tree and ends at a split across it or beside a dock. Every other group keeps
//! its size.
use egui::Rect;
@@ -7,6 +15,9 @@ use super::{dock::dock_rects, node_limits, split_bounds};
use crate::docking::{DockContent, DockStyle, Node, PanelLimits};
use crate::layout::{SplitAxis, SplitLayout, SplitSize, split_rect};
/// A split's two children with the rects they are drawn in.
type Children<'n, P> = [(&'n Node<P>, Rect); 2];
/// Room a group keeps above its minimum after a drop, so each of its dividers can still
/// travel both ways.
pub(in crate::docking) const DROP_MARGIN: f32 = 1.0;
@@ -78,8 +89,9 @@ impl<P> Sizer<'_, P> {
}
/// How far the end edge (`end`) or start edge of `node` drawn in `rect` can move along
/// `axis`: inward while the groups touching it stay at their minimums, and outward up to
/// their maximums.
/// `axis`: inward until every group along the axis from that edge is at its minimum, and
/// outward while the groups touching it stay below their maximums. Groups side by side
/// across the axis move together, so the first of them to reach its limit stops them.
pub(in crate::docking) fn travel(&self, node: &Node<P>, rect: Rect, axis: SplitAxis, end: bool) -> (f32, f32) {
let docked =
matches!(node, Node::Split { first, second, .. } if matches!(**first, Node::Dock { .. }) || matches!(**second, Node::Dock { .. }));
@@ -89,8 +101,9 @@ impl<P> Sizer<'_, P> {
self.travel(other, rect, axis, end)
}
(Node::Split { axis: split_axis, .. }, Some([a, b])) if *split_axis == axis => {
let (child, rect) = if end { b } else { a };
self.travel(child, rect, axis, end)
let (near, far) = if end { (b, a) } else { (a, b) };
let (near, far) = (self.travel(near.0, near.1, axis, end), self.travel(far.0, far.1, axis, end));
(near.0 + far.0, near.1)
}
(_, Some([a, b])) => {
let (a, b) = (self.travel(a.0, a.1, axis, end), self.travel(b.0, b.1, axis, end));
@@ -105,7 +118,9 @@ impl<P> Sizer<'_, P> {
}
/// The sizes that move the end (`end`) or start edge of `node` drawn in `rect` outward by
/// `grow` points: only the groups touching that edge change. Paths are relative to `path`.
/// `grow` points. Growing, only the groups touching that edge change. Shrinking, the group
/// at the edge gives way down to its minimum, then the next one along the axis, and so on.
/// Paths are relative to `path`.
pub(in crate::docking) fn follow(
&self,
(node, rect): (&Node<P>, Rect),
@@ -118,55 +133,195 @@ impl<P> Sizer<'_, P> {
let Some([a, b]) = self.children(node, rect) else { return };
let Node::Split { axis: split_axis, first, second, .. } = node else { return };
let docked = matches!(**first, Node::Dock { .. }) || matches!(**second, Node::Dock { .. });
let visit = |child: (&Node<P>, Rect), second_child: bool, path: &mut Vec<bool>, out: &mut Vec<(Vec<bool>, SplitSize)>| {
let visit = |child: (&Node<P>, Rect), second_child: bool, grow: f32, path: &mut Vec<bool>, out: &mut Vec<(Vec<bool>, SplitSize)>| {
path.push(second_child);
self.follow(child, axis, end, grow, path, out);
path.pop();
};
if docked {
let dock_first = matches!(**first, Node::Dock { .. });
visit(if dock_first { b } else { a }, dock_first, path, out);
visit(if dock_first { b } else { a }, dock_first, grow, path, out);
} else if *split_axis == axis {
let available = extent(a.1, axis) + extent(b.1, axis) + grow;
let first_size = extent(a.1, axis) + if end { 0.0 } else { grow };
if available > 0.0 {
out.push((path.clone(), SplitSize::Ratio((first_size / available).clamp(0.0, 1.0))));
let (near, far) = if end { (b, a) } else { (a, b) };
let near_grow = if grow < 0.0 { grow.max(-self.travel(near.0, near.1, axis, end).0) } else { grow };
let far_grow = grow - near_grow;
let (near_size, far_size) = (extent(near.1, axis) + near_grow, extent(far.1, axis) + far_grow);
let first_size = if end { far_size } else { near_size };
push_ratio(path, first_size, near_size + far_size, out);
visit(near, end, near_grow, path, out);
if far_grow != 0.0 {
visit(far, !end, far_grow, path, out);
}
visit(if end { b } else { a }, end, path, out);
} else {
visit(a, false, path, out);
visit(b, true, path, out);
visit(a, false, grow, path, out);
visit(b, true, grow, path, out);
}
}
/// The divider of the split `node` drawn in `rect` moved by `delta` points, clamped to its
/// travel: the split's own size and those of the splits that keep the groups away from the
/// divider at their sizes. Paths are relative to `path`, the split's own.
pub(in crate::docking) fn drag(&self, node: &Node<P>, rect: Rect, delta: f32, path: &mut Vec<bool>) -> Vec<(Vec<bool>, SplitSize)> {
/// The drawn splits from `root` down to the one at `path`, each with its rect.
fn chain<'n>(&self, root: (&'n Node<P>, Rect), path: &[bool]) -> Option<Vec<(&'n Node<P>, Rect)>> {
let mut chain = vec![root];
for &second in path {
let (node, rect) = *chain.last()?;
let [a, b] = self.children(node, rect)?;
chain.push(if second { b } else { a });
}
Some(chain)
}
/// The ancestors that continue the line of the split at the end of `chain` along `axis`:
/// each with its children and whether the line runs through its second child, nearest first.
/// The line ends at a split across the axis or beside a dock.
fn line<'n>(&self, chain: &[(&'n Node<P>, Rect)], path: &[bool], axis: SplitAxis) -> Vec<(usize, Children<'n, P>, bool)> {
let mut line = Vec::new();
for depth in (0..path.len()).rev() {
let Some(&(node, rect)) = chain.get(depth) else { break };
let Node::Split { axis: split_axis, first, second, .. } = node else { break };
if *split_axis != axis || matches!(**first, Node::Dock { .. }) || matches!(**second, Node::Dock { .. }) {
break;
}
let (Some(children), Some(&second_child)) = (self.children(node, rect), path.get(depth)) else { break };
line.push((depth, children, second_child));
}
line
}
/// The divider of the split at `path` under `root` (a node and the rect it is drawn in)
/// moved by `delta` points, clamped to its travel. The groups touching the divider on the
/// side it moves toward give way, then the groups beyond them along the axis, one after
/// another, as far as the line of same-axis splits reaches; the groups on the other side
/// that touch the divider take the room. Paths are absolute, like `path`.
pub(in crate::docking) fn drag(&self, root: (&Node<P>, Rect), path: &[bool], delta: f32) -> Vec<(Vec<bool>, SplitSize)> {
let Some(chain) = self.chain(root, path) else { return Vec::new() };
let Some(&(node, rect)) = chain.last() else { return Vec::new() };
let Node::Split { axis, size, first, second } = node else { return Vec::new() };
let Some(split) = self.split(*axis, *size, first, second, rect) else { return Vec::new() };
let (lo, hi) = self.range(node, rect);
let axis = *axis;
let Some(split) = self.split(axis, *size, first, second, rect) else { return Vec::new() };
let (lo, hi) = self.range(root, path);
let delta = delta.clamp(lo, hi);
if delta == 0.0 || !delta.is_finite() || split.available() <= 0.0 {
return Vec::new();
}
let mut out = vec![(path.clone(), SplitSize::Ratio(((split.first_size() + delta) / split.available()).clamp(0.0, 1.0)))];
// Toward the end edge the second child gives way, toward the start the first.
let forward = delta > 0.0;
let moved = delta.abs();
let given = if forward {
moved.min(self.travel(second, split.second, axis, false).0)
} else {
moved.min(self.travel(first, split.first, axis, true).0)
};
let (first_grow, second_grow) = if forward { (moved, -given) } else { (-given, moved) };
let mut out = Vec::new();
let mut path = path.to_vec();
let first_size = split.first_size() + first_grow;
push_ratio(&path, first_size, first_size + extent(split.second, axis) + second_grow, &mut out);
path.push(false);
self.follow((first, split.first), *axis, true, delta, path, &mut out);
self.follow((first, split.first), axis, true, first_grow, &mut path, &mut out);
path.pop();
path.push(true);
self.follow((second, split.second), *axis, false, -delta, path, &mut out);
self.follow((second, split.second), axis, false, second_grow, &mut path, &mut out);
path.pop();
// What the split's own child could not give, the ancestors' children beyond it give:
// the split grows by `rest` toward them, and so does each ancestor until one absorbs it.
let mut rest = moved - given;
for (depth, [a, b], second_child) in self.line(&chain, &path, axis) {
if rest <= 0.0 {
break;
}
path.truncate(depth);
let (a_size, b_size) = (extent(a.1, axis), extent(b.1, axis));
let (first_size, second_size) = match (forward, second_child) {
(true, false) => {
let taken = rest.min(self.travel(b.0, b.1, axis, false).0);
path.push(true);
self.follow(b, axis, false, -taken, &mut path, &mut out);
path.pop();
let sizes = (a_size + rest, b_size - taken);
rest -= taken;
sizes
}
(false, true) => {
let taken = rest.min(self.travel(a.0, a.1, axis, true).0);
path.push(false);
self.follow(a, axis, true, -taken, &mut path, &mut out);
path.pop();
let sizes = (a_size - taken, b_size + rest);
rest -= taken;
sizes
}
(true, true) => (a_size, b_size + rest),
(false, false) => (a_size + rest, b_size),
};
push_ratio(&path, first_size, first_size + second_size, &mut out);
}
out
}
/// How far the divider of the split `node` drawn in `rect` can move: `(lo, hi)`, with
/// `lo <= 0 <= hi`.
pub(in crate::docking) fn range(&self, node: &Node<P>, rect: Rect) -> (f32, f32) {
/// How far the divider of the split at `path` under `root` can move: `(lo, hi)`, with
/// `lo <= 0 <= hi`. Each way it is the lesser of the room the groups touching the divider
/// have to grow and the room every group beyond the divider, along the line of same-axis
/// splits, has to shrink.
pub(in crate::docking) fn range(&self, root: (&Node<P>, Rect), path: &[bool]) -> (f32, f32) {
let Some(chain) = self.chain(root, path) else { return (0.0, 0.0) };
let Some(&(node, rect)) = chain.last() else { return (0.0, 0.0) };
let Node::Split { axis, size, first, second } = node else { return (0.0, 0.0) };
let Some(split) = self.split(*axis, *size, first, second, rect) else { return (0.0, 0.0) };
let (first_in, first_out) = self.travel(first, split.first, *axis, true);
let (second_in, second_out) = self.travel(second, split.second, *axis, false);
let (mut first_in, first_out) = self.travel(first, split.first, *axis, true);
let (mut second_in, second_out) = self.travel(second, split.second, *axis, false);
for (_, [a, b], second_child) in self.line(&chain, path, *axis) {
if second_child {
first_in += self.travel(a.0, a.1, *axis, true).0;
} else {
second_in += self.travel(b.0, b.1, *axis, false).0;
}
}
(-first_in.min(second_out), first_out.min(second_in))
}
}
/// The size of a split at `path` whose first child is `first` of `available` points.
fn push_ratio(path: &[bool], first: f32, available: f32, out: &mut Vec<(Vec<bool>, SplitSize)>) {
if available > 0.0 {
out.push((path.to_vec(), SplitSize::Ratio((first / available).clamp(0.0, 1.0))));
}
}
/// One group of a flat row, such as the panels of a stack or the groups of a dock column:
/// its size along the row and its limits.
#[derive(Clone, Copy)]
pub(in crate::docking) struct RowItem {
pub(in crate::docking) size: f32,
pub(in crate::docking) min: f32,
pub(in crate::docking) max: f32,
}
/// How far the divider after `row[index]` can move: `(lo, hi)`, with `lo <= 0 <= hi`, by the
/// rule of [`row_drag`].
pub(in crate::docking) fn row_range(row: &[RowItem], index: usize) -> (f32, f32) {
let room = |items: &[RowItem]| items.iter().map(|item| (item.size - item.min).max(0.0)).sum::<f32>();
let grow = |item: Option<&RowItem>| item.map_or(0.0, |item| (item.max - item.size).max(0.0));
let (before, after) = row.split_at((index + 1).min(row.len()));
(-room(before).min(grow(after.first())), room(after).min(grow(before.last())))
}
/// The sizes of `row` after the divider after `row[index]` moves by `delta`, clamped to its
/// travel: the item touching the divider on the side it moves toward gives way down to its
/// minimum, then the next one, and so on; the item on the other side takes the room.
pub(in crate::docking) fn row_drag(row: &[RowItem], index: usize, delta: f32) -> Vec<f32> {
let (lo, hi) = row_range(row, index);
let delta = if delta.is_finite() { delta.clamp(lo, hi) } else { 0.0 };
let mut sizes: Vec<f32> = row.iter().map(|item| item.size).collect();
let (grows, givers): (usize, Vec<usize>) =
if delta > 0.0 { (index, (index + 1..row.len()).collect()) } else { (index + 1, (0..=index).rev().collect()) };
let mut rest = delta.abs();
for giver in givers {
let (Some(size), Some(item)) = (sizes.get_mut(giver), row.get(giver)) else { continue };
let taken = rest.min((item.size - item.min).max(0.0));
*size -= taken;
rest -= taken;
}
if let Some(size) = sizes.get_mut(grows) {
*size += delta.abs() - rest;
}
sizes
}
+27 -5
View File
@@ -227,6 +227,24 @@ fn a_divider_resizes_only_the_groups_that_share_it() {
assert_eq!(group(&d, PROPERTIES[0]), properties);
}
#[test]
fn a_divider_dragged_past_a_groups_minimum_shrinks_the_next_group_along_the_row() {
// A | B | C | D, 357 pt each, as (A | B) | (C | D): the cascade runs on past B's split.
let row = hsplit(0.5, hsplit(0.5, tabs(&[1]), tabs(&[2])), hsplit(0.5, tabs(&[3]), tabs(&[4])));
let mut d = driver(Layout { root: Some(row), floating: Vec::new() }, Film::default());
let widths = |d: &Driver| [1, 2, 3, 4].map(|panel| group(d, panel).width().round());
assert_eq!(widths(&d), [357.0, 357.0, 357.0, 357.0]);
// B gives way down to its 40 pt minimum, then C.
drag_hit(&mut d, divider(&[false]), vec2(400.0, 0.0));
assert_eq!(widths(&d), [757.0, 40.0, 274.0, 357.0]);
// The drag stops when B, C and D are all at their minimums.
drag_hit(&mut d, divider(&[false]), vec2(670.0, 0.0));
assert_eq!(widths(&d), [1308.0, 40.0, 40.0, 40.0]);
// Back the other way, A gives way and only B, which touches the divider, grows.
drag_hit(&mut d, divider(&[false]), vec2(-1300.0, 0.0));
assert_eq!(widths(&d), [40.0, 1308.0, 40.0, 40.0]);
}
#[test]
fn an_intersection_moves_both_dividers() {
let mut d = film();
@@ -361,12 +379,16 @@ fn assert_sizes(d: &Driver, context: &str) {
let room = g.rect.size() - g.limits.min;
assert!(room.x >= -0.01 && room.y >= -0.01, "{context}: {:?} is below its minimum {:?}", g.rect, g.limits.min);
}
let mut nodes = vec![(root, area)];
while let Some((node, rect)) = nodes.pop() {
let Some(children) = sizer.children(node, rect) else { continue };
let (lo, hi) = sizer.range(node, rect);
let mut nodes = vec![(root, area, Vec::new())];
while let Some((node, rect, path)) = nodes.pop() {
let Some([a, b]) = sizer.children(node, rect) else { continue };
let (lo, hi) = sizer.range((root, area), &path);
assert!(lo < -0.5 && hi > 0.5, "{context}: a divider is stuck ({lo}, {hi}) at {rect:?} in {:?}", d.layout);
nodes.extend(children);
for (second, (child, rect)) in [(false, a), (true, b)] {
let mut path = path.clone();
path.push(second);
nodes.push((child, rect, path));
}
}
}
}
+4 -4
View File
@@ -51,9 +51,9 @@ pub struct DockStyle {
/// The outer edge band also runs along the left and right edges, where a drop adds a
/// full-height column. Off: only the top and bottom edges add a full-width row.
pub side_edge_zones: bool,
/// How far a group's side drop zones reach into its body, below the tab strip. A body less
/// than three times as wide or tall gets zones a third of its extent deep in that axis, so
/// it keeps a center.
/// How far a group's side drop zones reach into its body, below the tab strip. All four
/// zones share one depth: this, or a quarter of the body's smaller side when that is less,
/// so the body keeps a center.
pub zone_depth: f32,
/// [D] The docked area's left and right edges, where no dock is yet, take a drop as a new
/// dock (see [`Self::new_dock_band`]).
@@ -875,7 +875,7 @@ impl<'a, P: Clone + Eq + Hash + Debug + Send + Sync + 'static> DockArea<'a, P> {
cross: Default::default(),
};
if let Some(root) = &view.root {
renderer.node(ui, root, rect, &mut Vec::new());
renderer.node(ui, root, rect, &mut Vec::new(), (root, rect));
ui.allocate_rect(rect, Sense::hover());
}
renderer.flyout(ui.ctx());
+10 -9
View File
@@ -1,4 +1,4 @@
use egui::{Pos2, Rangef, Rect, Vec2, pos2, vec2};
use egui::{Pos2, Rangef, Rect, Vec2, pos2};
use super::{Placement, Side, Target, Zone};
@@ -32,10 +32,11 @@ pub(super) fn usable(rect: Rect) -> bool {
}
/// Tab header (the top `tab_height` of `rect`) is the center; otherwise the nearest side zone of
/// the body below it wins. A side zone reaches `depth` into the body, or a third of the body's
/// extent in that axis when that is less, so a body always keeps a center; a `depth` of zero
/// or less leaves only the center. Outside, non-finite, empty and inverted rectangles have no
/// target.
/// the body below it wins. Every side zone reaches the same depth into the body: `depth`, or a
/// quarter of the body's smaller side when that is less, so a body always keeps a center and a
/// narrow body's top and bottom zones are no deeper than its left and right ones. A `depth` of
/// zero or less leaves only the center. Outside, non-finite, empty and inverted rectangles have
/// no target.
pub fn drop_zone(rect: Rect, tab_height: f32, depth: f32, pointer: Pos2) -> Option<Zone> {
if !usable(rect) || !pointer.is_finite() || !rect.contains(pointer) || !tab_height.is_finite() || tab_height < 0.0 {
return None;
@@ -65,10 +66,10 @@ fn body(rect: Rect, tab_height: f32) -> Rect {
}
/// How deep the side zones of `body` reach in from its left and right edges (`x`) and its top
/// and bottom edges (`y`).
/// and bottom edges (`y`): the same on all four sides.
fn side_depths(body: Rect, depth: f32) -> Vec2 {
let depth = if depth > 0.0 { depth } else { 0.0 };
vec2(depth.min(body.width() / 3.0), depth.min(body.height() / 3.0))
Vec2::splat(depth.min(body.width().min(body.height()) / 4.0))
}
/// The outline of a drop zone of the group drawn at `rect`, as [`drop_zone`] finds it with the
@@ -152,8 +153,8 @@ pub fn tab_insertion_marker<P: Eq>(target: &DropTarget<P>, before: Option<&P>) -
/// Resolve a pointer against visible groups. The frontmost containing group occludes groups
/// behind it even if it rejects the drop. A strip reorders by midpoint; the body of the source
/// group is a no-op at center. The body's side zones are [`drop_zone`]'s with `zone_depth` (see
/// [`crate::docking::DockStyle::zone_depth`]). Floating groups normally set `allow_splits` to
/// false.
/// [`crate::docking::DockStyle::zone_depth`]): one depth on all four sides, at most a quarter of
/// the body's smaller side. Floating groups normally set `allow_splits` to false.
pub fn resolve_drop<P: Clone + Eq>(panel: &P, pointer: Pos2, targets: &[DropTarget<P>], zone_depth: f32) -> Option<DropProposal<P>> {
if !pointer.is_finite() || targets.len() > super::MAX_PANELS {
return None;
+23 -5
View File
@@ -303,23 +303,30 @@ fn pointer_targets_distinguish_reorder_center_split_and_occlusion() {
}
#[test]
fn side_zones_are_40_pt_deep_or_a_third_of_a_small_body() {
fn side_zones_are_40_pt_deep_or_a_quarter_of_the_bodys_smaller_side() {
let depth = DockStyle::default().zone_depth;
assert_eq!(depth, 40.0);
// The inner corner of the left trapezoid is the depth of both bands.
let inner = |rect: Rect| zone_shape(rect, 0.0, depth, Zone::Left).unwrap()[1] - rect.min;
for size in [vec2(600.0, 400.0), vec2(130.0, 130.0)] {
for size in [vec2(600.0, 400.0), vec2(160.0, 160.0)] {
let rect = Rect::from_min_size(pos2(10.0, 20.0), size);
assert_eq!(inner(rect), vec2(40.0, 40.0), "{size:?}");
let y = rect.center().y;
assert_eq!(drop_zone(rect, 0.0, depth, pos2(rect.left() + 39.0, y)), Some(Zone::Left), "{size:?}");
assert_eq!(drop_zone(rect, 0.0, depth, pos2(rect.left() + 41.0, y)), Some(Zone::Center), "{size:?}");
}
// A 90 pt body keeps a 30 pt center.
// A 90 pt body keeps a 45 pt center.
let rect = Rect::from_min_size(pos2(10.0, 20.0), vec2(90.0, 90.0));
assert_eq!(inner(rect), vec2(30.0, 30.0));
assert_eq!(inner(rect), vec2(22.5, 22.5));
assert_eq!(drop_zone(rect, 0.0, depth, rect.center()), Some(Zone::Center));
assert_eq!(drop_zone(rect, 0.0, depth, pos2(rect.left() + 29.0, rect.center().y)), Some(Zone::Left));
assert_eq!(drop_zone(rect, 0.0, depth, pos2(rect.left() + 22.0, rect.center().y)), Some(Zone::Left));
// A tall narrow body: its top and bottom zones are as deep as its left and right ones.
let rect = Rect::from_min_size(pos2(10.0, 20.0), vec2(120.0, 600.0));
assert_eq!(inner(rect), vec2(30.0, 30.0));
let top = zone_shape(rect, 0.0, depth, Zone::Top).unwrap();
assert_eq!(top[2].y - rect.top(), 30.0);
assert_eq!(drop_zone(rect, 0.0, depth, pos2(rect.center().x, rect.top() + 29.0)), Some(Zone::Top));
assert_eq!(drop_zone(rect, 0.0, depth, pos2(rect.center().x, rect.top() + 31.0)), Some(Zone::Center));
// The bands start below the tab header.
let rect = Rect::from_min_size(pos2(10.0, 20.0), vec2(600.0, 400.0));
assert_eq!(drop_zone(rect, 24.0, depth, pos2(rect.center().x, rect.top() + 60.0)), Some(Zone::Top));
@@ -653,6 +660,17 @@ fn stack_dividers_resize_adjacent_open_bodies_by_pointer_and_keyboard() {
let Node::Stack { entries } = layout.root.as_ref().unwrap() else { panic!() };
assert!(entries[0].height.unwrap() > after_pointer);
assert!((entries[0].height.unwrap() + entries[2].height.unwrap() - 300.0).abs() < 0.001);
// Dragged past the next body's minimum, the one after it gives way too, down to the same
// minimum; the closed entry keeps its height.
let start = ctx.read_response(id).unwrap().rect.center();
step(&ctx, &mut layout, vec![Event::PointerMoved(start), pointer_button(start, true)]);
step(&ctx, &mut layout, vec![Event::PointerMoved(start + vec2(0.0, 600.0))]);
step(&ctx, &mut layout, vec![pointer_button(start + vec2(0.0, 600.0), false)]);
let Node::Stack { entries } = layout.root.as_ref().unwrap() else { panic!() };
let heights = entries.iter().map(|entry| entry.height.unwrap()).collect::<Vec<_>>();
assert!((heights[2] - heights[3]).abs() < 0.01 && heights[3] < 120.0, "{heights:?}");
assert!((heights[0] + heights[2] + heights[3] - 420.0).abs() < 0.01, "{heights:?}");
assert_eq!(heights[1], 91.0);
}
#[test]
+10 -5
View File
@@ -217,16 +217,21 @@ A flyout fits its content the same way, without the title bar.
limits and the screen. A focused resize handle moves its edge 8 pt per arrow key.
- Over a frame, the tab strip and the middle join its tabs, and the nearest side splits it. The
side zones are trapezoids along the four edges of the body below the tab strip, like a picture
frame: `DockStyle::zone_depth` (40 pt) deep, or a third of the body's width or height when that
is less, so every frame keeps a center. A split that would leave either half without
frame, all four the same depth: `DockStyle::zone_depth` (40 pt), or a quarter of the body's
smaller side when that is less, so every frame keeps a center. A split that would leave either half without
`DockStyle::min_pane` joins the frame's tabs instead. The gap between two frames is no target.
- The outer edge band (`DockStyle::edge_band`) takes a drop as a new frame across the whole
window side: top and bottom, and left and right with `side_edge_zones`. It takes a quarter of
the window and is offered only when every frame keeps its minimum. Past the band, a frame's own
side zones apply.
- A divider resizes only the frames that touch it; every other frame keeps its size. It stops
when a frame touching it reaches its minimum. Where a divider ends on another divider, a
four-way handle (`Divider::Intersection`) moves both.
- A dragged divider grows the frames that touch it on one side, up to their maximums. On the
other side the frame touching it shrinks to its minimum, then the next frame along the same
axis, and so on: the divider stops when every frame on that side is at its minimum. Frames
side by side across the axis shrink together, and the next frame gives way once one of them
is at its minimum. The line of frames ends at a split across the axis or at a dock; every
other frame keeps its size. Dividers between stacked panels and between the groups of a dock
column work the same way. Where a divider ends on another divider, a four-way handle
(`Divider::Intersection`) moves both.
- Every frame has the same minimum, `DockStyle::min_pane` (plus its tab strip), unless its panels
ask for more through `PanelLimits::min`. Frames have no maximum unless every panel in them asks
for one through `PanelLimits::max`: a panel without a maximum lifts the maximum of the panels it