1  #include "win32_window.h"
  2  
  3  #include <dwmapi.h>
  4  #include <flutter_windows.h>
  5  
  6  #include "resource.h"
  7  
  8  namespace {
  9  
 10  /// Window attribute that enables dark mode window decorations.
 11  ///
 12  /// Redefined in case the developer's machine has a Windows SDK older than
 13  /// version 10.0.22000.0.
 14  /// See: https://docs.microsoft.com/windows/win32/api/dwmapi/ne-dwmapi-dwmwindowattribute
 15  #ifndef DWMWA_USE_IMMERSIVE_DARK_MODE
 16  #define DWMWA_USE_IMMERSIVE_DARK_MODE 20
 17  #endif
 18  
 19  constexpr const wchar_t kWindowClassName[] = L"FLUTTER_RUNNER_WIN32_WINDOW";
 20  
 21  /// Registry key for app theme preference.
 22  ///
 23  /// A value of 0 indicates apps should use dark mode. A non-zero or missing
 24  /// value indicates apps should use light mode.
 25  constexpr const wchar_t kGetPreferredBrightnessRegKey[] =
 26  	L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize";
 27  constexpr const wchar_t kGetPreferredBrightnessRegValue[] = L"AppsUseLightTheme";
 28  
 29  // The number of Win32Window objects that currently exist.
 30  static int g_active_window_count = 0;
 31  
 32  using EnableNonClientDpiScaling = BOOL __stdcall(HWND hwnd);
 33  
 34  // Scale helper to convert logical scaler values to physical using passed in
 35  // scale factor
 36  int Scale(int source, double scale_factor) {
 37  	return static_cast<int>(source * scale_factor);
 38  }
 39  
 40  // Dynamically loads the |EnableNonClientDpiScaling| from the User32 module.
 41  // This API is only needed for PerMonitor V1 awareness mode.
 42  void EnableFullDpiSupportIfAvailable(HWND hwnd) {
 43  	HMODULE user32_module = LoadLibraryA("User32.dll");
 44  	if (!user32_module) {
 45  		return;
 46  	}
 47  	auto enable_non_client_dpi_scaling =
 48  			reinterpret_cast<EnableNonClientDpiScaling*>(
 49  					GetProcAddress(user32_module, "EnableNonClientDpiScaling"));
 50  	if (enable_non_client_dpi_scaling != nullptr) {
 51  		enable_non_client_dpi_scaling(hwnd);
 52  	}
 53  	FreeLibrary(user32_module);
 54  }
 55  
 56  }  // namespace
 57  
 58  // Manages the Win32Window's window class registration.
 59  class WindowClassRegistrar {
 60   public:
 61  	~WindowClassRegistrar() = default;
 62  
 63  	// Returns the singleton registrar instance.
 64  	static WindowClassRegistrar* GetInstance() {
 65  		if (!instance_) {
 66  			instance_ = new WindowClassRegistrar();
 67  		}
 68  		return instance_;
 69  	}
 70  
 71  	// Returns the name of the window class, registering the class if it hasn't
 72  	// previously been registered.
 73  	const wchar_t* GetWindowClass();
 74  
 75  	// Unregisters the window class. Should only be called if there are no
 76  	// instances of the window.
 77  	void UnregisterWindowClass();
 78  
 79   private:
 80  	WindowClassRegistrar() = default;
 81  
 82  	static WindowClassRegistrar* instance_;
 83  
 84  	bool class_registered_ = false;
 85  };
 86  
 87  WindowClassRegistrar* WindowClassRegistrar::instance_ = nullptr;
 88  
 89  const wchar_t* WindowClassRegistrar::GetWindowClass() {
 90  	if (!class_registered_) {
 91  		WNDCLASS window_class{};
 92  		window_class.hCursor = LoadCursor(nullptr, IDC_ARROW);
 93  		window_class.lpszClassName = kWindowClassName;
 94  		window_class.style = CS_HREDRAW | CS_VREDRAW;
 95  		window_class.cbClsExtra = 0;
 96  		window_class.cbWndExtra = 0;
 97  		window_class.hInstance = GetModuleHandle(nullptr);
 98  		window_class.hIcon =
 99  				LoadIcon(window_class.hInstance, MAKEINTRESOURCE(IDI_APP_ICON));
100  		window_class.hbrBackground = 0;
101  		window_class.lpszMenuName = nullptr;
102  		window_class.lpfnWndProc = Win32Window::WndProc;
103  		RegisterClass(&window_class);
104  		class_registered_ = true;
105  	}
106  	return kWindowClassName;
107  }
108  
109  void WindowClassRegistrar::UnregisterWindowClass() {
110  	UnregisterClass(kWindowClassName, nullptr);
111  	class_registered_ = false;
112  }
113  
114  Win32Window::Win32Window() {
115  	++g_active_window_count;
116  }
117  
118  Win32Window::~Win32Window() {
119  	--g_active_window_count;
120  	Destroy();
121  }
122  
123  bool Win32Window::Create(const std::wstring& title,
124  												 const Point& origin,
125  												 const Size& size) {
126  	Destroy();
127  
128  	const wchar_t* window_class =
129  			WindowClassRegistrar::GetInstance()->GetWindowClass();
130  
131  	const POINT target_point = {static_cast<LONG>(origin.x),
132  															static_cast<LONG>(origin.y)};
133  	HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTONEAREST);
134  	UINT dpi = FlutterDesktopGetDpiForMonitor(monitor);
135  	double scale_factor = dpi / 96.0;
136  
137  	HWND window = CreateWindow(
138  			window_class, title.c_str(), WS_OVERLAPPEDWINDOW,
139  			Scale(origin.x, scale_factor), Scale(origin.y, scale_factor),
140  			Scale(size.width, scale_factor), Scale(size.height, scale_factor),
141  			nullptr, nullptr, GetModuleHandle(nullptr), this);
142  
143  	if (!window) {
144  		return false;
145  	}
146  
147  	UpdateTheme(window);
148  
149  	return OnCreate();
150  }
151  
152  bool Win32Window::Show() {
153  	return ShowWindow(window_handle_, SW_SHOWNORMAL);
154  }
155  
156  // static
157  LRESULT CALLBACK Win32Window::WndProc(HWND const window,
158  																			UINT const message,
159  																			WPARAM const wparam,
160  																			LPARAM const lparam) noexcept {
161  	if (message == WM_NCCREATE) {
162  		auto window_struct = reinterpret_cast<CREATESTRUCT*>(lparam);
163  		SetWindowLongPtr(window, GWLP_USERDATA,
164  										 reinterpret_cast<LONG_PTR>(window_struct->lpCreateParams));
165  
166  		auto that = static_cast<Win32Window*>(window_struct->lpCreateParams);
167  		EnableFullDpiSupportIfAvailable(window);
168  		that->window_handle_ = window;
169  	} else if (Win32Window* that = GetThisFromHandle(window)) {
170  		return that->MessageHandler(window, message, wparam, lparam);
171  	}
172  
173  	return DefWindowProc(window, message, wparam, lparam);
174  }
175  
176  LRESULT
177  Win32Window::MessageHandler(HWND hwnd,
178  														UINT const message,
179  														WPARAM const wparam,
180  														LPARAM const lparam) noexcept {
181  	switch (message) {
182  		case WM_DESTROY:
183  			window_handle_ = nullptr;
184  			Destroy();
185  			if (quit_on_close_) {
186  				PostQuitMessage(0);
187  			}
188  			return 0;
189  
190  		case WM_DPICHANGED: {
191  			auto newRectSize = reinterpret_cast<RECT*>(lparam);
192  			LONG newWidth = newRectSize->right - newRectSize->left;
193  			LONG newHeight = newRectSize->bottom - newRectSize->top;
194  
195  			SetWindowPos(hwnd, nullptr, newRectSize->left, newRectSize->top, newWidth,
196  									 newHeight, SWP_NOZORDER | SWP_NOACTIVATE);
197  
198  			return 0;
199  		}
200  		case WM_SIZE: {
201  			RECT rect = GetClientArea();
202  			if (child_content_ != nullptr) {
203  				// Size and position the child window.
204  				MoveWindow(child_content_, rect.left, rect.top, rect.right - rect.left,
205  									 rect.bottom - rect.top, TRUE);
206  			}
207  			return 0;
208  		}
209  
210  		case WM_ACTIVATE:
211  			if (child_content_ != nullptr) {
212  				SetFocus(child_content_);
213  			}
214  			return 0;
215  
216  		case WM_DWMCOLORIZATIONCOLORCHANGED:
217  			UpdateTheme(hwnd);
218  			return 0;
219  	}
220  
221  	return DefWindowProc(window_handle_, message, wparam, lparam);
222  }
223  
224  void Win32Window::Destroy() {
225  	OnDestroy();
226  
227  	if (window_handle_) {
228  		DestroyWindow(window_handle_);
229  		window_handle_ = nullptr;
230  	}
231  	if (g_active_window_count == 0) {
232  		WindowClassRegistrar::GetInstance()->UnregisterWindowClass();
233  	}
234  }
235  
236  Win32Window* Win32Window::GetThisFromHandle(HWND const window) noexcept {
237  	return reinterpret_cast<Win32Window*>(
238  			GetWindowLongPtr(window, GWLP_USERDATA));
239  }
240  
241  void Win32Window::SetChildContent(HWND content) {
242  	child_content_ = content;
243  	SetParent(content, window_handle_);
244  	RECT frame = GetClientArea();
245  
246  	MoveWindow(content, frame.left, frame.top, frame.right - frame.left,
247  						 frame.bottom - frame.top, true);
248  
249  	SetFocus(child_content_);
250  }
251  
252  RECT Win32Window::GetClientArea() {
253  	RECT frame;
254  	GetClientRect(window_handle_, &frame);
255  	return frame;
256  }
257  
258  HWND Win32Window::GetHandle() {
259  	return window_handle_;
260  }
261  
262  void Win32Window::SetQuitOnClose(bool quit_on_close) {
263  	quit_on_close_ = quit_on_close;
264  }
265  
266  bool Win32Window::OnCreate() {
267  	// No-op; provided for subclasses.
268  	return true;
269  }
270  
271  void Win32Window::OnDestroy() {
272  	// No-op; provided for subclasses.
273  }
274  
275  void Win32Window::UpdateTheme(HWND const window) {
276  	DWORD light_mode;
277  	DWORD light_mode_size = sizeof(light_mode);
278  	LSTATUS result = RegGetValue(HKEY_CURRENT_USER, kGetPreferredBrightnessRegKey,
279  															 kGetPreferredBrightnessRegValue,
280  															 RRF_RT_REG_DWORD, nullptr, &light_mode,
281  															 &light_mode_size);
282  
283  	if (result == ERROR_SUCCESS) {
284  		BOOL enable_dark_mode = light_mode == 0;
285  		DwmSetWindowAttribute(window, DWMWA_USE_IMMERSIVE_DARK_MODE,
286  													&enable_dark_mode, sizeof(enable_dark_mode));
287  	}
288  }