Dock: move app-side dock code into app::dock, trim tests, drop icon tooltip

- The dock's state handling and drawing move out of update/dialog.rs and
  view/mod.rs into src/app/dock/ (update.rs, view.rs, tests.rs). The
  overlay view_main stacked over the workspace (floating pallets, + menu,
  drag preview, pointer capture) becomes one `dock_overlay` call. Code is
  moved, not changed.
- Strip icons no longer show the pallet name on hover.
- Tests trimmed where they overlapped: the top / bottom half drops are
  one test, the two hover tests are one, and the in-group icon reorder,
  raise-float, empty floating title bar and slot-span tests are dropped
  (each is covered by another test).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013RyGiMXcsf9HTKfqDxaQGt

src/app/dock/tests.rs

@@ -0,0 +1,570 @@
+//! Dock behaviour through the app: drags, hover, menus, and the real view.
+
+use crate::app::{Message, OpenCADStudio};
+
+fn fresh() -> OpenCADStudio {
+    let mut app = OpenCADStudio::new_for_test();
+    app.automation_op(r#"{"op":"new"}"#);
+    app
+}
+
+#[test]
+fn blockpalette_pin_toggles_autocollapse_and_close_hides() {
+    let mut app = fresh();
+    app.show_block_palette = true;
+    let id = crate::ui::dock::PanelId::BlockPalette;
+    let _ = app.on_dock(crate::ui::dock::DockMsg::AutoCollapseToggle(id));
+    assert!(app.dock.auto_hides(id), "pin enables auto-hide");
+    let _ = app.on_dock(crate::ui::dock::DockMsg::AutoCollapseToggle(id));
+    assert!(!app.dock.auto_hides(id), "second pin disables auto-hide");
+    let _ = app.on_dock(crate::ui::dock::DockMsg::Close(id));
+    assert!(!app.show_block_palette, "close dismisses the sidebar");
+}
+
+/// A hermetic app with a 1600×900 workspace and the default dock layout
+/// (Properties left, block palette right), both shown.
+fn dock_app() -> OpenCADStudio {
+    let mut app = fresh();
+    // Tests load the user's persisted config; reset the dock to a known
+    // state so this stays hermetic.
+    app.dock = Default::default();
+    app.dock.ensure_settings();
+    app.show_properties = true;
+    app.show_block_palette = true;
+    let i = app.active_tab;
+    app.tabs[i].scene.selection.borrow_mut().view.vp_size = (1600.0, 900.0);
+    app.win_size = (1600.0, 900.0).into();
+    app
+}
+
+/// Where the current dock drag would land, if it has started.
+fn drag_target(app: &OpenCADStudio) -> Option<crate::ui::dock::DropTarget> {
+    app.dock_drag.and_then(|d| d.movement()).and_then(|(_, _, target)| target)
+}
+
+/// Press `id`'s title bar at `from`, drag to `to`, and return the target
+/// shown just before release.
+fn drag_panel(
+    app: &mut OpenCADStudio,
+    id: crate::ui::dock::PanelId,
+    from: iced::Point,
+    to: iced::Point,
+) -> Option<crate::ui::dock::DropTarget> {
+    use crate::ui::dock::DockMsg;
+    let _ = app.on_dock(DockMsg::DockGrab(id));
+    let _ = app.on_dock(DockMsg::DragMove(from));
+    let _ = app.on_dock(DockMsg::DragMove(to));
+    let target = drag_target(app);
+    let _ = app.on_dock(DockMsg::DragRelease);
+    target
+}
+
+#[test]
+fn dropping_on_a_pallets_top_or_bottom_half_stacks_above_or_below_it() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DropTarget, PanelId};
+    let mut app = dock_app();
+    let id = PanelId::BlockPalette;
+    assert_eq!(app.dock.location(id), Some((DockSide::Right, 0)));
+    let target = drag_panel(
+        &mut app,
+        id,
+        iced::Point::new(1500.0, 10.0),
+        iced::Point::new(150.0, 300.0),
+    );
+    assert_eq!(
+        target,
+        Some(DropTarget::Join {
+            side: DockSide::Left,
+            group: 0,
+            index: 0
+        })
+    );
+    assert_eq!(
+        app.dock.left[0].panels,
+        vec![PanelId::BlockPalette, PanelId::Properties]
+    );
+    assert!(app.dock.right.is_empty());
+    // The bottom half of a pallet stacks below it.
+    let target = drag_panel(
+        &mut app,
+        id,
+        iced::Point::new(150.0, 100.0),
+        iced::Point::new(150.0, 800.0),
+    );
+    assert_eq!(
+        target,
+        Some(DropTarget::Join {
+            side: DockSide::Left,
+            group: 0,
+            index: 2
+        })
+    );
+    assert_eq!(
+        app.dock.left[0].panels,
+        vec![PanelId::Properties, PanelId::BlockPalette]
+    );
+}
+
+#[test]
+fn dock_dragging_a_lone_pallet_over_its_own_group_is_a_no_op() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DropTarget, PanelId};
+    let mut app = dock_app();
+    let before = app.dock.clone();
+    // The right edge's only group holds just the block palette; drag it
+    // around over itself.
+    let target = drag_panel(
+        &mut app,
+        PanelId::BlockPalette,
+        iced::Point::new(1500.0, 10.0),
+        iced::Point::new(1450.0, 600.0),
+    );
+    assert_eq!(
+        target,
+        Some(DropTarget::Join {
+            side: DockSide::Right,
+            group: 0,
+            index: 1
+        })
+    );
+    assert_eq!(app.dock, before);
+}
+
+#[test]
+fn dock_click_without_drag_changes_nothing() {
+    let mut app = dock_app();
+    let before = app.dock.clone();
+    let id = crate::ui::dock::PanelId::BlockPalette;
+    let p = iced::Point::new(1500.0, 10.0);
+    let target = drag_panel(&mut app, id, p, iced::Point::new(1502.0, 11.0));
+    assert_eq!(target, None, "movement under the threshold is a click");
+    assert_eq!(app.dock, before);
+}
+
+#[test]
+fn dock_drop_below_the_strip_groups_starts_a_new_shown_group() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DropTarget, PanelId};
+    let mut app = dock_app();
+    let (_, plus_top) = app.dock_strip_layout(DockSide::Left);
+    let target = drag_panel(
+        &mut app,
+        PanelId::BlockPalette,
+        iced::Point::new(1500.0, 10.0),
+        iced::Point::new(18.0, plus_top + 10.0),
+    );
+    assert_eq!(
+        target,
+        Some(DropTarget::Edge {
+            side: DockSide::Left,
+            index: 1
+        })
+    );
+    assert_eq!(app.dock.left.len(), 2);
+    assert_eq!(app.dock.left[1].panels, vec![PanelId::BlockPalette]);
+    // The new group is the one shown: the column holds only the palette.
+    assert_eq!(app.dock_shown_group(DockSide::Left), Some(1));
+    assert_eq!(app.dock_slot_spans(DockSide::Left), vec![(0, 0.0, 900.0)]);
+}
+
+#[test]
+fn dock_icon_press_switches_the_shown_group() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockGroup, DockMsg, PanelId};
+    let mut app = dock_app();
+    app.show_browser = true;
+    app.dock.left = vec![
+        DockGroup::stack(vec![PanelId::Properties, PanelId::BlockPalette]),
+        DockGroup::single(PanelId::Browser),
+    ];
+    app.dock.right.clear();
+    // Group 0 shows both stacked pallets.
+    assert_eq!(app.dock_slot_spans(DockSide::Left).len(), 2);
+    let _ = app.on_dock(DockMsg::IconPress(PanelId::Browser));
+    let _ = app.on_dock(DockMsg::DragRelease);
+    assert_eq!(app.dock_shown_group(DockSide::Left), Some(1));
+    assert_eq!(app.dock_slot_spans(DockSide::Left), vec![(0, 0.0, 900.0)]);
+    // Each group keeps its own width.
+    app.dock.set_width(PanelId::Browser, 400.0);
+    assert_eq!(app.dock_column_width(DockSide::Left), 400.0);
+    let _ = app.on_dock(DockMsg::IconPress(PanelId::BlockPalette));
+    let _ = app.on_dock(DockMsg::DragRelease);
+    assert_eq!(app.dock_column_width(DockSide::Left), 260.0);
+}
+
+#[test]
+fn dock_drop_over_the_viewport_floats_the_panel() {
+    use crate::ui::dock::{DropTarget, PanelId};
+    let mut app = dock_app();
+    let target = drag_panel(
+        &mut app,
+        PanelId::BlockPalette,
+        iced::Point::new(1500.0, 10.0),
+        iced::Point::new(800.0, 400.0),
+    );
+    assert!(matches!(target, Some(DropTarget::Float { .. })));
+    assert!(app.dock.right.is_empty());
+    let f = app.dock.float_rect(PanelId::BlockPalette).expect("floating");
+    assert!(f.x > 600.0 && f.x < 800.0 && f.y > 350.0 && f.y < 400.0);
+    // Dragging a floating panel keeps the grab point under the pointer.
+    let target = drag_panel(
+        &mut app,
+        PanelId::BlockPalette,
+        iced::Point::new(f.x + 20.0, f.y + 10.0),
+        iced::Point::new(f.x + 120.0, f.y + 60.0),
+    );
+    assert_eq!(target, Some(DropTarget::Float { x: f.x + 100.0, y: f.y + 50.0 }));
+    // Opening a floating panel must not re-dock it.
+    assert!(app.dock.is_placed(PanelId::BlockPalette));
+}
+
+#[test]
+fn dock_dragging_an_icon_into_another_group_lands_between_its_icons() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockGroup, DockMsg, DropTarget, PanelId, STRIP_CELL_H};
+    let mut app = dock_app();
+    app.show_browser = true;
+    app.dock.left = vec![
+        DockGroup::stack(vec![PanelId::Properties, PanelId::Browser]),
+        DockGroup::single(PanelId::BlockPalette),
+    ];
+    app.dock.right.clear();
+    let (layout, _) = app.dock_strip_layout(DockSide::Left);
+    // Drag the Blocks icon (group 1) to between Properties and Browser.
+    let _ = app.on_dock(DockMsg::IconPress(PanelId::BlockPalette));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(20.0, layout[1].icons_top + 10.0)));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(
+        20.0,
+        layout[0].icons_top + STRIP_CELL_H + 2.0,
+    )));
+    assert_eq!(
+        drag_target(&app),
+        Some(DropTarget::Join {
+            side: DockSide::Left,
+            group: 0,
+            index: 1
+        })
+    );
+    let _ = app.on_dock(DockMsg::DragRelease);
+    assert_eq!(app.dock.left.len(), 1, "the emptied group goes away");
+    assert_eq!(
+        app.dock.left[0].panels,
+        vec![PanelId::Properties, PanelId::BlockPalette, PanelId::Browser]
+    );
+}
+
+#[test]
+fn dock_grip_drag_moves_a_whole_group() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockGroup, DockMsg, PanelId};
+    let mut app = dock_app();
+    app.show_browser = true;
+    app.dock.left = vec![
+        DockGroup::stack(vec![PanelId::Properties, PanelId::Browser]),
+        DockGroup::single(PanelId::BlockPalette),
+    ];
+    app.dock.right.clear();
+    let (layout, plus_top) = app.dock_strip_layout(DockSide::Left);
+    let _ = app.on_dock(DockMsg::GroupGrab(DockSide::Left, 0));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(18.0, layout[0].top + 2.0)));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(18.0, plus_top + 10.0)));
+    let _ = app.on_dock(DockMsg::DragRelease);
+    assert_eq!(app.dock.left[0].panels, vec![PanelId::BlockPalette]);
+    assert_eq!(
+        app.dock.left[1].panels,
+        vec![PanelId::Properties, PanelId::Browser]
+    );
+    // A group dropped over the viewport does not float or split up.
+    let before = app.dock.clone();
+    let _ = app.on_dock(DockMsg::GroupGrab(DockSide::Left, 1));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(18.0, 300.0)));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(800.0, 400.0)));
+    assert_eq!(drag_target(&app), None);
+    let _ = app.on_dock(DockMsg::DragRelease);
+    assert_eq!(app.dock, before);
+}
+
+#[test]
+fn dock_closed_pallets_take_no_room_and_empty_groups_hide() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockGroup, PanelId};
+    let mut app = dock_app();
+    app.dock.left = vec![
+        DockGroup::stack(vec![PanelId::BlockPalette, PanelId::Properties]),
+        DockGroup::single(PanelId::Browser),
+    ];
+    app.show_block_palette = false;
+    app.show_browser = false;
+    // Only Properties is open: one listed group, full height.
+    assert_eq!(app.dock_visible_groups(DockSide::Left), vec![0]);
+    assert_eq!(app.dock_slot_spans(DockSide::Left), vec![(1, 0.0, 900.0)]);
+    // A shown group with nothing open falls back to one that has.
+    app.dock.show_group(DockSide::Left, 1);
+    assert_eq!(app.dock_shown_group(DockSide::Left), Some(0));
+}
+
+#[test]
+fn dock_splitter_drag_changes_pallet_heights() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockGroup, DockMsg, PanelId};
+    let mut app = dock_app();
+    app.dock.left = vec![DockGroup::stack(vec![PanelId::BlockPalette, PanelId::Properties])];
+    app.dock.right.clear();
+    let _ = app.on_dock(DockMsg::SplitGrab(DockSide::Left, 0, 0, 1));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(100.0, 450.0)));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(100.0, 675.0)));
+    let _ = app.on_dock(DockMsg::DragRelease);
+    // 225 px of a 900 px edge holding 2 weight units = 0.5 units.
+    let w = &app.dock.left[0].weights;
+    assert!((w[0] - 1.5).abs() < 1e-4 && (w[1] - 0.5).abs() < 1e-4);
+    let _ = app.on_dock(DockMsg::SplitReset(DockSide::Left, 0));
+    assert_eq!(app.dock.left[0].weights, vec![1.0, 1.0]);
+}
+
+#[test]
+fn dock_hover_reveals_groups_only_on_an_auto_hiding_edge() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockGroup, DockMsg, PanelId};
+    let mut app = dock_app();
+    app.show_browser = true;
+    app.dock.left.push(DockGroup::single(PanelId::Browser));
+    // The pin on any docked pallet turns auto-hide on for its edge.
+    let _ = app.on_dock(DockMsg::AutoCollapseToggle(PanelId::Properties));
+    assert!(app.dock.edge_auto_hide(DockSide::Left));
+    assert!(!app.dock.edge_auto_hide(DockSide::Right));
+    assert!(!app.dock_edge_expanded(DockSide::Left));
+    // Hovering an icon flies its group out.
+    let _ = app.on_dock(DockMsg::Hover(Some(PanelId::Browser)));
+    assert!(app.dock_edge_expanded(DockSide::Left));
+    assert_eq!(app.dock_shown_group(DockSide::Left), Some(1));
+    let _ = app.on_dock(DockMsg::HoverExit);
+    assert!(!app.dock_edge_expanded(DockSide::Left));
+    // Without auto-hide, hovering does not switch groups (clicks do).
+    let _ = app.on_dock(DockMsg::AutoCollapseToggle(PanelId::Properties));
+    let _ = app.on_dock(DockMsg::Hover(Some(PanelId::Properties)));
+    assert_eq!(app.dock_shown_group(DockSide::Left), Some(1));
+    assert!(app.dock_edge_expanded(DockSide::Left));
+}
+
+#[test]
+fn dock_float_resize_grows_the_panel() {
+    use crate::ui::dock::{DockMsg, FloatPanel, PanelId};
+    let mut app = dock_app();
+    app.dock.float(FloatPanel {
+        id: PanelId::BlockPalette,
+        x: 100.0,
+        y: 100.0,
+        w: 260.0,
+        h: 300.0,
+    });
+    let _ = app.on_dock(DockMsg::FloatResizeGrab(PanelId::BlockPalette, false));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(360.0, 400.0)));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(400.0, 450.0)));
+    let _ = app.on_dock(DockMsg::DragRelease);
+    let f = app.dock.float_rect(PanelId::BlockPalette).unwrap();
+    assert_eq!((f.w, f.h), (300.0, 350.0));
+    // The bottom-left grip grows the panel leftward, keeping its right edge.
+    let _ = app.on_dock(DockMsg::FloatResizeGrab(PanelId::BlockPalette, true));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(100.0, 450.0)));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(60.0, 450.0)));
+    let _ = app.on_dock(DockMsg::DragRelease);
+    let g = app.dock.float_rect(PanelId::BlockPalette).unwrap();
+    assert_eq!((g.x, g.w, g.h), (f.x - 40.0, 340.0, 350.0));
+}
+
+#[test]
+fn dock_edge_menu_adds_and_hides_pallets() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockMsg, PanelId};
+    let mut app = dock_app();
+    app.show_browser = false;
+    let _ = app.on_dock(DockMsg::EdgeMenu(Some(DockSide::Left)));
+    // Checking a closed pallet opens it as a new, shown group here.
+    let _ = app.on_dock(DockMsg::EdgeMenuToggle(DockSide::Left, PanelId::Browser));
+    assert!(app.show_browser);
+    assert_eq!(app.dock.left.len(), 2);
+    assert_eq!(app.dock.left[1].panels, vec![PanelId::Browser]);
+    assert_eq!(app.dock_shown_group(DockSide::Left), Some(1));
+    assert_eq!(app.dock_edge_menu, None, "the menu closes after adding");
+    let _ = app.on_dock(DockMsg::EdgeMenu(Some(DockSide::Left)));
+    // Unchecking hides it but keeps its place.
+    let _ = app.on_dock(DockMsg::EdgeMenuToggle(DockSide::Left, PanelId::Browser));
+    assert!(!app.show_browser);
+    assert_eq!(app.dock.location(PanelId::Browser), Some((DockSide::Left, 1)));
+    // Opening it again from the same edge reuses that place.
+    let _ = app.on_dock(DockMsg::EdgeMenuToggle(DockSide::Left, PanelId::Browser));
+    assert_eq!(app.dock.left.len(), 2);
+    // A pallet open on the other edge is not checked here: picking it
+    // moves it over instead of hiding it.
+    let _ = app.on_dock(DockMsg::EdgeMenuToggle(DockSide::Left, PanelId::BlockPalette));
+    assert!(app.show_block_palette);
+    assert!(app.dock.right.is_empty());
+    assert_eq!(app.dock.location(PanelId::BlockPalette), Some((DockSide::Left, 2)));
+}
+
+#[test]
+fn dock_divider_resizes_only_its_group() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockGroup, DockMsg, PanelId};
+    let mut app = dock_app();
+    app.dock.left = vec![
+        DockGroup::stack(vec![PanelId::Properties, PanelId::BlockPalette]),
+        DockGroup::single(PanelId::Count),
+    ];
+    app.dock.right.clear();
+    let _ = app.on_dock(DockMsg::ResizeGrab(PanelId::Properties));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(300.0, 100.0)));
+    let _ = app.on_dock(DockMsg::DragMove(iced::Point::new(330.0, 100.0)));
+    let _ = app.on_dock(DockMsg::DragRelease);
+    // The group was 260 wide (its widest pallet); it is now 290, while
+    // the other group and the pallets' own widths are untouched.
+    assert_eq!(app.dock_group_width(DockSide::Left, 0), 290.0);
+    assert_eq!(app.dock_group_width(DockSide::Left, 1), 280.0);
+    assert_eq!(app.dock.settings(PanelId::Properties).width, 250.0);
+}
+
+#[test]
+fn layers_command_opens_a_floating_pallet_and_toggles_it_closed() {
+    use crate::ui::dock::PanelId;
+    let mut app = dock_app();
+    let _ = app.update(Message::ToggleLayers);
+    assert!(app.show_layers);
+    assert!(app.active_modal.is_none(), "no modal backdrop");
+    let f = app.dock.float_rect(PanelId::Layers).expect("floats on first use");
+    assert!(f.x > 0.0 && f.y >= 0.0);
+    let _ = app.update(Message::ToggleLayers);
+    assert!(!app.show_layers);
+    // Its place is kept for next time.
+    assert!(app.dock.float_rect(PanelId::Layers).is_some());
+}
+
+/// A headless renderer for driving the real view.
+fn headless_renderer() -> iced::Renderer {
+    iced_test::futures::futures::executor::block_on(
+        <iced::Renderer as iced_test::core::renderer::Headless>::new(
+            iced_test::core::renderer::Settings::default(),
+            None,
+        ),
+    )
+    .expect("headless renderer")
+}
+
+/// Size the real view is laid out at.
+const VIEW_SIZE: iced::Size = iced::Size::new(1600.0, 900.0);
+
+/// Centre of the first text `label` in the real view.
+fn find_in_view(app: &OpenCADStudio, label: &str) -> iced::Point {
+    use iced_test::core::widget;
+    use iced_test::runtime::user_interface::{Cache, UserInterface};
+    use iced_test::Selector;
+    let mut renderer = headless_renderer();
+    let mut ui = UserInterface::build(app.view_main(), VIEW_SIZE, Cache::default(), &mut renderer);
+    let mut find = Selector::find(label);
+    ui.operate(&renderer, &mut widget::operation::black_box(&mut find));
+    match widget::Operation::finish(&find) {
+        widget::operation::Outcome::Some(Some(target)) => target
+            .visible_bounds()
+            .expect("visible")
+            .center(),
+        _ => panic!("{label} not found"),
+    }
+}
+
+/// Drive the real view through iced's `UserInterface` with the pointer at
+/// `at`: feed `events` one at a time, and between events hand the
+/// published messages to the app and rebuild the view while keeping the
+/// widget-tree cache, as the runtime does.
+fn drive_view(app: &mut OpenCADStudio, at: iced::Point, events: &[iced::Event]) {
+    use iced_test::core::{mouse, shell, window};
+    use iced_test::runtime::user_interface::{Cache, UserInterface};
+    let mut renderer = headless_renderer();
+    let mut cache = Cache::default();
+    let cursor = mouse::Cursor::Available(at);
+    for event in events {
+        let mut messages = Vec::new();
+        {
+            let mut ui = UserInterface::build(app.view_main(), VIEW_SIZE, cache, &mut renderer);
+            let _ = ui.update(
+                &window::Headless,
+                &shell::Waker::noop(),
+                std::slice::from_ref(event),
+                cursor,
+                &mut renderer,
+                &mut messages,
+            );
+            cache = ui.into_cache();
+        }
+        for message in messages {
+            let _ = app.update(message);
+        }
+    }
+}
+
+#[test]
+fn docked_title_bar_double_click_floats_the_pallet_in_the_real_view() {
+    use crate::ui::dock::PanelId;
+    let mut app = dock_app();
+    let press = iced::Event::Mouse(iced::mouse::Event::ButtonPressed(iced::mouse::Button::Left));
+    let release =
+        iced::Event::Mouse(iced::mouse::Event::ButtonReleased(iced::mouse::Button::Left));
+    // The block palette's title text sits in its docked title bar.
+    let title = find_in_view(&app, "Blocks");
+    drive_view(&mut app, title, &[press.clone(), release.clone(), press, release]);
+    assert!(
+        app.dock.float_rect(PanelId::BlockPalette).is_some(),
+        "a double-click on a docked title bar floats the pallet"
+    );
+}
+
+#[test]
+fn hovering_a_strip_icon_reveals_an_auto_hiding_edge_in_the_real_view() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockMsg, PanelId, STRIP_CELL_H, STRIP_PAD};
+    let mut app = dock_app();
+    // Mirror the layout onto the left so the block palette's title marks
+    // where the workspace starts, then auto-hide the right edge.
+    let title = find_in_view(&app, "Blocks");
+    let _ = app.on_dock(DockMsg::AutoCollapseToggle(PanelId::BlockPalette));
+    assert!(!app.dock_edge_expanded(DockSide::Right));
+    // The title bar text sits ~13 px below the workspace top; the strip's
+    // first icon is centred STRIP_PAD + half a cell below it.
+    let workspace_top = title.y - 13.0;
+    let icon = iced::Point::new(
+        VIEW_SIZE.width - crate::ui::dock::DOCK_STRIP_W / 2.0,
+        workspace_top + STRIP_PAD + STRIP_CELL_H / 2.0,
+    );
+    drive_view(
+        &mut app,
+        icon,
+        &[iced::Event::Mouse(iced::mouse::Event::CursorMoved { position: icon })],
+    );
+    assert!(
+        app.dock_edge_expanded(DockSide::Right),
+        "hovering the icon reveals the auto-hiding edge"
+    );
+}
+
+#[test]
+fn dock_double_clicks_float_and_dock_panels() {
+    use crate::app::config::DockSide;
+    use crate::ui::dock::{DockMsg, PanelId};
+    let mut app = dock_app();
+    let _ = app.on_dock(DockMsg::FloatOut(PanelId::Properties));
+    assert!(app.dock.left.is_empty());
+    let f = app.dock.float_rect(PanelId::Properties).expect("floating");
+    assert!(f.x > 0.0, "floats clear of the left edge");
+    let _ = app.on_dock(DockMsg::DockTo(PanelId::Properties, DockSide::Right));
+    assert!(app.dock.floating.is_empty());
+    assert_eq!(app.dock.location(PanelId::Properties), Some((DockSide::Right, 1)));
+}
+
+#[test]
+fn blockpalette_width_reset() {
+    use crate::app::config::DockSide;
+    let mut app = dock_app();
+    let id = crate::ui::dock::PanelId::BlockPalette;
+    app.dock.set_group_width(DockSide::Right, 0, 500.0);
+    let _ = app.on_dock(crate::ui::dock::DockMsg::WidthReset(id));
+    assert_eq!(app.dock.group_width(DockSide::Right, 0), 260.0);
+}