cd06f89e59
Extends the resizable="true"/minw/minh markup grammar's coverage past MarkupDocument's own parse tests to the two host seams a resizable plugin panel actually flows through, proving no host-side wiring beyond what MarkupDocument.Build already sets on the panel was needed: - RetailWindowManagerTests: a resizable="true" markup panel accepts RetailWindowManager.ResizeTo within its minw/minh floor (and clamps to it below the floor); a plain (non-resizable) markup panel refuses — Width/Height unchanged and no Resized event, exactly today's fixed-size behavior. - RetailWindowLayoutPersistenceTests: a resizable panel's dragged size round-trips through save/restore into a fresh session, and a saved size below the panel's CURRENT minw/minh floor (a legacy save, or a plugin update that raised its floor) clamps UP to the floor on restore rather than restoring the too-small legacy value. Mutation proof: reverted MarkupDocument.cs to its pre-feature state and reran the new tests — the two RetailWindowManagerTests cases failed (the old UiNineSlicePanel ctor default of Resizable=true/MinWidth=40 let the "fixed" window resize and let the "resizable" window shrink below the new floor), and the persistence floor-clamp case failed (80x60 came back instead of clamping to 200x150). The plain save/restore round-trip case passed either way — the old ctor default was already resizable, so it exercises a real but coincidentally already-covered path; kept for its own documentation value. Restoring the implementation returns 256/257 (1 pre-existing unrelated skip) on the full Markup/PluginSidePanel/RetailWindow/Anchor-filtered App suite and 9/9 on the MossTank markup-filtered suite, both green. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
560 lines
21 KiB
C#
560 lines
21 KiB
C#
using AcDream.App.UI;
|
||
using AcDream.App.UI.Layout;
|
||
using AcDream.UI.Abstractions.Panels.Settings;
|
||
|
||
namespace AcDream.App.Tests.UI;
|
||
|
||
public sealed class RetailWindowLayoutPersistenceTests : IDisposable
|
||
{
|
||
private readonly string _directory = Path.Combine(
|
||
Path.GetTempPath(), "acdream-window-layout-tests-" + Guid.NewGuid().ToString("N"));
|
||
private string PathName => Path.Combine(_directory, "settings.json");
|
||
|
||
[Fact]
|
||
public void CompletedInteractions_SaveCompleteCharacterResolutionLayout()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
RetailWindowHandle handle = Mount(root, "chat");
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => (800, 600));
|
||
|
||
handle.MoveTo(44f, 55f);
|
||
handle.ResizeTo(320f, 180f);
|
||
handle.Hide();
|
||
|
||
UiWindowLayout saved = Assert.IsType<UiWindowLayout>(
|
||
store.LoadWindowLayout("Alice", "800x600", "chat", default));
|
||
Assert.Equal((44f, 55f, 320f, 180f), (saved.X, saved.Y, saved.Width, saved.Height));
|
||
Assert.False(saved.Visible);
|
||
}
|
||
|
||
[Fact]
|
||
public void MainPanelMove_PersistsCanonicalPositionForEveryPrimaryChild()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
RetailWindowHandle inventory = Mount(root, WindowNames.Inventory);
|
||
RetailWindowHandle character = Mount(root, WindowNames.Character);
|
||
inventory.Hide();
|
||
character.Hide();
|
||
|
||
using var panels = new RetailPanelUiController(
|
||
root.IsWindowVisible,
|
||
root.ShowWindow,
|
||
root.HideWindow);
|
||
panels.RegisterMainPanel(
|
||
RetailPanelCatalog.Inventory,
|
||
WindowNames.Inventory,
|
||
inventory);
|
||
panels.RegisterMainPanel(
|
||
RetailPanelCatalog.Character,
|
||
WindowNames.Character,
|
||
character);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager,
|
||
store,
|
||
() => "Alice",
|
||
() => (800, 600));
|
||
|
||
panels.SetPanelVisibility(RetailPanelCatalog.Inventory, visible: true);
|
||
inventory.MoveTo(244f, 133f);
|
||
|
||
UiWindowLayout savedInventory = Assert.IsType<UiWindowLayout>(
|
||
store.LoadWindowLayout(
|
||
"Alice", "800x600", WindowNames.Inventory, default));
|
||
UiWindowLayout savedCharacter = Assert.IsType<UiWindowLayout>(
|
||
store.LoadWindowLayout(
|
||
"Alice", "800x600", WindowNames.Character, default));
|
||
Assert.Equal((244f, 133f), (savedInventory.X, savedInventory.Y));
|
||
Assert.Equal((244f, 133f), (savedCharacter.X, savedCharacter.Y));
|
||
}
|
||
|
||
[Fact]
|
||
public void Restore_ClampsBoundsAndReappliesPanelStateAndVisibility()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
store.SaveWindowLayout(
|
||
"Alice",
|
||
"640x480",
|
||
"chat",
|
||
new UiWindowLayout(900f, 700f, 500f, 300f, false, false, true));
|
||
|
||
var root = new UiRoot { Width = 640, Height = 480 };
|
||
var state = new FakeWindowState();
|
||
RetailWindowHandle handle = Mount(root, "chat", state);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => (640, 480));
|
||
|
||
persistence.RestoreAll();
|
||
|
||
Assert.Equal((500f, 300f), (handle.Width, handle.Height));
|
||
Assert.Equal((140f, 180f), (handle.Left, handle.Top));
|
||
Assert.False(handle.IsVisible);
|
||
Assert.True(state.Restored.Maximized);
|
||
}
|
||
|
||
[Fact]
|
||
public void Restore_OlderAuthoredGeometryRevision_ResetsOnlySavedExtent()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
store.SaveWindowLayout(
|
||
"Alice",
|
||
"800x600",
|
||
WindowNames.Examination,
|
||
new UiWindowLayout(
|
||
44f,
|
||
55f,
|
||
310f,
|
||
545f,
|
||
true,
|
||
false,
|
||
false,
|
||
AuthoredGeometryRevision: 0));
|
||
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
RetailWindowHandle handle = Mount(
|
||
root,
|
||
WindowNames.Examination,
|
||
authoredGeometryRevision: 1,
|
||
width: 310f,
|
||
height: 400f);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager,
|
||
store,
|
||
() => "Alice",
|
||
() => (800, 600));
|
||
|
||
persistence.RestoreAll();
|
||
|
||
Assert.Equal((44f, 55f), (handle.Left, handle.Top));
|
||
Assert.Equal((310f, 400f), (handle.Width, handle.Height));
|
||
UiWindowLayout migrated = Assert.IsType<UiWindowLayout>(
|
||
store.LoadWindowLayout(
|
||
"Alice",
|
||
"800x600",
|
||
WindowNames.Examination,
|
||
default));
|
||
Assert.Equal(1, migrated.AuthoredGeometryRevision);
|
||
}
|
||
|
||
[Fact]
|
||
public void RestoreNamed_OlderRevisionUsesMountedAuthoredExtent_NotCurrentSize()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
store.SaveNamedWindowLayout(
|
||
"legacy",
|
||
WindowNames.Examination,
|
||
new UiWindowLayout(
|
||
44f,
|
||
55f,
|
||
310f,
|
||
545f,
|
||
true,
|
||
false,
|
||
false,
|
||
AuthoredGeometryRevision: 0));
|
||
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
RetailWindowHandle handle = Mount(
|
||
root,
|
||
WindowNames.Examination,
|
||
authoredGeometryRevision: 1,
|
||
width: 310f,
|
||
height: 400f);
|
||
handle.ResizeTo(500f, 300f);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager,
|
||
store,
|
||
() => "Alice",
|
||
() => (800, 600));
|
||
|
||
persistence.RestoreNamed("legacy");
|
||
|
||
Assert.Equal((44f, 55f), (handle.Left, handle.Top));
|
||
Assert.Equal((310f, 400f), (handle.Width, handle.Height));
|
||
}
|
||
|
||
[Fact]
|
||
public void DefaultPreLoginKey_NeverOverwritesCharacterLayouts()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
RetailWindowHandle handle = Mount(root, "radar");
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "default", () => (800, 600));
|
||
|
||
handle.MoveTo(123f, 234f);
|
||
|
||
Assert.Null(store.LoadWindowLayout("default", "800x600", "radar", default));
|
||
}
|
||
|
||
[Fact]
|
||
public void Restore_StateManagedWindow_PreservesAuthoritativeVisibility()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
store.SaveWindowLayout(
|
||
"Alice",
|
||
"800x600",
|
||
"combat",
|
||
new UiWindowLayout(44f, 55f, 200f, 100f, true, false, false));
|
||
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
RetailWindowHandle handle = Mount(root, "combat");
|
||
handle.Hide();
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager,
|
||
store,
|
||
() => "Alice",
|
||
() => (800, 600),
|
||
stateManagedVisibilityWindows: ["combat"]);
|
||
|
||
persistence.RestoreAll();
|
||
|
||
Assert.Equal((44f, 55f), (handle.Left, handle.Top));
|
||
Assert.False(handle.IsVisible);
|
||
|
||
// Combat mode owns subsequent show/hide transitions as well; they must
|
||
// not turn into saved user visibility preferences.
|
||
handle.Show();
|
||
UiWindowLayout saved = Assert.IsType<UiWindowLayout>(
|
||
store.LoadWindowLayout("Alice", "800x600", "combat", default));
|
||
Assert.False(saved.Visible);
|
||
}
|
||
|
||
[Fact]
|
||
public void NamedProfile_SaveAndRestore_AppliesEveryMountedWindow()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
RetailWindowHandle chat = Mount(root, "chat");
|
||
RetailWindowHandle radar = Mount(root, "radar");
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => (800, 600));
|
||
|
||
chat.MoveTo(44f, 55f);
|
||
radar.MoveTo(300f, 120f);
|
||
radar.Hide();
|
||
persistence.SaveNamed("hunting");
|
||
|
||
chat.MoveTo(1f, 2f);
|
||
radar.MoveTo(3f, 4f);
|
||
radar.Show();
|
||
persistence.RestoreNamed("hunting");
|
||
|
||
Assert.Equal((44f, 55f), (chat.Left, chat.Top));
|
||
Assert.Equal((300f, 120f), (radar.Left, radar.Top));
|
||
Assert.False(radar.IsVisible);
|
||
}
|
||
|
||
// ── #390: retail's display-change anti-stranding cascade ────────────
|
||
// The clamp rule is each floating window's own MoveTo override,
|
||
// x = max(0, min(x, parentW − selfW)) (top-left priority), re-applied
|
||
// unconditionally on every display change — see
|
||
// docs/research/2026-08-13-retail-ui-display-change.md.
|
||
|
||
[Fact]
|
||
public void ClampAllToScreen_ReclampsStrandedWindows_TopLeftPriority()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 2560, Height = 1440 };
|
||
RetailWindowHandle handle = Mount(
|
||
root, WindowNames.Examination, width: 310f, height: 400f);
|
||
handle.MoveTo(2200f, 1000f); // parked near the bottom-right corner
|
||
(int Width, int Height) screen = (2560, 1440);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => screen);
|
||
|
||
screen = (1280, 720); // the display shrank
|
||
persistence.ClampAllToScreen();
|
||
|
||
Assert.Equal(1280f - 310f, handle.Left);
|
||
Assert.Equal(720f - 400f, handle.Top);
|
||
}
|
||
|
||
[Fact]
|
||
public void ClampAllToScreen_OversizedWindow_PinsTopLeftToZero()
|
||
{
|
||
// max(0, min(...)) — the max applies LAST, so a window larger than
|
||
// the screen pins to 0 and its top-left chrome stays reachable.
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
RetailWindowHandle handle = Mount(
|
||
root, WindowNames.Examination, width: 310f, height: 400f);
|
||
handle.MoveTo(400f, 300f);
|
||
(int Width, int Height) screen = (800, 600);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => screen);
|
||
|
||
screen = (200, 200); // smaller than the window itself
|
||
persistence.ClampAllToScreen();
|
||
|
||
Assert.Equal(0f, handle.Left);
|
||
Assert.Equal(0f, handle.Top);
|
||
}
|
||
|
||
[Fact]
|
||
public void ClampAllToScreen_InBoundsWindow_DoesNotMove()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 2560, Height = 1440 };
|
||
RetailWindowHandle handle = Mount(
|
||
root, WindowNames.Examination, width: 310f, height: 400f);
|
||
handle.MoveTo(100f, 120f);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => (1280, 720));
|
||
|
||
persistence.ClampAllToScreen();
|
||
|
||
Assert.Equal((100f, 120f), (handle.Left, handle.Top));
|
||
}
|
||
|
||
[Fact]
|
||
public void ClampAllToScreen_DoesNotSaveTheClampedPositions()
|
||
{
|
||
// The clamp runs per resize FRAME during a live window drag; its
|
||
// MoveTo must not trip the per-move save (settings.json writes per
|
||
// frame, keyed by whatever intermediate resolution the drag passes
|
||
// through). Only USER moves save.
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 2560, Height = 1440 };
|
||
RetailWindowHandle handle = Mount(
|
||
root, WindowNames.Examination, width: 310f, height: 400f);
|
||
handle.MoveTo(2200f, 1000f); // pre-attach: no save subscription yet
|
||
(int Width, int Height) screen = (2560, 1440);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => screen);
|
||
|
||
screen = (1280, 720);
|
||
persistence.ClampAllToScreen();
|
||
|
||
Assert.Equal(1280f - 310f, handle.Left); // it DID clamp…
|
||
Assert.Null(store.LoadWindowLayout( // …and did NOT write.
|
||
"Alice", "1280x720", WindowNames.Examination, default));
|
||
}
|
||
|
||
[Fact]
|
||
public void RestoreAfterDisplayChange_WritesNothingToTheStore()
|
||
{
|
||
// The live display-change reload (#390) must not persist — retail
|
||
// saves layouts only via @saveui/@saveautoui, and a mid-drag reload
|
||
// writing would litter settings.json with intermediate-resolution
|
||
// keys.
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
_ = Mount(root, WindowNames.Examination, width: 310f, height: 400f);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => (800, 600));
|
||
|
||
persistence.RestoreAfterDisplayChange();
|
||
|
||
Assert.Null(store.LoadWindowLayout(
|
||
"Alice", "800x600", WindowNames.Examination, default));
|
||
}
|
||
|
||
[Fact]
|
||
public void RestoreAfterDisplayChange_RestoresGeometryButPreservesLiveVisibility()
|
||
{
|
||
// Retail's global-message-0xE auto-layout file contains only X/Y/W/H.
|
||
// Our richer ambient settings schema also remembers visibility and
|
||
// collapsed/maximized state, but replaying visibility during a
|
||
// resolution change used to hide an open Options panel. Config's OnHidden reset
|
||
// then restored the previous resolution, creating the user-observed
|
||
// resize-out/resize-back blip.
|
||
var store = new SettingsStore(PathName);
|
||
store.SaveWindowLayout(
|
||
"Alice",
|
||
"1280x720",
|
||
WindowNames.Options,
|
||
new UiWindowLayout(
|
||
X: 700f,
|
||
Y: 200f,
|
||
Width: 310f,
|
||
Height: 400f,
|
||
Visible: false,
|
||
Collapsed: true,
|
||
Maximized: true));
|
||
|
||
var root = new UiRoot { Width = 1280, Height = 720 };
|
||
var state = new FakeWindowState();
|
||
var lifecycle = new FakePanelController();
|
||
RetailWindowHandle handle = Mount(
|
||
root,
|
||
WindowNames.Options,
|
||
state,
|
||
controller: lifecycle,
|
||
width: 300f,
|
||
height: 300f);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager,
|
||
store,
|
||
() => "Alice",
|
||
() => (1280, 720));
|
||
|
||
persistence.RestoreAfterDisplayChange();
|
||
|
||
Assert.Equal((700f, 200f, 310f, 400f),
|
||
(handle.Left, handle.Top, handle.Width, handle.Height));
|
||
Assert.True(handle.IsVisible);
|
||
Assert.Equal(0, lifecycle.HiddenCount);
|
||
Assert.Equal(1, state.RestoreCount);
|
||
Assert.True(state.Restored.Collapsed);
|
||
Assert.True(state.Restored.Maximized);
|
||
}
|
||
|
||
// ── Review fix round finding 4 (plugin-shelf campaign, 2026-09-06):
|
||
// attach late registrations, not only windows present at construction ──
|
||
|
||
[Fact]
|
||
public void WindowRegisteredAfterConstruction_StillRoundTrips()
|
||
{
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => (800, 600));
|
||
|
||
// The window is registered AFTER persistence already exists — before
|
||
// this fix only windows present in RetailWindowManager.Windows at
|
||
// construction time ever got a save subscription.
|
||
RetailWindowHandle handle = Mount(root, "late-window");
|
||
handle.MoveTo(77f, 88f);
|
||
|
||
UiWindowLayout saved = Assert.IsType<UiWindowLayout>(
|
||
store.LoadWindowLayout("Alice", "800x600", "late-window", default));
|
||
Assert.Equal((77f, 88f), (saved.X, saved.Y));
|
||
}
|
||
|
||
// ── 2026-09-07: a resizable plugin markup panel's resized geometry
|
||
// persists and restores exactly like any other registered window — no
|
||
// persistence-layer change was needed for this, since RetailWindowLayoutPersistence
|
||
// already clamps against the frame's own MinWidth/MinHeight/MaxWidth/
|
||
// MaxHeight (Apply's ClampDimension) for every registered handle. ────────
|
||
|
||
[Fact]
|
||
public void ResizableMarkupPluginPanel_ResizedSize_RoundTripsThroughPersistence()
|
||
{
|
||
const string xml =
|
||
"<panel x=\"0\" y=\"0\" w=\"300\" h=\"200\" resizable=\"true\" minw=\"200\" minh=\"150\"></panel>";
|
||
var panel = MarkupDocument.Build(xml, new object(), _ => (1u, 32, 32));
|
||
var store = new SettingsStore(PathName);
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
root.AddChild(panel);
|
||
RetailWindowHandle handle = root.RegisterWindow("plugin-resizable-panel", panel);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => (800, 600));
|
||
|
||
handle.MoveTo(60f, 70f);
|
||
handle.ResizeTo(420f, 260f);
|
||
|
||
UiWindowLayout saved = Assert.IsType<UiWindowLayout>(
|
||
store.LoadWindowLayout("Alice", "800x600", "plugin-resizable-panel", default));
|
||
Assert.Equal((60f, 70f, 420f, 260f), (saved.X, saved.Y, saved.Width, saved.Height));
|
||
|
||
// Simulate a fresh session: rebuild the same markup (a fresh, un-resized
|
||
// panel) and restore — the saved 420x260 must come back, not the
|
||
// authored 300x200.
|
||
var freshPanel = MarkupDocument.Build(xml, new object(), _ => (1u, 32, 32));
|
||
var freshRoot = new UiRoot { Width = 800, Height = 600 };
|
||
freshRoot.AddChild(freshPanel);
|
||
RetailWindowHandle freshHandle = freshRoot.RegisterWindow(
|
||
"plugin-resizable-panel", freshPanel);
|
||
using var freshPersistence = new RetailWindowLayoutPersistence(
|
||
freshRoot.WindowManager, store, () => "Alice", () => (800, 600));
|
||
|
||
freshPersistence.RestoreAll();
|
||
|
||
Assert.Equal((420f, 260f), (freshPanel.Width, freshPanel.Height));
|
||
Assert.Equal((60f, 70f), (freshPanel.Left, freshPanel.Top));
|
||
}
|
||
|
||
[Fact]
|
||
public void ResizableMarkupPluginPanel_RestoreClampsBelowFloorToAuthoredMin()
|
||
{
|
||
// A legacy save from before this feature's minw/minh existed (or one
|
||
// from a plugin update that raised its floor) can carry a size below
|
||
// the CURRENT authored minimum. Restore must clamp up to that floor —
|
||
// this is what RetailWindowLayoutPersistence.Apply's ClampDimension
|
||
// already does against frame.MinWidth/MinHeight for every registered
|
||
// window; it only bites here because MarkupDocument now sets those
|
||
// fields from minw/minh instead of leaving them at UiElement's
|
||
// generic 40x40 default.
|
||
const string xml =
|
||
"<panel x=\"0\" y=\"0\" w=\"300\" h=\"200\" resizable=\"true\" minw=\"200\" minh=\"150\"></panel>";
|
||
var store = new SettingsStore(PathName);
|
||
store.SaveWindowLayout(
|
||
"Alice",
|
||
"800x600",
|
||
"plugin-resizable-floor",
|
||
new UiWindowLayout(60f, 70f, 80f, 60f, true, false, false));
|
||
|
||
var panel = MarkupDocument.Build(xml, new object(), _ => (1u, 32, 32));
|
||
var root = new UiRoot { Width = 800, Height = 600 };
|
||
root.AddChild(panel);
|
||
root.RegisterWindow("plugin-resizable-floor", panel);
|
||
using var persistence = new RetailWindowLayoutPersistence(
|
||
root.WindowManager, store, () => "Alice", () => (800, 600));
|
||
|
||
persistence.RestoreAll();
|
||
|
||
Assert.Equal((200f, 150f), (panel.Width, panel.Height));
|
||
}
|
||
|
||
private static RetailWindowHandle Mount(
|
||
UiRoot root,
|
||
string name,
|
||
IRetainedWindowStateController? state = null,
|
||
int authoredGeometryRevision = 0,
|
||
float width = 200f,
|
||
float height = 100f,
|
||
IRetainedPanelController? controller = null)
|
||
{
|
||
var frame = new UiPanel
|
||
{
|
||
Left = 10f,
|
||
Top = 20f,
|
||
Width = width,
|
||
Height = height,
|
||
MinWidth = 100f,
|
||
MinHeight = 80f,
|
||
MaxWidth = 600f,
|
||
MaxHeight = 400f,
|
||
Draggable = true,
|
||
Resizable = true,
|
||
};
|
||
root.AddChild(frame);
|
||
return root.RegisterWindow(
|
||
name,
|
||
frame,
|
||
controller: controller,
|
||
stateController: state,
|
||
authoredGeometryRevision: authoredGeometryRevision);
|
||
}
|
||
|
||
public void Dispose()
|
||
{
|
||
if (Directory.Exists(_directory)) Directory.Delete(_directory, recursive: true);
|
||
}
|
||
|
||
private sealed class FakeWindowState : IRetainedWindowStateController
|
||
{
|
||
public RetainedWindowState Restored { get; private set; }
|
||
public int RestoreCount { get; private set; }
|
||
public RetainedWindowState CaptureWindowState() => Restored;
|
||
public void RestoreWindowState(RetainedWindowState state)
|
||
{
|
||
Restored = state;
|
||
RestoreCount++;
|
||
}
|
||
}
|
||
|
||
private sealed class FakePanelController : IRetainedPanelController
|
||
{
|
||
public int HiddenCount { get; private set; }
|
||
|
||
public void OnShown() { }
|
||
|
||
public void OnHidden() => HiddenCount++;
|
||
|
||
public void Dispose() { }
|
||
}
|
||
}
|