chrome-w2: net change of 2 commits

- chrome-w2: written from its sheet
- chrome-w2: repair 1
This commit is contained in:
bflatastic committed 2026-11-21 21:26:38 +07:00
1 parent 78864e28b3
commit 3846cbbaac
10 files changed
+247 -50

No files matched your search

+15 -8
View File
@@ -243,11 +243,16 @@ impl ShellCx {
self.inner.panels_hidden
}
/// Whether the dock at `edge` shows: in normal mode, during the Tab reveal and, for the `Start` and `End` edges,
/// while that edge's reveal is on, unless the panels are hidden.
/// Whether the dock at `edge` shows: in normal mode and during the Tab reveal unless the panels are hidden, and the
/// `Start` and `End` docks also while that edge's reveal is on, in body-only mode or while the panels are hidden.
pub fn dock_visible(&self, edge: super::PaneEdge) -> bool {
let _ = edge; // P3(chrome-w2): ch.K1
!self.inner.panels_hidden && (self.inner.mode == BodyMode::Normal || self.inner.tab_reveal || self.edge_revealed(RevealEdge::End))
let inner = &*self.inner;
let base = !inner.panels_hidden && (inner.mode == BodyMode::Normal || inner.tab_reveal);
base || match edge {
super::PaneEdge::Start => self.edge_revealed(RevealEdge::Start),
super::PaneEdge::End => self.edge_revealed(RevealEdge::End),
_ => false,
}
}
/// Whether floating frames show: in normal mode; in body-only mode only during the Tab reveal; never while the
@@ -290,16 +295,18 @@ impl ShellCx {
self.inner.mode == BodyMode::Normal && self.inner.tabs
}
/// Are slots shown by a reveal (Tab or edge) on this pass? Only body-only mode reveals.
/// Are slots shown by a reveal (Tab or edge) on this pass? Only body-only mode reveals with Tab; an edge reveals in
/// body-only mode and while the panels are hidden.
pub fn revealed(&self) -> bool {
let inner = &*self.inner;
inner.mode == BodyMode::Only && (inner.tab_reveal || inner.edges.iter().any(|on| *on))
let body_only = inner.mode == BodyMode::Only;
(body_only && inner.tab_reveal) || ((body_only || inner.panels_hidden) && inner.edges.iter().any(|on| *on))
}
/// Is the edge reveal on for `edge`? False in normal mode and during the Tab reveal.
/// Is the edge reveal on for `edge`? False while the panels show in normal mode, and during the Tab reveal.
pub fn edge_revealed(&self, edge: RevealEdge) -> bool {
let inner = &*self.inner;
inner.mode == BodyMode::Only && !inner.tab_reveal && inner.edges[edge.index()]
(inner.mode == BodyMode::Only || inner.panels_hidden) && !inner.tab_reveal && inner.edges[edge.index()]
}
/// The body rect and the shown slots of this pass.
+2 -3
View File
@@ -400,8 +400,7 @@ pub(crate) fn note_removed_gesture(ctx: &Context, id: GestureId) {
/// Adds a component whose live preview ended to the next `FrameOutput`.
pub(crate) fn note_ended_preview(ctx: &Context, id: Id) {
let _ = (ctx, id);
todo!("ty.X1")
pass_state::with::<FrameState, _>(ctx, |state| state.output.ended_previews.push(id));
}
/// Adds a step of an outer gesture to the next `FrameOutput`.
@@ -556,7 +555,7 @@ pub(crate) fn facts(ctx: &Context) -> PassFacts {
})
}
/// The running pass's time in seconds, read once by the begin hook: what an app waits on.
/// The running pass's time in seconds, the same on every pass of a frame: for app code that times a wait.
pub fn clock(ctx: &Context) -> f64 {
match running(ctx) {
Some(facts) => facts.now,
@@ -3,7 +3,7 @@
use super::native::{WindowAction, act, route_hit_test};
use super::placement::{record_placement, saved_placement};
use super::shell::{app_id, os_of, refresh};
use super::spec::{WindowSpec, frame_of_spec};
use super::spec::{WindowLevel, WindowSpec, frame_of_spec};
use super::{Record, refuse_close_under_modal, shared};
use crate::runtime::egui::viewports;
use crate::runtime::frame::PerViewport;
@@ -77,6 +77,8 @@ pub(crate) fn show_viewport(ctx: &Context, open: &ViewportOpen<'_>, mut body: im
record.level.get_or_insert(spec.level).for_egui(active, os)
});
let app = app_id(ctx);
// PLAN: `Shared::palettes_yield` is written by shell-w1 (ch.K8); a palette built while it holds opens hidden.
let yielding = shared(ctx, |shared| shared.palettes_yield);
let opens = viewports::Spec {
title: open.title,
// The builder carries the place only until the window opens: egui would send each change of it as a command.
@@ -92,7 +94,9 @@ pub(crate) fn show_viewport(ctx: &Context, open: &ViewportOpen<'_>, mut body: im
level,
resizable: open.resizable,
taskbar: spec.taskbar,
hidden: PerViewport::<Record>::with(ctx, viewport, |record| record.awaiting_first_paint),
hidden: PerViewport::<Record>::with(ctx, viewport, |record| {
record.awaiting_first_paint || (yielding && record.level == Some(WindowLevel::Palette))
}),
app_id: &app,
};
viewports::show_immediate(ctx, viewport, &opens, |ui| {
+85 -1
View File
@@ -1,12 +1,17 @@
//! The wheel service: the begin hook splits the pass's wheel input among last pass's takers.
use craft_behavior::overlay::{Align, Side};
use craft_behavior::{GESTURE_GAP, Sense, Wheel, WheelPhase, WheelTaker};
use craft_host::target::Os;
use craft_ui::contract::overlay::{Anchor, Place};
use craft_ui::contract::{Common, Component, Container, ContainerProps, Cx, Mount, Overlay, Props as _, Role, Show as _, ShowContainer as _, Sizing};
use craft_ui::style::StyleCx;
use craft_ui::testing::pointer;
use craft_ui::testing::sensing::{ProbeRoot, show};
use craft_ui::testing::wheel::{register, take, take_share};
use craft_ui::testing::{Fixture, Frames, trial};
use egui::{Event, Id, Modifiers, MouseWheelSource, MouseWheelUnit, Pos2, Rect, TouchPhase, Vec2};
use craft_ui_test_kit::contract::{PlainStyle, Probe, Seen};
use egui::{Event, Id, Modifiers, MouseWheelSource, MouseWheelUnit, Pos2, Rect, Response, TouchPhase, Ui, Vec2};
use std::cell::RefCell;
use std::rc::Rc;
@@ -184,3 +189,82 @@ fn a_wheel_gesture_ends_for_a_value_control_in_any_wheel_scope_and_not_for_a_scr
assert_eq!(ends(&close(&mut frames, &mut show_frame)), [owner], "the device's end reaches the gesture's owner once");
}
}
/// A popup layer that holds one probe.
#[derive(craft_ui::contract::Component)]
#[component(container)]
struct Popup {
#[common]
common: Common,
#[container]
props: ContainerProps,
}
impl Component for Popup {
const ROLE: Role = Role::GROUP;
type Style = PlainStyle;
type Output = Response;
fn style(_: &StyleCx<'_>, _: PopupStyleKey) -> PlainStyle {
PlainStyle::default()
}
fn finish(self, cx: Cx<'_, Self>) -> Response {
cx.response.clone()
}
}
impl Container for Popup {}
#[trial]
fn a_wheel_over_an_open_popup_goes_to_the_popup_and_not_to_the_region_under_it() {
let anchor = Rect::from_min_size(Pos2::new(200.0, 100.0), Vec2::new(30.0, 20.0));
let (field_seen, popup_seen) = (RefCell::new(Seen::default()), RefCell::new(Seen::default()));
let open = std::cell::Cell::new(false);
let popup_rect = std::cell::Cell::new(Rect::NOTHING);
let field = std::cell::Cell::new(Id::NULL);
let popup = Id::unique("wheel_popup");
let panel = Id::unique("wheel_panel");
let shares: RefCell<Vec<(Id, Wheel)>> = RefCell::new(Vec::new());
let mut show_frame = |ui: &mut Ui| {
let ctx = ui.ctx().clone();
let field_rect = Rect::from_min_size(Pos2::ZERO, Vec2::new(100.0, 20.0));
field.set(Probe::new(&field_seen).size(field_rect.size()).sense(Sense::CLICK | Sense::FOCUS).show(ui).id);
if open.get() {
let overlay = Overlay::popover().place(Place::anchored(Anchor::Rect(anchor), Side::Below, Align::Start));
let props = ContainerProps::new().mount(Mount::Layer(overlay)).sizing(Sizing::Content);
let out = Popup { common: Common::new(), props }.id_salt("wheel_popup_layer").show(ui, |ui, _| {
Probe::new(&popup_seen).size(Vec2::new(120.0, 60.0)).show(ui);
});
popup_rect.set(out.output.rect);
}
register(&ctx, WheelTaker::new(panel, Rect::from_min_size(Pos2::ZERO, Vec2::splat(400.0))).vertical(true).scrolls(true));
register(&ctx, WheelTaker::new(field.get(), field_rect).vertical(true).field(true));
if open.get() {
register(&ctx, WheelTaker::new(popup, popup_rect.get()).vertical(true).scrolls(true));
}
for id in [panel, field.get(), popup] {
if let Some(share) = take_share(&ctx, id) {
shares.borrow_mut().push((id, share));
}
}
};
let mut frames = Frames::new();
frames.idle(2, &mut show_frame);
pointer::click(&mut frames, Pos2::new(50.0, 10.0), &mut show_frame);
let mut wheel_at = |frames: &mut Frames, at: Pos2, show_frame: &mut dyn FnMut(&mut Ui)| -> Vec<Id> {
frames.frame(vec![pointer::moved(at)], &mut *show_frame);
shares.borrow_mut().clear();
frames.frame(vec![pointer::wheel(-30.0)], &mut *show_frame);
shares.borrow().iter().map(|(id, _)| *id).collect()
};
let beside = Pos2::new(300.0, 300.0);
assert_eq!(wheel_at(&mut frames, beside, &mut show_frame), [field.get()], "the focused field takes the wheel over the region");
open.set(true);
frames.idle(4, &mut show_frame);
assert!(popup_rect.get().is_positive(), "the popup shows: {:?}", popup_rect.get());
let on_popup = popup_rect.get().center();
assert_eq!(wheel_at(&mut frames, on_popup, &mut show_frame), [popup], "the popup under the pointer takes the wheel, not the focused field or the region");
}
+2 -2
View File
@@ -207,13 +207,13 @@ impl<P: Clone + Eq + Hash + Debug + Send + Sync + 'static> Drops<'_, P> {
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(), None); // P3(chrome-w2): ch.K7
let prune = hide::Prune::new(self.layout, 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));
target.placing = Some(Placing::new(sizes, &spec, &protected).shown(prune.hide(), self.maximized));
cx.drop_target::<GroupDrag<P>, _>(&target).or_else(|| cx.drop_target::<PanelDrag, _>(&target))
}
}
+64 -15
View File
@@ -4,7 +4,7 @@
use crate::docking::HidePanels;
use crate::docking::frame::{FrameView, maximize};
use crate::runtime::env::{PaneEdge, ShellCx};
use craft_behavior::dock::{DockEdge, Layout};
use craft_behavior::dock::{DockEdge, Layout, Node, PanelPlace, node_at};
use std::hash::Hash;
/// The layout as the area shows it, and whether its floating windows show.
@@ -16,9 +16,10 @@ pub(super) struct Shown<'a, P: Clone> {
}
/// `layout` with the host's `hide`, the shell's panel visibility and the frame of `maximized` applied. Protected
/// panels always stay, so a canvas shows while the dock is hidden. While the shell hides the panels and keeps the
/// tools (Shift+Tab), the panels the host's `HidePanels::Except` names stay, docked or floating, and every other panel
/// hides; while the shell hides the dock (Tab, body-only mode), every panel hides. Size edits made on the view go back
/// panels always stay, so a canvas shows while the dock is hidden. The shell decides per dock (see [`resolved`]): a
/// dock that shows keeps the host's `hide`; while the shell hides the panels and keeps the tools (Shift+Tab), the
/// panels the host's `HidePanels::Except` names stay, docked or floating, and every other panel of a hidden dock hides;
/// while the shell hides the dock (Tab, body-only mode), every panel of it hides. Size edits made on the view go back
/// through `FrameView::write_back`.
pub(super) fn shown<'a, P: Clone + Eq + Hash>(
layout: &'a Layout<P>,
@@ -27,22 +28,70 @@ pub(super) fn shown<'a, P: Clone + Eq + Hash>(
shell: Option<&ShellCx>,
protected: &dyn Fn(&P) -> bool,
) -> Shown<'a, P> {
let (hide, floating) = resolved(hide, shell, None);
Shown { view: maximize(layout, maximized, hide, protected), floating }
let prune = Prune::new(layout, hide, shell);
Shown { view: maximize(layout, maximized, prune.hide(), protected), floating: prune.floating }
}
/// The panels the area hides, the host's `hide` with the shell's panel visibility applied, and whether floating windows
/// show (see [`shown`]). `side` is the dock the panels sit in; `None` is panels outside every dock.
/// The host's `hide` with the shell's per-dock visibility applied over a layout. `maximize` takes one `HidePanels` for
/// the whole layout, so a shell that hides a dock turns it into a per-panel keep.
pub(super) struct Prune<'a, P> {
hide: HidePanels<'a, P>,
keep: Option<Box<dyn Fn(&P) -> bool + 'a>>,
/// Floating windows show.
pub(super) floating: bool,
}
impl<'a, P: Clone + Eq + Hash> Prune<'a, P> {
/// The prune of `layout` under `shell`. When every dock shows the host's `hide` goes through unchanged, so
/// `maximize` can skip the prune.
pub(super) fn new(layout: &'a Layout<P>, hide: HidePanels<'a, P>, shell: Option<&ShellCx>) -> Self {
let floating = resolved(hide, shell, None).1;
let Some(shell) = shell.filter(|shell| !shell.dock_visible(PaneEdge::Top)) else {
return Prune { hide, keep: None, floating };
};
let shell = shell.clone();
let keep = move |panel: &P| match resolved(hide, Some(&shell), dock_side(layout, panel)).0 {
HidePanels::None => true,
HidePanels::All => false,
HidePanels::Except(keep) => keep(panel),
};
Prune { hide, keep: Some(Box::new(keep)), floating }
}
/// The panels the area hides.
pub(super) fn hide(&self) -> HidePanels<'_, P> {
match &self.keep {
Some(keep) => HidePanels::Except(&**keep),
None => self.hide,
}
}
}
/// The side of the dock `panel` sits in; `None` for a panel outside every dock.
fn dock_side<P: Clone + Eq + Hash>(layout: &Layout<P>, panel: &P) -> Option<DockEdge> {
let PanelPlace::Dock { path, .. } = layout.place(panel)? else { return None };
match layout.root.as_ref().and_then(|root| node_at(root, &path))? {
Node::Dock { side, .. } => Some(*side),
_ => None,
}
}
/// The panels the area hides in the dock at `side` (`None`: panels outside every dock), the host's `hide` with the
/// shell's panel visibility applied, and whether floating windows show. A dock whose edge shows keeps the host's
/// `hide`; a hidden one keeps the host's `Except` while the shell hides only the panels (Shift+Tab) and nothing under
/// Tab.
pub(super) fn resolved<'h, P>(hide: HidePanels<'h, P>, shell: Option<&ShellCx>, side: Option<DockEdge>) -> (HidePanels<'h, P>, bool) {
// P3(chrome-w2): ch.K7 -- `DockEdge` has no `From` into the shell's `PaneEdge`; the writer replaces this mapping.
let Some(shell) = shell else { return (hide, true) };
let edge = match side {
Some(DockEdge::Start) => PaneEdge::Start,
Some(DockEdge::End) => PaneEdge::End,
_ => PaneEdge::Center,
_ => PaneEdge::Top,
};
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(edge) { hide } else { HidePanels::All }, shell.floating_visible()),
}
let floating = shell.panels_hidden() || shell.floating_visible();
let hide = match hide {
_ if shell.dock_visible(edge) => hide,
HidePanels::Except(_) if shell.panels_hidden() => hide,
_ => HidePanels::All,
};
(hide, floating)
}
+15 -13
View File
@@ -639,23 +639,25 @@ impl<'a, P: Clone + Eq + Hash + Debug + Send + Sync + 'static> PaneArea<'a, P> {
let shown_root = root.show(ui, |ui, cx| {
let Some(sizes) = cx.style::<DockRoot<'_, Vec<PaneRequest<P>>>>().map(|style| *style.sizes()) else { return };
let (docks, floats) = cx.shell().as_ref().map_or((true, true), |shell| (shell.dock_visible(PaneEdge::Center), shell.floating_visible())); // P3(chrome-w2): ch.K1
let bounds = cx.shell().map_or(cx.rect, |shell| shell.float_bounds());
let shell = cx.shell();
let floats = shell.as_ref().is_none_or(|shell| shell.floating_visible());
let bounds = shell.as_ref().map_or(cx.rect, |shell| shell.float_bounds());
let mut order = [PaneEdge::Bottom, PaneEdge::Top, PaneEdge::Start, PaneEdge::End];
if rtl {
order.swap(2, 3);
}
if docks {
for edge in order {
let on_edge: Vec<&Shown<P>> = shown.iter().filter(|s| s.docked_at() == Some(edge)).collect();
let slot = on_edge.iter().rposition(|s| s.spec.closable);
for (at, pane) in on_edge.iter().enumerate() {
if policy == SidePolicy::OneSlot && pane.spec.closable && slot != Some(at) {
continue;
}
if show_docked(ui, &pass, pane, edge) {
*pass.focused.borrow_mut() = Some(pane.pane.clone());
}
for edge in order {
if !shell.as_ref().is_none_or(|shell| shell.dock_visible(edge)) {
continue;
}
let on_edge: Vec<&Shown<P>> = shown.iter().filter(|s| s.docked_at() == Some(edge)).collect();
let slot = on_edge.iter().rposition(|s| s.spec.closable);
for (at, pane) in on_edge.iter().enumerate() {
if policy == SidePolicy::OneSlot && pane.spec.closable && slot != Some(at) {
continue;
}
if show_docked(ui, &pass, pane, edge) {
*pass.focused.borrow_mut() = Some(pane.pane.clone());
}
}
}
@@ -2,16 +2,19 @@
//! and the released drop applies to the layout.
use craft_behavior::Axis;
use craft_behavior::dock::{Layout, Node, Permissions, SplitSize};
use craft_behavior::dock::{Layout, Node, Permissions, SplitSize, Workspace};
use craft_ui::contract::SizeLimits;
use craft_ui::contract::{Bind, Common, Component, Cx, MeasureCx, Pointer as _, Role, Show as _, ShowContainer as _};
use craft_ui::contract::{Bind, BodyCx, Common, Component, Cx, MeasureCx, Pointer as _, Role, Show as _, ShowContainer as _};
use craft_ui::docking::tree::{self, FrameRules};
use craft_ui::docking::{DockDropTarget, DockDropped, DockGroup, DockSizes, GroupDrag, PanelDrag, PanelKey, PanelTitle, SplitArea};
use craft_ui::docking::{
DockConfig, DockDropTarget, DockDropped, DockGroup, DockPanels, DockSizes, GroupDrag, PanelDrag, PanelKey, PanelSpec, PanelTitle, SplitArea,
};
use craft_ui::patterns::dock::DockArea;
use craft_ui::runtime::drag;
use craft_ui::style::{ComponentStyle, StyleCx};
use craft_ui::testing::pointer::{moved, press, release};
use craft_ui::testing::{Fixture, trial};
use egui::{Id, Pos2, Rect, Response, Vec2};
use egui::{Id, Pos2, Rect, Response, Ui, Vec2};
use std::cell::RefCell;
use std::rc::Rc;
@@ -171,3 +174,36 @@ fn a_header_drag_shows_the_drop_mark_over_a_group_side_and_docks_on_release() {
assert_eq!(groups(&layout.borrow()).len(), 2, "the group moved beside the right group");
assert_eq!(groups(&layout.borrow())[1], panels(&["Layers", "Channels"]));
}
/// Panels with no body: the drag is all the trial needs.
struct Named;
impl DockPanels<String> for Named {
fn spec(&self, panel: &String) -> PanelSpec {
PanelSpec::new(panel.clone())
}
fn body(&mut self, _: &String, _: &mut Ui, _: &mut BodyCx<'_>) {}
}
#[trial]
fn a_drag_started_under_another_workspace_revision_ends_when_the_workspace_is_replaced() {
let workspace = Rc::new(RefCell::new(Workspace::new(wide_left_group())));
let shared = Rc::clone(&workspace);
let mut fixture = Fixture::new(move |ui| {
let mut held = shared.borrow_mut();
DockArea::new("Replaced dock", Bind::bound(&mut *held), &mut Named, DockConfig::default()).show(ui);
});
fixture.settle();
let grip = left_grip(&fixture);
hold_and_move(&mut fixture, grip, Pos2::new(395.0, 150.0));
assert!(drag::active::<GroupDrag<String>>(fixture.ctx()).is_some(), "the header drag started a group drag in the dock");
fixture.frame(Vec::new());
assert!(drag::active::<GroupDrag<String>>(fixture.ctx()).is_some(), "the dock's own passes keep the drag");
let replacement = Workspace::new(Layout::new(Some(Node::tabs(panels(&["Properties"]), 0)), Vec::new()));
workspace.borrow_mut().replace(replacement);
fixture.frame(Vec::new());
fixture.idle(1);
assert!(drag::active::<GroupDrag<String>>(fixture.ctx()).is_none(), "replacing the workspace ended the drag");
assert_eq!(groups(&workspace.borrow().layout), vec![panels(&["Properties"])], "the new workspace's layout stays as it was set");
}
+17 -1
View File
@@ -5,7 +5,7 @@ use craft_behavior::dock::{Column, DockEdge, Floating, Group, Layout, Node, Perm
use craft_ui::contract::{Bind, BodyCx};
use craft_ui::docking::{DockConfig, DockPanels, HidePanels, PanelSpec};
use craft_ui::patterns::dock::DockArea;
use craft_ui::runtime::env::{BodyMode, ShellCx, ShellEntry, WindowKey};
use craft_ui::runtime::env::{BodyMode, RevealEdge, ShellCx, ShellEntry, WindowKey};
use craft_ui::testing::{Fixture, trial};
use egui::{Pos2, Rect, Ui, Vec2};
use std::cell::RefCell;
@@ -83,3 +83,19 @@ fn shift_tab_keeps_the_panels_the_host_names_docked_and_floating_and_tab_hides_t
let tab = ShellCx::detached(WindowKey::main(), BodyMode::Only, room);
assert_eq!(shown_under(tab, true), BTreeSet::from([CANVAS]), "Tab keeps the canvas only, whatever the host names");
}
#[trial]
fn a_revealed_edge_shows_its_dock_alone_under_tab_and_shift_tab() {
let room = Rect::from_min_size(Pos2::ZERO, Vec2::new(400.0, 300.0));
let tab = ShellCx::detached(WindowKey::main(), BodyMode::Only, room);
let shift_tab = ShellCx::detached(WindowKey::main(), BodyMode::Normal, room).with_panels_hidden(true);
for (keys, hiding) in [("Tab", tab), ("Shift+Tab", shift_tab)] {
let under = |edge: Option<RevealEdge>| match edge {
Some(edge) => shown_under(hiding.clone().with_edge_reveal(edge, true), false),
None => shown_under(hiding.clone(), false),
};
assert_eq!(under(Some(RevealEdge::Start)), BTreeSet::from([CANVAS, TOOLBAR]), "{keys}: the start edge shows the start dock alone");
assert_eq!(under(Some(RevealEdge::End)), BTreeSet::from([CANVAS, LAYERS]), "{keys}: the end edge shows the end dock alone");
assert_eq!(under(None), BTreeSet::from([CANVAS]), "{keys}: with no edge revealed no dock shows");
}
}
+1 -1
View File
@@ -65,7 +65,7 @@ The binding decides who applies the edits. With `Bind::bound` the area writes ev
A panel body, or code a body calls, changes the workspace during the pass with `docking::request_actions(ctx, actions)`, never by writing the workspace the area shows. The running area takes them unapplied and returns them in `DockAreaOutput::requested`, in order, for the host to apply after `actions` in the same frame. With no area over that panel type running, `request_actions` hands the actions back for the caller to apply.
Props: `hide` (`HidePanels::None`, `All` or `Except`), `maximized`, `auto_collapse`, `locked`, and `flyout`, which binds the open flyout to the host's value (the area keeps it otherwise). A hidden panel keeps its place for restore. Inside an `AppShell`, the shell's hiding wins over `hide`: while it hides the panels and keeps the tools (Shift+Tab, `ShellCx::panels_hidden`), only the panels an `Except` names stay, docked or floating (a toolbar); while it hides the dock (Tab), no panel shows. Protected panels always show.
Props: `hide` (`HidePanels::None`, `All` or `Except`), `maximized`, `auto_collapse`, `locked`, and `flyout`, which binds the open flyout to the host's value (the area keeps it otherwise). A hidden panel keeps its place for restore. Inside an `AppShell`, the shell's hiding wins over `hide`: while it hides the panels and keeps the tools (Shift+Tab, `ShellCx::panels_hidden`), only the panels an `Except` names stay, docked or floating (a toolbar); while it hides the dock (Tab), no panel shows. Under Tab and Shift+Tab, an edge the pointer reveals (`ShellCx::edge_revealed`) shows its `Start` or `End` dock, with the host's `hide` applied to it. Protected panels always show.
A panel in a column collapsed to icons shows in its flyout (`Layout::opens_in_flyout`). The host opens and closes it by writing the `flyout` binding, not the layout: `WindowMenuRows` checks such a panel's row while its flyout is open (`WindowMenuRows::flyout`) and reports a pick in `WindowMenuRowsOutput::flyout`.