Merge pull request #21497 from unoplatform/dev/mazi/maximize-win

Author: MartinZikmund

src/Uno.UI.Runtime.Skia.Win32/UI/Windowing/Win32WindowWrapper.OverlappedPresenter.cs

@@ -12,6 +12,8 @@ namespace Uno.UI.Runtime.Skia.Win32;
 
 internal partial class Win32WindowWrapper : INativeOverlappedPresenter
 {
+	private OverlappedPresenterState? _pendingState;
+
 	protected override IDisposable ApplyFullScreenPresenter()
 	{
 		// The WasShown guards are so that if a call to ApplyFullScreenPresenter is made before
@@ -35,10 +37,7 @@ protected override IDisposable ApplyFullScreenPresenter()
 
 	protected override IDisposable ApplyOverlappedPresenter(OverlappedPresenter presenter)
 	{
-		if (WasShown)
-		{
-			presenter.SetNative(this);
-		}
+		presenter.SetNative(this);
 		return base.ApplyOverlappedPresenter(presenter);
 	}
 
@@ -79,11 +78,41 @@ public void SetIsAlwaysOnTop(bool isAlwaysOnTop)
 		}
 	}
 
-	public void Maximize() => PInvoke.ShowWindow(_hwnd, SHOW_WINDOW_CMD.SW_MAXIMIZE);
+	public void Maximize()
+	{
+		if (WasShown)
+		{
+			PInvoke.ShowWindow(_hwnd, SHOW_WINDOW_CMD.SW_MAXIMIZE);
+		}
+		else
+		{
+			_pendingState = OverlappedPresenterState.Maximized;
+		}
+	}
 
-	public void Minimize(bool activateWindow) => PInvoke.ShowWindow(_hwnd, activateWindow ? SHOW_WINDOW_CMD.SW_MINIMIZE : SHOW_WINDOW_CMD.SW_SHOWMINNOACTIVE);
+	public void Minimize(bool activateWindow)
+	{
+		if (WasShown)
+		{
+			PInvoke.ShowWindow(_hwnd, activateWindow ? SHOW_WINDOW_CMD.SW_MINIMIZE : SHOW_WINDOW_CMD.SW_SHOWMINNOACTIVE);
+		}
+		else
+		{
+			_pendingState = OverlappedPresenterState.Minimized;
+		}
+	}
 
-	public void Restore(bool activateWindow) => PInvoke.ShowWindow(_hwnd, activateWindow ? SHOW_WINDOW_CMD.SW_SHOWNORMAL : SHOW_WINDOW_CMD.SW_SHOWNOACTIVATE);
+	public void Restore(bool activateWindow)
+	{
+		if (WasShown)
+		{
+			PInvoke.ShowWindow(_hwnd, activateWindow ? SHOW_WINDOW_CMD.SW_SHOWNORMAL : SHOW_WINDOW_CMD.SW_SHOWNOACTIVATE);
+		}
+		else
+		{
+			_pendingState = OverlappedPresenterState.Restored;
+		}
+	}
 
 	public OverlappedPresenterState State
 	{

src/Uno.UI.Runtime.Skia.Win32/UI/Xaml/Window/Win32WindowWrapper.cs

@@ -379,6 +379,24 @@ protected override void ShowCore()
 			SetWindowStyle(WINDOW_STYLE.WS_DLGFRAME, false);
 			_ = PInvoke.ShowWindow(_hwnd, SHOW_WINDOW_CMD.SW_MAXIMIZE);
 		}
+		else if (Window?.AppWindow.Presenter is OverlappedPresenter overlappedPresenter)
+		{
+			switch (_pendingState)
+			{
+				case OverlappedPresenterState.Maximized:
+					_ = PInvoke.ShowWindow(_hwnd, SHOW_WINDOW_CMD.SW_MAXIMIZE);
+					break;
+				case OverlappedPresenterState.Minimized:
+					_ = PInvoke.ShowWindow(_hwnd, SHOW_WINDOW_CMD.SW_MINIMIZE);
+					break;
+				case OverlappedPresenterState.Restored:
+					_ = PInvoke.ShowWindow(_hwnd, SHOW_WINDOW_CMD.SW_RESTORE);
+					break;
+				default:
+					_ = PInvoke.ShowWindow(_hwnd, SHOW_WINDOW_CMD.SW_SHOWDEFAULT);
+					break;
+			}
+		}
 		else
 		{
 			PInvoke.ShowWindow(_hwnd, SHOW_WINDOW_CMD.SW_SHOWDEFAULT);

src/Uno.UI.RuntimeTests/Tests/Microsoft_UI_Windowing/Given_AppWindow.cs

@@ -2,6 +2,8 @@
 using System;
 using System.Reflection;
 using System.Threading.Tasks;
+using Combinatorial.MSTest;
+using AwesomeAssertions;
 using Microsoft.UI.Windowing;
 using Microsoft.UI.Xaml;
 using Private.Infrastructure;
@@ -150,6 +152,38 @@ void OnChanged(AppWindow s, AppWindowChangedEventArgs e)
 		}
 	}
 
+	[TestMethod]
+	[CombinatorialData]
+	[GitHubWorkItem("https://github.com/unoplatform/uno/issues/21435")]
+	[PlatformCondition(ConditionMode.Exclude, RuntimeTestPlatforms.SkiaX11 | RuntimeTestPlatforms.SkiaMacOS)] // Skia/X11 & macOS: Fail in CI (#21194)
+	public async Task When_Change_Window_State_Before_Activate(OverlappedPresenterState state)
+	{
+		AssertPositioningAndSizingSupport();
+		var newWindow = new Window();
+		var appWindow = newWindow.AppWindow;
+		var activated = false;
+		try
+		{
+			var overlappedPresenter = (OverlappedPresenter)appWindow.Presenter;
+			Action act = state switch
+			{
+				OverlappedPresenterState.Maximized => () => overlappedPresenter.Maximize(),
+				OverlappedPresenterState.Minimized => () => overlappedPresenter.Minimize(),
+				_ => () => overlappedPresenter.Restore()
+			};
+			act.Should().NotThrow();
+			newWindow.Activated += (s, e) => activated = true;
+			newWindow.Activate();
+			await TestServices.WindowHelper.WaitFor(() => activated);
+			Assert.AreEqual(state, overlappedPresenter.State);
+		}
+		finally
+		{
+			await TestServices.WindowHelper.WaitForIdle();
+			await TestServices.RunOnUIThread(() => newWindow.Close());
+		}
+	}
+
 	private void AssertPositioningAndSizingSupport()
 	{
 		if (!OperatingSystem.IsLinux() &&

src/Uno.UWP/Microsoft/UI/Windowing/OverlappedPresenter.cs

@@ -1,5 +1,3 @@
-using System.ComponentModel;
-using System.Runtime.CompilerServices;
 using Microsoft.UI.Windowing.Native;
 
 namespace Microsoft.UI.Windowing;
@@ -16,6 +14,7 @@ public partial class OverlappedPresenter : AppWindowPresenter
 	private bool _isAlwaysOnTop;
 	private bool _hasBorder;
 	private bool _hasTitleBar;
+	private OverlappedPresenterState? _pendingState;
 
 	internal OverlappedPresenter() : base(AppWindowPresenterKind.Overlapped)
 	{
@@ -77,13 +76,23 @@ public bool IsAlwaysOnTop
 
 	public bool HasTitleBar => _hasTitleBar;
 
-	public OverlappedPresenterState State => Native?.State ?? OverlappedPresenterState.Restored;
+	public OverlappedPresenterState State => Native?.State ?? _pendingState ?? OverlappedPresenterState.Restored;
 
 	public static OverlappedPresenterState RequestedStartupState { get; } = OverlappedPresenterState.Restored;
 
 	public void Restore() => Restore(false);
 
-	public void Maximize() => Native.Maximize();
+	public void Maximize()
+	{
+		if (Native is not null)
+		{
+			Native.Maximize();
+		}
+		else
+		{
+			_pendingState = OverlappedPresenterState.Maximized;
+		}
+	}
 
 	/// <summary>
 	/// Minimizes the window that the presenter is applied to.
@@ -94,7 +103,17 @@ public bool IsAlwaysOnTop
 	/// 
 	/// </summary>
 	/// <param name="activateWindow"></param>
-	public void Minimize(bool activateWindow) => Native.Minimize(activateWindow);
+	public void Minimize(bool activateWindow)
+	{
+		if (Native is not null)
+		{
+			Native.Minimize(activateWindow);
+		}
+		else
+		{
+			_pendingState = OverlappedPresenterState.Minimized;
+		}
+	}
 
 	/// <summary>
 	/// Sets the border and title bar properties of the window.
@@ -108,7 +127,17 @@ public void SetBorderAndTitleBar(bool hasBorder, bool hasTitleBar)
 		Native?.SetBorderAndTitleBar(hasBorder, hasTitleBar);
 	}
 
-	public void Restore(bool activateWindow) => Native.Restore(activateWindow);
+	public void Restore(bool activateWindow)
+	{
+		if (Native is not null)
+		{
+			Native.Restore(activateWindow);
+		}
+		else
+		{
+			_pendingState = OverlappedPresenterState.Restored;
+		}
+	}
 
 	/// <summary>
 	/// Creates a new instance of OverlappedPresenter.
@@ -194,6 +223,21 @@ internal void SetNative(INativeOverlappedPresenter nativePresenter)
 			Native.SetIsMaximizable(IsMaximizable);
 			Native.SetIsAlwaysOnTop(IsAlwaysOnTop);
 			Native.SetBorderAndTitleBar(HasBorder, HasTitleBar);
+
+			if (_pendingState is OverlappedPresenterState.Maximized)
+			{
+				Native.Maximize();
+			}
+			else if (_pendingState is OverlappedPresenterState.Minimized)
+			{
+				Native.Minimize(false);
+			}
+			else
+			{
+				Native.Restore(false);
+			}
+
+			_pendingState = null;
 		}
 	}
 }