From b572143761020719c39bd8b77b58eaab620af62c Mon Sep 17 00:00:00 2001 From: David Mann Date: Sat, 21 Nov 2026 23:02:39 +0100 Subject: [PATCH 1/3] WIP: Docking: grips as the reference's upright ticks; a grip under the toolbar's header (photocraft#16332, photocraft#16333) From 9597f188d5fe9ddbe6ba034180568eaaae140368 Mon Sep 17 00:00:00 2001 From: David Mann Date: Sat, 21 Nov 2026 23:32:24 +0100 Subject: [PATCH 2/3] Docking: grips are the reference's upright ticks; a tool rail gets a grip under its column bar (photocraft#16332, photocraft#16333) The grip above each icon group of a collapsed column was a dotted hairline in a lighter ink than the panel (7bf0a9b6d, e5e007233). The reference application draws its dock grips as ten upright ticks, one point wide, four tall and one apart, a little darker than the panel in every interface colour, the same under the pointer. `GripMarks` paints that row, through the new `Rule::ticks` (the dotted rule is now its square case) and `Draw::grip_ticks` (exactly `count` marks at every scale). A tool rail the host shows itself (a panel with a `DockGrid`, taken by `group_view`) now gets a grip strip of `DockSizes::grip` on top, under its column bar: a `GroupGrip` with the ticks, whose drag moves the rail's group. The host's view gets the room under it, and the group measures the strip on top of the view's height. Co-Authored-By: Claude Opus 5.5 --- crates/ui-contract/src/primitives/draw.rs | 20 +++- crates/ui-contract/src/primitives/rule.rs | 33 +++++-- crates/ui-contract/tests/it/paint/painters.rs | 43 +++++++++ crates/ui-panels/src/docking/group.rs | 62 +++++++++++- crates/ui-panels/src/docking/iconic.rs | 37 ++------ crates/ui-panels/src/docking/iconic/trials.rs | 54 +++++++++++ crates/ui-panels/src/docking/targets.rs | 5 + crates/ui-patterns/src/patterns/dock/area.rs | 46 +++++++-- .../tests/it/docking/group_view.rs | 95 ++++++++++++++++++- docs/contract-api.md | 5 +- 10 files changed, 341 insertions(+), 59 deletions(-) diff --git a/crates/ui-contract/src/primitives/draw.rs b/crates/ui-contract/src/primitives/draw.rs index ae2716b40..1e976bd76 100644 --- a/crates/ui-contract/src/primitives/draw.rs +++ b/crates/ui-contract/src/primitives/draw.rs @@ -495,11 +495,29 @@ impl<'a> Draw<'a> { self.painter.extend(super::rule::Rule::shapes(look, from, to, self.painter.pixels_per_point())); } - /// Paints the line `look` from `from` to `to` as dots `gap` points apart (`Rule::dotted`): a grip's dotted line. + /// Paints the line `look` from `from` to `to` as dots `gap` points apart (`Rule::dotted`): a dotted line. pub fn dotted_rule_with(&self, look: &crate::style::RuleLook, from: Pos2, to: Pos2, gap: f32) { self.painter.extend(super::rule::Rule::dotted(look, from, to, gap, self.painter.pixels_per_point())); } + /// Paints the line `look` from `from` to `to` as ticks `across` points long, `gap` points apart (`Rule::ticks`): + /// a grip's row of marks. + pub fn ticked_rule_with(&self, look: &crate::style::RuleLook, from: Pos2, to: Pos2, gap: f32, across: f32) { + self.painter.extend(super::rule::Rule::ticks(look, from, to, gap, across, self.painter.pixels_per_point())); + } + + /// Paints `count` upright ticks of `look` centred on `centre`, side by side on a level line, `gap` points apart and + /// `across` points tall (`Rule::ticks`): a grip's row of marks, `count` of them at every display scale. + pub fn grip_ticks(&self, look: &crate::style::RuleLook, centre: Pos2, count: u16, gap: f32, across: f32) { + let ppp = self.painter.pixels_per_point().max(f32::EPSILON); + let (side, gap_px) = (look.width.pixels(ppp), (gap * ppp).round().max(1.0)); + // The run `Rule::ticks` fits exactly `count` marks into: their sides, the gaps between them and the one free + // pixel it keeps. + let length = f32::from(count) * side + f32::from(count.saturating_sub(1)) * gap_px + 1.0; + let half = egui::vec2(length / ppp / 2.0, 0.0); + self.ticked_rule_with(look, centre - half, centre + half, gap, across); + } + /// Paints a surface of `kind` (tracks, plot wells). pub fn surface(&self, rect: Rect, kind: SurfaceKind, corners: Corners) { let style = surface_style(self.env.tokens, kind); diff --git a/crates/ui-contract/src/primitives/rule.rs b/crates/ui-contract/src/primitives/rule.rs index 3cf908347..bc279c12b 100644 --- a/crates/ui-contract/src/primitives/rule.rs +++ b/crates/ui-contract/src/primitives/rule.rs @@ -70,30 +70,45 @@ impl Rule { } /// The dotted form of the line from `from` to `to`: square dots as wide as the line, `gap` points apart, the run - /// of whole dots centred between the ends (a grip, a dotted guide or grid line). The gap is whole physical pixels, - /// at least one, and each dot's centre is snapped on both axes by the rule `shapes` snaps across with, so every dot - /// covers whole physical pixels and dots on a level or upright line are evenly spaced. The dots are one mesh. + /// of whole dots centred between the ends (a dotted guide or grid line). The gap is whole physical pixels, at least + /// one, and each dot's centre is snapped on both axes by the rule `shapes` snaps across with, so every dot covers + /// whole physical pixels and dots on a level or upright line are evenly spaced. The dots are one mesh. pub fn dotted(look: &RuleLook, from: Pos2, to: Pos2, gap: f32, pixels_per_point: f32) -> Vec { + let side = look.width.points(pixels_per_point); + Self::ticks(look, from, to, gap, side, pixels_per_point) + } + + /// The line from `from` to `to` as a run of ticks: marks as wide as the line along it and `across` points long + /// across it, `gap` points apart, the run of whole marks centred between the ends (a grip's row of upright ticks). + /// With `across` the line's width the marks are the square dots of [`dotted`](Self::dotted). The gap and both + /// sides of a mark are whole physical pixels, at least one, and each mark's centre is snapped on both axes, so every + /// mark covers whole physical pixels. A mark stands across a level line and lies across an upright one; a slanted + /// line takes the level form. The marks are one mesh. + pub fn ticks(look: &RuleLook, from: Pos2, to: Pos2, gap: f32, across: f32, pixels_per_point: f32) -> Vec { let ppp = pixels_per_point.max(f32::EPSILON); let side = look.width.pixels(ppp); + let long = (across * ppp).round().max(1.0); let gap = (gap * ppp).round().max(1.0); let length = (to - from).length() * ppp; - // The run leaves at least a physical pixel of the line free, so snapping, which moves a dot at most half a - // pixel, keeps every dot between the ends. + // The run leaves at least a physical pixel of the line free, so snapping, which moves a mark at most half a + // pixel, keeps every mark between the ends. let count = ((length - 1.0 + gap) / (side + gap)).floor(); if !count.is_finite() || count < 1.0 { return Vec::new(); } let direction = (to - from).normalized(); + let level = direction.x.abs() >= direction.y.abs(); + // The mark's physical size on the x and y axes. + let (wide, tall) = if level { (side, long) } else { (long, side) }; let first = (length - (count * side + (count - 1.0) * gap)) / 2.0 + side / 2.0; - let dot = Vec2::splat(side / ppp); + let mark = Vec2::new(wide / ppp, tall / ppp); // One mesh of plain quads: a filled rect two pixels wide or less is tessellated as a line segment, whose ends - // the tessellator rounds inward, and a one-pixel dot drawn that way vanishes. + // the tessellator rounds inward, and a one-pixel mark drawn that way vanishes. let mut mesh = Mesh::default(); for i in 0..count as usize { let centre = from + direction * ((first + i as f32 * (side + gap)) / ppp); - let centre = Pos2::new(snap(centre.x, side, ppp), snap(centre.y, side, ppp)); - mesh.add_colored_rect(Rect::from_center_size(centre, dot), look.color); + let centre = Pos2::new(snap(centre.x, wide, ppp), snap(centre.y, tall, ppp)); + mesh.add_colored_rect(Rect::from_center_size(centre, mark), look.color); } vec![Shape::mesh(mesh)] } diff --git a/crates/ui-contract/tests/it/paint/painters.rs b/crates/ui-contract/tests/it/paint/painters.rs index 84b652ccb..a779e5853 100644 --- a/crates/ui-contract/tests/it/paint/painters.rs +++ b/crates/ui-contract/tests/it/paint/painters.rs @@ -169,6 +169,49 @@ fn a_dotted_rule_is_whole_pixel_dots_at_one_pitch_between_its_ends() { } } +#[trial] +fn ticks_stand_across_a_level_rule_and_lie_across_an_upright_one() { + use craft_ui::primitives::Rule; + use craft_ui::style::{RuleLook, RuleWidth}; + use egui::{Color32, Rect, Shape}; + + let whole = |v: f32| (v - v.round()).abs() < EPS; + for ppp in [1.0, 1.25, 1.5, 2.0] { + let look = RuleLook { color: Color32::WHITE, width: RuleWidth::Points(1.0) }; + let side = look.width.points(ppp); + let long = (4.0 * ppp).round() / ppp; + for (from, to) in [(pos2(10.3, 20.6), pos2(31.1, 20.6)), (pos2(7.7, 3.2), pos2(7.7, 24.9))] { + let shapes = Rule::ticks(&look, from, to, 1.0, 4.0, ppp); + let [Shape::Mesh(mesh)] = shapes.as_slice() else { panic!("the ticks are one mesh") }; + let ticks: Vec = mesh.vertices.chunks(4).map(|quad| Rect::from_points(&quad.iter().map(|v| v.pos).collect::>())).collect(); + assert!(ticks.len() > 2, "at {ppp}x: several ticks"); + let level = from.y == to.y; + for tick in &ticks { + let px = *tick * ppp; + assert!([px.min.x, px.min.y, px.max.x, px.max.y].into_iter().all(whole), "at {ppp}x: {px:?} is not whole pixels"); + let (along, across) = if level { (tick.width(), tick.height()) } else { (tick.height(), tick.width()) }; + assert!((along - side).abs() < EPS && (across - long).abs() < EPS, "at {ppp}x: {tick:?} is {side} along, {long} across"); + } + let starts: Vec = ticks.iter().map(|tick| if level { tick.min.x } else { tick.min.y }).collect(); + assert!(starts.windows(2).all(|w| w[1] - w[0] > side + EPS), "at {ppp}x: ticks are apart: {starts:?}"); + } + } +} + +#[trial] +fn a_dotted_rule_is_the_ticks_as_long_as_the_line_is_wide() { + use craft_ui::primitives::Rule; + use craft_ui::style::{RuleLook, RuleWidth}; + use egui::Color32; + + for ppp in [1.0, 1.5, 2.0] { + let look = RuleLook { color: Color32::WHITE, width: RuleWidth::Points(1.0) }; + let (from, to) = (pos2(10.3, 20.6), pos2(41.1, 20.6)); + let across = look.width.points(ppp); + assert_eq!(Rule::dotted(&look, from, to, 2.0, ppp), Rule::ticks(&look, from, to, 2.0, across, ppp), "at {ppp}x"); + } +} + #[trial] fn ant_edges_are_whole_device_pixels_at_a_fractional_scale() { use craft_theme::{Contrast, Mode}; diff --git a/crates/ui-panels/src/docking/group.rs b/crates/ui-panels/src/docking/group.rs index 237c1014a..6de32b790 100644 --- a/crates/ui-panels/src/docking/group.rs +++ b/crates/ui-panels/src/docking/group.rs @@ -18,10 +18,10 @@ use crate::runtime::commands::{CommandSet as _, CommandState, Commands as _}; use crate::runtime::env::Label; use crate::runtime::focus::{self, FocusTarget}; use crate::runtime::memory::sub; -use crate::style::{ComponentStyle, Corners, StyleCx, SurfaceKind}; +use crate::style::{ComponentStyle, Corners, RuleLook, RuleWidth, StyleColor, StyleCx, SurfaceKind}; use crate::tabs::{Tab, TabKind, TabStrip, TornOff}; use craft_behavior::{DockSide, IconId, Metrics, PartKey, PressPhase, Sense, keyed}; -use craft_theme::{ControlSize, Tokens}; +use craft_theme::{ControlSize, Rgba, Tokens}; use egui::{Id, Pos2, Rect, Response, Ui, Vec2}; use std::borrow::Cow; use std::fmt::Debug; @@ -33,6 +33,49 @@ use std::hash::Hash; pub struct GroupGripStyle { #[style(metrics)] metrics: Metrics, + /// The marks a grip with [`ticks`](GroupGrip::ticks) shows. + marks: GripMarks, +} + +/// How many ticks a grip's row of marks has, at every display scale. +const GRIP_TICKS: u16 = 10; +/// How tall a grip's tick is, in points. +const GRIP_TICK_LENGTH: f32 = 4.0; +/// The share of the panel's lightness a grip's ticks keep: the references' marks are a little darker than the panel +/// they sit on in every interface colour (`#454545` on `#535353`, `#272727` on `#323232`, `#9e9e9e` on `#b8b8b8`). +const GRIP_INK_SHARE: f32 = 0.83; + +/// The row of marks a dock grip shows, as the references draw it: ten upright ticks, a thin stroke wide, four points +/// tall and a thin stroke apart, centred on the grip, a little darker than the panel. They keep their ink under the +/// pointer, as the references' do. A toolbar's grip under its column bar and the grip above each icon group of a +/// collapsed column paint the same marks. +#[derive(Clone, Copy, Debug, PartialEq)] +pub(super) struct GripMarks { + ink: StyleColor, + /// The width of a tick and the gap between two of them. + side: f32, + /// The height of a tick. + length: f32, +} + +impl GripMarks { + /// The marks in the tokens of `cx`. + pub(super) fn style(cx: &StyleCx<'_>) -> Self { + GripMarks { ink: cx.color(grip_ink(cx.tokens.color.surface.panel)), side: cx.tokens.stroke.thin, length: GRIP_TICK_LENGTH } + } + + /// Paints the row centred on `centre`. + pub(super) fn paint(&self, ui: &PaintUi<'_>, centre: Pos2) { + let look = RuleLook { color: self.ink.egui(), width: RuleWidth::Points(self.side) }; + ui.draw().grip_ticks(&look, centre, GRIP_TICKS, self.side, self.length); + } +} + +/// The ink of a grip's ticks on a `panel` surface: the panel's channels at [`GRIP_INK_SHARE`]. +fn grip_ink(panel: Rgba) -> Rgba { + let [r, g, b, a] = panel.0; + let darker = |channel: u8| (f32::from(channel) * GRIP_INK_SHARE).round().clamp(0.0, 255.0) as u8; + Rgba([darker(r), darker(g), darker(b), a]) } /// What a group grip reports: its response, the second press of a double click and whether it started a group @@ -73,6 +116,9 @@ pub struct GroupGrip { /// A drag on the grip drags the unit. #[prop] movable: bool, + /// The grip shows the dock's row of grip marks ([`GripMarks`]) in its middle; else it is an unmarked band. + #[prop] + ticks: bool, double: bool, started: bool, } @@ -80,7 +126,7 @@ pub struct GroupGrip { impl GroupGrip

{ /// The grip of `unit`, whose shown panel is `active`. pub fn new(unit: DragUnit

, active: PanelKey) -> Self { - GroupGrip { common: Common::new(), unit, active, ghost: None, movable: true, double: false, started: false } + GroupGrip { common: Common::new(), unit, active, ghost: None, movable: true, ticks: false, double: false, started: false } } } @@ -92,8 +138,8 @@ impl Component for GroupGrip

{ type Style = GroupGripStyle; type Output = GroupGripOutput; - fn style(_: &StyleCx<'_>, _: GroupGripStyleKey

) -> GroupGripStyle { - GroupGripStyle { metrics: Metrics::new() } + fn style(cx: &StyleCx<'_>, _: GroupGripStyleKey

) -> GroupGripStyle { + GroupGripStyle { metrics: Metrics::new(), marks: GripMarks::style(cx) } } fn measure(&mut self, cx: &MeasureCx<'_, Self>) -> Vec2 { @@ -112,6 +158,12 @@ impl Component for GroupGrip

{ } } + fn paint(&mut self, ui: &mut PaintUi<'_>, cx: &Cx<'_, Self>) { + if self.ticks { + cx.style.marks.paint(ui, cx.rect.center()); + } + } + fn finish(self, cx: Cx<'_, Self>) -> GroupGripOutput { GroupGripOutput { response: cx.response.clone(), double_pressed: self.double, drag_started: self.started } } diff --git a/crates/ui-panels/src/docking/iconic.rs b/crates/ui-panels/src/docking/iconic.rs index 3a850af21..673f0d740 100644 --- a/crates/ui-panels/src/docking/iconic.rs +++ b/crates/ui-panels/src/docking/iconic.rs @@ -4,6 +4,7 @@ use super::divider::{self, Divider, Drag}; use super::dock_column::{ BarRecord, CHEVRON, ColumnArrow, ColumnBar, bar_band, bar_slots, column_grip, describe_chevron, paint_chevron, register_edges, show_bar, }; +use super::group::GripMarks; use super::{DockSizes, DockSpot, DockTargets, DockWords, DragUnit, Flyout, GroupAt, PanelKey, PanelSpec, Splitter, start_icon_drag}; use crate::buttons::IconButton; use crate::contract::overlay::Anchor; @@ -16,7 +17,7 @@ use crate::menu::GroupItem; use crate::primitives::{IconSpec, TextRun}; use crate::runtime::env::Label; use crate::runtime::focus::KeyUse; -use crate::style::{ComponentStyle, Corners, GlyphRole, RuleLook, RuleWidth, StyleColor, StyleCx, SurfaceKind}; +use crate::style::{ComponentStyle, Corners, GlyphRole, StyleColor, StyleCx, SurfaceKind}; use craft_behavior::dock::{Column, DockEdge, Group}; use craft_behavior::overlay::Side; use craft_behavior::{Axis, CursorIcon, DockSide, Metrics, PartKey, PressPhase, Sense, Value}; @@ -54,12 +55,6 @@ pub struct IconicSizes { /// The column width, in rail widths, from which the cells show their panels' names: 96 points at the Compact size. const LABELS_IN_RAIL_WIDTHS: f32 = 2.4; -/// The length of a group's grip line, in icon cell heights: half a cell, 15 points at the Compact size (18 at -/// Comfortable). That holds several dots, so it reads as a handle and not as a dot, and in a rail-wide column (40 -/// points at Compact) it leaves more than a quarter of the width free on each side, so it does not read as a rule -/// between the groups. -const GRIP_LINE_IN_CELLS: f32 = 0.5; - impl IconicSizes { /// The sizes of the style context `cx`. pub fn style(cx: &StyleCx<'_>) -> Self { @@ -149,21 +144,15 @@ pub struct IconicColumnStyle { name_open: StyleColor, /// The room between an icon and its name. name_gap: f32, - /// The ink of a group's grip line. - grip: StyleColor, - /// The ink of a group's grip line while the pointer is over it or drags it. - grip_active: StyleColor, - /// The grip line's length across the group. - grip_length: f32, - /// The side of the grip line's dots, and the gap between two of them. - grip_dot: f32, + /// The marks of a group's grip. + grip: GripMarks, } /// A column collapsed to icons: the column bar over icon groups, one cell per panel. A panel without an icon shows the /// first letter of its name in a box. A column widened past `IconicSizes::labels` shows each panel's name beside its /// icon, cut with an ellipsis to the cell; a click or drag on the name acts as one on the icon. A click or Enter on an icon /// opens the flyout of its panel beside the column, switches it to that panel or closes it; one flyout is open at a -/// time. A drag of an icon starts a move of its panel, a drag of the grip line on top of a group a move of the group, a +/// time. A drag of an icon starts a move of its panel, a drag of the grip on top of a group a move of the group, a /// drag of the bar beside its button a move of the column; each starts through the drag session, and a press outside /// the flyout closes it. Escape and a press /// outside close the flyout; with `auto_collapse` the focus leaving it does too. @@ -422,12 +411,8 @@ impl Component for IconicColumn<'_, P> { name: cx.color(colors.text.normal), name_open: cx.color(colors.accent.text), name_gap: cx.tokens.space.gap.item, - // A handle that is found when looked for, as the references' faint grips: hairline dots one dot apart in - // the faint ink, the normal ink under the pointer. - grip: cx.color(colors.text.faint), - grip_active: cx.color(colors.text.normal), - grip_length: cx.tokens.size.rail.button * GRIP_LINE_IN_CELLS, - grip_dot: cx.tokens.stroke.thin, + // The references' grip: a row of upright ticks a little darker than the panel. + grip: GripMarks::style(cx), } } @@ -577,12 +562,8 @@ impl Component for IconicColumn<'_, P> { ui.face(CELL.at(at as u64), cell); } let style = &cx.style; - for (group, strip) in self.laid.as_ref().map_or(&[][..], |plan| &plan.grips[..]) { - let part = cx.part(GRIP.at(*group as u64)); - let ink = if part.hovered || part.pressed() { style.grip_active } else { style.grip }; - let half = Vec2::new(style.grip_length.min(strip.width()) / 2.0, 0.0); - let look = RuleLook { color: ink.egui(), width: RuleWidth::Points(style.grip_dot) }; - ui.draw().dotted_rule_with(&look, strip.center() - half, strip.center() + half, style.grip_dot); + for (_, strip) in self.laid.as_ref().map_or(&[][..], |plan| &plan.grips[..]) { + style.grip.paint(ui, strip.center()); } // The edge's line lies on the column's inner edge; its handle stays inside the column. A floating window's // edges are the window's. diff --git a/crates/ui-panels/src/docking/iconic/trials.rs b/crates/ui-panels/src/docking/iconic/trials.rs index 3b5519ee9..538de5b95 100644 --- a/crates/ui-panels/src/docking/iconic/trials.rs +++ b/crates/ui-panels/src/docking/iconic/trials.rs @@ -429,3 +429,57 @@ fn icon_groups_take_the_drops_of_an_expanded_columns_groups() { assert_eq!(found[3], Some(DockSpot::group(3, DockSide::Center)), "a one-icon group keeps its middle for the join"); assert_eq!(found[4], Some(DockSpot::group(3, DockSide::Bottom)), "the foot under the icons stacks below the last group"); } + +/// The ticks of a grip strip in `shapes`: the quads of the one mesh that lies inside `strip`, and their colour. +pub(crate) fn grip_ticks(shapes: &[egui::Shape], strip: Rect) -> Option<(Vec, egui::Color32)> { + shapes.iter().find_map(|shape| { + let egui::Shape::Mesh(mesh) = shape else { return None }; + let quads: Vec = mesh.vertices.chunks(4).map(|quad| Rect::from_points(&quad.iter().map(|v| v.pos).collect::>())).collect(); + let inside = !quads.is_empty() && quads.iter().all(|quad| strip.expand(0.01).contains_rect(*quad)); + inside.then(|| (quads, mesh.vertices.first().map_or(egui::Color32::TRANSPARENT, |v| v.color))) + }) +} + +/// Checks the ticks of a grip strip: ten upright marks, one point wide, four tall, one point apart, centred on the +/// strip and darker than the panel `panel`. +pub(crate) fn assert_grip_ticks(ticks: &[Rect], ink: egui::Color32, strip: Rect, panel: craft_theme::Rgba, what: &str) { + assert_eq!(ticks.len(), 10, "{what}: ten ticks: {ticks:?}"); + for tick in ticks { + assert!((tick.width() - 1.0).abs() < 0.01 && (tick.height() - 4.0).abs() < 0.01, "{what}: a tick is 1 x 4 points: {tick:?}"); + } + assert!(ticks.windows(2).all(|w| (w[1].min.x - w[0].max.x - 1.0).abs() < 0.01), "{what}: one point apart: {ticks:?}"); + let run = ticks.iter().fold(Rect::NOTHING, |run, tick| run.union(*tick)); + assert!((run.center().x - strip.center().x).abs() <= 0.5, "{what}: centred across the strip: {run:?} in {strip:?}"); + assert!((run.center().y - strip.center().y).abs() <= 0.5, "{what}: centred in the strip's height: {run:?} in {strip:?}"); + let [r, g, b, _] = panel.0; + assert!(ink.r() < r && ink.g() < g && ink.b() < b && ink.r() >= r / 2, "{what}: the ticks are a little darker than the panel {panel:?}: {ink:?}"); +} + +/// The grip above each icon group is the references' row of upright ticks, not a line: ten separate marks a little +/// darker than the panel, the same under the pointer. +#[trial] +fn a_groups_grip_is_a_row_of_upright_ticks_darker_than_the_panel() { + let mut fixture = + Fixture::hosted(|ui| { + let mut column = Column::new(vec![Group::new(vec![1, 2], 0), Group::new(vec![3], 0)]); + column.iconic = true; + let place = Rect::from_min_size(Pos2::ZERO, Vec2::new(RAIL, SCREEN.y)); + let output = IconicColumn::new("Panels", global("iconic column", "ticks"), &column, Bind::kept(), &named) + .within(screen()) + .show_flyouts_at(ui, place, |_, _, _, _| None); + Some(output.into()) + }); + fixture.room(SCREEN).settle(); + let id = fixture.root_id().expect("the column shows"); + let panel = StyleCx::with_root(fixture.ctx(), |cx| cx.tokens.color.surface.panel); + for group in [0, 1] { + let strip = fixture.part_rect(id, GRIP.at(group)).expect("each group has its grip"); + let shapes = fixture.frame_shapes(); + let (ticks, ink) = grip_ticks(&shapes, strip).expect("the grip paints its ticks"); + assert_grip_ticks(&ticks, ink, strip, panel, &format!("group {group}")); + fixture.frame(vec![egui::Event::PointerMoved(strip.center())]); + let hovered = fixture.frame_shapes(); + let (_, hover_ink) = grip_ticks(&hovered, strip).expect("the grip paints its ticks under the pointer"); + assert_eq!(hover_ink, ink, "group {group}: the ticks keep their ink under the pointer"); + } +} diff --git a/crates/ui-panels/src/docking/targets.rs b/crates/ui-panels/src/docking/targets.rs index ab44830f8..3c20611ee 100644 --- a/crates/ui-panels/src/docking/targets.rs +++ b/crates/ui-panels/src/docking/targets.rs @@ -80,6 +80,10 @@ pub struct DockSizes { pub rail_first: f32, /// The width each further column of a tool rail adds: a rail button and the tight gap before it. pub rail_step: f32, + /// The height of a grip strip, the band with the dock's grip marks: above each icon group of a collapsed column, + /// and under the column bar of a tool rail (a group whose panel has a [`DockGrid`](super::DockGrid)) that the host + /// shows itself (the least hit size). + pub grip: f32, } impl DockSizes { @@ -124,6 +128,7 @@ impl DockSizes { column: size.dock.column, rail_first: size.rail.button + 2.0 * cx.tokens.space.pad.control, rail_step: size.rail.button + cx.tokens.space.gap.tight, + grip: size.hit.target, } } diff --git a/crates/ui-patterns/src/patterns/dock/area.rs b/crates/ui-patterns/src/patterns/dock/area.rs index 954fc901f..4abd26459 100644 --- a/crates/ui-patterns/src/patterns/dock/area.rs +++ b/crates/ui-patterns/src/patterns/dock/area.rs @@ -5,16 +5,17 @@ use super::hide::{self, PruneKey}; use crate::contract::Revision; use crate::contract::overlay::{PlacementChange, PlacementKind}; use crate::contract::{ - Bind, BindMut, BodyCx, Cx, Entry, MemoKey, NoValue, Outcome, Pad, Pointer as _, Props as _, ShowContainer as _, Sizing, Tracked, WordSetCx as _, + Bind, BindMut, BodyCx, Cx, Entry, MemoKey, NoValue, Outcome, Pad, Pointer as _, Props as _, Show as _, ShowContainer as _, Sizing, Tracked, + WordSetCx as _, }; use crate::docking::SplitFramesCx as _; use crate::docking::stack::{StackSection, StackSections, section_heights}; 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, PanelSpecs, PanelTitle, Placing, SpecSource, SplitArea, Titles, WindowColumn, actions, - column_cells, dock_states, frame, move_actions, with_area_rules, + DockSizes, DockSpot, DockTargets, DockTo, DockWords, DragUnit, FloatSpace, FloatingGroup, FlyoutResize, GroupAt, GroupDrag, GroupGrip, + HidePanels, IconicColumn, IconicSizes, PanelDrag, PanelKey, PanelSpec, PanelSpecs, PanelTitle, Placing, SpecSource, SplitArea, Titles, + WindowColumn, actions, column_cells, dock_states, frame, move_actions, with_area_rules, }; use crate::menu::{GroupItem, MenuWords, PanelMenu, PanelRow}; use crate::runtime::commands::{CommandRef, CommandSet as _, CommandState, Commands as _, focus_within}; @@ -915,16 +916,35 @@ impl Pass<'_, P> { } } + /// The grip strip on top of a tool rail the host shows itself: the dock's grip marks over a band that drags the + /// group, which floats at `size`, the group's size. + fn rail_grip(&mut self, ui: &mut Ui, anchor: &P, shown: &P, strip: Rect, size: Vec2) { + let scene = self.scene; + let label = Label::from(scene.spec(shown).label.as_str().to_owned()); + let held = GroupGrip::new(DragUnit::Group(anchor.clone()), PanelKey::of(shown)) + .ticks(true) + .movable(scene.permissions(shown).movable) + .ghost(label.clone()) + .label(label) + .show_at(ui, strip); + if held.drag_started { + drag::amend::>(ui.ctx(), |drag| drag.source = Some(size)); + } + } + /// One group, by the host's `group_view` when it takes the group, else as a `DockGroup` over the host's panels: /// shown in a rect, or measured at a width the way it would show, returning its height. fn group(&mut self, ui: &mut Ui, body: &mut BodyCx<'_>, members: &[P], active: usize, look: Look, at: GroupAt) -> Option { let scene = self.scene; let anchor = members.first()?; let active = active.min(members.len() - 1); + // A tool rail (a panel with a grid) that the host shows itself gets the dock's grip strip on top, under its + // column bar, as the references' toolbar: the host's view takes the room under it. + let grip = if members.get(active).is_some_and(|panel| scene.spec(panel).grid.is_some()) { scene.sizes.grip } else { 0.0 }; if let GroupAt::Measure(_) = at && let Some(height) = self.panels.group_view(members, active, ui, at, body) { - return Some(height); + return Some(height + grip); } let shown = &members[active]; let words = body.words::(); @@ -994,12 +1014,13 @@ impl Pass<'_, P> { // the group's room, never in the room the area has left. Where the host leaves the group to the dock, the // group shows in its place. Both run every pass; the host memoizes inside its view, the group inside its // header and its bodies. + let (strip, view) = if grip > 0.0 { rect.split_top_bottom_at_y(rect.top() + grip.min(rect.height())) } else { (Rect::NOTHING, rect) }; let output = ui .scope_builder(UiBuilder::new().max_rect(rect), |ui| { let taken = ui - .scope_builder(UiBuilder::new().max_rect(rect), |ui| { - ui.shrink_clip_rect(rect); - panels.borrow_mut().group_view(members, active, ui, at, body) + .scope_builder(UiBuilder::new().max_rect(view), |ui| { + ui.shrink_clip_rect(view); + panels.borrow_mut().group_view(members, active, ui, GroupAt::Show(view), body) }) .inner; match taken { @@ -1008,8 +1029,13 @@ impl Pass<'_, P> { } }) .inner; - // A host view took the group. - let output = output?; + // A host view took the group: a rail's grip drags the group, as the band of a group's header does. + let Some(output) = output else { + if strip.is_positive() { + self.rail_grip(ui, anchor, shown, strip, rect.size()); + } + return None; + }; // The size `panel` floats at out of this group: the group's width, and the height the group measures at with // `panel` shown in a floating window's room, so content that fills the body takes that room. let fitted = |ui: &Ui, panel: &P| { diff --git a/crates/ui-patterns/tests/it/docking/group_view.rs b/crates/ui-patterns/tests/it/docking/group_view.rs index 62d980cc5..616e18b57 100644 --- a/crates/ui-patterns/tests/it/docking/group_view.rs +++ b/crates/ui-patterns/tests/it/docking/group_view.rs @@ -1,13 +1,15 @@ -//! A group the host takes with `group_view` lays out in the group's rect, not in the room the dock area has left. +//! A group the host takes with `group_view` lays out in the group's rect, not in the room the dock area has left; a +//! tool rail the host takes has the dock's grip strip on top. use craft_behavior::Axis; -use craft_behavior::dock::{Layout, Node, SplitSize, Workspace}; +use craft_behavior::dock::{Column, DockEdge, Group, Layout, Node, SplitSize, Workspace}; use craft_ui::contract::{Bind, BodyCx, PlainData, Tracked}; -use craft_ui::docking::{DockConfig, DockPanels, GroupAt, PanelSpec, PanelSpecs}; +use craft_ui::docking::{DockConfig, DockGrid, DockPanels, DockSizes, DragUnit, GroupAt, GroupDrag, PanelSpec, PanelSpecs}; use craft_ui::patterns::dock::DockArea; +use craft_ui::runtime::drag; use craft_ui::testing::{Fixture, trial}; -use egui::{Rect, Ui, Vec2}; -use std::cell::Cell; +use egui::{Rect, Shape, Ui, Vec2}; +use std::cell::{Cell, RefCell}; use std::rc::Rc; use std::sync::Arc; @@ -59,3 +61,86 @@ fn a_group_view_lays_out_and_clips_to_its_group_rect() { assert!(rect.contains_rect(room), "the view's room {room:?} lies in its group's rect {rect:?}"); assert!(rect.contains_rect(clip), "the view's clip {clip:?} lies in its group's rect {rect:?}"); } + +/// The tool rail of the grip trial: a panel with a rail grid, which the host shows itself. +const RAIL: usize = 7; +/// The height the host's rail measures at. +const RAIL_HEIGHT: f32 = 200.0; + +/// The rail is a tool rail; the rest are plain panels. +#[derive(PlainData)] +struct RailSpecs; + +impl PanelSpecs for RailSpecs { + fn spec(&self, panel: &usize) -> PanelSpec { + let spec = PanelSpec::new(format!("Panel {panel}")); + if *panel == RAIL { spec.grid(DockGrid::rail(4)) } else { spec } + } +} + +/// The host shows the rail itself and records the rect it was given. +struct RailPanels { + seen: Rc>>, +} + +impl DockPanels for RailPanels { + fn body(&mut self, _: &usize, _: &mut Ui, _: &mut BodyCx<'_>) {} + + fn group_view(&mut self, panels: &[usize], _: usize, _: &mut Ui, at: GroupAt, _: &mut BodyCx<'_>) -> Option { + if !panels.contains(&RAIL) { + return None; + } + match at { + GroupAt::Measure(_) => Some(RAIL_HEIGHT), + GroupAt::Show(rect) => { + self.seen.set(Some(rect)); + Some(rect.height()) + } + } + } +} + +/// A tool rail the host shows itself has the dock's grip under its column bar, as the references' toolbar: a strip of +/// ten upright ticks, a little darker than the panel, above the host's view, which keeps the height it measured at; a +/// drag on the strip moves the rail's group. +#[trial] +fn a_tool_rail_shown_by_its_host_has_a_grip_strip_that_drags_it() { + let seen = Rc::new(Cell::new(None)); + let dock = Node::dock(DockEdge::Start, vec![Column::new(vec![Group::new(vec![RAIL], 0)]).with_steps(1)]); + let root = Node::split(Axis::X, SplitSize::FixedFirst(120.0), dock, Node::tabs(vec![1], 0)); + let mut workspace = Arc::new(Workspace::new(Layout::new(Some(root), Vec::new()))); + let (mut panels, specs) = (RailPanels { seen: seen.clone() }, Tracked::new(RailSpecs)); + let columns: Rc>> = Rc::default(); + let placed = Rc::clone(&columns); + let mut fixture = Fixture::new(move |ui| { + let out = DockArea::new("Rail dock", Bind::bound(&mut workspace), &specs, &mut panels, DockConfig::default()).show(ui); + *placed.borrow_mut() = out.columns; + }); + fixture.room(Vec2::new(800.0, 600.0)).settle(); + let sizes = DockSizes::of(fixture.ctx()); + let view = seen.get().expect("the host showed the rail"); + let column = columns.borrow().iter().find(|(panel, _)| *panel == RAIL).map(|(_, rect)| *rect).expect("the rail's column shows"); + let strip = Rect::from_min_max(egui::pos2(view.left(), view.top() - sizes.grip), egui::pos2(view.right(), view.top())); + assert!(sizes.grip > 0.0 && column.top() < strip.top(), "the strip lies under the column bar: {strip:?} in {column:?}"); + assert!((view.height() - RAIL_HEIGHT).abs() < 0.5, "the host's view keeps the height it measured at: {view:?}"); + + // The strip's ticks: one mesh inside it of ten upright marks. + let shapes = fixture.frame_shapes(); + let ticks: Vec = shapes + .iter() + .find_map(|shape| { + let Shape::Mesh(mesh) = shape else { return None }; + let quads: Vec = mesh.vertices.chunks(4).map(|quad| Rect::from_points(&quad.iter().map(|v| v.pos).collect::>())).collect(); + (!quads.is_empty() && quads.iter().all(|quad| strip.expand(0.01).contains_rect(*quad))).then_some(quads) + }) + .expect("the strip paints its ticks"); + assert_eq!(ticks.len(), 10, "ten ticks: {ticks:?}"); + assert!(ticks.iter().all(|tick| tick.height() > tick.width()), "the ticks stand upright: {ticks:?}"); + let run = ticks.iter().fold(Rect::NOTHING, |run, tick| run.union(*tick)); + assert!((run.center().x - strip.center().x).abs() <= 0.5, "the ticks are centred across the rail: {run:?} in {strip:?}"); + + fixture.drag_hold_at(strip.center(), Vec2::new(200.0, 0.0)); + let unit = drag::active::>(fixture.ctx()).map(|drag| drag.unit.clone()); + assert_eq!(unit, Some(DragUnit::Group(RAIL)), "a drag on the grip moves the rail's group"); + fixture.release_at(strip.center() + Vec2::new(200.0, 0.0)).settle(); +} diff --git a/docs/contract-api.md b/docs/contract-api.md index 70e62b511..49b52c58c 100644 --- a/docs/contract-api.md +++ b/docs/contract-api.md @@ -2910,7 +2910,9 @@ Painters, `Draw`, the sensing core, the text adapter and `ImeSurface`. - `pub fn scroll_bar(&self, look: &crate::style::ScrollBarLook, track: Rect, axis: craft_behavior::Axis, rtl: bool, span: &craft_behavior::ScrollSpan, state: &crate::style::StateSet,)`. Paints the scroll bar in `track` along `axis` for `span`, in the bar's `state` (`ScrollBar::shapes`; - `pub fn rule_width(&self, kind: RuleKind) -> f32`. The width in points of the line `rule` paints for `kind`. - `pub fn rule_with(&self, look: &crate::style::RuleLook, from: Pos2, to: Pos2)`. Paints the line `look` from `from` to `to`, snapped to physical pixels as `rule` is: a rule in a component's own - - `pub fn dotted_rule_with(&self, look: &crate::style::RuleLook, from: Pos2, to: Pos2, gap: f32)`. Paints the line `look` from `from` to `to` as dots `gap` points apart (`Rule::dotted`): a grip's dotted line. + - `pub fn dotted_rule_with(&self, look: &crate::style::RuleLook, from: Pos2, to: Pos2, gap: f32)`. Paints the line `look` from `from` to `to` as dots `gap` points apart (`Rule::dotted`): a dotted line. + - `pub fn ticked_rule_with(&self, look: &crate::style::RuleLook, from: Pos2, to: Pos2, gap: f32, across: f32)`. Paints the line `look` from `from` to `to` as ticks `across` points long, `gap` points apart (`Rule::ticks`): + - `pub fn grip_ticks(&self, look: &crate::style::RuleLook, centre: Pos2, count: u16, gap: f32, across: f32)`. Paints `count` upright ticks of `look` centred on `centre`, side by side on a level line, `gap` points apart and - `pub fn surface(&self, rect: Rect, kind: SurfaceKind, corners: Corners)`. Paints a surface of `kind` (tracks, plot wells). - `pub fn surface_styled(&self, rect: Rect, style: &SurfaceStyle)`. Paints a surface of an already resolved `style` (a kind's look with one field changed, as a knob's round radius). - `pub fn surface_look(&self, rect: Rect, look: &crate::style::SurfaceLook, state: &crate::style::StateSet)`. Paints `look` over `rect` in `state`, as the paint step paints a component's surface: a part's own surface (an @@ -3050,6 +3052,7 @@ Painters, `Draw`, the sensing core, the text adapter and `ImeSurface`. - `craft_ui::primitives::Rule`: `pub struct Rule`. The rule painter. - `pub fn shapes(look: &RuleLook, from: Pos2, to: Pos2, pixels_per_point: f32) -> Vec`. The line from `from` to `to`, snapped across its direction: a line whose physical width is odd sits on a - `pub fn dotted(look: &RuleLook, from: Pos2, to: Pos2, gap: f32, pixels_per_point: f32) -> Vec`. The dotted form of the line from `from` to `to`: square dots as wide as the line, `gap` points apart, the run + - `pub fn ticks(look: &RuleLook, from: Pos2, to: Pos2, gap: f32, across: f32, pixels_per_point: f32) -> Vec`. The line from `from` to `to` as a run of ticks: marks as wide as the line along it and `across` points long - `pub fn edge(look: &RuleLook, rect: Rect, side: RectSide, pixels_per_point: f32) -> Vec`. The line along the `side` edge of `rect`, on the physical pixels just inside it: a row's bottom rule or a - `craft_ui::primitives::RuleKind`: `pub enum RuleKind { Divider, Edge, Grid, DropMark }`. Which rule a look is for. - `craft_ui::primitives::RulerFace`: `pub enum RulerFace { Edge, Centred }`. How a ruler lays out its marks and numbers. A ruler takes a face from its `face` prop, else from the scope's From 2749cb5229ad29a17748455fa0c30b004d1a7dc4 Mon Sep 17 00:00:00 2001 From: David Mann Date: Sun, 22 Nov 2026 00:24:21 +0100 Subject: [PATCH 3/3] Docking: no doc link from the public grip option to the private marks style (photocraft#16332) Co-Authored-By: Claude Opus 5.5 --- crates/ui-panels/src/docking/group.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/ui-panels/src/docking/group.rs b/crates/ui-panels/src/docking/group.rs index 6de32b790..be2673f53 100644 --- a/crates/ui-panels/src/docking/group.rs +++ b/crates/ui-panels/src/docking/group.rs @@ -116,7 +116,7 @@ pub struct GroupGrip { /// A drag on the grip drags the unit. #[prop] movable: bool, - /// The grip shows the dock's row of grip marks ([`GripMarks`]) in its middle; else it is an unmarked band. + /// The grip shows the dock's row of grip marks in its middle; else it is an unmarked band. #[prop] ticks: bool, double: bool,