From 956a401f9c955f26b7e661dc80f76bfc43fc4124 Mon Sep 17 00:00:00 2001
From: crupest <crupest@outlook.com>
Date: Sat, 1 Sep 2018 23:28:28 +0800
Subject: Initial commit

---
 CruUI/ui/events/ui_event.h | 180 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 CruUI/ui/events/ui_event.h

(limited to 'CruUI/ui/events/ui_event.h')

diff --git a/CruUI/ui/events/ui_event.h b/CruUI/ui/events/ui_event.h
new file mode 100644
index 00000000..efb0479b
--- /dev/null
+++ b/CruUI/ui/events/ui_event.h
@@ -0,0 +1,180 @@
+#pragma once
+
+#include "system_headers.h"
+#include <optional>
+
+#include "base.h"
+#include "cru_event.h"
+#include "ui/ui_base.h"
+
+namespace cru
+{
+    namespace ui
+    {
+        class Control;
+
+        namespace events
+        {
+            class UiEventArgs : public BasicEventArgs
+            {
+            public:
+                UiEventArgs(Object* sender, Object* original_sender)
+                    : BasicEventArgs(sender), original_sender_(original_sender)
+                {
+
+                }
+
+                UiEventArgs(const UiEventArgs& other) = default;
+                UiEventArgs(UiEventArgs&& other) = default;
+                UiEventArgs& operator=(const UiEventArgs& other) = default;
+                UiEventArgs& operator=(UiEventArgs&& other) = default;
+                ~UiEventArgs() override = default;
+
+                Object* GetOriginalSender() const
+                {
+                    return original_sender_;
+                }
+
+            private:
+                Object* original_sender_;
+            };
+
+
+            class MouseEventArgs : public UiEventArgs
+            {
+            public:
+                MouseEventArgs(Object* sender, Object* original_sender, const std::optional<Point>& point = std::nullopt)
+                    : UiEventArgs(sender, original_sender), point_(point)
+                {
+                    
+                }
+                MouseEventArgs(const MouseEventArgs& other) = default;
+                MouseEventArgs(MouseEventArgs&& other) = default;
+                MouseEventArgs& operator=(const MouseEventArgs& other) = default;
+                MouseEventArgs& operator=(MouseEventArgs&& other) = default;
+                ~MouseEventArgs() override = default;
+
+                Point GetPoint(Control* control) const;
+
+            private:
+                std::optional<Point> point_;
+            };
+
+
+            class MouseButtonEventArgs : public MouseEventArgs
+            {
+            public:
+                MouseButtonEventArgs(Object* sender, Object* original_sender, const Point& point, const MouseButton button)
+                    : MouseEventArgs(sender, original_sender, point), button_(button)
+                {
+                    
+                }
+                MouseButtonEventArgs(const MouseButtonEventArgs& other) = default;
+                MouseButtonEventArgs(MouseButtonEventArgs&& other) = default;
+                MouseButtonEventArgs& operator=(const MouseButtonEventArgs& other) = default;
+                MouseButtonEventArgs& operator=(MouseButtonEventArgs&& other) = default;
+                ~MouseButtonEventArgs() override = default;
+
+                MouseButton GetMouseButton() const
+                {
+                    return button_;
+                }
+
+            private:
+                MouseButton button_;
+            };
+
+
+            class DrawEventArgs : public UiEventArgs
+            {
+            public:
+                DrawEventArgs(Object* sender, Object* original_sender, ID2D1DeviceContext* device_context)
+                    : UiEventArgs(sender, original_sender), device_context_(device_context)
+                {
+                    
+                }
+                DrawEventArgs(const DrawEventArgs& other) = default;
+                DrawEventArgs(DrawEventArgs&& other) = default;
+                DrawEventArgs& operator=(const DrawEventArgs& other) = default;
+                DrawEventArgs& operator=(DrawEventArgs&& other) = default;
+                ~DrawEventArgs() = default;
+
+                ID2D1DeviceContext* GetDeviceContext() const
+                {
+                    return device_context_;
+                }
+
+            private:
+                ID2D1DeviceContext * device_context_;
+            };
+
+
+            class PositionChangedEventArgs : public UiEventArgs
+            {
+            public:
+                PositionChangedEventArgs(Object* sender, Object* original_sender, const Point& old_position, const Point& new_position)
+                    : UiEventArgs(sender, original_sender), old_position_(old_position), new_position_(new_position)
+                {
+                    
+                }
+                PositionChangedEventArgs(const PositionChangedEventArgs& other) = default;
+                PositionChangedEventArgs(PositionChangedEventArgs&& other) = default;
+                PositionChangedEventArgs& operator=(const PositionChangedEventArgs& other) = default;
+                PositionChangedEventArgs& operator=(PositionChangedEventArgs&& other) = default;
+                ~PositionChangedEventArgs() override = default;
+
+                Point GetOldPosition() const
+                {
+                    return old_position_;
+                }
+
+                Point GetNewPosition() const
+                {
+                    return new_position_;
+                }
+
+            private:
+                Point old_position_;
+                Point new_position_;
+            };
+
+
+            class SizeChangedEventArgs : public UiEventArgs
+            {
+            public:
+                SizeChangedEventArgs(Object* sender, Object* original_sender, const Size& old_size, const Size& new_size)
+                    : UiEventArgs(sender, original_sender), old_size_(old_size), new_size_(new_size)
+                {
+                    
+                }
+                SizeChangedEventArgs(const SizeChangedEventArgs& other) = default;
+                SizeChangedEventArgs(SizeChangedEventArgs&& other) = default;
+                SizeChangedEventArgs& operator=(const SizeChangedEventArgs& other) = default;
+                SizeChangedEventArgs& operator=(SizeChangedEventArgs&& other) = default;
+                ~SizeChangedEventArgs() override = default;
+
+                Size GetOldSize() const
+                {
+                    return old_size_;
+                }
+
+                Size GetNewSize() const
+                {
+                    return new_size_;
+                }
+
+            private:
+                Size old_size_;
+                Size new_size_;
+            };
+
+
+            using UiEvent = Event<UiEventArgs>;
+            using MouseEvent = Event<MouseEventArgs>;
+            using MouseButtonEvent = Event<MouseButtonEventArgs>;
+            using DrawEvent = Event<DrawEventArgs>;
+            using PositionChangedEvent = Event<PositionChangedEventArgs>;
+            using SizeChangedEvent = Event<SizeChangedEventArgs>;
+        }
+    }
+}
-- 
cgit v1.2.3