feat: implement window state persistence and restore functionality

- Added PersistedWindowState record to manage window properties.
- Implemented methods to save and load main window position and compact state.
- Enhanced MainWindow to save its position and state on close and restore on open.
- Introduced functionality to save and restore open secondary windows.
- Updated WindowHelper with methods to position windows within the visible area.

Author: devohmycode

AppSettings.cs

@@ -14,6 +14,13 @@ public record BackdropSettings(
     string FallbackColor = "#000000",
     string Kind = "Base");
 
+public record PersistedWindowState(
+    string Type,
+    string NoteId,
+    int X,
+    int Y,
+    bool IsCompact = false);
+
 public static class AppSettings
 {
     private static readonly string SettingsDir =
@@ -294,6 +301,47 @@ public static string LoadThemeSetting()
         return "system";
     }
 
+    public static (int X, int Y)? LoadMainWindowPosition()
+    {
+        try
+        {
+            if (!File.Exists(SettingsPath))
+                return null;
+
+            var json = File.ReadAllText(SettingsPath);
+            var doc = JsonDocument.Parse(json);
+            var root = doc.RootElement;
+            if (root.TryGetProperty("mainWindowX", out var xProp) &&
+                root.TryGetProperty("mainWindowY", out var yProp) &&
+                xProp.TryGetInt32(out var x) &&
+                yProp.TryGetInt32(out var y))
+            {
+                return (x, y);
+            }
+        }
+        catch { }
+        return null;
+    }
+
+    public static bool LoadMainWindowCompact()
+    {
+        try
+        {
+            if (!File.Exists(SettingsPath))
+                return false;
+
+            var json = File.ReadAllText(SettingsPath);
+            var doc = JsonDocument.Parse(json);
+            if (doc.RootElement.TryGetProperty("mainWindowCompact", out var compactProp) &&
+                (compactProp.ValueKind == JsonValueKind.True || compactProp.ValueKind == JsonValueKind.False))
+            {
+                return compactProp.GetBoolean();
+            }
+        }
+        catch { }
+        return false;
+    }
+
     public static void SaveBackdropSettings(BackdropSettings settings)
     {
         MergeAndSaveSettings(new Dictionary<string, object>
@@ -312,6 +360,107 @@ public static void SaveThemeSetting(string theme)
         MergeAndSaveSettings(new Dictionary<string, object> { ["theme"] = theme });
     }
 
+    public static void SaveMainWindowPosition(Windows.Graphics.PointInt32 position)
+    {
+        MergeAndSaveSettings(new Dictionary<string, object>
+        {
+            ["mainWindowX"] = position.X,
+            ["mainWindowY"] = position.Y
+        });
+    }
+
+    public static void SaveMainWindowCompact(bool isCompact)
+    {
+        MergeAndSaveSettings(new Dictionary<string, object>
+        {
+            ["mainWindowCompact"] = isCompact
+        });
+    }
+
+    public static List<PersistedWindowState> LoadOpenWindows()
+    {
+        var result = new List<PersistedWindowState>();
+        try
+        {
+            if (!File.Exists(SettingsPath))
+                return result;
+
+            var json = File.ReadAllText(SettingsPath);
+            var doc = JsonDocument.Parse(json);
+            if (!doc.RootElement.TryGetProperty("openWindows", out var windowsProp))
+            {
+                return result;
+            }
+
+            var arrayElement = windowsProp;
+            JsonDocument? nestedDoc = null;
+            if (windowsProp.ValueKind == JsonValueKind.String)
+            {
+                var raw = windowsProp.GetString();
+                if (!string.IsNullOrWhiteSpace(raw))
+                {
+                    nestedDoc = JsonDocument.Parse(raw);
+                    arrayElement = nestedDoc.RootElement;
+                }
+            }
+
+            if (arrayElement.ValueKind != JsonValueKind.Array)
+            {
+                nestedDoc?.Dispose();
+                return result;
+            }
+
+            foreach (var item in arrayElement.EnumerateArray())
+            {
+                if (item.ValueKind != JsonValueKind.Object)
+                    continue;
+
+                var type = item.TryGetProperty("type", out var typeProp)
+                    ? typeProp.GetString() ?? ""
+                    : "";
+                var noteId = item.TryGetProperty("noteId", out var noteIdProp)
+                    ? noteIdProp.GetString() ?? ""
+                    : "";
+                if (!item.TryGetProperty("x", out var xProp) ||
+                    !item.TryGetProperty("y", out var yProp) ||
+                    !xProp.TryGetInt32(out var x) ||
+                    !yProp.TryGetInt32(out var y) ||
+                    string.IsNullOrWhiteSpace(type))
+                {
+                    continue;
+                }
+
+                var isCompact =
+                    item.TryGetProperty("isCompact", out var compactProp) &&
+                    (compactProp.ValueKind == JsonValueKind.True || compactProp.ValueKind == JsonValueKind.False) &&
+                    compactProp.GetBoolean();
+
+                result.Add(new PersistedWindowState(type, noteId, x, y, isCompact));
+            }
+
+            nestedDoc?.Dispose();
+        }
+        catch { }
+        return result;
+    }
+
+    public static void SaveOpenWindows(IEnumerable<PersistedWindowState> windows)
+    {
+        var payload = windows.Select(w => new Dictionary<string, object>
+        {
+            ["type"] = w.Type,
+            ["noteId"] = w.NoteId,
+            ["x"] = w.X,
+            ["y"] = w.Y,
+            ["isCompact"] = w.IsCompact
+        }).ToList();
+
+        MergeAndSaveSettings(new Dictionary<string, object>
+        {
+            ["openWindows"] = payload
+        });
+    }
+
     private static void MergeAndSaveSettings(Dictionary<string, object> newValues)
     {
         try
@@ -324,14 +473,7 @@ private static void MergeAndSaveSettings(Dictionary<string, object> newValues)
                 foreach (var prop in doc.RootElement.EnumerateObject())
                 {
                     if (newValues.ContainsKey(prop.Name)) continue;
-                    existing[prop.Name] = prop.Value.ValueKind switch
-                    {
-                        JsonValueKind.Number => prop.Value.TryGetInt64(out var l) ? l : prop.Value.GetDouble(),
-                        JsonValueKind.String => prop.Value.GetString()!,
-                        JsonValueKind.True => true,
-                        JsonValueKind.False => false,
-                        _ => prop.Value.GetRawText()
-                    };
+                    existing[prop.Name] = ConvertJsonElement(prop.Value) ?? "";
                 }
             }
 
@@ -344,6 +486,24 @@ private static void MergeAndSaveSettings(Dictionary<string, object> newValues)
         catch { }
     }
 
+    private static object? ConvertJsonElement(JsonElement value)
+    {
+        return value.ValueKind switch
+        {
+            JsonValueKind.Object => value.EnumerateObject()
+                .ToDictionary(p => p.Name, p => ConvertJsonElement(p.Value)),
+            JsonValueKind.Array => value.EnumerateArray()
+                .Select(ConvertJsonElement)
+                .ToList(),
+            JsonValueKind.String => value.GetString(),
+            JsonValueKind.Number => value.TryGetInt64(out var l) ? l : value.GetDouble(),
+            JsonValueKind.True => true,
+            JsonValueKind.False => false,
+            JsonValueKind.Null => null,
+            _ => value.GetRawText()
+        };
+    }
+
     public static Windows.UI.Color ParseColor(string hex)
     {
         hex = hex.TrimStart('#');

MainWindow.xaml.cs

@@ -60,7 +60,11 @@ public MainWindow()
 
         WindowHelper.RemoveWindowBorder(this);
         AppWindow.Resize(new Windows.Graphics.SizeInt32(380, 650));
-        WindowHelper.CenterOnScreen(this);
+        var savedMainPos = AppSettings.LoadMainWindowPosition();
+        if (savedMainPos is { } pos)
+            WindowHelper.MoveToVisibleArea(this, pos.X, pos.Y);
+        else
+            WindowHelper.MoveToBottomRight(this);
         WindowShadow.Apply(this);
 
         // Set window icon (for taskbar / Alt+Tab)
@@ -93,15 +97,18 @@ public MainWindow()
         // Hide to tray instead of closing
         AppWindow.Closing += (_, args) =>
         {
+            SaveMainWindowPosition();
             if (!_isExiting)
             {
+                SaveOpenedSecondaryWindows();
                 args.Cancel = true;
                 AppWindow.Hide();
             }
         };
 
         this.Closed += (_, _) =>
         {
+            SaveMainWindowPosition();
             _textExpansion?.Stop();
             _reminderService?.Dispose();
             ReminderService.Shutdown();
@@ -117,6 +124,8 @@ public MainWindow()
         _textExpansion.Start();
         ApplyLocalization();
         RefreshNotesList();
+        SetCompactState(AppSettings.LoadMainWindowCompact(), animate: false);
+        RestorePersistedWindows();
 
         _reminderService = new ReminderService(_notes);
         _reminderService.ReminderFired += () => DispatcherQueue.TryEnqueue(() => RefreshCurrentView());
@@ -147,6 +156,8 @@ private async Task InitCloudSync()
     private void ExitApplication()
     {
         _isExiting = true;
+        SaveMainWindowPosition();
+        SaveOpenedSecondaryWindows();
         foreach (var w in _openNoteWindows.ToList())
         {
             try { w.Close(); } catch { }
@@ -177,6 +188,61 @@ private void RefreshNotesList(string? search = null)
         }
     }
 
+    private void SaveMainWindowPosition()
+    {
+        AppSettings.SaveMainWindowPosition(AppWindow.Position);
+        AppSettings.SaveMainWindowCompact(_isCompact);
+    }
+
+    private void SaveOpenedSecondaryWindows()
+    {
+        var windows = new List<PersistedWindowState>();
+        foreach (var noteWindow in _openNoteWindows.ToList())
+        {
+            var pos = noteWindow.AppWindow.Position;
+            windows.Add(new PersistedWindowState("note", noteWindow.NoteId, pos.X, pos.Y, noteWindow.IsCompact));
+        }
+
+        if (_notepadWindow != null)
+        {
+            var pos = _notepadWindow.AppWindow.Position;
+            windows.Add(new PersistedWindowState("notepad", "", pos.X, pos.Y));
+        }
+
+        AppSettings.SaveOpenWindows(windows);
+    }
+
+    private void RestorePersistedWindows()
+    {
+        var windows = AppSettings.LoadOpenWindows();
+        if (windows.Count == 0)
+            return;
+
+        var notepadRestored = false;
+        foreach (var window in windows)
+        {
+            if (window.Type == "note" && !string.IsNullOrWhiteSpace(window.NoteId))
+            {
+                OpenNote(window.NoteId);
+                var opened = _openNoteWindows.FirstOrDefault(w => w.NoteId == window.NoteId);
+                if (opened != null)
+                {
+                    opened.SetCompactState(window.IsCompact, animate: false);
+                    WindowHelper.MoveToVisibleArea(opened, window.X, window.Y);
+                }
+                continue;
+            }
+
+            if (window.Type == "notepad" && !notepadRestored)
+            {
+                OpenNotepad();
+                if (_notepadWindow != null)
+                    WindowHelper.MoveToVisibleArea(_notepadWindow, window.X, window.Y);
+                notepadRestored = true;
+            }
+        }
+    }
+
     private UIElement CreateNoteCard(NoteEntry note)
     {
         var color = NoteColors.Get(note.Color);
@@ -978,24 +1044,57 @@ private void Pin_Click(object sender, RoutedEventArgs e)
 
     private void Compact_Click(object sender, RoutedEventArgs e)
     {
-        _isCompact = !_isCompact;
+        SetCompactState(!_isCompact);
+    }
+
+    private void SetCompactState(bool compact, bool animate = true)
+    {
+        if (_isCompact == compact)
+            return;
+
+        _isCompact = compact;
         _targetHeight = _isCompact ? CompactHeight : FullHeight;
         CompactIcon.Glyph = _isCompact ? "\uE70D" : "\uE70E";
 
         if (_isCompact)
         {
-            AnimationHelper.FadeOut(TitleLabel, 100);
-            AnimationHelper.FadeOut(NotesScroll, 120);
+            if (animate)
+            {
+                AnimationHelper.FadeOut(TitleLabel, 100);
+                AnimationHelper.FadeOut(NotesScroll, 120);
+            }
+            else
+            {
+                TitleLabel.Opacity = 0;
+                NotesScroll.Opacity = 0;
+            }
         }
         else
         {
-            AnimationHelper.FadeIn(TitleLabel, 200, 80);
-            AnimationHelper.FadeIn(SearchGrid, 200, 120);
-            AnimationHelper.FadeIn(NotesScroll, 250, 160);
+            if (animate)
+            {
+                AnimationHelper.FadeIn(TitleLabel, 200, 80);
+                AnimationHelper.FadeIn(SearchGrid, 200, 120);
+                AnimationHelper.FadeIn(NotesScroll, 250, 160);
+            }
+            else
+            {
+                TitleLabel.Opacity = 1;
+                SearchGrid.Opacity = 1;
+                NotesScroll.Opacity = 1;
+            }
         }
 
-        _currentAnimHeight = AppWindow.Size.Height;
         _animTimer?.Stop();
+        _animTimer = null;
+        if (!animate)
+        {
+            _currentAnimHeight = _targetHeight;
+            AppWindow.Resize(new Windows.Graphics.SizeInt32(380, _targetHeight));
+            return;
+        }
+
+        _currentAnimHeight = AppWindow.Size.Height;
         _animTimer = new Microsoft.UI.Xaml.DispatcherTimer
         {
             Interval = TimeSpan.FromMilliseconds(8)