Show a window maximized before its first show maximized (#75)

Maximize() on a window not shown yet showed it there and then, before its
content was ready, and the host's own first show undid it: a Flutter
runner's ShowWindow(SW_SHOWNORMAL) on its first frame restores even a
maximized window (leanflutter/window_manager#412, #572). The window now
stays hidden with the request recorded; whatever shows it, the show is held
back and it is shown maximized right after, so it is maximized from its
first visible frame. IsMaximized() reports the request; Unmaximize() takes
it back. window_startup_maximize_windows_test covers it; a real Flutter
app (tools/gui/flutter_window_reports_test.ps1, startup-maximize) now
appears maximized and stays so, where it used to revert after a black frame.

Author: lijy91

src/platform/windows/window_windows.cpp

@@ -121,6 +121,13 @@ static const wchar_t* kFocusReturnWindowProperty = L"NativeAPIFocusReturnWindow"
 // hands the foreground back to it. Distinct from the focus-policy property above,
 // which only a no-activate window uses and its policy change clears.
 static const wchar_t* kBlurReturnWindowProperty = L"NativeAPIBlurReturnWindow";
+// Maximize() on a window that is not shown yet: shown later by anyone - a
+// Flutter runner's first-frame ShowWindow(SW_SHOWNORMAL) - it appears maximized.
+static const wchar_t* kShowMaximizedProperty = L"NativeAPIShowMaximized";
+static UINT ShowMaximizedMessage() {
+  static const UINT message = RegisterWindowMessageW(L"NativeAPIShowMaximized");
+  return message;
+}
 // The app-drawn maximize button (MaximizeButtonArea), owned by the HWND.
 static const wchar_t* kMaximizeButtonProperty = L"NativeAPIMaximizeButton";
 struct MaximizeButtonArea {
@@ -717,6 +724,7 @@ static LRESULT WindowLifetimeMessage(HWND hwnd, UINT message, WPARAM wp, LPARAM
     RemovePropW(hwnd, kNonActivatingProperty);
     RemovePropW(hwnd, kFocusReturnWindowProperty);
     RemovePropW(hwnd, kBlurReturnWindowProperty);
+    RemovePropW(hwnd, kShowMaximizedProperty);
     delete static_cast<MaximizeButtonArea*>(RemovePropW(hwnd, kMaximizeButtonProperty));
     RemovePropW(hwnd, kVisualEffectProperty);
     RemovePropW(hwnd, kCornerPreferenceProperty);
@@ -740,6 +748,19 @@ static LRESULT WindowLifetimeMessage(HWND hwnd, UINT message, WPARAM wp, LPARAM
   if (message == WM_PARENTNOTIFY && LOWORD(wp) == WM_CREATE &&
       (GetWindowLongPtrW(hwnd, GWL_EXSTYLE) & WS_EX_NOACTIVATE))
     EnumChildWindows(hwnd, InstallFocusPolicyChild, 0);
+  if (message == WM_WINDOWPOSCHANGING && GetPropW(hwnd, kShowMaximizedProperty)) {
+    auto* pos = reinterpret_cast<WINDOWPOS*>(lp);
+    if (pos && (pos->flags & SWP_SHOWWINDOW)) {
+      // Whatever shows it would show it restored (SW_SHOWNORMAL restores even a
+      // maximized window): keep it hidden and show it maximized right after.
+      pos->flags &= ~SWP_SHOWWINDOW;
+      PostMessageW(hwnd, ShowMaximizedMessage(), 0, 0);
+    }
+  }
+  if (message == ShowMaximizedMessage()) {
+    if (RemovePropW(hwnd, kShowMaximizedProperty)) ShowWindow(hwnd, SW_SHOWMAXIMIZED);
+    return 0;
+  }
   if (message == WM_WINDOWPOSCHANGED) {
     const auto* pos = reinterpret_cast<const WINDOWPOS*>(lp);
     const LRESULT result = DefSubclassProc(hwnd, message, wp, lp);
@@ -1187,12 +1208,19 @@ bool Window::IsOcclusionStateSupported() {
 }
 
 void Window::Maximize() {
-  if (pimpl_->hwnd_ && !IsMaximized()) {
-    ShowWindow(pimpl_->hwnd_, SW_MAXIMIZE);
+  if (!pimpl_->hwnd_ || IsMaximized()) return;
+  if (!IsWindowVisible(pimpl_->hwnd_)) {
+    // SW_MAXIMIZE would show it now, before its content is ready, and the
+    // host's own show (a Flutter runner's, on its first frame) would restore
+    // it. Shown maximized when it is shown; see kShowMaximizedProperty.
+    SetPropW(pimpl_->hwnd_, kShowMaximizedProperty, reinterpret_cast<HANDLE>(1));
+    return;
   }
+  ShowWindow(pimpl_->hwnd_, SW_MAXIMIZE);
 }
 
 void Window::Unmaximize() {
+  if (pimpl_->hwnd_ && RemovePropW(pimpl_->hwnd_, kShowMaximizedProperty)) return;
   if (pimpl_->hwnd_ && IsMaximized()) {
     ShowWindow(pimpl_->hwnd_, SW_RESTORE);
   }
@@ -1201,6 +1229,7 @@ void Window::Unmaximize() {
 bool Window::IsMaximized() const {
   if (!pimpl_->hwnd_)
     return false;
+  if (GetPropW(pimpl_->hwnd_, kShowMaximizedProperty)) return true;  // To be shown maximized.
   WINDOWPLACEMENT wp = {};
   wp.length = sizeof(WINDOWPLACEMENT);
   GetWindowPlacement(pimpl_->hwnd_, &wp);

src/window.h

@@ -504,7 +504,10 @@ class Window : public EventEmitter<WindowEvent>, public NativeObjectProvider,
    * @brief Maximizes the window to fill the available screen space.
    *
    * Expands the window to occupy the maximum available area on the screen,
-   * typically excluding taskbars and docks.
+   * typically excluding taskbars and docks. A window that is not shown yet
+   * stays hidden and appears maximized when it is shown, also when its host
+   * shows it as a restored window (a Flutter runner on its first frame);
+   * IsMaximized() already reports true, and Unmaximize() takes it back.
    */
   void Maximize();
 

tests/CMakeLists.txt

@@ -15,6 +15,14 @@ add_executable(screen_layout_test screen_layout_test.cpp)
 target_link_libraries(screen_layout_test PRIVATE nativeapi)
 add_test(NAME screen_layout_test COMMAND screen_layout_test)
 
+# window_manager#412 / #572 (#75): Maximize() before the first show.
+if(WIN32)
+  add_executable(window_startup_maximize_windows_test window_startup_maximize_windows_test.cpp)
+  target_link_libraries(window_startup_maximize_windows_test PRIVATE nativeapi comctl32)
+  add_test(NAME window_startup_maximize_windows_test COMMAND window_startup_maximize_windows_test)
+  set_tests_properties(window_startup_maximize_windows_test PROPERTIES TIMEOUT 20)
+endif()
+
 # window_manager#569 (#77): WS_POPUP windows and their caption.
 # window_manager#534 (#78): Application::SetIcon on the application's windows.
 if(WIN32)

tests/window_startup_maximize_windows_test.cpp

@@ -0,0 +1,79 @@
+// leanflutter/window_manager#412 / #572 (#75): Maximize() on a window that is
+// not shown yet keeps it hidden, and the host's own ShowWindow(SW_SHOWNORMAL)
+// - a Flutter runner's, on its first frame - shows it maximized from its very
+// first visible frame instead of restoring it. No input.
+#include <windows.h>
+#include <commctrl.h>
+#include <iostream>
+#include "nativeapi.h"
+
+namespace {
+int failures = 0;
+void Check(bool ok, const char* label) {
+  std::cout << (ok ? "PASS " : "FAIL ") << label << std::endl;
+  failures += !ok;
+}
+void Pump() {
+  MSG message;
+  for (int i = 0; i < 30; ++i) {
+    while (PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE)) {
+      TranslateMessage(&message);
+      DispatchMessageW(&message);
+    }
+    Sleep(10);
+  }
+}
+// Whether the window was maximized at the moment it first became visible.
+int shown_zoomed = -1;
+LRESULT CALLBACK Watch(HWND hwnd, UINT message, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR) {
+  if (message == WM_WINDOWPOSCHANGED && shown_zoomed < 0 &&
+      (reinterpret_cast<WINDOWPOS*>(lp)->flags & SWP_SHOWWINDOW))
+    shown_zoomed = IsZoomed(hwnd) ? 1 : 0;
+  return DefSubclassProc(hwnd, message, wp, lp);
+}
+HWND Create() {
+  WNDCLASSW cls = {};
+  cls.lpfnWndProc = DefWindowProcW;
+  cls.hInstance = GetModuleHandleW(nullptr);
+  cls.hbrBackground = static_cast<HBRUSH>(GetStockObject(GRAY_BRUSH));
+  cls.lpszClassName = L"NativeApiStartupMaximizeTest";
+  RegisterClassW(&cls);
+  return CreateWindowExW(0, cls.lpszClassName, L"nativeapi startup maximize", WS_OVERLAPPEDWINDOW,
+                         200, 200, 600, 400, nullptr, nullptr, cls.hInstance, nullptr);
+}
+}  // namespace
+
+int main() {
+  SetProcessDPIAware();
+  nativeapi::Application::GetInstance();
+
+  HWND hwnd = Create();
+  SetWindowSubclass(hwnd, Watch, 1, 0);
+  nativeapi::Window window(hwnd);
+  window.Maximize();
+  Pump();
+  Check(!IsWindowVisible(hwnd), "Maximize() leaves a window that is not shown yet hidden");
+  Check(window.IsMaximized(), "but reports it maximized already");
+  ShowWindow(hwnd, SW_SHOWNORMAL);  // The host's show, as a Flutter runner's.
+  Pump();
+  Check(IsWindowVisible(hwnd), "the host's show shows it");
+  Check(shown_zoomed == 1, "maximized from its first visible frame");
+  Check(IsZoomed(hwnd) && window.IsMaximized(), "and it stays maximized");
+  window.Unmaximize();
+  Pump();
+  Check(!IsZoomed(hwnd), "Unmaximize() restores it");
+  DestroyWindow(hwnd);
+
+  hwnd = Create();
+  nativeapi::Window second(hwnd);
+  second.Maximize();
+  second.Unmaximize();
+  Check(!second.IsMaximized(), "Unmaximize() before the show takes the request back");
+  ShowWindow(hwnd, SW_SHOWNORMAL);
+  Pump();
+  Check(IsWindowVisible(hwnd) && !IsZoomed(hwnd), "and the window then shows restored");
+  DestroyWindow(hwnd);
+
+  std::cout << (failures ? "FAILED" : "OK") << std::endl;
+  return failures ? 1 : 0;
+}