5 files changed, 453 insertions, 13 deletions

diff --git a/src/platform_win/CMakeLists.txt b/src/platform_win/CMakeLists.txt
index fbcf1c00..9e7d8a89 100644
--- a/src/platform_win/CMakeLists.txt
+++ b/src/platform_win/CMakeLists.txt
@@ -4,7 +4,9 @@ add_library(cru_platform_win STATIC
 	god_window.cpp
 	timer.cpp
 	win_application.cpp
-	window_class.cpp)
+	win_native_window.cpp
+	window_class.cpp
+	window_manager.cpp)
 target_include_directories(cru_platform_win PUBLIC ${PROJECT_SOURCE_DIR}/include .)
 target_link_libraries(cru_platform_win PRIVATE D3D11 D2d1 DWrite)
 target_compile_definitions(cru_platform_win PUBLIC UNICODE _UNICODE) # use unicode
diff --git a/src/platform_win/god_window.cpp b/src/platform_win/god_window.cpp
index 2b4fbe48..0cb1a0e4 100644
--- a/src/platform_win/god_window.cpp
+++ b/src/platform_win/god_window.cpp
@@ -14,10 +14,11 @@ LRESULT CALLBACK GodWndProc(HWND hWnd, UINT uMsg, WPARAM wParam,
   const auto app = WinApplication::GetInstance();
 
   if (app) {
-    const auto result =
-        app->GetGodWindow()->HandleGodWindowMessage(hWnd, uMsg, wParam, lParam);
-    if (result.has_value())
-      return result.value();
+    LRESULT result;
+    const auto handled =
+        app->GetGodWindow()->HandleGodWindowMessage(hWnd, uMsg, wParam, lParam, &result);
+    if (handled)
+      return result;
     else
       return DefWindowProcW(hWnd, uMsg, wParam, lParam);
   } else
@@ -41,15 +42,15 @@ GodWindow::GodWindow(WinApplication* application) {
 
 GodWindow::~GodWindow() { ::DestroyWindow(hwnd_); }
 
-std::optional<LRESULT> GodWindow::HandleGodWindowMessage(HWND hwnd, int msg,
-                                                         WPARAM w_param,
-                                                         LPARAM l_param) {
+bool GodWindow::HandleGodWindowMessage(HWND hwnd, UINT msg, WPARAM w_param,
+                                       LPARAM l_param, LRESULT* result) {
   switch (msg) {
     case invoke_later_message_id: {
       const auto p_action = reinterpret_cast<std::function<void()>*>(w_param);
       (*p_action)();
       delete p_action;
-      return 0;
+      *result = 0;
+      return true;
     }
     case WM_TIMER: {
       const auto id = static_cast<UINT_PTR>(w_param);
@@ -58,13 +59,14 @@ std::optional<LRESULT> GodWindow::HandleGodWindowMessage(HWND hwnd, int msg,
         (action.value().second)();
         if (!action.value().first)
           application_->GetTimerManager()->KillTimer(id);
-        return 0;
+        result = 0;
+        return true;
       }
       break;
     }
     default:
-      return std::nullopt;
+      return false;
   }
-  return std::nullopt;
+  return false;
 }
-}  // namespace cru::platform::win
\ No newline at end of file
+}  // namespace cru::platform::win
diff --git a/src/platform_win/win_native_window.cpp b/src/platform_win/win_native_window.cpp
new file mode 100644
index 00000000..74d9466f
--- /dev/null
+++ b/src/platform_win/win_native_window.cpp
@@ -0,0 +1,331 @@
+#include "cru/platform/win/win_native_window.hpp"
+
+#include "cru/platform/dpi_util.hpp"
+#include "cru/platform/win/exception.hpp"
+#include "cru/platform/win/win_application.hpp"
+#include "cru/platform/win/window_class.hpp"
+#include "window_manager.hpp"
+
+#include <assert.h>
+#include <windowsx.h>
+
+namespace cru::platform::win {
+WinNativeWindow::WinNativeWindow(WinApplication* application,
+                                 std::shared_ptr<WindowClass> window_class,
+                                 DWORD window_style, WinNativeWindow* parent) {
+  assert(application);  // application can't be null.
+  assert(parent == nullptr ||
+         parent->IsValid());  // Parent window is not valid.
+
+  application_ = application;
+  parent_window_ = parent;
+
+  const auto window_manager = application->GetWindowManager();
+
+  hwnd_ = CreateWindowExW(
+      0, window_manager->GetGeneralWindowClass()->GetName(), L"", window_style,
+      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+      parent == nullptr ? nullptr : parent->GetWindowHandle(), nullptr,
+      application->GetInstanceHandle(), nullptr);
+
+  if (hwnd_ == nullptr)
+    throw Win32Error(::GetLastError(), "Failed to create window.");
+
+  window_manager->RegisterWindow(hwnd_, this);
+}
+
+WinNativeWindow::~WinNativeWindow() {
+  if (IsValid()) {
+    SetDeleteThisOnDestroy(false);  // avoid double delete.
+    Close();
+  }
+}
+
+bool WinNativeWindow::IsValid() { return hwnd_ != nullptr; }
+
+void WinNativeWindow::SetDeleteThisOnDestroy(bool value) {
+  delete_this_on_destroy_ = value;
+}
+
+void WinNativeWindow::Close() {
+  if (IsValid()) DestroyWindow(hwnd_);
+}
+
+bool WinNativeWindow::IsVisible() {
+  if (IsValid()) return ::IsWindowVisible(hwnd_);
+  return false;
+}
+
+void WinNativeWindow::SetVisible(bool is_visible) {
+  if (!IsValid()) return;
+  is_visible ? ShowWindow(hwnd_, SW_SHOWNORMAL) : ShowWindow(hwnd_, SW_HIDE);
+}
+ui::Size WinNativeWindow::GetClientSize() {
+  if (!IsValid()) return ui::Size{};
+
+  const auto pixel_rect = GetClientRectPixel();
+  return ui::Size(PixelToDipX(pixel_rect.right),
+                  PixelToDipY(pixel_rect.bottom));
+}
+
+void WinNativeWindow::SetClientSize(const ui::Size& size) {
+  if (IsValid()) {
+    const auto window_style =
+        static_cast<DWORD>(GetWindowLongPtr(hwnd_, GWL_STYLE));
+    const auto window_ex_style =
+        static_cast<DWORD>(GetWindowLongPtr(hwnd_, GWL_EXSTYLE));
+
+    RECT rect;
+    rect.left = 0;
+    rect.top = 0;
+    rect.right = DipToPixelX(size.width);
+    rect.bottom = DipToPixelY(size.height);
+    if (!AdjustWindowRectEx(&rect, window_style, FALSE, window_ex_style))
+      throw Win32Error(::GetLastError(),
+                       "Failed to invoke AdjustWindowRectEx.");
+
+    if (!SetWindowPos(hwnd_, nullptr, 0, 0, rect.right - rect.left,
+                      rect.bottom - rect.top, SWP_NOZORDER | SWP_NOMOVE))
+      throw Win32Error(::GetLastError(), "Failed to invoke SetWindowPos.");
+  }
+}
+
+ui::Rect WinNativeWindow::GetWindowRect() {
+  if (!IsValid()) return ui::Rect{};
+
+  RECT rect;
+  if (!::GetWindowRect(hwnd_, &rect))
+    throw Win32Error(::GetLastError(), "Failed to invoke GetWindowRect.");
+
+  return ui::Rect::FromVertices(PixelToDipX(rect.left), PixelToDipY(rect.top),
+                                PixelToDipX(rect.right),
+                                PixelToDipY(rect.bottom));
+}
+
+void WinNativeWindow::SetWindowRect(const ui::Rect& rect) {
+  if (IsValid()) {
+    if (!SetWindowPos(hwnd_, nullptr, DipToPixelX(rect.left),
+                      DipToPixelY(rect.top), DipToPixelX(rect.GetRight()),
+                      DipToPixelY(rect.GetBottom()), SWP_NOZORDER))
+      throw Win32Error(::GetLastError(), "Failed to invoke SetWindowPos.");
+  }
+}
+
+bool WinNativeWindow::HandleNativeWindowMessage(HWND hwnd, UINT msg,
+                                                WPARAM w_param, LPARAM l_param,
+                                                LRESULT* result) {
+  WindowNativeMessageEventArgs args{
+      WindowNativeMessage{hwnd, msg, w_param, l_param}};
+  native_message_event_.Raise(args);
+  if (args.IsHandled()) {
+    *result = args.GetResult();
+    return true;
+  }
+
+  switch (msg) {
+    case WM_PAINT:
+      OnPaintInternal();
+      *result = 0;
+      return true;
+    case WM_ERASEBKGND:
+      *result = 1;
+      return true;
+    case WM_SETFOCUS:
+      OnSetFocusInternal();
+      *result = 0;
+      return true;
+    case WM_KILLFOCUS:
+      OnKillFocusInternal();
+      *result = 0;
+      return true;
+    case WM_MOUSEMOVE: {
+      POINT point;
+      point.x = GET_X_LPARAM(l_param);
+      point.y = GET_Y_LPARAM(l_param);
+      OnMouseMoveInternal(point);
+      *result = 0;
+      return true;
+    }
+    case WM_LBUTTONDOWN: {
+      POINT point;
+      point.x = GET_X_LPARAM(l_param);
+      point.y = GET_Y_LPARAM(l_param);
+      OnMouseDownInternal(MouseButton::Left, point);
+      *result = 0;
+      return true;
+    }
+    case WM_LBUTTONUP: {
+      POINT point;
+      point.x = GET_X_LPARAM(l_param);
+      point.y = GET_Y_LPARAM(l_param);
+      OnMouseUpInternal(MouseButton::Left, point);
+      *result = 0;
+      return true;
+    }
+    case WM_RBUTTONDOWN: {
+      POINT point;
+      point.x = GET_X_LPARAM(l_param);
+      point.y = GET_Y_LPARAM(l_param);
+      OnMouseDownInternal(MouseButton::Right, point);
+      *result = 0;
+      return true;
+    }
+    case WM_RBUTTONUP: {
+      POINT point;
+      point.x = GET_X_LPARAM(l_param);
+      point.y = GET_Y_LPARAM(l_param);
+      OnMouseUpInternal(MouseButton::Right, point);
+      *result = 0;
+      return true;
+    }
+    case WM_MBUTTONDOWN: {
+      POINT point;
+      point.x = GET_X_LPARAM(l_param);
+      point.y = GET_Y_LPARAM(l_param);
+      OnMouseDownInternal(MouseButton::Middle, point);
+      *result = 0;
+      return true;
+    }
+    case WM_MBUTTONUP: {
+      POINT point;
+      point.x = GET_X_LPARAM(l_param);
+      point.y = GET_Y_LPARAM(l_param);
+      OnMouseUpInternal(MouseButton::Middle, point);
+      *result = 0;
+      return true;
+    }
+    case WM_MOUSEWHEEL:
+      POINT point;
+      point.x = GET_X_LPARAM(l_param);
+      point.y = GET_Y_LPARAM(l_param);
+      ScreenToClient(hwnd, &point);
+      OnMouseWheelInternal(GET_WHEEL_DELTA_WPARAM(w_param), point);
+      *result = 0;
+      return true;
+    case WM_KEYDOWN:
+      OnKeyDownInternal(static_cast<int>(w_param));
+      *result = 0;
+      return true;
+    case WM_KEYUP:
+      OnKeyUpInternal(static_cast<int>(w_param));
+      *result = 0;
+      return true;
+    case WM_CHAR:
+      OnCharInternal(static_cast<wchar_t>(w_param));
+      *result = 0;
+      return true;
+    case WM_SIZE:
+      OnResizeInternal(LOWORD(l_param), HIWORD(l_param));
+      *result = 0;
+      return true;
+    case WM_ACTIVATE:
+      if (w_param == WA_ACTIVE || w_param == WA_CLICKACTIVE)
+        OnActivatedInternal();
+      else if (w_param == WA_INACTIVE)
+        OnDeactivatedInternal();
+      *result = 0;
+      return true;
+    case WM_DESTROY:
+      OnDestroyInternal();
+      *result = 0;
+      return true;
+    default:
+      return false;
+  }
+}
+
+RECT WinNativeWindow::GetClientRectPixel() {
+  RECT rect;
+  if (!GetClientRect(hwnd_, &rect))
+    throw Win32Error(::GetLastError(), "Failed to invoke GetClientRect.");
+  return rect;
+}
+
+void WinNativeWindow::OnDestroyInternal() {
+  application_->GetWindowManager()->UnregisterWindow(hwnd_);
+  hwnd_ = nullptr;
+  if (delete_this_on_destroy_)
+    application_->InvokeLater([this] { delete this; });
+}
+
+void WinNativeWindow::OnPaintInternal() {
+  paint_event_.Raise();
+  ValidateRect(hwnd_, nullptr);
+}
+
+void WinNativeWindow::OnResizeInternal(const int new_width,
+                                       const int new_height) {
+  // render_target_->ResizeBuffer(new_width, new_height);
+  if (!(new_width == 0 && new_height == 0))
+    resize_event_.Raise(
+        ui::Size{PixelToDipX(new_width), PixelToDipY(new_height)});
+}
+
+void WinNativeWindow::OnSetFocusInternal() {
+  has_focus_ = true;
+  focus_event_.Raise(true);
+}
+
+void WinNativeWindow::OnKillFocusInternal() {
+  has_focus_ = false;
+  focus_event_.Raise(false);
+}
+
+inline ui::Point PiToDip(const POINT& pi_point) {
+  return ui::Point(PixelToDipX(pi_point.x), PixelToDipY(pi_point.y));
+}
+
+void WinNativeWindow::OnMouseMoveInternal(const POINT point) {
+  // when mouse was previous outside the window
+  if (!is_mouse_in_) {
+    // invoke TrackMouseEvent to have WM_MOUSELEAVE sent.
+    TRACKMOUSEEVENT tme;
+    tme.cbSize = sizeof tme;
+    tme.dwFlags = TME_LEAVE;
+    tme.hwndTrack = hwnd_;
+
+    TrackMouseEvent(&tme);
+
+    is_mouse_in_ = true;
+    mouse_enter_leave_event_.Raise(true);
+  }
+
+  const auto dip_point = PiToDip(point);
+  mouse_move_event_.Raise(dip_point);
+}
+
+void WinNativeWindow::OnMouseLeaveInternal() {
+  is_mouse_in_ = false;
+  mouse_enter_leave_event_.Raise(false);
+}
+
+void WinNativeWindow::OnMouseDownInternal(MouseButton button, POINT point) {
+  const auto dip_point = PiToDip(point);
+  mouse_down_event_.Raise(button, dip_point);
+}
+
+void WinNativeWindow::OnMouseUpInternal(MouseButton button, POINT point) {
+  const auto dip_point = PiToDip(point);
+  mouse_up_event_.Raise(button, dip_point);
+}
+
+void WinNativeWindow::OnMouseWheelInternal(short delta, POINT point) {
+}
+
+void WinNativeWindow::OnKeyDownInternal(int virtual_code) {
+  key_down_event_.Raise(virtual_code);
+}
+
+void WinNativeWindow::OnKeyUpInternal(int virtual_code) {
+  key_up_event_.Raise(virtual_code);
+}
+
+void WinNativeWindow::OnCharInternal(wchar_t c) {
+}
+
+void WinNativeWindow::OnActivatedInternal() {
+}
+
+void WinNativeWindow::OnDeactivatedInternal() {
+}
+}  // namespace cru::platform::win
diff --git a/src/platform_win/window_manager.cpp b/src/platform_win/window_manager.cpp
new file mode 100644
index 00000000..62a73499
--- /dev/null
+++ b/src/platform_win/window_manager.cpp
@@ -0,0 +1,53 @@
+#include "window_manager.hpp"
+
+#include "cru/platform/win/win_application.hpp"
+#include "cru/platform/win/win_native_window.hpp"
+
+#include <assert.h>
+
+namespace cru::platform::win {
+LRESULT __stdcall GeneralWndProc(HWND hWnd, UINT Msg, WPARAM wParam,
+                                 LPARAM lParam) {
+  auto window = WinApplication::GetInstance()->GetWindowManager()->FromHandle(hWnd);
+
+  LRESULT result;
+  if (window != nullptr &&
+      window->HandleNativeWindowMessage(hWnd, Msg, wParam, lParam, &result))
+    return result;
+
+  return DefWindowProc(hWnd, Msg, wParam, lParam);
+}
+
+WindowManager::WindowManager(WinApplication* application) {
+  application_ = application;
+  general_window_class_ = std::make_shared<WindowClass>(
+      L"CruUIWindowClass", GeneralWndProc,
+      application->GetInstanceHandle());
+}
+
+void WindowManager::RegisterWindow(HWND hwnd, WinNativeWindow* window) {
+  assert(window_map_.count(hwnd) == 0);  // The hwnd is already in the map.
+  window_map_.emplace(hwnd, window);
+}
+
+void WindowManager::UnregisterWindow(HWND hwnd) {
+  const auto find_result = window_map_.find(hwnd);
+  assert(find_result != window_map_.end());  // The hwnd is not in the map.
+  window_map_.erase(find_result);
+  if (window_map_.empty()) application_->Quit(0);
+}
+
+WinNativeWindow* WindowManager::FromHandle(HWND hwnd) {
+  const auto find_result = window_map_.find(hwnd);
+  if (find_result == window_map_.end())
+    return nullptr;
+  else
+    return find_result->second;
+}
+
+std::vector<WinNativeWindow*> WindowManager::GetAllWindows() const {
+  std::vector<WinNativeWindow*> windows;
+  for (auto [key, value] : window_map_) windows.push_back(value);
+  return windows;
+}
+}
diff --git a/src/platform_win/window_manager.hpp b/src/platform_win/window_manager.hpp
new file mode 100644
index 00000000..6e36ead1
--- /dev/null
+++ b/src/platform_win/window_manager.hpp
@@ -0,0 +1,52 @@
+#pragma once
+#include "cru/platform/win/win_pre_config.hpp"
+
+#include "cru/common/base.hpp"
+
+#include <map>
+#include <memory>
+#include <vector>
+
+namespace cru::platform::win {
+class WinApplication;
+class WinNativeWindow;
+class WindowClass;
+
+class WindowManager : public Object {
+ public:
+  WindowManager(WinApplication* application);
+  WindowManager(const WindowManager& other) = delete;
+  WindowManager(WindowManager&& other) = delete;
+  WindowManager& operator=(const WindowManager& other) = delete;
+  WindowManager& operator=(WindowManager&& other) = delete;
+  ~WindowManager() override = default;
+
+  // Get the general window class for creating ordinary window.
+  std::shared_ptr<WindowClass> GetGeneralWindowClass() const {
+    return general_window_class_;
+  }
+
+  // Register a window newly created.
+  // This function adds the hwnd to hwnd-window map.
+  // It should be called immediately after a window was created.
+  void RegisterWindow(HWND hwnd, WinNativeWindow* window);
+
+  // Unregister a window that is going to be destroyed.
+  // This function removes the hwnd from the hwnd-window map.
+  // It should be called immediately before a window is going to be destroyed,
+  void UnregisterWindow(HWND hwnd);
+
+  // Return a pointer to the Window object related to the HWND or nullptr if the
+  // hwnd is not in the map.
+  WinNativeWindow* FromHandle(HWND hwnd);
+
+  std::vector<WinNativeWindow*> GetAllWindows() const;
+
+ private:
+  WinApplication* application_;
+
+  std::shared_ptr<WindowClass> general_window_class_;
+  std::map<HWND, WinNativeWindow*> window_map_;
+};
+
+}  // namespace cru::platform::win