...

14 files changed, 129 insertions, 115 deletions

diff --git a/include/cru/common/logger.hpp b/include/cru/common/logger.hpp
index 08765499..61d97422 100644
--- a/include/cru/common/logger.hpp
+++ b/include/cru/common/logger.hpp
@@ -28,6 +28,11 @@ class StdioLogSource : public virtual ILogSource {
   ~StdioLogSource() override = default;
 
   void Write(LogLevel level, const std::string_view& s) override {
+    // TODO: Emmm... Since it is buggy to use narrow char in UTF-8 on Windows. I
+    // think this implementation might be broken. (However, I didn't test it.)
+    // Maybe, I should detect Windows and use wide char (And I didn't test this
+    // either) or other more complicated implementation. Currently, I settled
+    // with this.
     if (level == LogLevel::Error) {
       std::cerr << s;
     } else {
diff --git a/include/cru/platform/native/cursor.hpp b/include/cru/platform/native/cursor.hpp
index 961dff34..cb8b7ed2 100644
--- a/include/cru/platform/native/cursor.hpp
+++ b/include/cru/platform/native/cursor.hpp
@@ -1,18 +1,18 @@
 #pragma once
 
-#include "../native_resource.hpp"
+#include "../resource.hpp"
 
 #include <memory>
 
 namespace cru::platform::native {
-struct ICursor : public virtual INativeResource {};
+struct ICursor : virtual INativeResource {};
 
 enum class SystemCursorType {
   Arrow,
   Hand,
 };
 
-struct ICursorManager : public virtual INativeResource {
+struct ICursorManager : virtual INativeResource {
   virtual std::shared_ptr<ICursor> GetSystemCursor(SystemCursorType type) = 0;
 
   // TODO: Add method to create cursor.
diff --git a/include/cru/platform/native/native_event.hpp b/include/cru/platform/native/event.hpp
index dcd7a336..48e9cfca 100644
--- a/include/cru/platform/native/native_event.hpp
+++ b/include/cru/platform/native/event.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../graphic_base.hpp"
+#include "../graph_base.hpp"
 #include "basic_types.hpp"
 
 namespace cru::platform::native {
@@ -12,5 +12,4 @@ struct NativeMouseButtonEventArgs {
 enum class FocusChangeType { Gain, Lost };
 
 enum class MouseEnterLeaveType { Enter, Leave };
-
 }  // namespace cru::platform::native
diff --git a/include/cru/platform/native/ui_application.hpp b/include/cru/platform/native/ui_application.hpp
index 6d2ab659..c1f10d15 100644
--- a/include/cru/platform/native/ui_application.hpp
+++ b/include/cru/platform/native/ui_application.hpp
@@ -1,30 +1,21 @@
 #pragma once
-#include "../native_resource.hpp"
+#include "../resource.hpp"
 
 #include <chrono>
 #include <functional>
 #include <vector>
 
+namespace cru::platform::graph {
+struct IGraphFactory;
+}
+
 namespace cru::platform::native {
 struct INativeWindow;
 struct ICursorManager;
 
 // The entry point of a ui application.
-// It will call IGraphFactory::CreateInstance during its creation
-// and set graph factory to be auto deleted. If you want to keep
-// the graph factory then you should manually set it to false after
-// creating the ui application.
 struct IUiApplication : public virtual INativeResource {
  public:
-  // Create a platform-specific instance and save it as the global instance.
-  // Do not create the instance twice. Implements should assert for that.
-  // After creating, get the instance by GetInstance.
-  static IUiApplication* CreateInstance();
-
-  // Get the global instance. If it is not created, then return nullptr.
-  static IUiApplication* GetInstance();
-
- public:
   // Block current thread and run the message loop. Return the exit code when
   // message loop gets a quit message (possibly posted by method RequestQuit).
   virtual int Run() = 0;
@@ -44,6 +35,8 @@ struct IUiApplication : public virtual INativeResource {
   virtual std::vector<INativeWindow*> GetAllWindow() = 0;
   virtual INativeWindow* CreateWindow(INativeWindow* parent) = 0;
 
+  virtual cru::platform::graph::IGraphFactory* GetGraphFactory() = 0;
+
   virtual ICursorManager* GetCursorManager() = 0;
 };
 }  // namespace cru::platform::native
diff --git a/include/cru/platform/native/native_window.hpp b/include/cru/platform/native/window.hpp
index cd2459e0..bfaf170b 100644
--- a/include/cru/platform/native/native_window.hpp
+++ b/include/cru/platform/native/window.hpp
@@ -1,12 +1,11 @@
 #pragma once
-#include "../native_resource.hpp"
+#include "../resource.hpp"
 
-#include "cru/common/event.hpp"
-
-#include "../graphic_base.hpp"
+#include "../graph_base.hpp"
 #include "basic_types.hpp"
+#include "cru/common/event.hpp"
 #include "cursor.hpp"
-#include "native_event.hpp"
+#include "event.hpp"
 
 namespace cru::platform::graph {
 struct IPainter;
@@ -21,7 +20,7 @@ namespace cru::platform::native {
 // Close or closed by the user, which leads to an invalid instance. You can
 // check the validity by IsValid. When you call perform native operations on the
 // invalid instance, there is no effect.
-struct INativeWindow : public virtual INativeResource {
+struct INativeWindow : virtual INativeResource {
   // Return if the window is still valid, that is, hasn't been closed or
   // destroyed.
   virtual bool IsValid() = 0;
diff --git a/include/cru/win/graph/direct/factory.hpp b/include/cru/win/graph/direct/factory.hpp
index ae4eeb3a..4c106f54 100644
--- a/include/cru/win/graph/direct/factory.hpp
+++ b/include/cru/win/graph/direct/factory.hpp
@@ -5,10 +5,9 @@
 
 namespace cru::platform::graph::win::direct {
 class DirectGraphFactory : public DirectResource, public virtual IGraphFactory {
- private:
+ public:
   DirectGraphFactory();
 
- public:
   CRU_DELETE_COPY(DirectGraphFactory)
   CRU_DELETE_MOVE(DirectGraphFactory)
 
diff --git a/include/cru/win/native/cursor.hpp b/include/cru/win/native/cursor.hpp
index 3ef480ea..e5728b1c 100644
--- a/include/cru/win/native/cursor.hpp
+++ b/include/cru/win/native/cursor.hpp
@@ -1,32 +1,30 @@
 #pragma once
-#include <memory>
-#include "../win_pre_config.hpp"
+#include "resource.hpp"
 
-#include "cru/common/base.hpp"
 #include "cru/platform/native/cursor.hpp"
-#include "cru/win/native/platform_id.hpp"
+
+#include <memory>
 
 namespace cru::platform::native::win {
-class WinCursor : public Cursor {
+class WinCursor : public WinNativeResource, public virtual ICursor {
  public:
-  WinCursor(HCURSOR handle, bool auto_delete);
+  WinCursor(HCURSOR handle, bool auto_destroy);
 
   CRU_DELETE_COPY(WinCursor)
   CRU_DELETE_MOVE(WinCursor)
 
   ~WinCursor() override;
 
-  CRU_PLATFORMID_IMPLEMENT_WIN
-
  public:
   HCURSOR GetHandle() const { return handle_; }
 
  private:
   HCURSOR handle_;
-  bool auto_delete_;
+  bool auto_destroy_;
 };
 
-class WinCursorManager : public CursorManager {
+class WinCursorManager : public WinNativeResource,
+                         public virtual ICursorManager {
  public:
   WinCursorManager();
 
@@ -35,13 +33,11 @@ class WinCursorManager : public CursorManager {
 
   ~WinCursorManager() override = default;
 
-  CRU_PLATFORMID_IMPLEMENT_WIN
-
  public:
-  std::shared_ptr<WinCursor> GetSystemWinCursor(SystemCursor type);
+  std::shared_ptr<WinCursor> GetSystemWinCursor(SystemCursorType type);
 
-  std::shared_ptr<Cursor> GetSystemCursor(SystemCursor type) override {
-    return std::static_pointer_cast<Cursor>(GetSystemWinCursor(type));
+  std::shared_ptr<ICursor> GetSystemCursor(SystemCursorType type) override {
+    return std::static_pointer_cast<ICursor>(GetSystemWinCursor(type));
   }
 
  private:
diff --git a/include/cru/win/native/god_window.hpp b/include/cru/win/native/god_window.hpp
index 9fd20caa..3cf97e0b 100644
--- a/include/cru/win/native/god_window.hpp
+++ b/include/cru/win/native/god_window.hpp
@@ -12,10 +12,10 @@ class WindowClass;
 class GodWindow : public Object {
  public:
   explicit GodWindow(WinUiApplication* application);
-  GodWindow(const GodWindow& other) = delete;
-  GodWindow(GodWindow&& other) = delete;
-  GodWindow& operator=(const GodWindow& other) = delete;
-  GodWindow& operator=(GodWindow&& other) = delete;
+
+  CRU_DELETE_COPY(GodWindow)
+  CRU_DELETE_MOVE(GodWindow)
+
   ~GodWindow() override;
 
   HWND GetHandle() const { return hwnd_; }
@@ -26,7 +26,7 @@ class GodWindow : public Object {
  private:
   WinUiApplication* application_;
 
-  std::shared_ptr<WindowClass> god_window_class_;
+  std::unique_ptr<WindowClass> god_window_class_;
   HWND hwnd_;
 };
-}  // namespace cru::win::native
\ No newline at end of file
+}  // namespace cru::platform::native::win
diff --git a/include/cru/win/native/resource.hpp b/include/cru/win/native/resource.hpp
new file mode 100644
index 00000000..2c76fe6b
--- /dev/null
+++ b/include/cru/win/native/resource.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include "../win_pre_config.hpp"
+
+#include "cru/platform/resource.hpp"
+
+namespace cru::platform::native::win {
+class WinNativeResource : public Object, public virtual INativeResource {
+ public:
+  static constexpr std::string_view k_platform_id = "Windows";
+
+ protected:
+  WinNativeResource() = default;
+
+ public:
+  CRU_DELETE_COPY(WinNativeResource)
+  CRU_DELETE_MOVE(WinNativeResource)
+
+  ~WinNativeResource() override = default;
+
+ public:
+  std::string_view GetPlatformId() const final { return k_platform_id; }
+};
+}  // namespace cru::platform::native::win
diff --git a/include/cru/win/native/ui_application.hpp b/include/cru/win/native/ui_application.hpp
index 94c4b1eb..65bdc9e4 100644
--- a/include/cru/win/native/ui_application.hpp
+++ b/include/cru/win/native/ui_application.hpp
@@ -1,39 +1,40 @@
 #pragma once
-#include "../win_pre_config.hpp"
+#include "resource.hpp"
 
 #include "cru/platform/native/ui_application.hpp"
 
-#include "platform_id.hpp"
-#include "cursor.hpp"
-
 #include <memory>
 
+namespace cru::platform::graph::win::direct {
+class DirectGraphFactory;
+}
+
 namespace cru::platform::native::win {
 class GodWindow;
 class TimerManager;
 class WindowManager;
+class WinCursorManager;
 
-class WinUiApplication : public UiApplication {
-  friend UiApplication* UiApplication::CreateInstance();
-
+class WinUiApplication : public WinNativeResource,
+                         public virtual IUiApplication {
  public:
-  static WinUiApplication* GetInstance();
+  static WinUiApplication* GetInstance() { return instance; }
+
+ private:
+  static WinUiApplication* instance;
 
  private:
-  explicit WinUiApplication(HINSTANCE h_instance);
+  WinUiApplication();
 
  public:
-  WinUiApplication(const WinUiApplication&) = delete;
-  WinUiApplication(WinUiApplication&&) = delete;
-  WinUiApplication& operator=(const WinUiApplication&) = delete;
-  WinUiApplication& operator=(WinUiApplication&&) = delete;
-  ~WinUiApplication() override;
+  CRU_DELETE_COPY(WinUiApplication)
+  CRU_DELETE_MOVE(WinUiApplication)
 
-  CRU_PLATFORMID_IMPLEMENT_WIN
+  ~WinUiApplication() override;
 
  public:
   int Run() override;
-  void Quit(int quit_code) override;
+  void RequestQuit(int quit_code) override;
 
   void AddOnQuitHandler(const std::function<void()>& handler) override;
 
@@ -47,25 +48,29 @@ class WinUiApplication : public UiApplication {
   std::vector<INativeWindow*> GetAllWindow() override;
   INativeWindow* CreateWindow(INativeWindow* parent) override;
 
-  WinCursorManager* GetCursorManager() override;
+  cru::platform::graph::IGraphFactory* GetGraphFactory() override;
+
+  cru::platform::graph::win::direct::DirectGraphFactory* GetDirectFactory() {
+    return graph_factory_.get();
+  }
 
-  bool IsAutoDelete() const { return auto_delete_; }
-  void SetAutoDelete(bool value) { auto_delete_ = value; }
+  ICursorManager* GetCursorManager() override;
 
-  HINSTANCE GetInstanceHandle() const { return h_instance_; }
+  HINSTANCE GetInstanceHandle() const { return instance_handle_; }
 
   GodWindow* GetGodWindow() const { return god_window_.get(); }
   TimerManager* GetTimerManager() const { return timer_manager_.get(); }
   WindowManager* GetWindowManager() const { return window_manager_.get(); }
 
  private:
-  bool auto_delete_ = false;
+  HINSTANCE instance_handle_;
 
-  HINSTANCE h_instance_;
+  std::unique_ptr<cru::platform::graph::win::direct::DirectGraphFactory>
+      graph_factory_;
 
-  std::shared_ptr<GodWindow> god_window_;
-  std::shared_ptr<TimerManager> timer_manager_;
-  std::shared_ptr<WindowManager> window_manager_;
+  std::unique_ptr<GodWindow> god_window_;
+  std::unique_ptr<TimerManager> timer_manager_;
+  std::unique_ptr<WindowManager> window_manager_;
 
   std::unique_ptr<WinCursorManager> cursor_manager_;
 
diff --git a/include/cru/win/native/native_window.hpp b/include/cru/win/native/window.hpp
index 16b14dbf..9752682f 100644
--- a/include/cru/win/native/native_window.hpp
+++ b/include/cru/win/native/window.hpp
@@ -1,30 +1,28 @@
 #pragma once
-#include "../win_pre_config.hpp"
+#include "resource.hpp"
 
-#include "cru/platform/native/native_window.hpp"
-#include "platform_id.hpp"
+#include "cru/platform/native/window.hpp"
 #include "window_native_message_event_args.hpp"
 
 #include <memory>
 
 namespace cru::platform::native::win {
 class WinUiApplication;
+class WinCursor;
 class WindowClass;
 class WindowManager;
 class WindowRenderTarget;
 
-class WinNativeWindow : public INativeWindow {
+class WinNativeWindow : public WinNativeResource, public virtual INativeWindow {
  public:
   WinNativeWindow(WinUiApplication* application,
-                  std::shared_ptr<WindowClass> window_class, DWORD window_style,
+                  WindowClass* window_class, DWORD window_style,
                   WinNativeWindow* parent);
-  WinNativeWindow(const WinNativeWindow& other) = delete;
-  WinNativeWindow(WinNativeWindow&& other) = delete;
-  WinNativeWindow& operator=(const WinNativeWindow& other) = delete;
-  WinNativeWindow& operator=(WinNativeWindow&& other) = delete;
-  ~WinNativeWindow() override;
 
-  CRU_PLATFORMID_IMPLEMENT_WIN
+  CRU_DELETE_COPY(WinNativeWindow)
+  CRU_DELETE_MOVE(WinNativeWindow)
+
+  ~WinNativeWindow() override;
 
  public:
   bool IsValid() override;
@@ -53,16 +51,16 @@ class WinNativeWindow : public INativeWindow {
   bool CaptureMouse() override;
   bool ReleaseMouse() override;
 
-  void Repaint() override;
-  graph::Painter* BeginPaint() override;
+  void RequestRepaint() override;
+  std::unique_ptr<graph::IPainter> BeginPaint() override;
 
-  void SetCursor(std::shared_ptr<Cursor> cursor) override;
+  void SetCursor(std::shared_ptr<ICursor> cursor) override;
 
   IEvent<std::nullptr_t>* DestroyEvent() override { return &destroy_event_; }
   IEvent<std::nullptr_t>* PaintEvent() override { return &paint_event_; }
   IEvent<Size>* ResizeEvent() override { return &resize_event_; }
-  IEvent<bool>* FocusEvent() override { return &focus_event_; }
-  IEvent<bool>* MouseEnterLeaveEvent() override {
+  IEvent<FocusChangeType>* FocusEvent() override { return &focus_event_; }
+  IEvent<MouseEnterLeaveType>* MouseEnterLeaveEvent() override {
     return &mouse_enter_leave_event_;
   }
   IEvent<Point>* MouseMoveEvent() override { return &mouse_move_event_; }
@@ -128,13 +126,15 @@ class WinNativeWindow : public INativeWindow {
   bool has_focus_ = false;
   bool is_mouse_in_ = false;
 
-  std::shared_ptr<WindowRenderTarget> window_render_target_;
+  std::unique_ptr<WindowRenderTarget> window_render_target_;
+
+  std::shared_ptr<WinCursor> cursor_;
 
   Event<std::nullptr_t> destroy_event_;
   Event<std::nullptr_t> paint_event_;
   Event<Size> resize_event_;
-  Event<bool> focus_event_;
-  Event<bool> mouse_enter_leave_event_;
+  Event<FocusChangeType> focus_event_;
+  Event<MouseEnterLeaveType> mouse_enter_leave_event_;
   Event<Point> mouse_move_event_;
   Event<platform::native::NativeMouseButtonEventArgs> mouse_down_event_;
   Event<platform::native::NativeMouseButtonEventArgs> mouse_up_event_;
diff --git a/include/cru/win/native/window_class.hpp b/include/cru/win/native/window_class.hpp
index fec3b32e..fd5102a5 100644
--- a/include/cru/win/native/window_class.hpp
+++ b/include/cru/win/native/window_class.hpp
@@ -8,12 +8,11 @@
 namespace cru::platform::native::win {
 class WindowClass : public Object {
  public:
-  WindowClass(const std::wstring& name, WNDPROC window_proc,
-              HINSTANCE h_instance);
-  WindowClass(const WindowClass& other) = delete;
-  WindowClass(WindowClass&& other) = delete;
-  WindowClass& operator=(const WindowClass& other) = delete;
-  WindowClass& operator=(WindowClass&& other) = delete;
+  WindowClass(std::wstring name, WNDPROC window_proc, HINSTANCE h_instance);
+
+  CRU_DELETE_COPY(WindowClass)
+  CRU_DELETE_MOVE(WindowClass)
+
   ~WindowClass() override = default;
 
   const wchar_t* GetName() const { return name_.c_str(); }
@@ -24,4 +23,4 @@ class WindowClass : public Object {
   std::wstring name_;
   ATOM atom_;
 };
-}  // namespace cru::win::native
+}  // namespace cru::platform::native::win
diff --git a/include/cru/win/native/window_native_message_event_args.hpp b/include/cru/win/native/window_native_message_event_args.hpp
index 4cf744f2..18de1f46 100644
--- a/include/cru/win/native/window_native_message_event_args.hpp
+++ b/include/cru/win/native/window_native_message_event_args.hpp
@@ -15,13 +15,8 @@ class WindowNativeMessageEventArgs : public Object {
  public:
   WindowNativeMessageEventArgs(const WindowNativeMessage& message)
       : message_(message) {}
-  WindowNativeMessageEventArgs(const WindowNativeMessageEventArgs& other) =
-      default;
-  WindowNativeMessageEventArgs(WindowNativeMessageEventArgs&& other) = default;
-  WindowNativeMessageEventArgs& operator=(
-      const WindowNativeMessageEventArgs& other) = default;
-  WindowNativeMessageEventArgs& operator=(
-      WindowNativeMessageEventArgs&& other) = default;
+  CRU_DEFAULT_COPY(WindowNativeMessageEventArgs)
+  CRU_DEFAULT_MOVE(WindowNativeMessageEventArgs)
   ~WindowNativeMessageEventArgs() override = default;
 
   WindowNativeMessage GetWindowMessage() const { return message_; }
@@ -42,4 +37,4 @@ class WindowNativeMessageEventArgs : public Object {
   LRESULT result_;
   bool handled_ = false;
 };
-}  // namespace cru::win::native
+}  // namespace cru::platform::native::win
diff --git a/include/cru/win/native/window_render_target.hpp b/include/cru/win/native/window_render_target.hpp
index bde47f4f..248bfc25 100644
--- a/include/cru/win/native/window_render_target.hpp
+++ b/include/cru/win/native/window_render_target.hpp
@@ -4,22 +4,23 @@
 #include "cru/common/base.hpp"
 
 namespace cru::platform::graph::win::direct {
-struct IDirectFactory;
+class DirectGraphFactory;
 }
 
 namespace cru::platform::native::win {
 // Represents a window render target.
 class WindowRenderTarget : public Object {
  public:
-  WindowRenderTarget(graph::win::direct::IDirectFactory* factory, HWND hwnd);
-  WindowRenderTarget(const WindowRenderTarget& other) = delete;
-  WindowRenderTarget(WindowRenderTarget&& other) = delete;
-  WindowRenderTarget& operator=(const WindowRenderTarget& other) = delete;
-  WindowRenderTarget& operator=(WindowRenderTarget&& other) = delete;
+  WindowRenderTarget(graph::win::direct::DirectGraphFactory* factory,
+                     HWND hwnd);
+
+  CRU_DELETE_COPY(WindowRenderTarget)
+  CRU_DELETE_MOVE(WindowRenderTarget)
+
   ~WindowRenderTarget() override = default;
 
  public:
-  graph::win::direct::IDirectFactory* GetWinNativeFactory() const {
+  graph::win::direct::DirectGraphFactory* GetDirectFactory() const {
     return factory_;
   }
 
@@ -39,7 +40,7 @@ class WindowRenderTarget : public Object {
   void CreateTargetBitmap();
 
  private:
-  graph::win::direct::IDirectFactory* factory_;
+  graph::win::direct::DirectGraphFactory* factory_;
   Microsoft::WRL::ComPtr<IDXGISwapChain1> dxgi_swap_chain_;
   Microsoft::WRL::ComPtr<ID2D1Bitmap1> target_bitmap_;
 };