2 files changed, 297 insertions, 0 deletions
diff --git a/src/ui/animations/animation.cpp b/src/ui/animations/animation.cpp
new file mode 100644
index 00000000..9d05860a
--- /dev/null
+++ b/src/ui/animations/animation.cpp
@@ -0,0 +1,190 @@
+#include "animation.h"
+
+#include <cassert>
+#include <utility>
+
+namespace cru::ui::animations
+{
+    namespace details
+    {
+        class AnimationDelegateImpl;
+        constexpr double frame_rate = 60;
+        constexpr AnimationTimeUnit frame_step_time = AnimationTimeUnit(1) / frame_rate;
+
+        
+        class AnimationDelegateImpl : public virtual IAnimationDelegate
+        {
+        public:
+            explicit AnimationDelegateImpl(String tag)
+                : tag_(std::move(tag))
+            {
+
+            }
+            AnimationDelegateImpl(const AnimationDelegateImpl& other) = delete;
+            AnimationDelegateImpl(AnimationDelegateImpl&& other) = delete;
+            AnimationDelegateImpl& operator=(const AnimationDelegateImpl& other) = delete;
+            AnimationDelegateImpl& operator=(AnimationDelegateImpl&& other) = delete;
+            ~AnimationDelegateImpl() override = default;
+
+            void Cancel() override
+            {
+                AnimationManager::GetInstance()->RemoveAnimation(tag_);
+            }
+
+        private:
+            String tag_;
+        };
+
+
+        class Animation : public Object
+        {
+        public:
+            Animation(
+                String tag,
+                AnimationTimeUnit duration,
+                Vector<AnimationStepHandlerPtr> step_handlers,
+                Vector<AnimationStartHandlerPtr> start_handlers,
+                Vector<ActionPtr> finish_handlers,
+                Vector<ActionPtr> cancel_handlers,
+                AnimationDelegatePtr delegate
+            );
+            Animation(const Animation& other) = delete;
+            Animation(Animation&& other) = delete;
+            Animation& operator=(const Animation& other) = delete;
+            Animation& operator=(Animation&& other) = delete;
+            ~Animation() override;
+
+
+            // If finish or invalid, return false.
+            bool Step(AnimationTimeUnit time);
+
+            String GetTag() const
+            {
+                return tag_;
+            }
+
+        private:
+            const String tag_;
+            const AnimationTimeUnit duration_;
+            Vector<AnimationStepHandlerPtr> step_handlers_;
+            Vector<AnimationStartHandlerPtr> start_handlers_;
+            Vector<ActionPtr> finish_handlers_;
+            Vector<ActionPtr> cancel_handlers_;
+            AnimationDelegatePtr delegate_;
+
+            AnimationTimeUnit current_time_ = AnimationTimeUnit::zero();
+        };
+
+        AnimationManager::AnimationManager()
+            : timer_action_(CreateActionPtr([this]()
+        {
+            auto i = animations_.cbegin();
+            while (i != animations_.cend())
+            {
+                auto current_i = i++;
+                if (current_i->second->Step(frame_step_time))
+                    animations_.erase(current_i);
+            }
+
+            if (animations_.empty())
+                KillTimer();
+        }))
+        {
+
+        }
+
+        AnimationManager::~AnimationManager()
+        {
+            KillTimer();
+        }
+
+        AnimationDelegatePtr AnimationManager::CreateAnimation(String tag, AnimationTimeUnit duration,
+            Vector<AnimationStepHandlerPtr> step_handlers, Vector<AnimationStartHandlerPtr> start_handlers,
+            Vector<ActionPtr> finish_handlers, Vector<ActionPtr> cancel_handlers)
+        {
+            if (animations_.empty())
+                SetTimer();
+
+            auto delegate = std::make_shared<AnimationDelegateImpl>(tag);
+
+            animations_[tag] = std::make_unique<Animation>(tag, duration, std::move(step_handlers), std::move(start_handlers), std::move(finish_handlers), std::move(cancel_handlers), delegate);
+
+            return delegate;
+        }
+
+        void AnimationManager::RemoveAnimation(const String& tag)
+        {
+            const auto find_result = animations_.find(tag);
+            if (find_result != animations_.cend())
+                animations_.erase(find_result);
+
+            if (animations_.empty())
+                KillTimer();
+        }
+
+        void AnimationManager::SetTimer()
+        {
+            if (timer_ == nullptr)
+                timer_ = SetInterval(std::chrono::duration_cast<std::chrono::milliseconds>(frame_step_time), timer_action_);
+        }
+
+        void AnimationManager::KillTimer()
+        {
+            if (timer_ != nullptr)
+            {
+                timer_->Cancel();
+                timer_ = nullptr;
+            }
+        }
+
+        Animation::Animation(
+            String tag,
+            AnimationTimeUnit duration,
+            Vector<AnimationStepHandlerPtr> step_handlers,
+            Vector<AnimationStartHandlerPtr> start_handlers,
+            Vector<ActionPtr> finish_handlers,
+            Vector<ActionPtr> cancel_handlers,
+            AnimationDelegatePtr delegate
+        ) : tag_(std::move(tag)), duration_(duration),
+            step_handlers_(std::move(step_handlers)),
+            start_handlers_(std::move(start_handlers)),
+            finish_handlers_(std::move(finish_handlers)),
+            cancel_handlers_(std::move(cancel_handlers)),
+            delegate_(std::move(delegate))
+        {
+
+        }
+
+        Animation::~Animation()
+        {
+            if (current_time_ < duration_)
+                for (auto& handler : cancel_handlers_)
+                    (*handler)();
+        }
+
+        bool Animation::Step(const AnimationTimeUnit time)
+        {
+            current_time_ += time;
+            if (current_time_ > duration_)
+            {
+                for (auto& handler : step_handlers_)
+                    (*handler)(delegate_, 1);
+                for (auto& handler : finish_handlers_)
+                    (*handler)();
+                return true;
+            }
+            else
+            {
+                for (auto& handler : step_handlers_)
+                    (*handler)(delegate_, current_time_ / duration_);
+                return false;
+            }
+        }
+
+    }
+
+    AnimationDelegatePtr AnimationBuilder::Start() const
+    {
+        return details::AnimationManager::GetInstance()->CreateAnimation(tag, duration, step_handlers_, start_handlers_, finish_handlers_, cancel_handlers_);
+    }
+}
diff --git a/src/ui/animations/animation.h b/src/ui/animations/animation.h
new file mode 100644
index 00000000..69b08b0c
--- /dev/null
+++ b/src/ui/animations/animation.h
@@ -0,0 +1,107 @@
+#pragma once
+
+#include <unordered_map>
+
+#include "base.h"
+#include "application.h"
+#include "timer.h"
+
+namespace cru::ui::animations
+{
+    using AnimationTimeUnit = FloatSecond;
+
+    
+    using IAnimationDelegate = ICancelable;
+    using AnimationDelegatePtr = CancelablePtr;
+
+    using AnimationStepHandlerPtr = FunctionPtr<void(AnimationDelegatePtr, double)>;
+    using AnimationStartHandlerPtr = FunctionPtr<void(AnimationDelegatePtr)>;
+
+
+    namespace details
+    {
+        class Animation;
+        using AnimationPtr = std::unique_ptr<Animation>;
+
+        class AnimationManager : public Object
+        {
+        public:
+            static AnimationManager* GetInstance()
+            {
+                return Application::GetInstance()->GetAnimationManager();
+            }
+
+        public:
+            AnimationManager();
+            AnimationManager(const AnimationManager& other) = delete;
+            AnimationManager(AnimationManager&& other) = delete;
+            AnimationManager& operator=(const AnimationManager& other) = delete;
+            AnimationManager& operator=(AnimationManager&& other) = delete;
+            ~AnimationManager() override;
+
+            AnimationDelegatePtr CreateAnimation(
+                String tag,
+                AnimationTimeUnit duration,
+                Vector<AnimationStepHandlerPtr> step_handlers,
+                Vector<AnimationStartHandlerPtr> start_handlers,
+                Vector<ActionPtr> finish_handlers,
+                Vector<ActionPtr> cancel_handlers
+            );
+            void RemoveAnimation(const String& tag);
+
+        private:
+            void SetTimer();
+            void KillTimer();
+
+        private:
+            std::unordered_map<String, AnimationPtr> animations_;
+            std::shared_ptr<ICancelable> timer_;
+            ActionPtr timer_action_;
+        };
+    }
+
+    class AnimationBuilder : public Object
+    {
+    public:
+        AnimationBuilder(String tag, const AnimationTimeUnit duration)
+            : tag(std::move(tag)), duration(duration)
+        {
+
+        }
+
+        String tag;
+        AnimationTimeUnit duration;
+
+        AnimationBuilder& AddStepHandler(AnimationStepHandlerPtr handler)
+        {
+            step_handlers_.push_back(std::move(handler));
+            return *this;
+        }
+
+        AnimationBuilder& AddStartHandler(AnimationStartHandlerPtr handler)
+        {
+            start_handlers_.push_back(std::move(handler));
+            return *this;
+        }
+
+        AnimationBuilder& AddFinishHandler(ActionPtr handler)
+        {
+            finish_handlers_.push_back(std::move(handler));
+            return *this;
+        }
+
+        AnimationBuilder& AddCancelHandler(ActionPtr handler)
+        {
+            cancel_handlers_.push_back(std::move(handler));
+            return *this;
+        }
+
+        AnimationDelegatePtr Start() const;
+
+    private:
+        Vector<AnimationStepHandlerPtr> step_handlers_;
+        Vector<AnimationStartHandlerPtr> start_handlers_;
+        Vector<ActionPtr> finish_handlers_;
+        Vector<ActionPtr> cancel_handlers_;
+    };
+}