Store/Restore setting via ApplicationDataContainer

Author: 0x5bfa

src/Files.App/Data/Items/WindowEx.cs

@@ -4,17 +4,23 @@
 using Microsoft.UI.Windowing;
 using Microsoft.UI.Xaml;
 using System.Runtime.InteropServices;
+using Windows.Foundation;
+using Windows.Foundation.Collections;
+using Windows.Storage;
 using Windows.Win32;
 using Windows.Win32.Foundation;
+using Windows.Win32.Graphics.Gdi;
 using Windows.Win32.UI.WindowsAndMessaging;
 
 namespace Files.App.Data.Items
 {
-	public unsafe class WindowEx : Window
+	public unsafe class WindowEx : Window, IDisposable
 	{
 		private readonly WNDPROC _oldWndProc;
 		private readonly WNDPROC _newWndProc;
 
+		private readonly ApplicationDataContainer _applicationDataContainer = ApplicationData.Current.LocalSettings;
+
 		public nint WindowHandle { get; }
 
 		public int MinWidth { get; set; }
@@ -27,7 +33,9 @@ public bool IsMaximizable
 			set
 			{
 				_IsMaximizable = value;
-				UpdateOverlappedPresenter((c) => c.IsMaximizable = value);
+
+				if (AppWindow.Presenter is OverlappedPresenter overlapped)
+					overlapped.IsMaximizable = value;
 
 				if (value)
 				{
@@ -51,8 +59,10 @@ public bool IsMinimizable
 			get => _IsMinimizable;
 			set
 			{
-				_IsMaximizable = value;
-				UpdateOverlappedPresenter((c) => c.IsMinimizable = value);
+				_IsMinimizable = value;
+
+				if (AppWindow.Presenter is OverlappedPresenter overlapped)
+					overlapped.IsMinimizable = value;
 			}
 		}
 
@@ -62,18 +72,164 @@ public unsafe WindowEx(int minWidth = 400, int minHeight = 300)
 			MinWidth = minWidth;
 			MinHeight = minHeight;
 
+			RestoreWindowPlacementData();
+
 			_newWndProc = new(NewWindowProc);
 			var pNewWndProc = Marshal.GetFunctionPointerForDelegate(_newWndProc);
 			var pOldWndProc = PInvoke.SetWindowLongPtr(new(WindowHandle), WINDOW_LONG_PTR_INDEX.GWL_WNDPROC, pNewWndProc);
 			_oldWndProc = Marshal.GetDelegateForFunctionPointer<WNDPROC>(pOldWndProc);
 		}
 
-		private void UpdateOverlappedPresenter(Action<OverlappedPresenter> action)
+		private unsafe void StoreWindowPlacementData()
 		{
-			if (AppWindow.Presenter is OverlappedPresenter overlapped)
-				action(overlapped);
+			// Save window placement only for MainWindow
+			if (!GetType().Name.Equals(nameof(MainWindow), StringComparison.OrdinalIgnoreCase))
+				return;
+
+			// Store monitor info
+			using var data = new SystemIO.MemoryStream();
+			using var sw = new SystemIO.BinaryWriter(data);
+
+			var monitors = GetAllMonitorInfo();
+			int nMonitors = PInvoke.GetSystemMetrics(SYSTEM_METRICS_INDEX.SM_CMONITORS);
+			sw.Write(nMonitors);
+
+			foreach (var monitor in monitors)
+			{
+				sw.Write(monitor.Item1);
+				sw.Write(monitor.Item2.Left);
+				sw.Write(monitor.Item2.Top);
+				sw.Write(monitor.Item2.Right);
+				sw.Write(monitor.Item2.Bottom);
+			}
+
+			WINDOWPLACEMENT placement = default;
+			PInvoke.GetWindowPlacement(new(WindowHandle), ref placement);
+
+			int structSize = Marshal.SizeOf(typeof(WINDOWPLACEMENT));
+			IntPtr buffer = Marshal.AllocHGlobal(structSize);
+			Marshal.StructureToPtr(placement, buffer, false);
+			byte[] placementData = new byte[structSize];
+			Marshal.Copy(buffer, placementData, 0, structSize);
+			Marshal.FreeHGlobal(buffer);
+
+			sw.Write(placementData);
+			sw.Flush();
+
+			var values = GetDataStore(out var oldDataExists);
+
+			values[oldDataExists ? "WindowPersistance_FilesMainWindow" : "MainWindowPlacementData"] = Convert.ToBase64String(data.ToArray());
+		}
+
+		private void RestoreWindowPlacementData()
+		{
+			// Save window placement only for MainWindow
+			if (!GetType().Name.Equals(nameof(MainWindow), StringComparison.OrdinalIgnoreCase))
+				return;
+
+			var values = GetDataStore(out var oldDataExists);
+
+			byte[]? data = null;
+			if (values.TryGetValue(oldDataExists ? "WindowPersistance_FilesMainWindow" : "MainWindowPlacementData", out object? value))
+			{
+				if (value is string base64)
+					data = Convert.FromBase64String(base64);
+			}
+
+			if (data is null)
+				return;
+
+			SystemIO.BinaryReader br = new(new SystemIO.MemoryStream(data));
+
+			// Check if monitor layout changed since we stored position
+			var monitors = GetAllMonitorInfo();
+			int monitorCount = br.ReadInt32();
+			int nMonitors = PInvoke.GetSystemMetrics(SYSTEM_METRICS_INDEX.SM_CMONITORS);
+			if (monitorCount != nMonitors)
+				return;
+
+			for (int i = 0; i < monitorCount; i++)
+			{
+				var pMonitor = monitors[i];
+				br.ReadString();
+				if (pMonitor.Item2.Left != br.ReadDouble() ||
+					pMonitor.Item2.Top != br.ReadDouble() ||
+					pMonitor.Item2.Right != br.ReadDouble() ||
+					pMonitor.Item2.Bottom != br.ReadDouble())
+					return;
+			}
+
+			int structSize = Marshal.SizeOf(typeof(WINDOWPLACEMENT));
+			byte[] placementData = br.ReadBytes(structSize);
+			IntPtr buffer = Marshal.AllocHGlobal(structSize);
+			Marshal.Copy(placementData, 0, buffer, structSize);
+			var windowPlacementData = (WINDOWPLACEMENT)Marshal.PtrToStructure(buffer, typeof(WINDOWPLACEMENT))!;
+
+			Marshal.FreeHGlobal(buffer);
+
+			// Ignore anything by maximized or normal
+			if (windowPlacementData.showCmd == (SHOW_WINDOW_CMD)0x0002 /*SW_INVALIDATE*/ &&
+				windowPlacementData.flags == WINDOWPLACEMENT_FLAGS.WPF_RESTORETOMAXIMIZED)
+				windowPlacementData.showCmd = SHOW_WINDOW_CMD.SW_MAXIMIZE;
+			else if (windowPlacementData.showCmd != SHOW_WINDOW_CMD.SW_MAXIMIZE)
+				windowPlacementData.showCmd = SHOW_WINDOW_CMD.SW_NORMAL;
+
+			PInvoke.SetWindowPlacement(new(WindowHandle), in windowPlacementData);
+
+			return;
+		}
+
+		private IPropertySet GetDataStore(out bool oldDataExists)
+		{
+			IPropertySet values;
+			oldDataExists = false;
+
+			// TODO: Remove this after a couple of months past
+			if (_applicationDataContainer.Containers.TryGetValue("WinUIEx", out var oldDataContainer))
+			{
+				values = oldDataContainer.Values;
+				oldDataExists = true;
+			}
+			else if (_applicationDataContainer.Containers.TryGetValue("Files", out var dataContainer))
+			{
+				values = dataContainer.Values;
+			}
 			else
-				throw new NotSupportedException($"'{AppWindow.Presenter.Kind}' presenter is not supported.");
+			{
+				values = _applicationDataContainer.CreateContainer(
+					"Files",
+					ApplicationDataCreateDisposition.Always).Values;
+			}
+
+			return values;
+		}
+
+		private unsafe List<Tuple<string, Rect>> GetAllMonitorInfo()
+		{
+			List<Tuple<string, Rect>> monitors = [];
+			MONITORENUMPROC callback = new((HMONITOR monitor, HDC deviceContext, RECT* rect, LPARAM data) =>
+			{
+				MONITORINFOEXW info = default;
+				info.monitorInfo.cbSize = (uint)Marshal.SizeOf<MONITORINFOEXW>();
+
+				//fixed (MONITORINFOEXW* pInfo = &info)
+				//{
+					PInvoke.GetMonitorInfo(monitor, (MONITORINFO*)&info);
+
+					monitors.Add(new(
+						info.szDevice.ToString(),
+						new(new Point(rect->left, rect->top), new Point(rect->right, rect->bottom))));
+				//}
+
+				return true;
+			});
+
+			LPARAM lParam = default;
+			bool ok = PInvoke.EnumDisplayMonitors(new(nint.Zero), (RECT*)null, callback, lParam);
+			if (!ok)
+				Marshal.ThrowExceptionForHR(Marshal.GetLastWin32Error());
+
+			return monitors;
 		}
 
 		private LRESULT NewWindowProc(HWND param0, uint param1, WPARAM param2, LPARAM param3)
@@ -95,5 +251,12 @@ private LRESULT NewWindowProc(HWND param0, uint param1, WPARAM param2, LPARAM pa
 
 			return PInvoke.CallWindowProc(_oldWndProc, param0, param1, param2, param3);
 		}
+
+		// Disposer
+
+		public void Dispose()
+		{
+			StoreWindowPlacementData();
+		}
 	}
 }

src/Files.App/NativeMethods.txt

@@ -103,3 +103,11 @@ GetDpiForWindow
 CallWindowProc
 MINMAXINFO
 SUBCLASSPROC
+SetWindowPlacement
+GetWindowPlacement
+WINDOWPLACEMENT
+GetSystemMetrics
+MONITORENUMPROC
+EnumDisplayMonitors
+MONITORINFOEXW
+GetMonitorInfo