14 files changed, 896 insertions, 0 deletions

diff --git a/src/win/native/CMakeLists.txt b/src/win/native/CMakeLists.txt
new file mode 100644
index 00000000..421f7515
--- /dev/null
+++ b/src/win/native/CMakeLists.txt
@@ -0,0 +1,10 @@
+add_library(cru_win_native STATIC
+	god_window.cpp
+	timer.cpp
+	win_application.cpp
+	win_native_window.cpp
+	window_class.cpp
+	window_manager.cpp
+	window_painter.cpp
+	window_render_target.cpp)
+target_link_libraries(cru_win_native PUBLIC cru_win_graph)
diff --git a/src/win/native/dpi_util.hpp b/src/win/native/dpi_util.hpp
new file mode 100644
index 00000000..d459e8c6
--- /dev/null
+++ b/src/win/native/dpi_util.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "cru/platform/native/basic_types.hpp"
+
+// The dpi awareness needs to be implemented in the future. Currently we use 96
+// as default.
+
+namespace cru::win::native {
+inline platform::native::Dpi GetDpi() {
+  return platform::native::Dpi{96.0f, 96.0f};
+}
+
+inline int DipToPixelInternal(const float dip, const float dpi) {
+  return static_cast<int>(dip * dpi / 96.0f);
+}
+
+inline int DipToPixelX(const float dip_x) {
+  return DipToPixelInternal(dip_x, GetDpi().x);
+}
+
+inline int DipToPixelY(const float dip_y) {
+  return DipToPixelInternal(dip_y, GetDpi().y);
+}
+
+inline float DipToPixelInternal(const int pixel, const float dpi) {
+  return static_cast<float>(pixel) * 96.0f / dpi;
+}
+
+inline float PixelToDipX(const int pixel_x) {
+  return DipToPixelInternal(pixel_x, GetDpi().x);
+}
+
+inline float PixelToDipY(const int pixel_y) {
+  return DipToPixelInternal(pixel_y, GetDpi().y);
+}
+}  // namespace cru::win::native
diff --git a/src/win/native/god_window.cpp b/src/win/native/god_window.cpp
new file mode 100644
index 00000000..58fb663c
--- /dev/null
+++ b/src/win/native/god_window.cpp
@@ -0,0 +1,73 @@
+#include "cru/win/native/god_window.hpp"
+
+#include "cru/win/exception.hpp"
+#include "cru/win/native/win_application.hpp"
+#include "cru/win/native/window_class.hpp"
+#include "god_window_message.hpp"
+#include "timer.hpp"
+
+namespace cru::win::native {
+constexpr auto god_window_class_name = L"GodWindowClass";
+
+LRESULT CALLBACK GodWndProc(HWND hWnd, UINT uMsg, WPARAM wParam,
+                            LPARAM lParam) {
+  const auto app = WinApplication::GetInstance();
+
+  if (app) {
+    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
+    return DefWindowProcW(hWnd, uMsg, wParam, lParam);
+}
+
+GodWindow::GodWindow(WinApplication* application) {
+  application_ = application;
+
+  const auto h_instance = application->GetInstanceHandle();
+
+  god_window_class_ = std::make_shared<WindowClass>(god_window_class_name,
+                                                    GodWndProc, h_instance);
+
+  hwnd_ = CreateWindowEx(0, god_window_class_name, L"", 0, CW_USEDEFAULT,
+                         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+                         HWND_MESSAGE, nullptr, h_instance, nullptr);
+
+  if (hwnd_ == nullptr)
+    throw Win32Error(::GetLastError(), "Failed to create god window.");
+}
+
+GodWindow::~GodWindow() { ::DestroyWindow(hwnd_); }
+
+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;
+      *result = 0;
+      return true;
+    }
+    case WM_TIMER: {
+      const auto id = static_cast<UINT_PTR>(w_param);
+      const auto action = application_->GetTimerManager()->GetAction(id);
+      if (action.has_value()) {
+        (action.value().second)();
+        if (!action.value().first)
+          application_->GetTimerManager()->KillTimer(id);
+        result = 0;
+        return true;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  return false;
+}
+}  // namespace cru::win::native
diff --git a/src/win/native/god_window_message.hpp b/src/win/native/god_window_message.hpp
new file mode 100644
index 00000000..10268625
--- /dev/null
+++ b/src/win/native/god_window_message.hpp
@@ -0,0 +1,6 @@
+#pragma once
+#include "cru/win/win_pre_config.hpp"
+
+namespace cru::win::native {
+constexpr int invoke_later_message_id = WM_USER + 2000;
+}
diff --git a/src/win/native/timer.cpp b/src/win/native/timer.cpp
new file mode 100644
index 00000000..9e3bbde6
--- /dev/null
+++ b/src/win/native/timer.cpp
@@ -0,0 +1,28 @@
+#include "timer.hpp"
+
+namespace cru::win::native {
+TimerManager::TimerManager(GodWindow* god_window) { god_window_ = god_window; }
+
+UINT_PTR TimerManager::CreateTimer(const UINT milliseconds, const bool loop,
+                                   const TimerAction& action) {
+  const auto id = current_count_++;
+  ::SetTimer(god_window_->GetHandle(), id, milliseconds, nullptr);
+  map_.emplace(id, std::make_pair(loop, action));
+  return id;
+}
+
+void TimerManager::KillTimer(const UINT_PTR id) {
+  const auto find_result = map_.find(id);
+  if (find_result != map_.cend()) {
+    ::KillTimer(god_window_->GetHandle(), id);
+    map_.erase(find_result);
+  }
+}
+
+std::optional<std::pair<bool, TimerAction>> TimerManager::GetAction(
+    const UINT_PTR id) {
+  const auto find_result = map_.find(id);
+  if (find_result == map_.cend()) return std::nullopt;
+  return find_result->second;
+}
+}  // namespace cru::win::native
diff --git a/src/win/native/timer.hpp b/src/win/native/timer.hpp
new file mode 100644
index 00000000..f30d9b91
--- /dev/null
+++ b/src/win/native/timer.hpp
@@ -0,0 +1,34 @@
+#pragma once
+#include "cru/win/win_pre_config.hpp"
+
+#include "cru/common/base.hpp"
+#include "cru/win/native/god_window.hpp"
+
+#include <chrono>
+#include <functional>
+#include <map>
+#include <optional>
+
+namespace cru::win::native {
+using TimerAction = std::function<void()>;
+
+class TimerManager : public Object {
+ public:
+  TimerManager(GodWindow* god_window);
+  TimerManager(const TimerManager& other) = delete;
+  TimerManager(TimerManager&& other) = delete;
+  TimerManager& operator=(const TimerManager& other) = delete;
+  TimerManager& operator=(TimerManager&& other) = delete;
+  ~TimerManager() override = default;
+
+  UINT_PTR CreateTimer(UINT milliseconds, bool loop, const TimerAction& action);
+  void KillTimer(UINT_PTR id);
+  std::optional<std::pair<bool, TimerAction>> GetAction(UINT_PTR id);
+
+ private:
+  GodWindow* god_window_;
+
+  std::map<UINT_PTR, std::pair<bool, TimerAction>> map_{};
+  UINT_PTR current_count_ = 0;
+};
+}  // namespace cru::win::native
diff --git a/src/win/native/win_application.cpp b/src/win/native/win_application.cpp
new file mode 100644
index 00000000..72e12fa0
--- /dev/null
+++ b/src/win/native/win_application.cpp
@@ -0,0 +1,100 @@
+#include "cru/win/native/win_application.hpp"
+
+#include "cru/win/exception.hpp"
+#include "cru/win/native/god_window.hpp"
+#include "cru/win/native/win_native_window.hpp"
+#include "god_window_message.hpp"
+#include "timer.hpp"
+#include "window_manager.hpp"
+
+#include <VersionHelpers.h>
+#include <cassert>
+
+namespace cru::platform::native {
+UiApplication* UiApplication::GetInstance() {
+  return win::native::WinApplication::GetInstance();
+}
+}  // namespace cru::platform::native
+
+namespace cru::win::native {
+WinApplication* WinApplication::instance_ = nullptr;
+
+WinApplication* WinApplication::GetInstance() {
+  if (instance_ == nullptr)
+    instance_ = new WinApplication(::GetModuleHandleW(nullptr));
+  return instance_;
+}
+
+WinApplication::WinApplication(HINSTANCE h_instance) : h_instance_(h_instance) {
+  if (instance_)
+    throw std::runtime_error("A application instance already exists.");
+
+  instance_ = this;
+
+  if (!::IsWindows8OrGreater())
+    throw std::runtime_error("Must run on Windows 8 or later.");
+
+  god_window_ = std::make_shared<GodWindow>(this);
+  timer_manager_ = std::make_shared<TimerManager>(god_window_.get());
+  window_manager_ = std::make_shared<WindowManager>(this);
+}
+
+WinApplication::~WinApplication() { instance_ = nullptr; }
+
+int WinApplication::Run() {
+  MSG msg;
+  while (GetMessageW(&msg, nullptr, 0, 0)) {
+    TranslateMessage(&msg);
+    DispatchMessageW(&msg);
+  }
+  return static_cast<int>(msg.wParam);
+}
+
+void WinApplication::Quit(const int quit_code) { ::PostQuitMessage(quit_code); }
+
+void WinApplication::InvokeLater(const std::function<void()>& action) {
+  // copy the action to a safe place
+  auto p_action_copy = new std::function<void()>(action);
+
+  if (PostMessageW(GetGodWindow()->GetHandle(), invoke_later_message_id,
+                   reinterpret_cast<WPARAM>(p_action_copy), 0) == 0)
+    throw Win32Error(::GetLastError(), "InvokeLater failed to post message.");
+}
+
+unsigned long WinApplication::SetTimeout(std::chrono::milliseconds milliseconds,
+                                         const std::function<void()>& action) {
+  return static_cast<unsigned long>(timer_manager_->CreateTimer(
+      static_cast<UINT>(milliseconds.count()), false, action));
+}
+
+unsigned long WinApplication::SetInterval(
+    std::chrono::milliseconds milliseconds,
+    const std::function<void()>& action) {
+  return static_cast<unsigned long>(timer_manager_->CreateTimer(
+      static_cast<UINT>(milliseconds.count()), true, action));
+}
+
+void WinApplication::CancelTimer(unsigned long id) {
+  timer_manager_->KillTimer(static_cast<UINT_PTR>(id));
+}
+
+std::vector<platform::native::NativeWindow*> WinApplication::GetAllWindow() {
+  const auto&& windows = window_manager_->GetAllWindows();
+  std::vector<platform::native::NativeWindow*> result;
+  for (const auto w : windows) {
+    result.push_back(static_cast<platform::native::NativeWindow*>(w));
+  }
+  return result;
+}
+
+platform::native::NativeWindow* WinApplication::CreateWindow(
+    platform::native::NativeWindow* parent) {
+  WinNativeWindow* p = nullptr;
+  if (parent != nullptr) {
+    p = dynamic_cast<WinNativeWindow*>(parent);
+    assert(p);
+  }
+  return new WinNativeWindow(this, window_manager_->GetGeneralWindowClass(),
+                             WS_OVERLAPPEDWINDOW, p);
+}
+}  // namespace cru::win::native
diff --git a/src/win/native/win_native_window.cpp b/src/win/native/win_native_window.cpp
new file mode 100644
index 00000000..0afad4e6
--- /dev/null
+++ b/src/win/native/win_native_window.cpp
@@ -0,0 +1,340 @@
+#include "cru/win/native/win_native_window.hpp"
+
+#include "cru/win/exception.hpp"
+#include "cru/win/graph/graph_manager.hpp"
+#include "cru/win/native/win_application.hpp"
+#include "cru/win/native/window_class.hpp"
+#include "cru/win/native/window_render_target.hpp"
+#include "dpi_util.hpp"
+#include "window_manager.hpp"
+#include "window_painter.hpp"
+
+#include <assert.h>
+#include <windowsx.h>
+
+namespace cru::win::native {
+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);
+
+  window_render_target_.reset(
+      new WindowRenderTarget(graph::GraphManager::GetInstance(), hwnd_));
+}
+
+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.");
+  }
+}
+
+platform::graph::Painter* WinNativeWindow::BeginPaint() {
+  return new WindowPainter(this);
+}
+
+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(platform::native::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(platform::native::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(platform::native::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(platform::native::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(platform::native::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(platform::native::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) {
+  if (!(new_width == 0 && new_height == 0)) {
+    window_render_target_->ResizeBuffer(new_width, new_height);
+    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(platform::native::MouseButton button,
+                                          POINT point) {
+  const auto dip_point = PiToDip(point);
+  mouse_down_event_.Raise(button, dip_point);
+}
+
+void WinNativeWindow::OnMouseUpInternal(platform::native::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::win::native
diff --git a/src/win/native/window_class.cpp b/src/win/native/window_class.cpp
new file mode 100644
index 00000000..6c7d0d3d
--- /dev/null
+++ b/src/win/native/window_class.cpp
@@ -0,0 +1,28 @@
+#include "cru/win/native/window_class.hpp"
+
+#include "cru/win/exception.hpp"
+
+namespace cru::win::native {
+WindowClass::WindowClass(const std::wstring& name, WNDPROC window_proc,
+                         HINSTANCE h_instance)
+    : name_(name) {
+  WNDCLASSEXW window_class;
+  window_class.cbSize = sizeof(WNDCLASSEXW);
+
+  window_class.style = CS_HREDRAW | CS_VREDRAW;
+  window_class.lpfnWndProc = window_proc;
+  window_class.cbClsExtra = 0;
+  window_class.cbWndExtra = 0;
+  window_class.hInstance = h_instance;
+  window_class.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+  window_class.hCursor = LoadCursor(NULL, IDC_ARROW);
+  window_class.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
+  window_class.lpszMenuName = NULL;
+  window_class.lpszClassName = name.c_str();
+  window_class.hIconSm = NULL;
+
+  atom_ = ::RegisterClassExW(&window_class);
+  if (atom_ == 0)
+    throw Win32Error(::GetLastError(), "Failed to create window class.");
+}
+}  // namespace cru::win::native
diff --git a/src/win/native/window_manager.cpp b/src/win/native/window_manager.cpp
new file mode 100644
index 00000000..a2fcdb54
--- /dev/null
+++ b/src/win/native/window_manager.cpp
@@ -0,0 +1,54 @@
+#include "window_manager.hpp"
+
+#include "cru/win/native/win_application.hpp"
+#include "cru/win/native/win_native_window.hpp"
+#include "cru/win/native/window_class.hpp"
+
+#include <assert.h>
+
+namespace cru::win::native {
+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;
+}
+}  // namespace cru::win::native
diff --git a/src/win/native/window_manager.hpp b/src/win/native/window_manager.hpp
new file mode 100644
index 00000000..fa5bbe9d
--- /dev/null
+++ b/src/win/native/window_manager.hpp
@@ -0,0 +1,52 @@
+#pragma once
+#include "cru/win/win_pre_config.hpp"
+
+#include "cru/common/base.hpp"
+
+#include <map>
+#include <memory>
+#include <vector>
+
+namespace cru::win::native {
+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::win::native
diff --git a/src/win/native/window_painter.cpp b/src/win/native/window_painter.cpp
new file mode 100644
index 00000000..46364cdd
--- /dev/null
+++ b/src/win/native/window_painter.cpp
@@ -0,0 +1,24 @@
+#include "window_painter.hpp"
+
+#include "cru/win/graph/graph_manager.hpp"
+#include "cru/win/native/window_render_target.hpp"
+
+#include <cassert>
+
+namespace cru::win::native {
+WindowPainter::WindowPainter(WinNativeWindow* window)
+    : WinPainter(window->GetWindowRenderTarget()
+                     ->GetGraphManager()
+                     ->GetD2D1DeviceContext()),
+      window_(window) {
+  window->GetWindowRenderTarget()->SetAsTarget();
+  window->GetWindowRenderTarget()
+      ->GetGraphManager()
+      ->GetD2D1DeviceContext()
+      ->BeginDraw();
+}
+
+void WindowPainter::DoEndDraw() {
+  WinPainter::DoEndDraw();
+  window_->GetWindowRenderTarget()->Present(); }
+}  // namespace cru::win::native
diff --git a/src/win/native/window_painter.hpp b/src/win/native/window_painter.hpp
new file mode 100644
index 00000000..0e6ab2cb
--- /dev/null
+++ b/src/win/native/window_painter.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include "cru/win/graph/win_painter.hpp"
+#include "cru/win/native/win_native_window.hpp"
+
+namespace cru::win::native {
+class WindowPainter : public graph::WinPainter {
+ public:
+  explicit WindowPainter(WinNativeWindow* window);
+  WindowPainter(const WindowPainter& other) = delete;
+  WindowPainter& operator=(const WindowPainter& other) = delete;
+  WindowPainter(WindowPainter&& other) = delete;
+  WindowPainter& operator=(WindowPainter&& other) = delete;
+  ~WindowPainter() override = default;
+
+ protected:
+  void DoEndDraw() override;
+
+ private:
+  WinNativeWindow* window_;
+};
+}  // namespace cru::win::native
diff --git a/src/win/native/window_render_target.cpp b/src/win/native/window_render_target.cpp
new file mode 100644
index 00000000..c49a920e
--- /dev/null
+++ b/src/win/native/window_render_target.cpp
@@ -0,0 +1,90 @@
+#include "cru/win/native/window_render_target.hpp"
+
+#include "cru/win/exception.hpp"
+#include "cru/win/graph/graph_manager.hpp"
+#include "dpi_util.hpp"
+
+#include <cassert>
+
+namespace cru::win::native {
+WindowRenderTarget::WindowRenderTarget(graph::GraphManager* graph_manager,
+                                       HWND hwnd) {
+  this->graph_manager_ = graph_manager;
+
+  const auto d3d11_device = graph_manager->GetD3D11Device();
+  const auto dxgi_factory = graph_manager->GetDxgiFactory();
+
+  // Allocate a descriptor.
+  DXGI_SWAP_CHAIN_DESC1 swap_chain_desc = {0};
+  swap_chain_desc.Width = 0;  // use automatic sizing
+  swap_chain_desc.Height = 0;
+  swap_chain_desc.Format =
+      DXGI_FORMAT_B8G8R8A8_UNORM;  // this is the most common swapchain format
+  swap_chain_desc.Stereo = false;
+  swap_chain_desc.SampleDesc.Count = 1;  // don't use multi-sampling
+  swap_chain_desc.SampleDesc.Quality = 0;
+  swap_chain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+  swap_chain_desc.BufferCount = 2;  // use double buffering to enable flip
+  swap_chain_desc.Scaling = DXGI_SCALING_NONE;
+  swap_chain_desc.SwapEffect =
+      DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;  // all apps must use this SwapEffect
+  swap_chain_desc.Flags = 0;
+
+  // Get the final swap chain for this window from the DXGI factory.
+  ThrowIfFailed(dxgi_factory->CreateSwapChainForHwnd(
+      d3d11_device, hwnd, &swap_chain_desc, nullptr, nullptr,
+      &dxgi_swap_chain_));
+
+  CreateTargetBitmap();
+}
+
+void WindowRenderTarget::ResizeBuffer(const int width, const int height) {
+  const auto graph_manager = graph_manager_;
+  const auto d2d1_device_context = graph_manager->GetD2D1DeviceContext();
+
+  Microsoft::WRL::ComPtr<ID2D1Image> old_target;
+  d2d1_device_context->GetTarget(&old_target);
+  const auto target_this = old_target == this->target_bitmap_;
+  if (target_this) d2d1_device_context->SetTarget(nullptr);
+
+  old_target = nullptr;
+  target_bitmap_ = nullptr;
+
+  ThrowIfFailed(dxgi_swap_chain_->ResizeBuffers(0, width, height,
+                                                DXGI_FORMAT_UNKNOWN, 0));
+
+  CreateTargetBitmap();
+
+  if (target_this) d2d1_device_context->SetTarget(target_bitmap_.Get());
+}
+
+void WindowRenderTarget::SetAsTarget() {
+  graph_manager_->GetD2D1DeviceContext()->SetTarget(target_bitmap_.Get());
+}
+
+void WindowRenderTarget::Present() {
+  ThrowIfFailed(dxgi_swap_chain_->Present(1, 0));
+}
+
+void WindowRenderTarget::CreateTargetBitmap() {
+  assert(target_bitmap_ == nullptr);  // target bitmap must not exist.
+
+  // Direct2D needs the dxgi version of the backbuffer surface pointer.
+  Microsoft::WRL::ComPtr<IDXGISurface> dxgi_back_buffer;
+  ThrowIfFailed(
+      dxgi_swap_chain_->GetBuffer(0, IID_PPV_ARGS(&dxgi_back_buffer)));
+
+  const auto dpi = GetDpi();
+
+  auto bitmap_properties = D2D1::BitmapProperties1(
+      D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,
+      D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE),
+      dpi.x, dpi.y);
+
+  // Get a D2D surface from the DXGI back buffer to use as the D2D render
+  // target.
+  ThrowIfFailed(
+      graph_manager_->GetD2D1DeviceContext()->CreateBitmapFromDxgiSurface(
+          dxgi_back_buffer.Get(), &bitmap_properties, &target_bitmap_));
+}
+}  // namespace cru::win::native