diff --git a/crates/behavior/src/dock/workspace.rs b/crates/behavior/src/dock/workspace.rs
index c7c344924..811c4dfa5 100644
--- a/crates/behavior/src/dock/workspace.rs
+++ b/crates/behavior/src/dock/workspace.rs
@@ -85,8 +85,8 @@ impl
Workspace
{
}
impl Workspace {
- /// Check the version, the layout and that every hidden panel is hidden once and absent
- /// from the layout.
+ /// Check the version, the layout, that every hidden panel is hidden once and absent
+ /// from the layout, and that the floated records are bounded and one per panel.
pub fn validate(&self) -> Result<(), DockError> {
if self.version > Self::VERSION {
return Err(DockError::UnsupportedVersion);
@@ -102,6 +102,13 @@ impl Workspace {
return Err(DockError::DuplicatePanel);
}
}
+ if self.floated.len() > MAX_PANELS {
+ return Err(DockError::LimitExceeded);
+ }
+ let mut recorded = HashSet::new();
+ if !self.floated.iter().all(|(panel, _)| recorded.insert(panel)) {
+ return Err(DockError::DuplicatePanel);
+ }
Ok(())
}
@@ -133,7 +140,7 @@ impl Workspace {
let before = proposed.layout.clone();
// Opening a hidden panel puts it back where it was.
let reopened = match &action {
- Action::Open { panel, .. } if proposed.hidden.iter().any(|(p, _)| p == panel) => proposed.reopen(panel)?,
+ Action::Open { panel, .. } if proposed.hidden.iter().any(|(p, _)| p == panel) => proposed.reopen(panel, &policy)?,
_ => false,
};
if !reopened {
@@ -191,14 +198,26 @@ impl Workspace {
}
/// Restore a hidden `panel` to its recorded place and make it the active tab. `Ok(false)` when the record
- /// cannot be restored, which leaves the workspace as it was.
- fn reopen(&mut self, panel: &P) -> Result {
+ /// cannot be restored, or the place it restores to refuses the panel under `permissions`; the workspace stays
+ /// as it was and the caller opens the panel by the ordinary, checked path.
+ fn reopen(&mut self, panel: &P, permissions: &impl Fn(&P) -> Permissions) -> Result {
+ // The restore also rewrites the records of the hidden panels it passed, so it runs on a copy.
+ let mut trial = self.clone();
let mut layout = self.layout.clone();
- if self.restore_from_hidden(&mut layout, panel).is_err() {
+ if trial.restore_from_hidden(&mut layout, panel).is_err() {
+ return Ok(false);
+ }
+ let allowed = layout
+ .location(panel)
+ .ok()
+ .and_then(|location| location.anchor.map(|anchor| location.placement.allowed_by(permissions(&anchor), floats(&layout, &anchor))))
+ .unwrap_or(true);
+ if !allowed {
return Ok(false);
}
layout.apply(Action::Activate { panel: panel.clone() })?;
self.layout = layout;
+ self.hidden = trial.hidden;
self.hidden.retain(|(p, _)| p != panel);
Ok(true)
}
diff --git a/crates/ui-panels/src/docking/floating.rs b/crates/ui-panels/src/docking/floating.rs
index beb0d449a..3e819847a 100644
--- a/crates/ui-panels/src/docking/floating.rs
+++ b/crates/ui-panels/src/docking/floating.rs
@@ -11,8 +11,8 @@ use crate::contract::BodyCx;
use crate::contract::SizeLimits;
use crate::contract::overlay::{PlacementChange, PlacementKind, Popup};
use crate::contract::{
- Bind, BindMut, Common, Component, Container, ContainerProps, Cx, DragBand, DropMark, DropOperation, HeaderRegion, Inner, Mount, NoValue, OsFiles,
- Outcome, Overlay, Pad, Pointer as _, Props as _, Role, Show as _, ShowContainer as _, Sizing, WindowDropTarget, WordSetCx as _,
+ Bind, BindMut, Common, Component, Container, ContainerProps, Cx, DragBand, HeaderRegion, Inner, Mount, NoValue, OsFiles, Outcome, Overlay, Pad,
+ Pointer as _, Props as _, Role, Show as _, ShowContainer as _, Sizing, WordSetCx as _,
};
use crate::runtime::drag::OsFile;
use crate::runtime::env::{Env, Label};
@@ -21,6 +21,7 @@ use crate::runtime::windows::WindowSpec;
use crate::sections::{HeaderAction, HeaderStrength, MenuRows, TitleRow};
use crate::style::{ComponentStyle, StyleCx, SurfaceKind};
use craft_behavior::{GesturePhase, Metrics, Sense};
+use craft_ui_widgets::popover::WholeWindow;
use egui::{Id, Rect, Response, Ui, Vec2};
use std::cell::RefCell;
use std::hash::Hash;
@@ -31,23 +32,6 @@ mod stories;
/// The actions a floating group's title row shows unless `actions` says otherwise.
const ACTIONS: [HeaderAction; 3] = [HeaderAction::Menu, HeaderAction::Float, HeaderAction::Close];
-/// The whole window of a native floating group as a target for files from the OS.
-struct OsWindowFiles {
- rect: Rect,
-}
-
-impl WindowDropTarget for OsWindowFiles {
- type Drop = OsFiles;
-
- fn accept(&self, payload: &OsFiles, _op: DropOperation) -> Option {
- (!payload.files.is_empty()).then(|| payload.clone())
- }
-
- fn mark(&self, _drop: &OsFiles) -> DropMark {
- DropMark::Into(self.rect)
- }
-}
-
/// The style of a floating group: the surface and padding come from the container.
#[derive(Clone, Debug, Default, PartialEq, ComponentStyle)]
#[non_exhaustive]
@@ -276,7 +260,7 @@ impl Component for FloatingGroup<'_> {
}
// A layer float lies in the app window, whose own targets take those drops.
if self.native.is_some() {
- let target = OsWindowFiles { rect: cx.rect };
+ let target = WholeWindow::new(cx.rect);
if let Some(dropped) = cx.window_drop_target::(&target) {
self.files = dropped.files;
}
diff --git a/crates/ui-patterns/tests/it/docking/native.rs b/crates/ui-patterns/tests/it/docking/native.rs
index ff9e7aa5c..363d78269 100644
--- a/crates/ui-patterns/tests/it/docking/native.rs
+++ b/crates/ui-patterns/tests/it/docking/native.rs
@@ -4,9 +4,10 @@
use craft_behavior::dock::{Action, Floating, Layout, Node, Permissions, Workspace};
use craft_behavior::placement::Placement;
use craft_host::target::{Backend, Caps, Os, ShellInfo};
-use craft_ui::contract::{Bind, BodyCx};
+use craft_ui::contract::{Bind, BodyCx, Show as _};
use craft_ui::docking::{DockConfig, DockPanels, PanelSpec};
use craft_ui::patterns::dock::DockArea;
+use craft_ui::popover::DropVeil;
use craft_ui::runtime::InstallSpec;
use craft_ui::runtime::drag;
use craft_ui::testing::input::key_press;
@@ -14,7 +15,7 @@ use craft_ui::testing::pointer::{moved, press, release};
use craft_ui::testing::trial;
use craft_ui::testing::windows::FakeSystem;
use craft_ui_test_kit::windows::Windows;
-use egui::{Event, Key, Modifiers, Pos2, Rect, Ui, Vec2, ViewportCommand, ViewportEvent, ViewportId, ViewportInfo};
+use egui::{DroppedFile, Event, HoveredFile, Key, Modifiers, Pos2, Rect, Ui, Vec2, ViewportCommand, ViewportEvent, ViewportId, ViewportInfo};
use std::sync::Arc;
/// The root window and the palette overlap; the palette is the larger.
@@ -349,28 +350,53 @@ fn an_app_change_of_a_native_floats_place_moves_its_window_once() {
assert_eq!(placing, [&ViewportCommand::OuterPosition(to.min), &ViewportCommand::InnerSize(to.size())], "one move and one size");
}
-/// OS files reach `DockAreaOutput::window_files` only from a drop on a native float's own window: with the float's
-/// OS window open and nothing dropped, the dock reports no files.
-// PLAN: the drop itself cannot be driven yet: the `Windows` kit (`crates/ui-test-kit/src/windows.rs`, outside this
-// set) gives a child pass only `Event`s, never `RawInput::dropped_files`. Once the kit lets a frame give the child
-// files, this trial drops one file no target takes and one a target takes, and asserts that only the first arrives.
+/// Palettes whose body is a veil over the window: a target inside the window that takes dropped files.
+struct Veiled;
+
+impl DockPanels for Veiled {
+ fn spec(&self, _: &u32) -> PanelSpec {
+ PanelSpec::new(PALETTE_TITLE)
+ }
+
+ fn body(&mut self, _: &u32, ui: &mut Ui, _: &mut BodyCx<'_>) {
+ let _ = DropVeil::new("Drop").show(ui, |_, _| {});
+ }
+}
+
+/// Files dropped on a native float's own OS window reach `DockAreaOutput::window_files` once, unless a target inside
+/// that window took them.
#[trial]
fn a_file_dropped_on_a_native_float_reaches_window_files_once() {
- let windows = Windows::new();
- windows.root_info(info(true, ROOT_AT));
- windows.child_info(info(true, PALETTE_AT));
- let mut workspace = Workspace::new(Layout::new(None, vec![float()]));
- let mut opened = false;
- let mut files = 0;
- for _ in 0..4 {
- let out = windows.frame(vec![], vec![], |ui| {
- let shown = DockArea::new("Native dock", Bind::bound(&mut workspace), &mut Palettes(Permissions::ALL), DockConfig::default()).show(ui);
- files += shown.window_files.len();
- });
- opened |= out.builders.iter().any(|(viewport, _)| *viewport != ViewportId::ROOT);
- }
- assert!(opened, "the float has its own OS window");
- assert_eq!(files, 0, "no drop, no files");
+ let reached = |veiled: bool| {
+ let windows = Windows::new();
+ windows.root_info(info(true, ROOT_AT));
+ windows.child_info(info(true, PALETTE_AT));
+ let mut workspace = Workspace::new(Layout::new(None, vec![float()]));
+ let mut frame = |hovered: Vec, dropped: Vec| {
+ let mut files = 0;
+ windows.frame_with_files(vec![], vec![], hovered, dropped, |ui| {
+ let config = DockConfig::default();
+ let shown = if veiled {
+ DockArea::new("Native dock", Bind::bound(&mut workspace), &mut Veiled, config).show(ui)
+ } else {
+ DockArea::new("Native dock", Bind::bound(&mut workspace), &mut Palettes(Permissions::ALL), config).show(ui)
+ };
+ files += shown.window_files.len();
+ });
+ files
+ };
+ for _ in 0..4 {
+ frame(vec![], vec![]);
+ }
+ let mut total = frame(vec![HoveredFile::default()], vec![]);
+ total += frame(vec![], vec![DroppedFile { name: "a.png".into(), ..DroppedFile::default() }]);
+ for _ in 0..2 {
+ total += frame(vec![], vec![]);
+ }
+ total
+ };
+ assert_eq!(reached(false), 1, "a file no target took arrives once");
+ assert_eq!(reached(true), 0, "a file a target in the window took does not");
}
/// A palette float made in the app window.
diff --git a/crates/ui-test-kit/src/windows.rs b/crates/ui-test-kit/src/windows.rs
index eece9ca9d..5aca8fe7f 100644
--- a/crates/ui-test-kit/src/windows.rs
+++ b/crates/ui-test-kit/src/windows.rs
@@ -10,7 +10,7 @@ use craft_ui::testing::Frames;
use craft_ui::testing::access::{AccessTree, tree_of};
use craft_ui::testing::windows::FakeSystem;
use craft_ui::testing::windows::{FullOutput, RawInput};
-use egui::{Context, Event, Pos2, Rect, Ui, Vec2, ViewportBuilder, ViewportCommand, ViewportId, ViewportInfo};
+use egui::{Context, DroppedFile, Event, HoveredFile, Pos2, Rect, Ui, Vec2, ViewportBuilder, ViewportCommand, ViewportId, ViewportInfo};
use std::cell::{Cell, RefCell};
use std::sync::Arc;
@@ -20,6 +20,8 @@ const CHILD_SIZE: Vec2 = Vec2::new(400.0, 300.0);
thread_local! {
/// The events the next child pass receives (the renderer runs on the trial's thread).
static CHILD_EVENTS: RefCell> = const { RefCell::new(Vec::new()) };
+ /// The files hovering over and dropped on the child's window in the next child pass.
+ static CHILD_FILES: RefCell<(Vec, Vec)> = const { RefCell::new((Vec::new(), Vec::new())) };
/// The window facts every child pass reports.
static CHILD_INFO: RefCell = RefCell::new(ViewportInfo::default());
/// The window facts the root reports.
@@ -109,10 +111,17 @@ fn render_child(ctx: &Context, viewport: egui::ImmediateViewport<'_>) {
patch_window(viewport.ids.this, viewport.builder);
let mut callback = viewport.viewport_ui_cb;
let events = CHILD_EVENTS.with(|events| std::mem::take(&mut *events.borrow_mut()));
+ let (hovered_files, dropped_files) = CHILD_FILES.with(|files| std::mem::take(&mut *files.borrow_mut()));
let mut info = CHILD_INFO.with(|info| info.borrow().clone());
info.parent = Some(viewport.ids.parent);
- let mut input =
- RawInput { viewport_id: viewport.ids.this, events, screen_rect: Some(Rect::from_min_size(Pos2::ZERO, CHILD_SIZE)), ..RawInput::default() };
+ let mut input = RawInput {
+ viewport_id: viewport.ids.this,
+ events,
+ hovered_files,
+ dropped_files,
+ screen_rect: Some(Rect::from_min_size(Pos2::ZERO, CHILD_SIZE)),
+ ..RawInput::default()
+ };
input.time = Some(NOW.with(Cell::get));
CHILDREN.with(|children| {
let mut children = children.borrow_mut();
@@ -171,6 +180,7 @@ impl Windows {
assert!(craft_ui::install(&ctx, spec).is_ok(), "the context takes the runtime once");
Context::set_immediate_viewport_renderer(render_child);
CHILD_EVENTS.with(|events| events.borrow_mut().clear());
+ CHILD_FILES.with(|files| *files.borrow_mut() = Default::default());
CHILD_INFO.with(|info| *info.borrow_mut() = ViewportInfo::default());
CHILDREN.with(|children| children.borrow_mut().clear());
COMMANDS.with(|kept| kept.borrow_mut().clear());
@@ -192,7 +202,21 @@ impl Windows {
/// One frame: `root` events go to the root viewport, `child` events to the child's next pass. Returns the
/// window commands of the frame.
pub fn frame(&self, root: Vec, child: Vec, ui: impl FnMut(&mut Ui)) -> Out {
+ self.frame_with_files(root, child, Vec::new(), Vec::new(), ui)
+ }
+
+ /// [`frame`](Self::frame) where the child's next pass also gets the OS files hovering over its window and the
+ /// files dropped on it.
+ pub fn frame_with_files(
+ &self,
+ root: Vec,
+ child: Vec,
+ hovered: Vec,
+ dropped: Vec,
+ ui: impl FnMut(&mut Ui),
+ ) -> Out {
CHILD_EVENTS.with(|events| *events.borrow_mut() = child);
+ CHILD_FILES.with(|files| *files.borrow_mut() = (hovered, dropped));
TREES.with(|kept| kept.borrow_mut().clear());
set_input(&self.ctx, FrameInput::new(RootEnv::default()));
let mut input = RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, ROOT_SIZE)), events: root, ..RawInput::default() };
diff --git a/crates/ui-widgets/src/popover/drop_veil.rs b/crates/ui-widgets/src/popover/drop_veil.rs
index 09e1c5258..b4ed6540a 100644
--- a/crates/ui-widgets/src/popover/drop_veil.rs
+++ b/crates/ui-widgets/src/popover/drop_veil.rs
@@ -113,11 +113,19 @@ impl Outcome for DropVeilOutput {
}
}
-/// The accepting side of a veil: any files, anywhere in the window, by any operation.
-struct WholeWindow {
+/// The accepting side of a veil: any files, anywhere in the window, by any operation. Other containers that report
+/// the files nothing else in their window took use it too.
+pub struct WholeWindow {
rect: Rect,
}
+impl WholeWindow {
+ /// A target over the window, marked with `rect` while files hover.
+ pub fn new(rect: Rect) -> Self {
+ WholeWindow { rect }
+ }
+}
+
impl WindowDropTarget for WholeWindow {
type Drop = OsFiles;
@@ -186,7 +194,7 @@ impl Component for DropVeil {
fn update(&mut self, cx: &mut Cx<'_, Self>) {
let held = drag::active::(&cx.ctx).is_some_and(|files| !files.files.is_empty());
- let target = WholeWindow { rect: cx.rect };
+ let target = WholeWindow::new(cx.rect);
let (id, ordinal) = (cx.id, drag::next_ordinal(&cx.ctx, cx.id));
self.dropped = cx.window_drop_target::(&target);
// The veil shows only while it is the target that would take the drop.