Merge pull request #61 from adeeteya/windows_size_persistence

✨ closes #55, allowing window size persistence on windows

Author: adeeteya

windows/runner/main.cpp

@@ -1,3 +1,4 @@
+#include <cmath>
 #include <flutter/dart_project.h>
 #include <flutter/flutter_view_controller.h>
 #include <windows.h>
@@ -27,6 +28,27 @@ int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev,
   FlutterWindow window(project);
   Win32Window::Point origin(10, 10);
   Win32Window::Size size(400, 800);
+  if (auto stored_size = LoadStoredWindowSize()) {
+    int restored_width = stored_size->width;
+    int restored_height = stored_size->height;
+    if (stored_size->is_physical) {
+        const POINT target_point = {static_cast<LONG>(origin.x),
+                                    static_cast<LONG>(origin.y)};
+        HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTONEAREST);
+        UINT dpi = 96;
+        if (monitor != nullptr) {
+            dpi = FlutterDesktopGetDpiForMonitor(monitor);
+        }
+        double scale_factor = dpi / 96.0;
+        if (scale_factor <= 0.0) {
+            scale_factor = 1.0;
+        }
+        restored_width = static_cast<int>(std::round(restored_width / scale_factor));
+        restored_height = static_cast<int>(std::round(restored_height / scale_factor));
+        SaveWindowSize(StoredWindowSize{restored_width, restored_height, false});
+    }
+    size = Win32Window::Size(restored_width, restored_height);
+  }
   if (!window.Create(L"ClassiPod", origin, size)) {
     return EXIT_FAILURE;
   }

windows/runner/utils.cpp

@@ -7,6 +7,13 @@
 
 #include <iostream>
 
+namespace {
+    constexpr wchar_t kWindowSizeRegistryKey[] = L"Software\\ClassiPod";
+    constexpr wchar_t kWindowWidthValueName[] = L"WindowWidth";
+    constexpr wchar_t kWindowHeightValueName[] = L"WindowHeight";
+    constexpr wchar_t kWindowSizeIsLogicalValueName[] = L"WindowSizeIsLogical";
+}
+
 void CreateAndAttachConsole() {
   if (::AllocConsole()) {
     FILE *unused;
@@ -41,6 +48,80 @@ std::vector<std::string> GetCommandLineArguments() {
   return command_line_arguments;
 }
 
+std::optional<StoredWindowSize> LoadStoredWindowSize() {
+    HKEY key_handle;
+    if (RegOpenKeyEx(HKEY_CURRENT_USER, kWindowSizeRegistryKey, 0, KEY_READ,
+                     &key_handle) != ERROR_SUCCESS) {
+        return std::nullopt;
+    }
+
+    DWORD width_value = 0;
+    DWORD width_size = sizeof(width_value);
+    if (RegQueryValueEx(key_handle, kWindowWidthValueName, nullptr, nullptr,
+                        reinterpret_cast<LPBYTE>(&width_value),
+                        &width_size) != ERROR_SUCCESS) {
+        RegCloseKey(key_handle);
+        return std::nullopt;
+    }
+
+    DWORD height_value = 0;
+    DWORD height_size = sizeof(height_value);
+    if (RegQueryValueEx(key_handle, kWindowHeightValueName, nullptr, nullptr,
+                        reinterpret_cast<LPBYTE>(&height_value),
+                        &height_size) != ERROR_SUCCESS) {
+        RegCloseKey(key_handle);
+        return std::nullopt;
+    }
+
+    DWORD logical_flag = 0;
+    DWORD logical_flag_size = sizeof(logical_flag);
+    bool is_physical = true;
+    if (RegQueryValueEx(key_handle, kWindowSizeIsLogicalValueName, nullptr,
+                        nullptr, reinterpret_cast<LPBYTE>(&logical_flag),
+                        &logical_flag_size) == ERROR_SUCCESS) {
+        is_physical = logical_flag != 1;
+    }
+
+    RegCloseKey(key_handle);
+
+    if (width_value == 0 || height_value == 0) {
+        return std::nullopt;
+    }
+
+    return StoredWindowSize{static_cast<int>(width_value),
+                            static_cast<int>(height_value), is_physical};
+}
+
+void SaveWindowSize(const StoredWindowSize& size) {
+    if (size.width <= 0 || size.height <= 0) {
+        return;
+    }
+
+    HKEY key_handle;
+    if (RegCreateKeyEx(HKEY_CURRENT_USER, kWindowSizeRegistryKey, 0, nullptr,
+                       REG_OPTION_NON_VOLATILE, KEY_WRITE, nullptr, &key_handle,
+                       nullptr) != ERROR_SUCCESS) {
+        return;
+    }
+
+    DWORD width_value = static_cast<DWORD>(size.width);
+    RegSetValueEx(key_handle, kWindowWidthValueName, 0, REG_DWORD,
+                  reinterpret_cast<const BYTE*>(&width_value),
+                  sizeof(width_value));
+
+    DWORD height_value = static_cast<DWORD>(size.height);
+    RegSetValueEx(key_handle, kWindowHeightValueName, 0, REG_DWORD,
+                  reinterpret_cast<const BYTE*>(&height_value),
+                  sizeof(height_value));
+
+    DWORD logical_flag = size.is_physical ? 0 : 1;
+    RegSetValueEx(key_handle, kWindowSizeIsLogicalValueName, 0, REG_DWORD,
+                  reinterpret_cast<const BYTE*>(&logical_flag),
+                  sizeof(logical_flag));
+
+    RegCloseKey(key_handle);
+}
+
 std::string Utf8FromUtf16(const wchar_t* utf16_string) {
   if (utf16_string == nullptr) {
     return std::string();

windows/runner/utils.h

@@ -1,9 +1,18 @@
 #ifndef RUNNER_UTILS_H_
 #define RUNNER_UTILS_H_
 
+#include <optional>
 #include <string>
 #include <vector>
 
+struct StoredWindowSize {
+    int width;
+    int height;
+    // True when the stored values represent physical pixels, false for logical
+    // coordinates.
+    bool is_physical;
+};
+
 // Creates a console for the process, and redirects stdout and stderr to
 // it for both the runner and the Flutter library.
 void CreateAndAttachConsole();
@@ -16,4 +25,10 @@ std::string Utf8FromUtf16(const wchar_t* utf16_string);
 // encoded in UTF-8. Returns an empty std::vector<std::string> on failure.
 std::vector<std::string> GetCommandLineArguments();
 
+// Loads the last saved window size, if present.
+std::optional<StoredWindowSize> LoadStoredWindowSize();
+
+// Persists the provided window size for future runs.
+void SaveWindowSize(const StoredWindowSize& size);
+
 #endif  // RUNNER_UTILS_H_

windows/runner/win32_window.cpp

@@ -1,9 +1,11 @@
 #include "win32_window.h"
 
+#include <cmath>
 #include <dwmapi.h>
 #include <flutter_windows.h>
 
 #include "resource.h"
+#include "utils.h"
 
 namespace {
 
@@ -179,14 +181,39 @@ Win32Window::MessageHandler(HWND hwnd,
                             WPARAM const wparam,
                             LPARAM const lparam) noexcept {
   switch (message) {
-    case WM_DESTROY:
-      window_handle_ = nullptr;
-      Destroy();
-      if (quit_on_close_) {
-        PostQuitMessage(0);
-      }
-      return 0;
-
+    case WM_DESTROY:{
+        WINDOWPLACEMENT placement;
+        placement.length = sizeof(WINDOWPLACEMENT);
+        if (GetWindowPlacement(hwnd, &placement)) {
+            RECT rect = placement.rcNormalPosition;
+            int width = rect.right - rect.left;
+            int height = rect.bottom - rect.top;
+
+            HMONITOR monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
+            UINT dpi = 96;
+            if (monitor != nullptr) {
+                dpi = FlutterDesktopGetDpiForMonitor(monitor);
+            }
+            double scale_factor = dpi / 96.0;
+            if (scale_factor <= 0.0) {
+                scale_factor = 1.0;
+            }
+
+            int logical_width =
+                    static_cast<int>(std::round(width / scale_factor));
+            int logical_height =
+                    static_cast<int>(std::round(height / scale_factor));
+
+            SaveWindowSize(
+                    StoredWindowSize{logical_width, logical_height, false});
+        }
+        window_handle_ = nullptr;
+        Destroy();
+        if (quit_on_close_) {
+            PostQuitMessage(0);
+        }
+        return 0;
+    }
     case WM_DPICHANGED: {
       auto newRectSize = reinterpret_cast<RECT*>(lparam);
       LONG newWidth = newRectSize->right - newRectSize->left;