mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 23:02:31 +00:00
Merge branch 'fx/dropview' into fx/all-1117
This commit is contained in:
@@ -150,18 +150,24 @@ fn paint_drag_badge(draw: &Draw<'_>, env: &Env, at: Pos2, text: &str) {
|
||||
}
|
||||
|
||||
/// The drop mark: bands of the drop rule on a halo of the panel surface one thin stroke wide, so the mark reads over
|
||||
/// any content. An area mark is the same band along the inside of its rect.
|
||||
/// any content. An area mark is the same band along the inside of its rect; a region is also washed with the rule's
|
||||
/// colour, so the area the payload takes reads as one piece, and carries its line band.
|
||||
fn paint_mark(painter: &egui::Painter, env: &Env, mark: DropMark) {
|
||||
let look = rule_look(&env.tokens, RuleKind::DropMark);
|
||||
let ppp = painter.ctx().pixels_per_point();
|
||||
let width = look.width.points(ppp);
|
||||
let halo = RuleWidth::Points(env.tokens.stroke.thin).points(ppp);
|
||||
let outline = |rect: Rect| {
|
||||
let inside = rect.shrink(width / 2.0 + halo);
|
||||
let corners = [inside.left_top(), inside.right_top(), inside.right_bottom(), inside.left_bottom()];
|
||||
(0..corners.len()).map(move |at| (corners[at], corners[(at + 1) % corners.len()]))
|
||||
};
|
||||
let segments: Vec<(Pos2, Pos2)> = match mark {
|
||||
DropMark::Line { from, to } => vec![(from, to)],
|
||||
DropMark::Into(rect) | DropMark::Split(rect) => {
|
||||
let inside = rect.shrink(width / 2.0 + halo);
|
||||
let corners = [inside.left_top(), inside.right_top(), inside.right_bottom(), inside.left_bottom()];
|
||||
(0..corners.len()).map(|at| (corners[at], corners[(at + 1) % corners.len()])).collect()
|
||||
DropMark::Into(rect) => outline(rect).collect(),
|
||||
DropMark::Region { area, line } => {
|
||||
painter.rect_filled(area, CornerRadius::ZERO, look.color.gamma_multiply(craft_theme::Opacity::WASH));
|
||||
outline(area).chain(line.map(|[from, to]| (from, to))).collect()
|
||||
}
|
||||
};
|
||||
let band = |(from, to): (Pos2, Pos2), half: f32| Rect::from_two_pos(from, to).expand(half);
|
||||
|
||||
@@ -60,8 +60,14 @@ pub enum DropMark {
|
||||
},
|
||||
/// The payload goes into this rect.
|
||||
Into(Rect),
|
||||
/// This rect is split, the payload taking one side.
|
||||
Split(Rect),
|
||||
/// The payload will occupy this area once dropped, such as the rect a docked panel takes beside a group.
|
||||
#[non_exhaustive]
|
||||
Region {
|
||||
/// The rect the payload takes.
|
||||
area: Rect,
|
||||
/// Where in it the payload goes in, such as the tab position of a panel joining a group.
|
||||
line: Option<[Pos2; 2]>,
|
||||
},
|
||||
}
|
||||
|
||||
impl DropMark {
|
||||
@@ -70,13 +76,23 @@ impl DropMark {
|
||||
DropMark::Line { from, to }
|
||||
}
|
||||
|
||||
/// The payload will occupy `area`.
|
||||
pub const fn region(area: Rect) -> Self {
|
||||
DropMark::Region { area, line: None }
|
||||
}
|
||||
|
||||
/// The payload will occupy `area` and goes in at the line from `from` to `to`.
|
||||
pub const fn region_at(area: Rect, from: Pos2, to: Pos2) -> Self {
|
||||
DropMark::Region { area, line: Some([from, to]) }
|
||||
}
|
||||
|
||||
/// The mark with every point passed through `map`.
|
||||
pub(crate) fn mapped(self, map: impl Fn(Pos2) -> Pos2) -> Self {
|
||||
let rect = |rect: Rect| Rect::from_two_pos(map(rect.min), map(rect.max));
|
||||
match self {
|
||||
DropMark::Line { from, to } => DropMark::Line { from: map(from), to: map(to) },
|
||||
DropMark::Into(target) => DropMark::Into(rect(target)),
|
||||
DropMark::Split(target) => DropMark::Split(rect(target)),
|
||||
DropMark::Region { area, line } => DropMark::Region { area: rect(area), line: line.map(|line| line.map(&map)) },
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32,7 +32,7 @@ use bar::panel_names;
|
||||
|
||||
pub(super) use bar::{BarRecord, CHEVRON, bar_band, bar_name, bar_slots, describe_chevron, paint_chevron, show_bar};
|
||||
use sizing::group_sizes;
|
||||
pub use sizing::{GroupSize, fit_widths, group_heights, scale_widths, stacked, stepped, width_bounds};
|
||||
pub use sizing::{GroupSize, column_cells, fit_widths, group_heights, scale_widths, stacked, stepped, width_bounds};
|
||||
|
||||
const DIVIDER: PartKey = PartKey::new("divider");
|
||||
const EDGE: PartKey = PartKey::new("edge");
|
||||
@@ -293,10 +293,16 @@ impl<'a, P: Value + Hash + 'static> DockColumn<'a, P> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Where the groups of `column` sit in `rect`, the column's rect with its bar `bar`, as the column lays them out while
|
||||
/// no divider between them is dragged.
|
||||
pub fn group_rects<P>(column: &Column<P>, spec: &dyn Fn(&P) -> PanelSpec, rect: Rect, bar: ColumnBar, sizes: &DockSizes) -> Vec<Rect> {
|
||||
column_plan(column, spec, rect, bar, sizes, |_, _| None).groups
|
||||
}
|
||||
|
||||
/// The bar and body of the column in `rect`, and the groups stacked in the body, with the drags `drags` makes of
|
||||
/// the dividers between open groups (the divider's part index and the divider as laid out before the drag). A
|
||||
/// column in a floating window has an empty bar on top.
|
||||
fn column_plan<P: Value + Hash>(
|
||||
fn column_plan<P>(
|
||||
column: &Column<P>,
|
||||
spec: &dyn Fn(&P) -> PanelSpec,
|
||||
rect: Rect,
|
||||
@@ -310,7 +316,7 @@ fn column_plan<P: Value + Hash>(
|
||||
}
|
||||
|
||||
/// [`column_plan`] for a column whose `bar` and `body` rects are known.
|
||||
fn body_plan<P: Value + Hash>(
|
||||
fn body_plan<P>(
|
||||
column: &Column<P>,
|
||||
spec: &dyn Fn(&P) -> PanelSpec,
|
||||
bar: Rect,
|
||||
|
||||
@@ -2,7 +2,8 @@
|
||||
|
||||
use crate::contract::SizeLimits;
|
||||
use crate::docking::{DockGrid, DockHeights, DockSizes, PanelSpec};
|
||||
use craft_behavior::dock::Column;
|
||||
use craft_behavior::Flow;
|
||||
use craft_behavior::dock::{Column, DockEdge};
|
||||
use egui::{Pos2, Rect};
|
||||
|
||||
/// The width bounds of an expanded column: no narrower than `least` or the widest minimum of its panels, no wider
|
||||
@@ -29,6 +30,31 @@ pub fn fit_widths(columns: &[(f32, Option<f32>)], room: f32) -> Vec<f32> {
|
||||
scale_widths(&bounded, room)
|
||||
}
|
||||
|
||||
/// The cells of a dock's columns in the dock's `rect`, from its window edge `edge` inwards, each the dock's full
|
||||
/// height: the columns' natural widths ([`DockSizes::natural`]) fitted into the dock's width ([`fit_widths`]). `flow`
|
||||
/// is the flow of the area the dock is in, which mirrors the edges for right-to-left.
|
||||
pub fn column_cells<P>(
|
||||
columns: &[Column<P>],
|
||||
rect: Rect,
|
||||
edge: DockEdge,
|
||||
flow: Flow,
|
||||
sizes: &DockSizes,
|
||||
spec: &dyn Fn(&P) -> PanelSpec,
|
||||
) -> Vec<Rect> {
|
||||
let widths = fit_widths(&sizes.natural(columns, spec), rect.width());
|
||||
let reading = flow.to_physical(rect);
|
||||
let start = edge == DockEdge::Start;
|
||||
let mut cursor = if start { reading.left() } else { reading.right() };
|
||||
widths
|
||||
.into_iter()
|
||||
.map(|width| {
|
||||
let span = if start { (cursor, cursor + width) } else { (cursor - width, cursor) };
|
||||
cursor = if start { span.1 } else { span.0 };
|
||||
flow.to_physical(Rect::from_x_y_ranges(span.0..=span.1, reading.y_range()))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The grid and steps of a stepped column: its [`Column::steps`] and the [`DockGrid`] of its first panel that
|
||||
/// declares a valid one. `None` for a column without steps or whose panels declare none, which sizes as any other.
|
||||
pub fn stepped<P>(column: &Column<P>, spec: &dyn Fn(&P) -> PanelSpec) -> Option<(DockGrid, u16)> {
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
//! windows, and returns the mark the ghost paints. Every drag of a group, a window or a column starts through
|
||||
//! [`start_group_drag`], or [`start_icon_drag`] out of a collapsed column.
|
||||
|
||||
use super::{DockSpot, DockTargets, FloatSpace, GroupDrag, PanelDrag, PanelKey, WindowColumn};
|
||||
use super::{DockSpot, DockTargets, FloatSpace, GroupDrag, PanelDrag, PanelKey, Placing, WindowColumn, placed_rect};
|
||||
use crate::contract::{Component, Cx, DropMark, DropOperation, DropTarget, Pointer as _};
|
||||
use crate::runtime::drag::{self, DragPreview};
|
||||
use crate::runtime::env::{AppValues, EnvValue, EnvView, Label};
|
||||
@@ -145,23 +145,29 @@ pub(crate) fn to_target<P: Clone>(unit: &DragUnit<P>, target: Target<P>) -> Acti
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether the model takes `action` and changes the arrangement by it: a dry run on a copy, so no mark shows for a
|
||||
/// drop that `Layout::apply_with_permissions` would refuse or that moves nothing.
|
||||
pub(crate) fn takes<P: Clone + Eq + Hash>(layout: &Layout<P>, action: &Action<P>, permissions: &dyn Fn(&P) -> Permissions) -> bool {
|
||||
/// The layout after `action`, when the model takes it and it changes the arrangement: a dry run on a copy, so no mark
|
||||
/// shows for a drop that `Layout::apply_with_permissions` would refuse or that moves nothing.
|
||||
pub(crate) fn applied<P: Clone + Eq + Hash>(layout: &Layout<P>, action: &Action<P>, permissions: &dyn Fn(&P) -> Permissions) -> Option<Layout<P>> {
|
||||
let mut copy = layout.clone();
|
||||
copy.apply_with_permissions(action.clone(), permissions).is_ok() && !copy.same_arrangement(layout)
|
||||
(copy.apply_with_permissions(action.clone(), permissions).is_ok() && !copy.same_arrangement(layout)).then_some(copy)
|
||||
}
|
||||
|
||||
/// The action a drop of `unit` on `spot` makes, or `None` when the unit cannot move there: the permissions refuse,
|
||||
/// the destination is the unit itself, the spot has no placement, or the model refuses the action.
|
||||
/// Whether the model takes `action` and changes the arrangement by it ([`applied`]).
|
||||
pub(crate) fn takes<P: Clone + Eq + Hash>(layout: &Layout<P>, action: &Action<P>, permissions: &dyn Fn(&P) -> Permissions) -> bool {
|
||||
applied(layout, action, permissions).is_some()
|
||||
}
|
||||
|
||||
/// The action a drop of `unit` on `spot` makes and the layout after it, or `None` when the unit cannot move there: the
|
||||
/// permissions refuse, the destination is the unit itself, the spot has no placement, or the model refuses the action.
|
||||
fn action_for<P: Clone + Eq + Hash>(
|
||||
layout: &Layout<P>,
|
||||
spot: &DockSpot<P>,
|
||||
unit: &DragUnit<P>,
|
||||
permissions: &dyn Fn(&P) -> Permissions,
|
||||
) -> Option<Action<P>> {
|
||||
) -> Option<(Action<P>, Layout<P>)> {
|
||||
let action = spot_action(layout, spot, unit, permissions)?;
|
||||
takes(layout, &action, permissions).then_some(action)
|
||||
let after = applied(layout, &action, permissions)?;
|
||||
Some((action, after))
|
||||
}
|
||||
|
||||
fn spot_action<P: Clone + Eq + Hash>(
|
||||
@@ -275,12 +281,15 @@ where
|
||||
{
|
||||
let unit = drag.unit(layout)?;
|
||||
let (spot, _) = DockTargets::<P>::resolve(ctx, dock, at)?;
|
||||
action_for(layout, &spot, &unit, permissions)
|
||||
action_for(layout, &spot, &unit, permissions).map(|(action, _)| action)
|
||||
}
|
||||
|
||||
/// The drop target of one dock over one layout, for a tab drag ([`PanelDrag`]) and a group drag ([`GroupDrag`]).
|
||||
///
|
||||
/// It accepts a move only. A release over a spot docks the unit there. Ctrl or Cmd held at the release floats it
|
||||
/// It accepts a move only. A release over a spot docks the unit there. With `placing`, the mark over a spot is the
|
||||
/// region the unit takes once dropped, laid out in the room the dock registered ([`placed_rect`]), with the tab line
|
||||
/// of a tab insertion; a reorder inside the unit's own group, and a drop whose panels get no rect of their own, mark
|
||||
/// the spot ([`DockSpot::mark`]). Ctrl or Cmd held at the release floats it
|
||||
/// instead (Photoshop: the key prevents docking), and with `float_on_empty` a release that no spot takes floats it;
|
||||
/// both float it into `space` under the pointer. A floating window dragged by its title bar moves itself and never
|
||||
/// floats into another window. Fields are assigned by the dock after [`Self::new`].
|
||||
@@ -299,12 +308,14 @@ pub struct DockDropTarget<'a, P> {
|
||||
pub float_on_empty: bool,
|
||||
/// A floating window dragged by its title bar docks on a spot (`DockConfig::title_bar_docks`). Off: it only moves.
|
||||
pub title_bar_docks: bool,
|
||||
/// How the dock lays out its panels, for the region a drop gives them. Without it every mark is the spot's.
|
||||
pub placing: Option<Placing<'a, P>>,
|
||||
}
|
||||
|
||||
impl<'a, P> DockDropTarget<'a, P> {
|
||||
/// The target of `dock` over `layout`: it docks on spots and floats nothing until `space` is set.
|
||||
pub fn new(ctx: &'a Context, dock: Id, layout: &'a Layout<P>, permissions: &'a dyn Fn(&P) -> Permissions) -> Self {
|
||||
DockDropTarget { ctx, dock, layout, permissions, rtl: false, space: None, float_on_empty: false, title_bar_docks: true }
|
||||
DockDropTarget { ctx, dock, layout, permissions, rtl: false, space: None, float_on_empty: false, title_bar_docks: true, placing: None }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -322,8 +333,14 @@ impl<P: Clone + Eq + Hash + Send + 'static> DockDropTarget<'_, P> {
|
||||
return None;
|
||||
}
|
||||
if let Some((spot, applies)) = DockTargets::<P>::resolve(self.ctx, self.dock, at) {
|
||||
if let Some(action) = action_for(self.layout, &spot, &unit, self.permissions) {
|
||||
let mark = spot.mark(applies, self.rtl)?;
|
||||
if let Some((action, after)) = action_for(self.layout, &spot, &unit, self.permissions) {
|
||||
let mark = match self.region(&spot, &unit, &after) {
|
||||
Some(area) => match spot.tab_line(applies, self.rtl) {
|
||||
Some([from, to]) => DropMark::region_at(area, from, to),
|
||||
None => DropMark::region(area),
|
||||
},
|
||||
None => spot.mark(applies, self.rtl)?,
|
||||
};
|
||||
return Some(DockDropped { action, mark });
|
||||
}
|
||||
if on_unit(self.layout, &spot, &unit) {
|
||||
@@ -336,6 +353,18 @@ impl<P: Clone + Eq + Hash + Send + 'static> DockDropTarget<'_, P> {
|
||||
self.float(&unit, at, drag.source(), drag.strip())
|
||||
}
|
||||
|
||||
/// The rect the panels of `unit` take in `after`, the layout once dropped on `spot`; `None` without `placing` or
|
||||
/// a registered room, for a reorder inside the unit's own group, which marks only its tab line, and where the
|
||||
/// panels get no rect of their own.
|
||||
fn region(&self, spot: &DockSpot<P>, unit: &DragUnit<P>, after: &Layout<P>) -> Option<Rect> {
|
||||
let placing = self.placing.as_ref()?;
|
||||
if matches!(spot, DockSpot::Tab { .. }) && on_unit(self.layout, spot, unit) {
|
||||
return None;
|
||||
}
|
||||
let room = DockTargets::<P>::room(self.ctx, self.dock)?;
|
||||
placed_rect(after, &moving_panels(self.layout, unit), room, placing, self.rtl)
|
||||
}
|
||||
|
||||
/// The unit floated under `at`, when it may float and the model takes it; `source` is its size where the drag
|
||||
/// started, `strip` the size of the icons it started on ([`float_drop`]).
|
||||
fn float(&self, unit: &DragUnit<P>, at: Pos2, source: Option<Vec2>, strip: Option<Vec2>) -> Option<DockDropped<P>> {
|
||||
|
||||
@@ -13,6 +13,7 @@ mod group;
|
||||
|
||||
mod floating;
|
||||
mod panels;
|
||||
mod placed;
|
||||
mod root;
|
||||
mod spec;
|
||||
mod splitter;
|
||||
@@ -40,6 +41,7 @@ pub use floating::{FloatingGroup, FloatingGroupOutput, FloatingGroupStyle, Windo
|
||||
pub use panels::{DockPanels, request_actions};
|
||||
#[doc(hidden)]
|
||||
pub use panels::{close_requests, open_requests};
|
||||
pub use placed::{Placing, placed_rect, with_area_rules};
|
||||
pub use root::{DockRoot, DockRootOutput, DockRootStyle};
|
||||
pub use spec::{DockGrid, DockHeights, PanelSpec};
|
||||
pub use splitter::{Splitter, SplitterStyle};
|
||||
@@ -56,8 +58,8 @@ mod flyout;
|
||||
mod iconic;
|
||||
|
||||
pub use dock_column::{
|
||||
ColumnArrow, ColumnBar, DockColumn, DockColumnOutput, DockColumnStyle, GroupSize, GroupView, fit_widths, group_heights, scale_widths, stacked,
|
||||
stepped, width_bounds,
|
||||
ColumnArrow, ColumnBar, DockColumn, DockColumnOutput, DockColumnStyle, GroupSize, GroupView, column_cells, fit_widths, group_heights,
|
||||
group_rects, scale_widths, stacked, stepped, width_bounds,
|
||||
};
|
||||
pub use flyout::{Flyout, FlyoutOutput, FlyoutShown, FlyoutStyle, GroupAt};
|
||||
pub use iconic::{FlyoutResize, IconicColumn, IconicColumnOutput, IconicColumnStyle, IconicSizes};
|
||||
|
||||
@@ -0,0 +1,122 @@
|
||||
//! Where a drop puts the panels it moves: the layout after the drop, pruned as the dock area shows it and laid out by
|
||||
//! the functions the dock draws with, so a drop's mark is the rect the moved panels take once dropped.
|
||||
|
||||
use super::frame::maximize;
|
||||
use super::tree::{self, FrameRules};
|
||||
use super::{ColumnBar, DockSizes, HidePanels, PanelSpec, column_cells, group_rects, stepped};
|
||||
use craft_behavior::Flow;
|
||||
use craft_behavior::dock::{Column, Layout, Node};
|
||||
use egui::Rect;
|
||||
use std::hash::Hash;
|
||||
|
||||
/// How a dock lays out its panels, which its drop target reads to mark where a drop puts them
|
||||
/// (`DockDropTarget::placing`).
|
||||
#[non_exhaustive]
|
||||
pub struct Placing<'a, P> {
|
||||
/// The dock's sizes.
|
||||
pub sizes: DockSizes,
|
||||
/// Each panel's spec: its limits, heights and whether it is a canvas.
|
||||
pub spec: &'a dyn Fn(&P) -> PanelSpec,
|
||||
/// The panels that always show, such as a canvas.
|
||||
pub protected: &'a dyn Fn(&P) -> bool,
|
||||
/// The panels the area hides, as the shell's visibility leaves them.
|
||||
pub hide: HidePanels<'a, P>,
|
||||
/// The panel whose frame the area shows maximized.
|
||||
pub maximized: Option<&'a P>,
|
||||
/// The floating window whose column the dock lays out, by its id; `None` for a dock area's docked tree.
|
||||
pub window: Option<u64>,
|
||||
}
|
||||
|
||||
impl<'a, P> Placing<'a, P> {
|
||||
/// The placing of a dock area's docked tree that hides nothing.
|
||||
pub fn new(sizes: DockSizes, spec: &'a dyn Fn(&P) -> PanelSpec, protected: &'a dyn Fn(&P) -> bool) -> Self {
|
||||
Placing { sizes, spec, protected, hide: HidePanels::None, maximized: None, window: None }
|
||||
}
|
||||
|
||||
/// The area hides `hide` and shows the frame of `maximized` alone.
|
||||
#[must_use]
|
||||
pub fn shown(mut self, hide: HidePanels<'a, P>, maximized: Option<&'a P>) -> Self {
|
||||
self.hide = hide;
|
||||
self.maximized = maximized;
|
||||
self
|
||||
}
|
||||
|
||||
/// The placing of the floating window `window` instead of the docked tree.
|
||||
#[must_use]
|
||||
pub fn window(mut self, window: u64) -> Self {
|
||||
self.window = Some(window);
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs `f` with the rules a dock area lays its docked tree out by: each panel's limits from `spec`, a dock as wide as
|
||||
/// its columns' natural widths ([`DockSizes::natural`]), and no strip on a canvas alone in its group.
|
||||
pub fn with_area_rules<P, R>(sizes: &DockSizes, spec: &dyn Fn(&P) -> PanelSpec, f: impl FnOnce(FrameRules<'_, P>) -> R) -> R {
|
||||
let limits = |panel: &P| spec(panel).limits;
|
||||
let dock_width = |columns: &[Column<P>]| sizes.natural(columns, spec).iter().map(|(width, _)| *width).sum::<f32>();
|
||||
let stripless = |panel: &P| spec(panel).canvas;
|
||||
f(FrameRules::new(&limits).dock_width(&dock_width).stripless(&stripless))
|
||||
}
|
||||
|
||||
/// The rect the panels `moved` take in `layout`, the layout after a drop, laid out in `room` (the room the dock
|
||||
/// registered, `DockTargets::room`) as the dock lays it out, pruned as the area shows it: the union of the rects of the
|
||||
/// groups that hold them, or the cell of a dock column they make up alone. `None` where one of them lands where the
|
||||
/// layout gives it no rect of its own: hidden, in a collapsed column (icons) or in a stepped column (sized by its
|
||||
/// content as it shows).
|
||||
pub fn placed_rect<P: Clone + Eq + Hash>(layout: &Layout<P>, moved: &[P], room: Rect, placing: &Placing<'_, P>, rtl: bool) -> Option<Rect> {
|
||||
let view = maximize(layout, placing.maximized, placing.hide, placing.protected);
|
||||
let layout: &Layout<P> = &view.layout;
|
||||
let mut rects = Vec::new();
|
||||
match placing.window {
|
||||
Some(id) => {
|
||||
let window = layout.floating.iter().find(|window| window.id == id)?;
|
||||
column_rects(&window.column, room, ColumnBar::Window, placing, moved, &mut rects)?;
|
||||
}
|
||||
None => {
|
||||
let root = layout.root.as_ref()?;
|
||||
let flow = Flow::new(room, rtl);
|
||||
with_area_rules(&placing.sizes, placing.spec, |rules| {
|
||||
for frame in tree::frames(root, room, &placing.sizes, &rules, rtl).groups {
|
||||
match frame.node {
|
||||
Node::Dock { side, columns } => {
|
||||
for (column, cell) in columns.iter().zip(column_cells(columns, frame.rect, *side, flow, &placing.sizes, placing.spec)) {
|
||||
column_rects(column, cell, ColumnBar::Own, placing, moved, &mut rects)?;
|
||||
}
|
||||
}
|
||||
Node::Tabs { panels, .. } if panels.iter().any(|panel| moved.contains(panel)) => rects.push(frame.rect),
|
||||
Node::Stack { entries, .. } if entries.iter().any(|entry| moved.contains(&entry.panel)) => rects.push(frame.rect),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Some(())
|
||||
})?;
|
||||
}
|
||||
}
|
||||
rects.into_iter().reduce(Rect::union)
|
||||
}
|
||||
|
||||
/// Adds the rects the moved panels take in `column` at `cell` to `rects`: the cell when they make up the column, else
|
||||
/// the rects of its groups that hold them. `None` when one lands in a collapsed or stepped column.
|
||||
fn column_rects<P: PartialEq>(
|
||||
column: &Column<P>,
|
||||
cell: Rect,
|
||||
bar: ColumnBar,
|
||||
placing: &Placing<'_, P>,
|
||||
moved: &[P],
|
||||
rects: &mut Vec<Rect>,
|
||||
) -> Option<()> {
|
||||
let moves = |panel: &P| moved.contains(panel);
|
||||
if !column.panels().any(moves) {
|
||||
return Some(());
|
||||
}
|
||||
if column.iconic || stepped(column, placing.spec).is_some() {
|
||||
return None;
|
||||
}
|
||||
if column.panels().all(moves) {
|
||||
rects.push(cell);
|
||||
return Some(());
|
||||
}
|
||||
let groups = column.groups.iter().zip(group_rects(column, placing.spec, cell, bar, &placing.sizes));
|
||||
rects.extend(groups.filter(|(group, _)| group.panels.iter().any(moves)).map(|(_, rect)| rect));
|
||||
Some(())
|
||||
}
|
||||
@@ -8,8 +8,8 @@ use super::{DragUnit, PanelKey, PanelSpec, scale_widths, stepped, width_bounds};
|
||||
use crate::contract::DropMark;
|
||||
use crate::runtime::frame::{self, PassStep, PerViewport, Stamped, Stored};
|
||||
use crate::style::StyleCx;
|
||||
use craft_behavior::DockSide;
|
||||
use craft_behavior::dock::{Action, Column, DockEdge, Layout, Node, ZoneSize, node_at, zones};
|
||||
use craft_behavior::{DockSide, Flow};
|
||||
use egui::{Context, Id, Pos2, Rect, Vec2};
|
||||
|
||||
pub use craft_behavior::dock::{SIDE_ZONE_DEPTH_SHARE, SIDE_ZONE_FRACTION};
|
||||
@@ -268,31 +268,40 @@ impl<P> DockSpot<P> {
|
||||
}
|
||||
}
|
||||
|
||||
/// What the drag ghost paints for a drop on this spot; `None` for [`DockSpot::Blocked`], which takes no drop.
|
||||
/// What the drag ghost paints for a drop on this spot when the dock cannot say where the moved panels land
|
||||
/// (`DockDropTarget::placing`); `None` for [`DockSpot::Blocked`], which takes no drop.
|
||||
///
|
||||
/// `rect` is the rect the spot applies to: the group's rect for [`DockSpot::Group`], whose side marks the half
|
||||
/// of it a docked panel would take (mirrored under `rtl`); the rect it registered with (`DockTargets::register_in`, else its hit rect) for the others. A tab
|
||||
/// insertion marks a line across the hit rect's start edge. A band (edge, seam, column, new dock) marks a line
|
||||
/// along its middle.
|
||||
/// `rect` is the rect the spot applies to: the group's rect for [`DockSpot::Group`]; the rect it registered with
|
||||
/// (`DockTargets::register_in`, else its hit rect) for the others. A group's middle marks the group as the region
|
||||
/// the panels join; a side of it marks a line along that edge of the group (mirrored under `rtl`). A tab insertion
|
||||
/// marks a line across the hit rect's start edge. A band (edge, seam, column, new dock) marks a line along its
|
||||
/// middle.
|
||||
pub fn mark(&self, rect: Rect, rtl: bool) -> Option<DropMark> {
|
||||
let (start, end) = if rtl { (rect.right(), rect.left()) } else { (rect.left(), rect.right()) };
|
||||
let across = |x: f32| DropMark::line(Pos2::new(x, rect.top()), Pos2::new(x, rect.bottom()));
|
||||
let along = |y: f32| DropMark::line(Pos2::new(rect.left(), y), Pos2::new(rect.right(), y));
|
||||
match self {
|
||||
DockSpot::Blocked => None,
|
||||
DockSpot::Group { side: DockSide::Center, .. } => Some(DropMark::Into(rect)),
|
||||
DockSpot::Group { side, .. } => Some(DropMark::Split(Flow::new(rect, rtl).to_physical(side.area(rect)))),
|
||||
DockSpot::Tab { .. } => {
|
||||
let x = if rtl { rect.right() } else { rect.left() };
|
||||
Some(DropMark::line(Pos2::new(x, rect.top()), Pos2::new(x, rect.bottom())))
|
||||
}
|
||||
DockSpot::Group { side, .. } => Some(match side {
|
||||
DockSide::Start => across(start),
|
||||
DockSide::End => across(end),
|
||||
DockSide::Top => along(rect.top()),
|
||||
DockSide::Bottom => along(rect.bottom()),
|
||||
_ => DropMark::region(rect),
|
||||
}),
|
||||
DockSpot::Tab { .. } => self.tab_line(rect, rtl).map(|[from, to]| DropMark::line(from, to)),
|
||||
DockSpot::Edge(_) | DockSpot::Seam { .. } | DockSpot::Column { .. } | DockSpot::NewDock(_) => {
|
||||
let centre = rect.center();
|
||||
Some(if rect.width() <= rect.height() {
|
||||
DropMark::line(Pos2::new(centre.x, rect.top()), Pos2::new(centre.x, rect.bottom()))
|
||||
} else {
|
||||
DropMark::line(Pos2::new(rect.left(), centre.y), Pos2::new(rect.right(), centre.y))
|
||||
})
|
||||
Some(if rect.width() <= rect.height() { across(centre.x) } else { along(centre.y) })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The tab line of a [`DockSpot::Tab`] at `rect`, the rect it registered with: across its start edge.
|
||||
pub(crate) fn tab_line(&self, rect: Rect, rtl: bool) -> Option<[Pos2; 2]> {
|
||||
let x = if rtl { rect.right() } else { rect.left() };
|
||||
matches!(self, DockSpot::Tab { .. }).then(|| [Pos2::new(x, rect.top()), Pos2::new(x, rect.bottom())])
|
||||
}
|
||||
}
|
||||
|
||||
/// How a group's body divides into side zones.
|
||||
@@ -326,15 +335,17 @@ struct Target<P> {
|
||||
applies: Rect,
|
||||
}
|
||||
|
||||
/// The spots of one dock in one pass with their hit rects. Spots are added back to front.
|
||||
/// The spots of one dock in one pass with their hit rects, and the room the dock laid its panels out in. Spots are
|
||||
/// added back to front.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct DockTargets<P> {
|
||||
targets: Vec<Target<P>>,
|
||||
room: Option<Rect>,
|
||||
}
|
||||
|
||||
impl<P> Default for DockTargets<P> {
|
||||
fn default() -> Self {
|
||||
DockTargets { targets: Vec::new() }
|
||||
DockTargets { targets: Vec::new(), room: None }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -414,6 +425,21 @@ impl<P: Clone + Send + 'static> DockTargets<P> {
|
||||
if !crate::runtime::measure::effect(ctx, "dock::register_target") {
|
||||
return;
|
||||
}
|
||||
Self::with_dock(ctx, dock, |targets| targets.add(spot, hit, applies));
|
||||
}
|
||||
|
||||
/// Registers `room`, the rect the dock `dock` lays its panels out in this pass: the docked tree's rect for a dock
|
||||
/// area, the column's rect for a floating window. A drop's mark lays the panels out in it as they land
|
||||
/// ([`placed_rect`](super::placed_rect)).
|
||||
pub fn register_room(ctx: &Context, dock: Id, room: Rect) {
|
||||
if !crate::runtime::measure::effect(ctx, "dock::register_room") {
|
||||
return;
|
||||
}
|
||||
Self::with_dock(ctx, dock, |targets| targets.room = Some(room));
|
||||
}
|
||||
|
||||
/// Runs `f` on the registry of `dock` in the running pass, made empty the first time.
|
||||
fn with_dock(ctx: &Context, dock: Id, f: impl FnOnce(&mut DockTargets<P>)) {
|
||||
Self::with_pass(ctx, |pass| {
|
||||
let at = match pass.now.iter().position(|(id, _)| *id == dock) {
|
||||
Some(at) => at,
|
||||
@@ -422,10 +448,16 @@ impl<P: Clone + Send + 'static> DockTargets<P> {
|
||||
pass.now.len() - 1
|
||||
}
|
||||
};
|
||||
pass.now[at].1.add(spot, hit, applies);
|
||||
f(&mut pass.now[at].1);
|
||||
});
|
||||
}
|
||||
|
||||
/// The room the dock `dock` laid its panels out in the previous pass ([`Self::register_room`]); `None` outside a
|
||||
/// pass and where the dock registered none.
|
||||
pub fn room(ctx: &Context, dock: Id) -> Option<Rect> {
|
||||
Self::with_pass(ctx, |pass| pass.before.iter().find(|(id, _)| *id == dock).and_then(|(_, targets)| targets.room)).flatten()
|
||||
}
|
||||
|
||||
/// The spot a drop at `at` lands on in the dock `dock`, by the spots of the previous pass, with the rect its
|
||||
/// mark applies to (`DockSpot::mark` takes it); `None` outside a pass.
|
||||
///
|
||||
|
||||
@@ -8,13 +8,12 @@ use crate::contract::{
|
||||
};
|
||||
use crate::docking::SplitFramesCx as _;
|
||||
use crate::docking::stack::{StackSection, StackSections, section_heights};
|
||||
use crate::docking::tree::FrameRules;
|
||||
use crate::docking::{Arrangement, close_requests, cross_window, end_replaced_drags, float_drop, native, open_requests};
|
||||
use crate::docking::{
|
||||
ColumnArrow, ColumnBar, DockColumn, DockCommands, DockConfig, DockDropTarget, DockDropped, DockEvent, DockGroup, DockPanels, DockRoot, DockScene,
|
||||
DockSizes, DockSpot, DockTargets, DockTo, DockWords, DragUnit, FloatSpace, FloatingGroup, FlyoutResize, GroupAt, GroupDrag, HidePanels,
|
||||
IconicColumn, IconicSizes, PanelDrag, PanelKey, PanelSpec, PanelTitle, SplitArea, WindowColumn, actions, dock_states, fit_widths, frame,
|
||||
move_actions, stepped,
|
||||
IconicColumn, IconicSizes, PanelDrag, PanelKey, PanelSpec, PanelTitle, Placing, SplitArea, WindowColumn, actions, column_cells, dock_states,
|
||||
frame, move_actions, stepped, with_area_rules,
|
||||
};
|
||||
use crate::menu::{GroupItem, MenuWords, PanelMenu, PanelRow};
|
||||
use crate::runtime::commands::{CommandRef, CommandSet as _, Commands as _, focus_within};
|
||||
@@ -185,13 +184,16 @@ impl<P> Default for AreaMemory<P> {
|
||||
}
|
||||
}
|
||||
|
||||
/// What the root's drop taker reads: the dock, the layout it shows, the rights and where a floating drop lands.
|
||||
/// What the root's drop taker reads: the dock, the layout it shows, the rights, where a floating drop lands and what
|
||||
/// the host hides.
|
||||
struct Drops<'a, P> {
|
||||
dock: Id,
|
||||
layout: &'a Layout<P>,
|
||||
permissions: &'a dyn Fn(&P) -> Permissions,
|
||||
config: &'a DockConfig,
|
||||
specs: &'a HashMap<P, PanelSpec>,
|
||||
hide: HidePanels<'a, P>,
|
||||
maximized: Option<&'a P>,
|
||||
rtl: bool,
|
||||
}
|
||||
|
||||
@@ -200,13 +202,18 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Drops<'_, P> {
|
||||
fn take(&self, cx: &mut Cx<'_, DockRoot<'_, DockDropped<P>>>) -> Option<DockDropped<P>> {
|
||||
let ctx = cx.core.ctx.clone();
|
||||
let sizes = *cx.style.sizes();
|
||||
let bounds = cx.env.get::<ShellEntry>().0.as_ref().map_or(cx.rect, ShellCx::float_bounds);
|
||||
let shell = cx.env.get::<ShellEntry>().0;
|
||||
let bounds = shell.as_ref().map_or(cx.rect, ShellCx::float_bounds);
|
||||
let space = float_space(bounds, &sizes, self.config, self.specs);
|
||||
let spec = |panel: &P| spec_in(self.specs, panel);
|
||||
let protected = |panel: &P| (self.permissions)(panel).is_protected();
|
||||
let (hide, _) = hide::resolved(self.hide, shell.as_ref());
|
||||
let mut target = DockDropTarget::new(&ctx, self.dock, self.layout, self.permissions);
|
||||
target.rtl = self.rtl;
|
||||
target.space = Some(&space);
|
||||
target.float_on_empty = self.config.float_on_empty_drop;
|
||||
target.title_bar_docks = self.config.title_bar_docks;
|
||||
target.placing = Some(Placing::new(sizes, &spec, &protected).shown(hide, self.maximized));
|
||||
cx.drop_target::<GroupDrag<P>, _>(&target).or_else(|| cx.drop_target::<PanelDrag, _>(&target))
|
||||
}
|
||||
}
|
||||
@@ -242,9 +249,14 @@ struct Scene<'s, P> {
|
||||
floated: &'s [(P, Location<P>)],
|
||||
}
|
||||
|
||||
/// The spec of `panel` in `specs`, or an unnamed one.
|
||||
fn spec_in<P: Eq + Hash>(specs: &HashMap<P, PanelSpec>, panel: &P) -> PanelSpec {
|
||||
specs.get(panel).cloned().unwrap_or_else(|| PanelSpec::new(Label::default()))
|
||||
}
|
||||
|
||||
impl<P: Clone + Eq + Hash> Scene<'_, P> {
|
||||
fn spec(&self, panel: &P) -> PanelSpec {
|
||||
self.specs.get(panel).cloned().unwrap_or_else(|| PanelSpec::new(Label::default()))
|
||||
spec_in(self.specs, panel)
|
||||
}
|
||||
|
||||
fn permissions(&self, panel: &P) -> Permissions {
|
||||
@@ -352,7 +364,16 @@ impl<'a, P: Clone + Eq + Hash + Debug + Send + Sync + 'static> DockArea<'a, P> {
|
||||
.collect();
|
||||
let policy = |panel: &P| rights.get(panel).copied().unwrap_or(Permissions::ALL);
|
||||
let specs: HashMap<P, PanelSpec> = current.layout.panels().into_iter().map(|panel| (panel.clone(), panels.spec(panel))).collect();
|
||||
let drops = Drops { dock: id, layout: ¤t.layout, permissions: &policy, config: &config, specs: &specs, rtl };
|
||||
let drops = Drops {
|
||||
dock: id,
|
||||
layout: ¤t.layout,
|
||||
permissions: &policy,
|
||||
config: &config,
|
||||
specs: &specs,
|
||||
hide,
|
||||
maximized: maximized.as_ref(),
|
||||
rtl,
|
||||
};
|
||||
let shows = Arrangement { dock: id, revision: current.revision() };
|
||||
end_replaced_drags::<P>(&ctx, shows);
|
||||
let dropped: RefCell<Option<Action<P>>> = RefCell::new(None);
|
||||
@@ -542,31 +563,30 @@ fn show_area<P: Clone + Eq + Hash + Debug + Send + Sync + 'static>(
|
||||
};
|
||||
|
||||
let spec_of = |panel: &P| scene.spec(panel);
|
||||
let limits = |panel: &P| scene.spec(panel).limits;
|
||||
let dock_width = |columns: &[Column<P>]| scene.sizes.natural(columns, &spec_of).iter().map(|(width, _)| *width).sum::<f32>();
|
||||
let stripless = |panel: &P| scene.spec(panel).canvas;
|
||||
let rules = FrameRules::new(&limits).dock_width(&dock_width).stripless(&stripless);
|
||||
let label = Label::from(body.words::<DockWords>().panels.as_str().to_owned());
|
||||
let mut leaves: Vec<(Vec<bool>, Rect)> = Vec::new();
|
||||
let area = SplitArea::new(label, Bind::given(layout.clone()), rules).show(ui, |ui, split| {
|
||||
for (anchor, rect) in split.group_frames::<P>() {
|
||||
let Some(place) = scene.layout.place(&anchor) else { continue };
|
||||
let Some(node) = scene.layout.node_of(&place) else { continue };
|
||||
if let PanelPlace::Node(path) = &place {
|
||||
let area = with_area_rules(&scene.sizes, &spec_of, |rules| {
|
||||
SplitArea::new(label, Bind::given(layout.clone()), rules).show(ui, |ui, split| {
|
||||
DockTargets::<P>::register_room(ctx, id, split.rect);
|
||||
for (anchor, rect) in split.group_frames::<P>() {
|
||||
let Some(place) = scene.layout.place(&anchor) else { continue };
|
||||
let Some(node) = scene.layout.node_of(&place) else { continue };
|
||||
if let PanelPlace::Node(path) = &place {
|
||||
leaves.push((path.clone(), rect));
|
||||
}
|
||||
pass.leaf(ui, split, node, rect);
|
||||
}
|
||||
let flow = Flow::new(split.rect, rtl);
|
||||
for (edge, rect) in split.dock_frames() {
|
||||
let Some(path) = scene.layout.dock_path(edge) else { continue };
|
||||
let Some(Node::Dock { columns, .. }) = scene.layout.root.as_ref().and_then(|root| node_at(root, &path)) else { continue };
|
||||
leaves.push((path.clone(), rect));
|
||||
if let Some(shell) = shell.as_ref().filter(|shell| shell.revealed() && crate::runtime::measure::effect(ctx, "shell::reveal_rect")) {
|
||||
shell.reveal_rect(if edge == DockEdge::Start { RevealEdge::Start } else { RevealEdge::End }, rect);
|
||||
}
|
||||
pass.dock(ui, split, DockPlan { edge, columns, rect, flow, open: open.clone() });
|
||||
}
|
||||
pass.leaf(ui, split, node, rect);
|
||||
}
|
||||
let flow = Flow::new(split.rect, rtl);
|
||||
for (edge, rect) in split.dock_frames() {
|
||||
let Some(path) = scene.layout.dock_path(edge) else { continue };
|
||||
let Some(Node::Dock { columns, .. }) = scene.layout.root.as_ref().and_then(|root| node_at(root, &path)) else { continue };
|
||||
leaves.push((path.clone(), rect));
|
||||
if let Some(shell) = shell.as_ref().filter(|shell| shell.revealed() && crate::runtime::measure::effect(ctx, "shell::reveal_rect")) {
|
||||
shell.reveal_rect(if edge == DockEdge::Start { RevealEdge::Start } else { RevealEdge::End }, rect);
|
||||
}
|
||||
pass.dock(ui, split, DockPlan { edge, columns, rect, flow, open: open.clone() });
|
||||
}
|
||||
})
|
||||
});
|
||||
let mut edit = area.output.edit.events.map(|edited| {
|
||||
let mut next = current.clone();
|
||||
@@ -922,14 +942,8 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Pass<'_, P> {
|
||||
fn dock(&mut self, ui: &mut Ui, body: &mut BodyCx<'_>, plan: DockPlan<'_, P>) {
|
||||
let scene = self.scene;
|
||||
let spec = |panel: &P| scene.spec(panel);
|
||||
let widths = fit_widths(&scene.sizes.natural(plan.columns, &spec), plan.rect.width());
|
||||
let reading = plan.flow.to_physical(plan.rect);
|
||||
let start = plan.edge == DockEdge::Start;
|
||||
let mut cursor = if start { reading.left() } else { reading.right() };
|
||||
for (column, width) in plan.columns.iter().zip(widths) {
|
||||
let span = if start { (cursor, cursor + width) } else { (cursor - width, cursor) };
|
||||
cursor = if start { span.1 } else { span.0 };
|
||||
let mut cell = plan.flow.to_physical(Rect::from_x_y_ranges(span.0..=span.1, reading.y_range()));
|
||||
let cells = column_cells(plan.columns, plan.rect, plan.edge, plan.flow, &scene.sizes, &spec);
|
||||
for (column, mut cell) in plan.columns.iter().zip(cells) {
|
||||
let Some(first) = column.groups.first().and_then(|group| group.panels.first()) else { continue };
|
||||
// A stepped column is as tall as its bar and content, from the top of the dock; content taller than the
|
||||
// dock gets the dock's height and scrolls inside. The rest of its slot is the dock's empty room.
|
||||
@@ -1031,6 +1045,9 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Pass<'_, P> {
|
||||
let dock = self.dock;
|
||||
let ColumnAt { cell, edge, bar, within, open } = at;
|
||||
let in_window = bar == ColumnBar::Window;
|
||||
if in_window {
|
||||
DockTargets::<P>::register_room(ui.ctx(), dock, cell);
|
||||
}
|
||||
let opens = if edge == DockEdge::Start { Side::End } else { Side::Start };
|
||||
let work = if column.iconic {
|
||||
let output = IconicColumn::new(name, dock, column, Bind::given(open), &spec)
|
||||
@@ -1132,6 +1149,7 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Pass<'_, P> {
|
||||
let scene = self.scene;
|
||||
let ctx = ui.ctx().clone();
|
||||
let policy = |panel: &P| scene.permissions(panel);
|
||||
let protected = |panel: &P| scene.permissions(panel).is_protected();
|
||||
let spec_of = |panel: &P| scene.spec(panel);
|
||||
let mut moved = None;
|
||||
for window in &scene.layout.floating {
|
||||
@@ -1158,6 +1176,8 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Pass<'_, P> {
|
||||
target.space = Some(scene.space);
|
||||
target.float_on_empty = scene.config.float_on_empty_drop;
|
||||
target.title_bar_docks = scene.config.title_bar_docks;
|
||||
// The scene's layout is the pruned view the windows show, so the placing hides nothing more.
|
||||
target.placing = Some(Placing::new(scene.sizes, &spec_of, &protected).window(window.id));
|
||||
// The window is an instance of the group scope: its menu's command rows reach it, and run on its active
|
||||
// panel through the same path as a docked group's.
|
||||
let states = dock_states(&DockScene::new(scene.layout, scene.space, false, &policy).floated(scene.floated), &active);
|
||||
|
||||
@@ -27,10 +27,16 @@ pub(super) fn shown<'a, P: Clone + Eq + Hash>(
|
||||
shell: Option<&ShellCx>,
|
||||
protected: &dyn Fn(&P) -> bool,
|
||||
) -> Shown<'a, P> {
|
||||
let (hide, floating) = match shell {
|
||||
let (hide, floating) = resolved(hide, shell);
|
||||
Shown { view: maximize(layout, maximized, hide, protected), floating }
|
||||
}
|
||||
|
||||
/// The panels the area hides, the host's `hide` with the shell's panel visibility applied, and whether floating windows
|
||||
/// show (see [`shown`]).
|
||||
pub(super) fn resolved<'h, P>(hide: HidePanels<'h, P>, shell: Option<&ShellCx>) -> (HidePanels<'h, P>, bool) {
|
||||
match shell {
|
||||
None => (hide, true),
|
||||
Some(shell) if shell.panels_hidden() => (if let HidePanels::Except(keep) = hide { HidePanels::Except(keep) } else { HidePanels::All }, true),
|
||||
Some(shell) => (if shell.dock_visible() { hide } else { HidePanels::All }, shell.floating_visible()),
|
||||
};
|
||||
Shown { view: maximize(layout, maximized, hide, protected), floating }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
//! A dock drop's mark is the region the dragged panel takes once dropped: the rect the area then gives its group.
|
||||
|
||||
use craft_behavior::Axis;
|
||||
use craft_behavior::dock::{Layout, Node, SplitSize, Workspace};
|
||||
use craft_ui::contract::{Bind, BodyCx, Role};
|
||||
use craft_ui::docking::{DockConfig, DockPanels, GroupAt, PanelSpec};
|
||||
use craft_ui::patterns::dock::DockArea;
|
||||
use craft_ui::runtime::drag::{self, DropMark};
|
||||
use craft_ui::testing::pointer::{moved, press, release};
|
||||
use craft_ui::testing::{Fixture, trial};
|
||||
use egui::{Pos2, Rect, Ui, Vec2};
|
||||
use std::cell::RefCell;
|
||||
use std::collections::HashMap;
|
||||
use std::rc::Rc;
|
||||
|
||||
const ROOM: Vec2 = Vec2::new(800.0, 500.0);
|
||||
const SLACK: f32 = 0.5;
|
||||
|
||||
/// Each group's rect as the area last showed it, by the group's panels.
|
||||
type Shown = Rc<RefCell<HashMap<Vec<usize>, Rect>>>;
|
||||
|
||||
/// Records the rect of every group the area shows and leaves the group to the dock.
|
||||
struct Panels {
|
||||
shown: Shown,
|
||||
}
|
||||
|
||||
impl DockPanels<usize> for Panels {
|
||||
fn spec(&self, panel: &usize) -> PanelSpec {
|
||||
PanelSpec::new(format!("Panel {panel}"))
|
||||
}
|
||||
|
||||
fn body(&mut self, _: &usize, _: &mut Ui, _: &mut BodyCx<'_>) {}
|
||||
|
||||
fn group_view(&mut self, panels: &[usize], _: usize, _: &mut Ui, at: GroupAt, _: &mut BodyCx<'_>) -> Option<f32> {
|
||||
if let GroupAt::Show(rect) = at {
|
||||
self.shown.borrow_mut().insert(panels.to_vec(), rect);
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
struct Bed {
|
||||
fixture: Fixture,
|
||||
workspace: Rc<RefCell<Workspace<usize>>>,
|
||||
shown: Shown,
|
||||
}
|
||||
|
||||
/// `[1, 2]` beside `[3]`.
|
||||
fn bed() -> Bed {
|
||||
let root = Node::split(Axis::X, SplitSize::Ratio(0.5), Node::tabs(vec![1, 2], 0), Node::tabs(vec![3], 0));
|
||||
let workspace = Rc::new(RefCell::new(Workspace::new(Layout::new(Some(root), Vec::new()))));
|
||||
let shown: Shown = Rc::default();
|
||||
let (held, seen) = (Rc::clone(&workspace), Rc::clone(&shown));
|
||||
let mut fixture = Fixture::new(move |ui| {
|
||||
let mut workspace = held.borrow().clone();
|
||||
let mut panels = Panels { shown: Rc::clone(&seen) };
|
||||
DockArea::new("Dock", Bind::bound(&mut workspace), &mut panels, DockConfig::default()).show(ui);
|
||||
*held.borrow_mut() = workspace;
|
||||
});
|
||||
fixture.room(ROOM).settle();
|
||||
Bed { fixture, workspace, shown }
|
||||
}
|
||||
|
||||
fn tab(bed: &Bed, panel: usize) -> Rect {
|
||||
let tree = bed.fixture.tree();
|
||||
let name = format!("Panel {panel}");
|
||||
bed.fixture
|
||||
.by_role(Role::TAB)
|
||||
.into_iter()
|
||||
.find(|tab| craft_ui::testing::access::name(tree, tab.node) == Some(name.as_str()))
|
||||
.map(|tab| tab.rect)
|
||||
.unwrap_or_else(|| panic!("the tab of panel {panel} shows"))
|
||||
}
|
||||
|
||||
/// Drags the tab of `panel` to `to` and returns the mark shown there, then releases it.
|
||||
fn drop_tab(bed: &mut Bed, panel: usize, to: Pos2) -> DropMark {
|
||||
let from = tab(bed, panel).center();
|
||||
bed.fixture.frame(vec![moved(from)]);
|
||||
bed.fixture.frame(vec![press(from)]);
|
||||
for step in 1..=4 {
|
||||
bed.fixture.frame(vec![moved(from + (to - from) * (step as f32 / 4.0))]);
|
||||
}
|
||||
bed.fixture.frame(Vec::new());
|
||||
let mark = drag::mark(bed.fixture.ctx()).expect("the dock takes the drop");
|
||||
bed.fixture.frame(vec![release(to)]);
|
||||
bed.fixture.settle();
|
||||
mark
|
||||
}
|
||||
|
||||
/// The rect the area shows the group of `panel` in.
|
||||
fn group_rect(bed: &Bed, panel: usize) -> Rect {
|
||||
let layout = bed.workspace.borrow().layout.clone();
|
||||
let place = layout.place(&panel).expect("the panel is docked");
|
||||
let Some(Node::Tabs { panels, .. }) = layout.node_of(&place) else { panic!("panel {panel} is in a tab group") };
|
||||
*bed.shown.borrow().get(panels).unwrap_or_else(|| panic!("the group {panels:?} was shown"))
|
||||
}
|
||||
|
||||
fn same(a: Rect, b: Rect) -> bool {
|
||||
(a.min - b.min).length() <= SLACK && (a.max - b.max).length() <= SLACK
|
||||
}
|
||||
|
||||
#[trial]
|
||||
fn a_tab_dropped_beside_a_group_marks_the_rect_its_group_takes() {
|
||||
let mut bed = bed();
|
||||
let right = group_rect(&bed, 3);
|
||||
// In the bottom third of the right group's body, clear of the layout's bottom edge band.
|
||||
let to = Pos2::new(right.center().x, right.bottom() - right.height() * 0.2);
|
||||
let mark = drop_tab(&mut bed, 2, to);
|
||||
let DropMark::Region { area, line: None, .. } = mark else { panic!("a side drop marks a region without a line: {mark:?}") };
|
||||
let placed = group_rect(&bed, 2);
|
||||
assert!(placed.top() > right.top(), "the tab went below the right group: {placed:?}");
|
||||
assert!(same(area, placed), "the mark {area:?} is the rect the dropped panel's group took: {placed:?}");
|
||||
}
|
||||
|
||||
#[trial]
|
||||
fn a_tab_joining_a_group_marks_the_group_and_its_tab_line_and_a_reorder_marks_the_line_only() {
|
||||
let mut bed = bed();
|
||||
let target = tab(&bed, 3);
|
||||
let mark = drop_tab(&mut bed, 2, Pos2::new(target.right() + 20.0, target.center().y));
|
||||
let DropMark::Region { area, line: Some(_), .. } = mark else { panic!("a tab join marks a region with its tab line: {mark:?}") };
|
||||
let joined = group_rect(&bed, 2);
|
||||
assert_eq!(joined, group_rect(&bed, 3), "the tab joined the right group");
|
||||
assert!(same(area, joined), "the mark {area:?} is the rect of the group it joined: {joined:?}");
|
||||
|
||||
let after = tab(&bed, 2);
|
||||
let mark = drop_tab(&mut bed, 3, Pos2::new(after.right() + 10.0, after.center().y));
|
||||
assert!(matches!(mark, DropMark::Line { .. }), "a reorder inside its own strip marks its line only: {mark:?}");
|
||||
}
|
||||
@@ -133,7 +133,7 @@ fn a_tab_dragged_over_a_floating_window_marks_and_joins_the_window() {
|
||||
let mark = drag::mark(bed.fixture.ctx()).expect("the window takes the drop");
|
||||
let points = match mark {
|
||||
DropMark::Line { from, to, .. } => vec![from, to],
|
||||
DropMark::Into(rect) | DropMark::Split(rect) => vec![rect.center()],
|
||||
DropMark::Into(rect) | DropMark::Region { area: rect, .. } => vec![rect.center()],
|
||||
_ => Vec::new(),
|
||||
};
|
||||
assert!(!points.is_empty() && points.iter().all(|point| WINDOW_AT.expand(SLACK).contains(*point)), "the mark is the window's: {mark:?}");
|
||||
@@ -481,7 +481,7 @@ fn a_drag_over_a_floating_window_joins_or_stacks_and_never_splits() {
|
||||
press_and_move(&mut expanded.fixture, tab.center(), side - tab.center());
|
||||
expanded.fixture.frame(Vec::new());
|
||||
let mark = drag::mark(expanded.fixture.ctx()).expect("the window takes the drop");
|
||||
assert!(matches!(mark, DropMark::Into(_)), "the start side of a floating group joins it: {mark:?}");
|
||||
assert!(matches!(mark, DropMark::Region { .. }), "the start side of a floating group joins it: {mark:?}");
|
||||
expanded.fixture.frame(vec![release(side)]).settle();
|
||||
|
||||
let mut window = Floating::single(vec![WINDOW], 0, WINDOW_AT);
|
||||
|
||||
@@ -12,6 +12,7 @@ mod runs;
|
||||
mod split;
|
||||
|
||||
mod drop;
|
||||
mod drop_preview;
|
||||
mod drop_session;
|
||||
|
||||
mod floating;
|
||||
|
||||
Reference in New Issue
Block a user