Add window state save/restore feature

WinUIGallery/Helpers/SettingsHelper/SettingsHelper.cs

@@ -63,4 +63,46 @@ public void UpdateRecentlyVisited(Action<List<string>> updater)
         updater(list);
         RecentlyVisited = list;
     }
+
+    public int MainWindowPositionX 
+    {
+        get => GetOrCreateDefault<int>(0);
+        set => Set(value);
+    }
+
+    public int MainWindowPositionY
+    {
+        get => GetOrCreateDefault<int>(0);
+        set => Set(value);
+    }
+
+    public int MainWindowWidth
+    {
+        get => GetOrCreateDefault<int>(0);
+        set => Set(value);
+    }
+
+    public int MainWindowHeight
+    {
+        get => GetOrCreateDefault<int>(0);
+        set => Set(value);
+    }
+
+    public bool IsMainWindowMaximized
+    {
+        get => GetOrCreateDefault<bool>(false);
+        set => Set(value);
+    }
+
+    public double MainWindowScale
+    {
+        get => GetOrCreateDefault<double>(1.0);
+        set => Set(value);
+    }
+
+    public bool SaveWindowState
+    {
+        get => GetOrCreateDefault<bool>(false);
+        set => Set(value);
+    }
 }

WinUIGallery/Helpers/WindowStateHelper.cs

@@ -0,0 +1,109 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Microsoft.UI.Windowing;
+using Microsoft.UI.Xaml;
+using System;
+using Windows.Graphics;
+using WinUIGallery.Models;
+
+namespace WinUIGallery.Helpers;
+
+public static class WindowStateHelper
+{
+    private static void SaveWindowState(WindowState state)
+    {
+        var s = SettingsHelper.Current;
+
+        s.MainWindowPositionX = state.PositionX;
+        s.MainWindowPositionY = state.PositionY;
+        s.MainWindowWidth = state.Width;
+        s.MainWindowHeight = state.Height;
+        s.MainWindowScale = state.Scale;
+        s.IsMainWindowMaximized = state.IsMaximized;
+    }
+
+    private static WindowState? LoadWindowState()
+    {
+        var s = SettingsHelper.Current;
+
+        bool isInvalid =
+            s.MainWindowWidth <= 0 ||
+            s.MainWindowHeight <= 0 ||
+            (
+                s.MainWindowPositionX == 0 &&
+                s.MainWindowPositionY == 0 &&
+                s.MainWindowWidth == 0 &&
+                s.MainWindowHeight == 0 &&
+                s.MainWindowScale == 1.0 &&
+                !s.IsMainWindowMaximized
+            );
+
+        if (isInvalid)
+            return null;
+
+        return new WindowState
+        {
+            PositionX = s.MainWindowPositionX,
+            PositionY = s.MainWindowPositionY,
+            Width = s.MainWindowWidth,
+            Height = s.MainWindowHeight,
+            Scale = s.MainWindowScale,
+            IsMaximized = s.IsMainWindowMaximized
+        };
+    }
+
+    public static void Save(Window window)
+    {
+        var appWindow = window.AppWindow;
+
+        double scale = window.Content.XamlRoot.RasterizationScale;
+        bool isMaximized = appWindow.Presenter is OverlappedPresenter p &&
+                           p.State == OverlappedPresenterState.Maximized;
+
+        // Restore before saving accurate dimensions
+        (appWindow.Presenter as OverlappedPresenter)?.Restore();
+
+        var state = new WindowState
+        {
+            PositionX = appWindow.Position.X,
+            PositionY = appWindow.Position.Y,
+            Width = appWindow.Size.Width,
+            Height = appWindow.Size.Height,
+            Scale = scale,
+            IsMaximized = isMaximized
+        };
+
+        SaveWindowState(state);
+    }
+
+    public static void ApplySavedState(Window window)
+    {
+        if (window.Content is FrameworkElement content)
+        {
+            double currentScale = content.XamlRoot.RasterizationScale;
+            var state = LoadWindowState();
+            if (state is null) return;
+
+            // adjust for DPI/scaling change
+            double scaleFactor = currentScale / state.Scale;
+            int width = (int)(state.Width * scaleFactor);
+            int height = (int)(state.Height * scaleFactor);
+            int x = state.PositionX;
+            int y = state.PositionY;
+
+            // ensure window fits display area
+            var displayArea = DisplayArea.GetFromPoint(new PointInt32(x,y), DisplayAreaFallback.Primary).WorkArea;
+            width = Math.Min(width, displayArea.Width);
+            height = Math.Min(height, displayArea.Height);
+            x = Math.Clamp(x, displayArea.X, displayArea.X + displayArea.Width - width);
+            y = Math.Clamp(y, displayArea.Y, displayArea.Y + displayArea.Height - height);
+
+            window.AppWindow.Move(new PointInt32(x, y));
+            window.AppWindow.Resize(new SizeInt32(width, height));
+
+            if (state.IsMaximized)
+                (window.AppWindow.Presenter as OverlappedPresenter)?.Maximize();
+        }
+    }
+}

WinUIGallery/MainWindow.xaml.cs

@@ -55,6 +55,24 @@ public MainWindow()
             AdjustNavigationViewMargin(force: true);
             AppWindow.Changed += (_, _) => AdjustNavigationViewMargin();
         }
+
+        // Restore window state on load
+        if (SettingsHelper.Current.SaveWindowState)
+        {
+            if (Content is FrameworkElement content)
+            {
+                content.Loaded += (_, _) => WindowStateHelper.ApplySavedState(this);
+            }
+        }
+
+        // Save window state on close
+        Closed += (_, _) =>
+        {
+            if (SettingsHelper.Current.SaveWindowState)
+            {
+                WindowStateHelper.Save(this);
+            }
+        };
     }
 
     // Adjusts the NavigationView margin based on the window state

WinUIGallery/Models/WindowState.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace WinUIGallery.Models;
+
+public class WindowState
+{
+    public int PositionX { get; set; }
+    public int PositionY { get; set; }
+    public int Width { get; set; }
+    public int Height { get; set; }
+    public double Scale { get; set; }
+    public bool IsMaximized { get; set; }
+}

WinUIGallery/Pages/SettingsPage.xaml

@@ -103,6 +103,15 @@
                         </StackPanel>
                     </toolkit:SettingsCard>
 
+                    <toolkit:SettingsCard Header="Save window state"
+                                          Description="Automatically save and restore window size and position between sessions">
+                        <toolkit:SettingsCard.HeaderIcon>
+                            <FontIcon Glyph="&#xE7C4;" />
+                        </toolkit:SettingsCard.HeaderIcon>
+                        <ToggleSwitch IsOn="{x:Bind Settings.SaveWindowState, Mode=TwoWay}"
+                                      OffContent="No"
+                                      OnContent="Yes" />
+                    </toolkit:SettingsCard>
 
                     <!--  About  -->
                     <TextBlock Style="{StaticResource SettingsSectionHeaderTextBlockStyle}" Text="About" />

WinUIGallery/Pages/SettingsPage.xaml.cs

@@ -28,7 +28,9 @@ public string Version
     }
 
     public string WinAppSdkRuntimeDetails => VersionHelper.WinAppSdkRuntimeDetails;
-    private int lastNavigationSelectionMode = 0;
+    private int lastNavigationSelectionMode = 0;
+
+    private SettingsHelper Settings => SettingsHelper.Current;
 
     public SettingsPage()
     {