Commit: 1f497834a6bd2ab8940eca99f16e1ce2bc355757 - sirius (git)

Simple C++ UI framework and more...

Commit MetaInfo

• Revision: 1f497834a6bd2ab8940eca99f16e1ce2bc355757 (tree)
• Zeit: 2018-05-16 00:12:51
• Autor: Starg <starg@user...>
• Commiter: Starg

Log Message

Implement widget and renderer

Ändern Zusammenfassung

• modified: include/sirius/animation.hpp
• modified: include/sirius/event.hpp
• delete: include/sirius/geometry.hpp
• add: include/sirius/intrinsics.hpp
• add: include/sirius/renderer.hpp
• add: include/sirius/simpletypes.hpp
• delete: include/sirius/uicontext.hpp
• add: include/sirius/uimanager.hpp
• modified: include/sirius/widget.hpp
• modified: src/CMakeLists.txt
• modified: src/animation.cpp
• modified: src/event.cpp
• add: src/renderer.cpp
• delete: src/uicontext.cpp
• modified: src/widget.cpp

Diff

--- a/include/sirius/animation.hpp
+++ b/include/sirius/animation.hpp
@@ -13,8 +13,6 @@
 namespace Sirius
 {
 
-class AnimationManager;
-
 enum class AnimationDirection
 {
     Forward,
@@ -99,28 +97,6 @@ private:
     float m_Value = 0.0f;
 };
 
-class SIRIUS_DLLEXPORT AnimationBlocker
-{
-public:
-    explicit AnimationBlocker(AnimationManager* pAnimationManager) noexcept : m_pAnimationManager(pAnimationManager)
-    {
-    }
-
-    AnimationBlocker(const AnimationBlocker&) = delete;
-    AnimationBlocker& operator=(const AnimationBlocker&) = delete;
-
-    AnimationBlocker(AnimationBlocker&& rhs) noexcept : m_pAnimationManager(std::exchange(rhs.m_pAnimationManager, nullptr))
-    {
-    }
-
-    AnimationBlocker& operator=(AnimationBlocker&& rhs) = delete;
-
-    ~AnimationBlocker();
-
-private:
-    AnimationManager* m_pAnimationManager;
-};
-
 class SIRIUS_DLLEXPORT AnimationManager
 {
     friend class AnimationBlocker;
@@ -136,16 +112,16 @@ public:
     void AbortAnimation(Animatable* pAnimatable);
     void AbortAllAnimations();
     void ReverseAnimation(Animatable* pAnimatable);
+    bool IsAnimationRunning(Animatable* pAnimatable) const;
 
     void Process();
-    bool HasActiveAnimations() const;
+    bool HasRunningAnimations() const;
 
     bool AreAnimationsBlocked() const;
-    AnimationBlocker BlockAllAnimations();
-
-private:
+    void BlockAllAnimations();
     void UnblockAllAnimations();
 
+private:
     struct AnimationInfo
     {
         Animatable* pAnimatable;
@@ -158,6 +134,8 @@ private:
         float RelativeStartTime;
     };
 
+    std::vector<AnimationInfo>::iterator FindAnimationInfoForAnimatable(Animatable* pAnimatable);
+    std::vector<AnimationInfo>::const_iterator FindAnimationInfoForAnimatable(Animatable* pAnimatable) const;
     std::vector<AnimationInfo>::iterator GetAnimationInfoForAnimatable(Animatable* pAnimatable);
     void AbortAnimation(std::vector<AnimationInfo>::const_iterator it);
 
@@ -168,4 +146,24 @@ private:
     std::int32_t m_BlockingCount = 0;
 };
 
+class AnimationBlocker
+{
+public:
+    explicit AnimationBlocker(AnimationManager& animationManager) : m_AnimationManager(animationManager)
+    {
+        m_AnimationManager.BlockAllAnimations();
+    }
+
+    AnimationBlocker(const AnimationBlocker&) = delete;
+    AnimationBlocker& operator=(const AnimationBlocker&) = delete;
+
+    ~AnimationBlocker()
+    {
+        m_AnimationManager.UnblockAllAnimations();
+    }
+
+private:
+    AnimationManager& m_AnimationManager;
+};
+
 } // namespace Sirius

--- a/include/sirius/event.hpp
+++ b/include/sirius/event.hpp
@@ -5,51 +5,32 @@
 
 #include <cstdint>
 
-#include <algorithm>
-#include <any>
+#include <atomic>
 #include <chrono>
-#include <deque>
-#include <optional>
+#include <future>
+#include <memory>
+#include <mutex>
+#include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace Sirius
 {
 
-class UIContext;
 class EventHandler;
 
-struct Event
-{
-    using EventKindType = std::int32_t;
-
-    Event() = default;
-
-    explicit Event(EventKindType kind) : Kind(kind)
-    {
-    }
-
-    template<typename TFirst, typename... TRest>
-    Event(EventKindType kind, TFirst&& first, TRest&&... rest)
-        : Kind(kind), Argument(std::forward<TFirst>(first), std::forward<TRest>(rest)...)
-    {
-    }
+// integer type to indicate event id
+using EventID = std::intptr_t;
 
-    template<typename... T>
-    Event(EventHandler* p, EventKindType kind, T&&... args)
-        : pTarget(p), Kind(kind), Argument(std::forward<T>(args)...)
-    {
-    }
-
-    Event(const Event&) = default;
-    Event& operator=(const Event&) = default;
-    Event(Event&&) = default;
-    Event& operator=(Event&&) = default;
-    ~Event() = default;
-
-    EventHandler* pTarget = nullptr;
-    EventKindType Kind = 0;
-    std::any Argument;
+// base class for event arguments
+class EventArgs
+{
+public:
+    EventArgs() = default;
+    EventArgs(const EventArgs&) = delete;
+    EventArgs& operator=(const EventArgs&) = delete;
+    virtual ~EventArgs() = default;
 };
 
 class EventListener
@@ -60,107 +41,339 @@ public:
     EventListener& operator=(const EventListener&) = delete;
     virtual ~EventListener() = default;
 
-    // return true to stop further event propagation
-    virtual bool OnEvent(const Event&)
+    virtual void OnEvent(const std::shared_ptr<EventHandler>& /* pTarget */, EventID /* id */, EventArgs* /* pArgs */)
     {
-        return false;
     }
 };
 
-class SIRIUS_DLLEXPORT EventHandler
+class SIRIUS_DLLEXPORT EventListenerManager
 {
 public:
-    explicit EventHandler(UIContext* pUIContext) : m_pUIContext(pUIContext)
-    {
-    }
-
-    virtual ~EventHandler() = default;
-
-    bool InvokeEvent(Event ev);
-    void PostEvent(Event ev);
-    void PostEventDelayed(Event ev, std::chrono::steady_clock::duration duration);
-    void PostEventDelayed(Event ev, std::chrono::steady_clock::time_point time);
-    const Event* PeekFirstEvent(Event::EventKindType kind);
-    void RemoveEvents(Event::EventKindType kind);
-    void RemoveAllEvents();
-
-    // return true to stop further event propagation
-    virtual bool OnEvent(const Event&);
-    virtual EventHandler* GetNextEventDestination() const;
+    EventListenerManager() = default;
+    EventListenerManager(const EventListenerManager&) = delete;
+    EventListenerManager& operator=(const EventListenerManager&) = delete;
+    ~EventListenerManager() = default;
 
-    void AddEventListener(EventListener* pEventListener);
-    void RemoveEventListener(EventListener* pEventListener);
-    bool HasEventListener(EventListener* pEventListener) const;
+    void AddEventListener(EventListener* pListener);
+    void AddEventListenerUnique(std::unique_ptr<EventListener> pListener);
+    void AddEventListenerShared(std::shared_ptr<EventListener> pListener);
+    void AddEventListenerWeak(std::weak_ptr<EventListener> pListener);
+    void RemoveEventListener(EventListener* pListener);
+    void RemoveAllEventListeners();
 
-protected:
-    UIContext* m_pUIContext;    // also used by Widget
+    void InvokeEventListeners(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs* pArgs);
 
 private:
-    std::vector<EventListener*> m_LocalEventListeners;
+    std::vector<std::variant<EventListener*, std::unique_ptr<EventListener>, std::shared_ptr<EventListener>, std::weak_ptr<EventListener>>> m_Listeners;
 };
 
-class SIRIUS_DLLEXPORT GlobalEventListenerManager
+class SIRIUS_DLLEXPORT EventHandler : public EventListenerManager
 {
 public:
-    void AddGlobalEventListener(EventListener* pEventListener);
-    void RemoveGlobalEventListener(EventListener* pEventListener);
-    bool HasGlobalEventListener(EventListener* pEventListener) const;
-    bool InvokeGlobalEventListeners(const Event& ev);
+    EventHandler() = default;
+    EventHandler(const EventHandler&) = delete;
+    EventHandler& operator=(const EventHandler&) = delete;
+    virtual ~EventHandler() = default;
 
-private:
-    std::vector<EventListener*> m_GlobalEventListeners;
+    virtual void OnEvent(EventID /* id */, EventArgs* /* pArgs */)
+    {
+    }
 };
 
-class SIRIUS_DLLEXPORT EventQueue
+enum class DesiredEventLoopTime
+{
+    Now,
+    NotSoon
+};
+
+class SIRIUS_DLLEXPORT EventManager : public EventListenerManager
 {
 public:
-    void PostEvent(Event ev);
-    void PostEventDelayed(Event ev, std::chrono::steady_clock::time_point time);
+    EventManager() = default;
+    EventManager(const EventManager&) = delete;
+    EventManager& operator=(const EventManager&) = delete;
+    ~EventManager() = default;
+
+    void InvokeEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs* pArgs = nullptr);
+    void InvokeEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs& args);
+    void InvokeEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs&& args);
+    void InvokeEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, const std::unique_ptr<EventArgs>& pArgs);
+
+    // Not thread safe
+    void PostEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, std::unique_ptr<EventArgs> pArgs = nullptr);
+    // Thread safe
+    void PostEventThreadSafe(const std::shared_ptr<EventHandler>& pTarget, EventID id, std::unique_ptr<EventArgs> pArgs = nullptr);
+
+    // Not thread safe
+    void PostEventOnTime(
+        const std::shared_ptr<EventHandler>& pTarget,
+        EventID id,
+        std::chrono::steady_clock::duration duration
+    );
+
+    void PostEventOnTime(
+        const std::shared_ptr<EventHandler>& pTarget,
+        EventID id,
+        std::unique_ptr<EventArgs> pArgs,
+        std::chrono::steady_clock::duration duration
+    );
+
+    // Not thread safe
+    void PostEventOnTime(
+        const std::shared_ptr<EventHandler>& pTarget,
+        EventID id,
+        std::chrono::steady_clock::time_point time
+    );
+
+    void PostEventOnTime(
+        const std::shared_ptr<EventHandler>& pTarget,
+        EventID id,
+        std::unique_ptr<EventArgs> pArgs,
+        std::chrono::steady_clock::time_point time
+    );
+
+    // Not thread safe
+    void PostEventOnTaskComplete(
+        const std::shared_ptr<EventHandler>& pTarget,
+        EventID id,
+        std::future<void> f
+    );
+
+    void PostEventOnTaskComplete(
+        const std::shared_ptr<EventHandler>& pTarget,
+        EventID id,
+        std::unique_ptr<EventArgs> pArgs,
+        std::future<void> f
+    );
+
+    // Not thread safe
+    void PostEventOnFutureReady(
+        const std::shared_ptr<EventHandler>& pTarget,
+        EventID id,
+        std::future<std::unique_ptr<EventArgs>> f
+    );
+
+    // Thread safe
+    void SendEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs* pArgs = nullptr);
+    void SendEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs& args);
+    void SendEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs&& args);
+    void SendEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, const std::unique_ptr<EventArgs>& pArgs);
+    std::future<std::unique_ptr<EventArgs>> SendEventAsync(
+        const std::shared_ptr<EventHandler>& pTarget,
+        EventID id,
+        std::unique_ptr<EventArgs> pArgs = nullptr
+    );
+
+    void RemoveAllEvents();
+
+    void ProcessEvents();
+    std::variant<DesiredEventLoopTime, std::chrono::steady_clock::time_point> GetDesiredEventLoopTime() const;
+
+private:
+    struct QueuedEvent
+    {
+        QueuedEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, std::unique_ptr<EventArgs> pArgs)
+            : pHandler(pTarget.get()), pWeakHandler(pTarget), ID(id), pArgs(std::move(pArgs))
+        {
+        }
+
+        QueuedEvent(EventHandler* pHandler, std::weak_ptr<EventHandler> pWeakHandler, EventID id, std::unique_ptr<EventArgs> pArgs)
+            : pHandler(pHandler), pWeakHandler(std::move(pWeakHandler)), ID(id), pArgs(std::move(pArgs))
+        {
+        }
+
+        EventHandler* pHandler;
+        std::weak_ptr<EventHandler> pWeakHandler;
+        EventID ID;
+        std::unique_ptr<EventArgs> pArgs;
+    };
+
+    struct QueuedEventWithTime : QueuedEvent
+    {
+        QueuedEventWithTime(
+            const std::shared_ptr<EventHandler>& pTarget,
+            EventID id,
+            std::unique_ptr<EventArgs> pArgs,
+            std::chrono::steady_clock::time_point fireTime
+        ) : QueuedEvent(pTarget, id, std::move(pArgs)), FireTime(fireTime)
+        {
+        }
+
+        std::chrono::steady_clock::time_point FireTime;
+    };
 
-    template<typename T>
-    const Event* PeekFirstEvent(T pred)
+    struct QueuedEventWithFuture : QueuedEvent
     {
-        auto it = std::find_if(m_Events.begin(), m_Events.end(), pred);
+        QueuedEventWithFuture(
+            const std::shared_ptr<EventHandler>& pTarget,
+            EventID id,
+            std::unique_ptr<EventArgs> pArgs,
+            std::future<void> f
+        ) : QueuedEvent(pTarget, id, std::move(pArgs)), Future(std::move(f))
+        {
+        }
 
-        if (it != m_Events.end())
+        QueuedEventWithFuture(
+            const std::shared_ptr<EventHandler>& pTarget,
+            EventID id,
+            std::future<std::unique_ptr<EventArgs>> f
+        ) : QueuedEvent(pTarget, id, nullptr), Future(std::move(f))
         {
-            return &*it;
         }
 
-        auto itDelayed = std::find_if(m_DelayedEvents.begin(), m_DelayedEvents.end(), [pred] (auto&& x) { return pred(x.Ev); });
+        std::variant<std::future<void>, std::future<std::unique_ptr<EventArgs>>> Future;
+    };
 
-        if (itDelayed != m_DelayedEvents.end())
+    struct SentEvent
+    {
+        SentEvent(const std::shared_ptr<EventHandler> pTarget, EventID id, EventArgs* pArgs)
+            : pHandler(pTarget), ID(id), pArgs(pArgs)
+        {
+        }
+
+        SentEvent(const std::shared_ptr<EventHandler> pTarget, EventID id, std::unique_ptr<EventArgs> pArgs)
+            : pHandler(pTarget), ID(id), pArgs(std::move(pArgs))
         {
-            return &itDelayed->Ev;
         }
 
-        return nullptr;
+        std::shared_ptr<EventHandler> pHandler;
+        EventID ID;
+        std::variant<EventArgs*, std::unique_ptr<EventArgs>> pArgs;
+        std::promise<std::unique_ptr<EventArgs>> Promise;
+    };
+
+    void TryInvokeQueuedEvent(QueuedEvent& ev);
+    void ProcessEventQueue();
+    void ProcessEventQueueWithTime();
+    void ProcessEventQueueWithFuture();
+    void ProcessSentEvents();
+
+    std::vector<QueuedEvent> m_EventQueue;
+    std::vector<QueuedEventWithTime> m_EventQueueWithTime;
+    std::vector<QueuedEventWithFuture> m_EventQueueWithFuture;
+    std::vector<SentEvent> m_SentEvents;
+
+    // These atomic and mutex are for m_ThreadSafeEventQueue and m_SentEventQueue.
+    std::atomic<bool> m_HasItemsInThreadSafeEventQueues;
+    std::mutex m_MutexForThreadSafeEventQueues;
+    std::vector<QueuedEvent> m_ThreadSafeEventQueue;
+    std::vector<SentEvent> m_ThreadSafeSentEventQueue;
+
+    static_assert(std::is_nothrow_move_constructible_v<QueuedEvent>);
+    static_assert(std::is_nothrow_move_assignable_v<QueuedEvent>);
+    static_assert(std::is_nothrow_move_constructible_v<SentEvent>);
+    static_assert(std::is_nothrow_move_assignable_v<SentEvent>);
+};
+
+// mixin class to define convenience wrapper for InvokeEvent(), etc.
+template<typename T>
+class EventInvokeUtility
+{
+protected:
+    EventInvokeUtility() = default;
+    ~EventInvokeUtility() = default;
+
+public:
+    void InvokeEvent(EventID id, EventArgs* pArgs = nullptr)
+    {
+        CallGetEventManager().InvokeEvent(CallGetEventHandler(), id, pArgs);
     }
 
-    template<typename T>
-    void RemoveEvents(T pred)
+    void InvokeEvent(EventID id, EventArgs& args)
     {
-        m_Events.erase(std::remove_if(m_Events.begin(), m_Events.end(), pred), m_Events.end());
-        m_DelayedEvents.erase(
-            std::remove_if(m_DelayedEvents.begin(), m_DelayedEvents.end(), [pred] (auto&& x) { return pred(x.Ev); }),
-            m_DelayedEvents.end()
-        );
+        CallGetEventManager().InvokeEvent(CallGetEventHandler(), id, args);
     }
 
-    void RemoveAllEvents();
+    void InvokeEvent(EventID id, EventArgs&& args)
+    {
+        CallGetEventManager().InvokeEvent(CallGetEventHandler(), id, args);
+    }
 
-    void ProcessEvents();
-    std::optional<std::chrono::steady_clock::time_point> GetNextEventFireTime() const;  // returns std::nullopt if nothing is queued
+    void InvokeEvent(EventID id, const std::unique_ptr<EventArgs>& pArgs)
+    {
+        CallGetEventManager().InvokeEvent(CallGetEventHandler(), id, pArgs);
+    }
+
+    void PostEvent(EventID id, std::unique_ptr<EventArgs> pArgs = nullptr)
+    {
+        CallGetEventManager().PostEvent(CallGetEventHandler(), id, std::move(pArgs));
+    }
+
+    void PostEventThreadSafe(EventID id, std::unique_ptr<EventArgs> pArgs = nullptr)
+    {
+        CallGetEventManager().PostEventThreadSafe(CallGetEventHandler(), id, std::move(pArgs));
+    }
+
+    void PostEventOnTime(EventID id, std::chrono::steady_clock::duration duration)
+    {
+        CallGetEventManager().PostEventOnTime(CallGetEventHandler(), id, duration);
+    }
+
+    void PostEventOnTime(EventID id, std::unique_ptr<EventArgs> pArgs, std::chrono::steady_clock::duration duration)
+    {
+        CallGetEventManager().PostEventOnTime(CallGetEventHandler(), id, std::move(pArgs), duration);
+    }
+
+    void PostEventOnTime(EventID id, std::chrono::steady_clock::time_point time)
+    {
+        CallGetEventManager().PostEventOnTime(CallGetEventHandler(), id, time);
+    }
+
+    void PostEventOnTime(EventID id, std::unique_ptr<EventArgs> pArgs, std::chrono::steady_clock::time_point time)
+    {
+        CallGetEventManager().PostEventOnTime(CallGetEventHandler(), id, std::move(pArgs), time);
+    }
+
+    void PostEventOnTaskComplete(EventID id, std::future<void> f)
+    {
+        CallGetEventManager().PostEventOnTaskComplete(CallGetEventHandler(), id, std::move(f));
+    }
+
+    void PostEventOnTaskComplete(EventID id, std::unique_ptr<EventArgs> pArgs, std::future<void> f)
+    {
+        CallGetEventManager().PostEventOnTaskComplete(CallGetEventHandler(), id, std::move(pArgs), std::move(f));
+    }
+
+    void PostEventOnFutureReady(EventID id, std::future<std::unique_ptr<EventArgs>> f)
+    {
+        CallGetEventManager().PostEventOnFutureReady(CallGetEventHandler(), id, std::move(f));
+    }
+
+    void SendEvent(EventID id, EventArgs* pArgs = nullptr)
+    {
+        CallGetEventManager().SendEvent(CallGetEventHandler(), id, pArgs);
+    }
+
+    void SendEvent(EventID id, EventArgs& args)
+    {
+        CallGetEventManager().SendEvent(CallGetEventHandler(), id, args);
+    }
+
+    void SendEvent(EventID id, EventArgs&& args)
+    {
+        CallGetEventManager().SendEvent(CallGetEventHandler(), id, args);
+    }
+
+    void SendEvent(EventID id, const std::unique_ptr<EventArgs>& pArgs)
+    {
+        CallGetEventManager().SendEvent(CallGetEventHandler(), id, pArgs);
+    }
+
+    std::future<std::unique_ptr<EventArgs>> SendEventAsync(EventID id, std::unique_ptr<EventArgs> pArgs = nullptr)
+    {
+        return CallGetEventManager().SendEventAsync(CallGetEventHandler(), id, std::move(pArgs));
+    }
 
 private:
-    struct DelayedEvent
+    std::shared_ptr<EventHandler> CallGetEventHandler()
     {
-        Event Ev;
-        std::chrono::steady_clock::time_point FireTime;
-    };
+        return static_cast<T*>(this)->GetEventHandler();
+    }
 
-    std::deque<Event> m_Events;
-    std::deque<DelayedEvent> m_DelayedEvents;    // must be sorted according to FireTime
+    EventManager& CallGetEventManager()
+    {
+        return static_cast<T*>(this)->GetEventManager();
+    }
 };
 
 } // namespace Sirius

--- a/include/sirius/geometry.hpp
+++ /dev/null
@@ -1,210 +0,0 @@
-// Copyright 2018 Starg
-// Distributed under the 3-Clause BSD License.
-
-#pragma once
-
-#include <type_traits>
-#include <utility>
-
-namespace Sirius
-{
-
-template<typename T>
-struct Point
-{
-    Point() noexcept = default;
-
-    Point(T x, T y) noexcept : X(x), Y(y)
-    {
-    }
-
-    Point(const Point<T>&) noexcept = default;
-    Point(Point<T>&&) noexcept = default;
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Point(const Point<T2>& rhs) noexcept : X(rhs.X), Y(rhs.Y)
-    {
-    }
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Point(Point<T2>&& rhs) noexcept : X(rhs.X), Y(rhs.Y)
-    {
-    }
-
-    Point<T>& operator=(const Point<T>&) noexcept = default;
-    Point<T>& operator=(Point<T>&&) noexcept = default;
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Point<T>& operator=(const Point<T2>& rhs) noexcept
-    {
-        X = rhs.X;
-        Y = rhs.Y;
-        return *this;
-    }
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Point<T>& operator=(Point<T2>&& rhs) noexcept
-    {
-        X = rhs.X;
-        Y = rhs.Y;
-        return *this;
-    }
-
-    void Swap(Point<T>& rhs) noexcept
-    {
-        using std::swap;
-        swap(X, rhs.X);
-        swap(Y, rhs.Y);
-    }
-
-    T X;
-    T Y;
-};
-
-template<typename T>
-void swap(Point<T>& lhs, Point<T>& rhs) noexcept
-{
-    lhs.Swap(rhs);
-}
-
-template<typename T>
-struct Size
-{
-    Size() noexcept = default;
-
-    Size(T w, T h) noexcept : Width(w), Height(h)
-    {
-    }
-
-    Size(const Size<T>&) noexcept = default;
-    Size(Size<T>&&) noexcept = default;
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Size(const Size<T2>& rhs) noexcept : Width(rhs.Width), Height(rhs.Height)
-    {
-    }
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Size(Size<T2>&& rhs) noexcept : Width(rhs.Width), Height(rhs.Height)
-    {
-    }
-
-    Size<T>& operator=(const Size<T>&) noexcept = default;
-    Size<T>& operator=(Size<T>&&) noexcept = default;
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Size<T>& operator=(const Size<T2>& rhs) noexcept
-    {
-        Width = rhs.Width;
-        Height = rhs.Height;
-        return *this;
-    }
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Size<T>& operator=(Size<T2>&& rhs) noexcept
-    {
-        Width = rhs.Width;
-        Height = rhs.Height;
-        return *this;
-    }
-
-    void Swap(Size<T>& rhs) noexcept
-    {
-        using std::swap;
-        swap(Width, rhs.Width);
-        swap(Height, rhs.Height);
-    }
-
-    T Width;
-    T Height;
-};
-
-template<typename T>
-void swap(Size<T>& lhs, Size<T>& rhs) noexcept
-{
-    lhs.Swap(rhs);
-}
-
-template<typename T>
-struct Rect
-{
-    Rect() noexcept = default;
-
-    Rect(const Point<T>& pt1, const Point<T>& pt2) noexcept
-        : Left(pt1.X), Top(pt1.Y), Right(pt2.X), Bottom(pt2.Y)
-    {
-    }
-
-    Rect(const Point<T>& pt, const Size<T>& size) noexcept
-        : Left(pt.X), Top(pt.Y), Right(pt.X + size.Width), Bottom(pt.Y + size.Height)
-    {
-    }
-
-    Rect(const Rect<T>&) noexcept = default;
-    Rect(Rect<T>&&) noexcept = default;
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Rect(const Rect<T2>& rhs) noexcept : Left(rhs.Left), Top(rhs.Top), Right(rhs.Right), Bottom(rhs.Bottom)
-    {
-    }
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Rect(Rect<T2>&& rhs) noexcept : Left(rhs.Left), Top(rhs.Top), Right(rhs.Right), Bottom(rhs.Bottom)
-    {
-    }
-
-    Rect<T>& operator=(const Rect<T>&) noexcept = default;
-    Rect<T>& operator=(Rect<T>&&) noexcept = default;
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Rect<T>& operator=(const Rect<T2>& rhs) noexcept
-    {
-        Left = rhs.Left;
-        Top = rhs.Top;
-        Right = rhs.Right;
-        Bottom = rhs.Bottom;
-        return *this;
-    }
-
-    template<typename T2, std::enable_if_t<std::is_convertible_v<T2, T>, int> = 0>
-    Rect<T>& operator=(Rect<T2>&& rhs) noexcept
-    {
-        Left = rhs.Left;
-        Top = rhs.Top;
-        Right = rhs.Right;
-        Bottom = rhs.Bottom;
-        return *this;
-    }
-
-    void Swap(Rect<T>& rhs) noexcept
-    {
-        using std::swap;
-        swap(Left, rhs.Left);
-        swap(Top, rhs.Top);
-        swap(Right, rhs.Right);
-        swap(Bottom, rhs.Bottom);
-    }
-
-    T GetWidth() const noexcept
-    {
-        return Right - Left;
-    }
-
-    T GetHeight() const noexcept
-    {
-        return Bottom - Top;
-    }
-
-    T Left;
-    T Top;
-    T Right;
-    T Bottom;
-};
-
-template<typename T>
-void swap(Rect<T>& lhs, Rect<T>& rhs) noexcept
-{
-    lhs.Swap(rhs);
-}
-
-} // namespace Sirius

--- /dev/null
+++ b/include/sirius/intrinsics.hpp
@@ -0,0 +1,25 @@
+// Copyright 2018 Starg
+// Distributed under the 3-Clause BSD License.
+
+#pragma once
+
+#define SIRIUS_X86_SIMD_LEVEL_NONE      0
+#define SIRIUS_X86_SIMD_LEVEL_SSE2      1
+#define SIRIUS_X86_SIMD_LEVEL_SSE42     2   // + POPCNT, LZCNT, and BMI
+#define SIRIUS_X86_SIMD_LEVEL_AVX2      3   // + FMA
+
+#ifndef SIRIUS_X86_SIMD_LEVEL
+
+#if defined(_M_IX86) || defined(__i386__) || defined(_M_X64) || defined(__x86_64__)
+#define SIRIUS_X86_SIMD_LEVEL   SIRIUS_X86_SIMD_LEVEL_SSE42
+#else
+#define SIRIUS_X86_SIMD_LEVEL   SIRIUS_X86_SIMD_LEVEL_NONE
+#endif
+
+#endif
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#elif defined(_M_IX86) || defined(__i386__) || defined(_M_X64) || defined(__x86_64__)
+#include <x86intrin.h>
+#endif

--- /dev/null
+++ b/include/sirius/renderer.hpp
@@ -0,0 +1,230 @@
+// Copyright 2018 Starg
+// Distributed under the 3-Clause BSD License.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "sirius/array_view.hpp"
+#include "sirius/simpletypes.hpp"
+
+namespace Sirius
+{
+
+class Renderer;
+class ChildRenderer;
+
+class RendererListener
+{
+public:
+    virtual ~RendererListener() = default;
+
+    virtual void OnCreateDevice(Renderer* /*pRenderer*/)
+    {
+    }
+
+    virtual void OnDestroyDevice(Renderer* /*pRenderer*/)
+    {
+    }
+
+    virtual void OnBeginDraw(Renderer* /*pRenderer*/)
+    {
+    }
+
+    virtual void OnEndDraw(Renderer* /*pRenderer*/)
+    {
+    }
+};
+
+class Paint
+{
+public:
+    Paint() = default;
+
+    explicit Paint(const Color& c) : m_Color(c)
+    {
+    }
+
+    Paint(const Color& c, float strokeWidth) : m_Color(c), m_StrokeWidth(strokeWidth)
+    {
+    }
+
+    Paint(const Color& c, std::string_view fontName, float fontSize)
+        : m_Color(c), m_FontName(fontName), m_FontSize(fontSize)
+    {
+    }
+
+    Paint(const Paint&) = default;
+    Paint& operator=(const Paint&) = default;
+    Paint(Paint&&) = default;
+    Paint& operator=(Paint&&) = default;
+    ~Paint() = default;
+
+    const Color& GetColor() const
+    {
+        return m_Color;
+    }
+
+    void SetColor(const Color& c)
+    {
+        m_Color = c;
+    }
+
+    float GetStrokeWidth() const
+    {
+        return m_StrokeWidth;
+    }
+
+    void SetStrokeWidth(float sw)
+    {
+        m_StrokeWidth = sw;
+    }
+
+    std::string_view GetFontName() const
+    {
+        return m_FontName;
+    }
+
+    void SetFontName(std::string_view fontName)
+    {
+        m_FontName = fontName;
+    }
+
+    float GetFontSize() const
+    {
+        return m_FontSize;
+    }
+
+    void SetFontSize(float fontSize)
+    {
+        m_FontSize = fontSize;
+    }
+
+    float GetFontWeight() const
+    {
+        return m_FontWeight;
+    }
+
+    void SetFontWeight(float weight)
+    {
+        m_FontWeight = weight;
+    }
+
+    bool GetIsItalicFont() const
+    {
+        return m_IsItalicFont;
+    }
+
+    void SetIsItalicFont(bool italic)
+    {
+        m_IsItalicFont = italic;
+    }
+
+private:
+    Color m_Color = {};
+    float m_StrokeWidth = 1.0f;
+    std::string m_FontName;
+    float m_FontSize = 12.0f;
+    float m_FontWeight = 1.0f;
+    bool m_IsItalicFont = false;
+};
+
+enum class PixelFormat
+{
+    A8R8G8B8
+};
+
+class Bitmap
+{
+public:
+    ~Bitmap() = default;
+
+    virtual Vec2<std::uint32_t> GetSize() const = 0;
+};
+
+class SIRIUS_DLLEXPORT Renderer
+{
+public:
+    virtual ~Renderer() = default;
+
+    void BeginDraw();
+    void EndDraw();
+
+    virtual void Clear(const Color& color) = 0;
+    virtual void DrawLine(Vec2<float> p1, Vec2<float> p2, const Paint& paint) = 0;
+    virtual void DrawRect(const Rect<float>& rect, const Paint& paint) = 0;
+    virtual void FillRect(const Rect<float>& rect, const Paint& paint) = 0;
+    virtual void DrawPolygon(ArrayView<Vec2<float>> points, const Paint& paint) = 0;
+    virtual void FillPolygon(ArrayView<Vec2<float>> points, const Paint& paint) = 0;
+
+    virtual void DrawEllipse(const Rect<float>& boundRect, const Paint& paint) = 0;
+    void DrawEllipse(Vec2<float> center, float radiusX, float radiusY, const Paint& paint);
+    virtual void FillEllipse(const Rect<float>& boundRect, const Paint& paint) = 0;
+    void FillEllipse(Vec2<float> center, float radiusX, float radiusY, const Paint& paint);
+
+    virtual void DrawArc(Vec2<float> center, float radius, float angleFrom, float angleTo, const Paint& paint) = 0;
+    virtual void FillArc(Vec2<float> center, float radius, float angleFrom, float angleTo, const Paint& paint) = 0;
+
+    virtual void DrawBitmap(Bitmap* pBitmap, const Rect<float>& srcRect, const Rect<float>& destRect) = 0;
+    void DrawBitmap(const std::unique_ptr<Bitmap>& pBitmap, const Rect<float>& srcRect, const Rect<float>& destRect);
+
+    virtual void DrawText(std::string_view text, const Rect<float>& rect, const Paint& paint) = 0;
+
+    virtual Rect<float> GetClipRect() const = 0;
+    virtual void SetClipRect(const Rect<float>& rect) = 0;
+
+    virtual Vec2<float> GetGlobalTranslation() const = 0;
+    virtual void SetGlobalTranslation(Vec2<float> globalTranslation) = 0;
+
+    virtual std::unique_ptr<Bitmap> CreateBitmap(ArrayView<std::byte> buffer, Vec2<std::uint32_t> size, PixelFormat format) = 0;
+
+    void AddListener(RendererListener* pListener);
+    void RemoveListener(RendererListener* pListener);
+    bool HasListener(RendererListener* pListener) const;
+
+    void InvokeCreateDevice();
+    void InvokeDestroyDevice();
+
+protected:
+    virtual void OnBeginDraw()
+    {
+    }
+
+    virtual void OnEndDraw()
+    {
+    }
+
+private:
+    std::vector<RendererListener*> m_Listeners;
+};
+
+class AutoRestoreRendererStates
+{
+public:
+    explicit AutoRestoreRendererStates(Renderer& renderer)
+        : m_Renderer(renderer), m_OldClipRect(renderer.GetClipRect()), m_OldTranslation(renderer.GetGlobalTranslation())
+    {
+    }
+
+    AutoRestoreRendererStates(const AutoRestoreRendererStates&) = delete;
+    AutoRestoreRendererStates& operator=(const AutoRestoreRendererStates&) = delete;
+
+    ~AutoRestoreRendererStates()
+    {
+        m_Renderer.SetGlobalTranslation(m_OldTranslation);
+        m_Renderer.SetClipRect(m_OldClipRect);
+    }
+
+private:
+    Renderer& m_Renderer;
+    Rect<float> m_OldClipRect;
+    Vec2<float> m_OldTranslation;
+};
+
+} // namespace Sirius

--- /dev/null
+++ b/include/sirius/simpletypes.hpp
@@ -0,0 +1,211 @@
+// Copyright 2018 Starg
+// Distributed under the 3-Clause BSD License.
+
+#pragma once
+
+#include <algorithm>
+
+namespace Sirius
+{
+
+template<typename T>
+struct Vec2
+{
+    constexpr Vec2() noexcept : X(0), Y(0)
+    {
+    }
+
+    constexpr Vec2(T x, T y) noexcept : X(x), Y(y)
+    {
+    }
+
+    constexpr bool operator==(Vec2<T> rhs) const noexcept
+    {
+        return X == rhs.X && Y == rhs.Y;
+    }
+
+    constexpr bool operator!=(Vec2<T> rhs) const noexcept
+    {
+        return !(*this == rhs);
+    }
+
+    constexpr Vec2<T>& operator+=(Vec2<T> rhs) noexcept
+    {
+        X += rhs.X;
+        Y += rhs.Y;
+        return *this;
+    }
+
+    constexpr Vec2<T>& operator-=(Vec2<T> rhs) noexcept
+    {
+        X -= rhs.X;
+        Y -= rhs.Y;
+        return *this;
+    }
+
+    constexpr Vec2<T>& operator*=(T f) noexcept
+    {
+        X *= f;
+        Y *= f;
+        return *this;
+    }
+
+    constexpr Vec2<T>& operator/=(T f) noexcept
+    {
+        X /= f;
+        Y /= f;
+        return *this;
+    }
+
+    Vec2<T> operator+() const noexcept
+    {
+        return *this;
+    }
+
+    Vec2<T> operator-() const noexcept
+    {
+        return Vec2<T>(-X, -Y);
+    }
+
+    Vec2<T> operator+(Vec2<T> rhs) const noexcept
+    {
+        return Vec2<T>(X + rhs.X, Y + rhs.Y);
+    }
+
+    Vec2<T> operator-(Vec2<T> rhs) const noexcept
+    {
+        return Vec2<T>(X - rhs.X, Y - rhs.Y);
+    }
+
+    Vec2<T> operator*(T f) const noexcept
+    {
+        return Vec2<T>(X * f, Y * f);
+    }
+
+    friend Vec2<T> operator*(T f, Vec2<T> rhs) noexcept
+    {
+        return Vec2<T>(f * rhs.X, f * rhs.Y);
+    }
+
+    Vec2<T> operator/(T f) const noexcept
+    {
+        return Vec2<T>(X / f, Y / f);
+    }
+
+    friend Vec2<T> operator/(T f, Vec2<T> rhs) noexcept
+    {
+        return Vec2<T>(f / rhs.X, f / rhs.Y);
+    }
+
+    T X;
+    T Y;
+};
+
+template<typename T>
+struct Rect
+{
+    static constexpr Rect FromPoints(Vec2<T> leftTop, Vec2<T> rightBottom) noexcept
+    {
+        return Rect(leftTop.X, leftTop.Y, rightBottom.X, rightBottom.Y);
+    }
+
+    static constexpr Rect FromPointAndSize(Vec2<T> leftTop, Vec2<T> size) noexcept
+    {
+        return Rect(leftTop.X, leftTop.Y, leftTop.X + size.X, leftTop.Y + size.Y);
+    }
+
+    constexpr Rect() noexcept : Left(0), Top(0), Right(0), Bottom(0)
+    {
+    }
+
+    constexpr Rect(T left, T top, T right, T bottom) noexcept
+        : Left(left), Top(top), Right(right), Bottom(bottom)
+    {
+    }
+
+    constexpr bool operator==(const Rect<T>& rhs) const noexcept
+    {
+        return Left == rhs.Left && Top == rhs.Top && Right == rhs.Right && Bottom == rhs.Bottom;
+    }
+
+    constexpr bool operator!=(const Rect<T>& rhs) const noexcept
+    {
+        return !(*this == rhs);
+    }
+
+    constexpr bool Includes(Vec2<T> pt) const noexcept
+    {
+        return Left <= pt.X && pt.X <= Right && Top <= pt.Y && pt.Y <= Bottom;
+    }
+
+    constexpr Rect<T> Translate(Vec2<T> offset) const noexcept
+    {
+        return Rect<T>(Left + offset.X, Top + offset.Y, Right + offset.X, Bottom + offset.Y);
+    }
+
+    constexpr Rect<T> Clip(const Rect<T>& rc) const noexcept
+    {
+        Vec2<T> leftTop(std::max(Left, rc.Left), std::max(Top, rc.Top));
+        return FromPoints(
+            leftTop,
+            Vec2<T>(std::max(std::min(Right, rc.Right), leftTop.X), std::max(std::min(Bottom, rc.Bottom), leftTop.Y))
+        );
+    }
+
+    constexpr T GetWidth() const noexcept
+    {
+        return Right - Left;
+    }
+
+    constexpr T GetHeight() const noexcept
+    {
+        return Bottom - Top;
+    }
+
+    constexpr Vec2<T> GetLeftTop() const noexcept
+    {
+        return Vec2<T>(Left, Top);
+    }
+
+    constexpr Vec2<T> GetRightBottom() const noexcept
+    {
+        return Vec2<T>(Right, Bottom);
+    }
+
+    T Left;
+    T Top;
+    T Right;
+    T Bottom;
+};
+
+struct Color
+{
+    constexpr Color() noexcept : Alpha(0.0f), Red(0.0f), Green(0.0f), Blue(0.0f)
+    {
+    }
+
+    constexpr Color(float r, float g, float b) noexcept : Alpha(1.0f), Red(r), Green(g), Blue(b)
+    {
+    }
+
+    constexpr Color(float a, float r, float g, float b) noexcept : Alpha(a), Red(r), Green(g), Blue(b)
+    {
+    }
+
+    constexpr bool operator==(const Color& rhs) const noexcept
+    {
+        return Alpha == rhs.Alpha && Red == rhs.Red && Green == rhs.Green && Blue == rhs.Blue;
+    }
+
+    constexpr bool operator!=(const Color& rhs) const noexcept
+    {
+        return !(*this == rhs);
+    }
+
+    float Alpha;
+    float Red;
+    float Green;
+    float Blue;
+};
+
+} // namespace Sirius

--- a/include/sirius/uicontext.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2018 Starg
-// Distributed under the 3-Clause BSD License.
-
-#pragma once
-
-#include <vector>
-
-#include "sirius/animation.hpp"
-#include "sirius/event.hpp"
-
-namespace Sirius
-{
-
-class SIRIUS_DLLEXPORT UIContext
-{
-public:
-    UIContext() = default;
-    UIContext(const UIContext&) = delete;
-    UIContext& operator=(const UIContext&) = delete;
-
-    GlobalEventListenerManager& GetGlobalEventListenerManager()
-    {
-        return m_GlobalEventListenerManager;
-    }
-
-    EventQueue& GetEventQueue()
-    {
-        return m_EventQueue;
-    }
-
-    AnimationManager& GetAnimationManager()
-    {
-        return m_AnimationManager;
-    }
-
-private:
-    GlobalEventListenerManager m_GlobalEventListenerManager;
-    EventQueue m_EventQueue;
-    AnimationManager m_AnimationManager;
-};
-
-} // namespace Sirius

--- /dev/null
+++ b/include/sirius/uimanager.hpp
@@ -0,0 +1,63 @@
+// Copyright 2018 Starg
+// Distributed under the 3-Clause BSD License.
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "sirius/animation.hpp"
+#include "sirius/event.hpp"
+
+namespace Sirius
+{
+
+class Widget;
+
+class SIRIUS_DLLEXPORT UIManager
+{
+public:
+    UIManager() = default;
+    UIManager(const UIManager&) = delete;
+    UIManager& operator=(const UIManager&) = delete;
+    ~UIManager() = default;
+
+    EventManager& GetEventManager()
+    {
+        return m_EventManager;
+    }
+
+    AnimationManager& GetAnimationManager()
+    {
+        return m_AnimationManager;
+    }
+
+    std::weak_ptr<Widget> GetFocusedWidget() const
+    {
+        return m_pFocusedWidget;
+    }
+
+    void SetFocusedWidget(std::weak_ptr<Widget> p)
+    {
+        m_pFocusedWidget = p;
+    }
+
+    std::weak_ptr<Widget> GetCapturedWidget() const
+    {
+        return m_pCapturedWidget;
+    }
+
+    void SetCapturedWidget(std::weak_ptr<Widget> p)
+    {
+        m_pCapturedWidget = p;
+    }
+
+private:
+    EventManager m_EventManager;
+    AnimationManager m_AnimationManager;
+
+    std::weak_ptr<Widget> m_pFocusedWidget;
+    std::weak_ptr<Widget> m_pCapturedWidget;
+};
+
+} // namespace Sirius

--- a/include/sirius/widget.hpp
+++ b/include/sirius/widget.hpp
@@ -3,59 +3,263 @@
 
 #pragma once
 
+#include <cstdint>
+
+#include <chrono>
+#include <future>
+#include <memory>
 #include <vector>
 
-#include "sirius/array_view.hpp"
 #include "sirius/event.hpp"
-#include "sirius/geometry.hpp"
+#include "sirius/simpletypes.hpp"
 
 namespace Sirius
 {
 
-class UIContext;
+class UIManager;
+class Widget;
+class Renderer;
 
 namespace WidgetEvent
 {
 
-//enum : Event::EventKindType
-//{
-//
-//};
+enum : EventID
+{
+    // This widget has been added as a child of another widget
+    // Argument: none
+    Added = 100,
+
+    // A new child has been added to this widget
+    // Argument: ChildWidgetEventArgs
+    ChildAdded,
+
+    // This widget is being removed from the parent
+    // Argument: none
+    Remove,
+
+    // A child widget is being removed from this widget
+    // Argument: ChildWidgetEventArgs
+    ChildRemove,
+
+    // widget's rect was changed
+    // Argument: none
+    RectChanged,
+
+    // widget's opacity was changed
+    // Argument: none
+    OpacityChanged,
+
+    // widget's visibility was changed
+    // Argument: none
+    VisibilityChanged,
+
+    // widget has been enabled or disabled
+    // Argument: none
+    EnabledOrDisabled,
+
+    // widget has gained focus
+    // Argument: none
+    FocusSet,
+
+    // widget has lost focus
+    // Argument: none
+    FocusKilled
+};
+
+struct ChildWidgetEventArgs : EventArgs
+{
+    explicit ChildWidgetEventArgs(std::weak_ptr<Widget> p) : pChildWidget(p)
+    {
+    }
+
+    std::weak_ptr<Widget> pChildWidget;
+};
 
 } // namespace WidgetEvent
 
-class SIRIUS_DLLEXPORT Widget : public EventHandler
+struct ModifierKeyState
+{
+    bool Alt : 1;
+    bool Ctrl : 1;
+    bool Shift : 1;
+};
+
+struct MouseButtonState
+{
+    bool Left : 1;
+    bool Right : 1;
+    bool Middle : 1;
+};
+
+enum class MouseButtonKind
+{
+    Left,
+    Right,
+    Middle
+};
+
+enum class SpecialKey
+{
+    Enter
+};
+
+class SIRIUS_DLLEXPORT Widget : public EventHandler, public std::enable_shared_from_this<Widget>, public EventInvokeUtility<Widget>
 {
 public:
-    explicit Widget(UIContext* pUIContext) : EventHandler(pUIContext)
+    explicit Widget(UIManager& uiManager) : m_UIManager(uiManager)
     {
     }
 
-    Widget* GetParent() const
+    Widget(const Widget&) = delete;
+    Widget& operator=(const Widget&) = delete;
+
+    virtual ~Widget() = default;
+
+    UIManager& GetUIManager()
+    {
+        return m_UIManager;
+    }
+
+    const UIManager& GetUIManager() const
+    {
+        return m_UIManager;
+    }
+
+    EventManager& GetEventManager();
+
+    std::shared_ptr<Widget> GetEventHandler()
+    {
+        return shared_from_this();
+    }
+
+    // parent - children
+
+    std::weak_ptr<Widget> GetParent() const
     {
         return m_pParent;
     }
 
-    ArrayView<Widget*> GetChildren() const
+    std::weak_ptr<Widget> GetRoot();
+
+    std::shared_ptr<Widget> GetChild(std::size_t i) const
+    {
+        return m_Children[i];
+    }
+
+    std::size_t GetChildCount() const
     {
-        return m_Children;
+        return m_Children.size();
     }
 
+    void AddChild(std::shared_ptr<Widget> pWidget);
+    void AddChild(std::shared_ptr<Widget> pWidget, Widget* pWInsertBeforeThisWidget);
+    void RemoveChild(Widget* pChild);
+
+    // widget state
+
+    bool GetIsVisible() const
+    {
+        return m_Flags.IsVisible;
+    }
+
+    void SetIsVisible(bool b);
+
+    bool GetIsEnabled() const
+    {
+        return m_Flags.IsEnabled;
+    }
+
+    void SetIsEnabled(bool b);
+
+    // in parent's coordinates
     Rect<float> GetRect() const
     {
         return m_Rect;
     }
 
+    void SetRect(const Rect<float>& rect);
+
     float GetOpacity() const
     {
         return m_Opacity;
     }
 
+    void SetOpacity(float opacity);
+
+    bool GetWantFocus() const
+    {
+        return m_Flags.WantFocus;
+    }
+
+    void SetWantFocus(bool b)
+    {
+        m_Flags.WantFocus = b;
+    }
+
+    // This function simply returns the value of IsFocusable flag.
+    // If this returns true, widgets may still be unfocusable for other reasons.
+    // Call CanFocus() to determine if the widget is actually focusable.
+    bool GetIsFocusable() const
+    {
+        return m_Flags.IsFocusable;
+    }
+
+    void SetIsFocusable(bool b)
+    {
+        m_Flags.IsFocusable = b;
+    }
+
+    bool CanFocus() const;
+    bool IsFocused() const;
+    bool SetFocus();
+
+    // pt is in parent's coordinate
+    virtual std::shared_ptr<Widget> FindWidgetAt(Vec2<float> pt);
+
+    virtual void InvokeRender(Renderer& renderer, bool renderFrontToBack = false);
+    virtual void OnRender(Renderer& renderer);
+
+    // pt is in root coordinates
+    bool InvokeMouseDown(Vec2<float> pt, MouseButtonKind mouseButtonKind, ModifierKeyState modifierKeyState);
+    bool InvokeMouseUp(Vec2<float> pt, MouseButtonKind mouseButtonKind, ModifierKeyState modifierKeyState);
+    bool InvokeMouseMove(Vec2<float> pt, MouseButtonState mouseButtonState, ModifierKeyState modifierKeyState);
+
+    bool InvokeTouchDown(std::uintptr_t id, Vec2<float> pt, ModifierKeyState modifierKeyState);
+    bool InvokeTouchUp(std::uintptr_t id, Vec2<float> pt, ModifierKeyState modifierKeyState);
+    bool InvokeTouchMove(std::uintptr_t id, Vec2<float> pt, ModifierKeyState modifierKeyState);
+    void InvokeTouchCancel(std::uintptr_t id);
+
+    bool InvokePenDown(std::uintptr_t id, Vec2<float> pt, float pressure, float tiltX, float tiltY, MouseButtonKind mouseButtonKind, ModifierKeyState modifierKeyState);
+    bool InvokePenUp(std::uintptr_t id, Vec2<float> pt, float pressure, float tiltX, float tiltY, MouseButtonKind mouseButtonKind, ModifierKeyState modifierKeyState);
+    bool InvokePenMove(std::uintptr_t id, Vec2<float> pt, float pressure, float tiltX, float tiltY, MouseButtonState mouseButtonState, ModifierKeyState modifierKeyState);
+    void InvokePenCancel(std::uintptr_t id);
+
+    bool InvokeWheel(Vec2<float> pt, float deltaX, float deltaY, ModifierKeyState modifierKeyState);
+    bool InvokeKeyDown(SpecialKey key, ModifierKeyState modifierKeyState);
+    bool InvokeKeyDown(char32_t key, ModifierKeyState modifierKeyState);
+    bool InvokeKeyUp(SpecialKey key, ModifierKeyState modifierKeyState);
+    bool InvokeKeyUp(char32_t key, ModifierKeyState modifierKeyState);
+
 private:
-    Widget* m_pParent = nullptr;
-    std::vector<Widget*> m_Children;
-    Rect<float> m_Rect{}; // (0, 0) is the left-top corner of the parent widget
+    std::vector<std::shared_ptr<Widget>>::iterator FindChild(Widget* pWidget);
+    std::vector<std::shared_ptr<Widget>>::const_iterator FindChild(Widget* pWidget) const;
+
+    struct WidgetStateFlags
+    {
+        bool IsVisible : 1;
+        bool IsEnabled : 1;
+        bool WantFocus : 1;
+        bool IsFocusable : 1;
+    };
+
+    UIManager& m_UIManager;
+
+    std::weak_ptr<Widget> m_pParent;
+    std::vector<std::shared_ptr<Widget>> m_Children;    // sorted in front to back order
+
+    Rect<float> m_Rect = {0.0f, 0.0f, 0.0f, 0.0f};  // in parent's coordinates
     float m_Opacity = 1.0f; // [0.0f, 1.0f]
+    WidgetStateFlags m_Flags = {};
 };
 
 } // namespace Sirius

--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -7,12 +7,14 @@ add_library(
     ../include/sirius/animation.hpp
     ../include/sirius/array_view.hpp
     ../include/sirius/event.hpp
-    ../include/sirius/geometry.hpp
-    ../include/sirius/uicontext.hpp
+    ../include/sirius/intrinsics.hpp
+    ../include/sirius/renderer.hpp
+    ../include/sirius/simpletypes.hpp
+    ../include/sirius/uimanager.hpp
     ../include/sirius/widget.hpp
     animation.cpp
     event.cpp
-    uicontext.cpp
+    renderer.cpp
     widget.cpp
 )
 

--- a/src/animation.cpp
+++ b/src/animation.cpp
@@ -13,14 +13,6 @@
 namespace Sirius
 {
 
-AnimationBlocker::~AnimationBlocker()
-{
-    if (m_pAnimationManager)
-    {
-        m_pAnimationManager->UnblockAllAnimations();
-    }
-}
-
 void AnimationManager::StartAnimation(
     Animatable* pAnimatable,
     AnimationCurve animationCurve,
@@ -29,14 +21,7 @@ void AnimationManager::StartAnimation(
     std::chrono::steady_clock::duration duration
 )
 {
-    auto it = std::find_if(
-        m_Animations.begin(),
-        m_Animations.end(),
-        [pAnimatable] (auto&& x)
-        {
-            return x.pAnimatable == pAnimatable;
-        }
-    );
+    auto it = FindAnimationInfoForAnimatable(pAnimatable);
 
     if (it != m_Animations.end())
     {
@@ -94,6 +79,11 @@ void AnimationManager::ReverseAnimation(Animatable* pAnimatable)
     it->pAnimatable->OnStart(it->Direction, currentValue);
 }
 
+bool AnimationManager::IsAnimationRunning(Animatable* pAnimatable) const
+{
+    return FindAnimationInfoForAnimatable(pAnimatable) != m_Animations.end();
+}
+
 void AnimationManager::Process()
 {
     auto now = std::chrono::steady_clock::now();
@@ -112,7 +102,7 @@ void AnimationManager::Process()
     }
 }
 
-bool AnimationManager::HasActiveAnimations() const
+bool AnimationManager::HasRunningAnimations() const
 {
     return !m_Animations.empty();
 }
@@ -122,11 +112,10 @@ bool AnimationManager::AreAnimationsBlocked() const
     return m_BlockingCount != 0;
 }
 
-AnimationBlocker AnimationManager::BlockAllAnimations()
+void AnimationManager::BlockAllAnimations()
 {
     AbortAllAnimations();
     m_BlockingCount++;
-    return AnimationBlocker(this);
 }
 
 void AnimationManager::UnblockAllAnimations()
@@ -134,12 +123,12 @@ void AnimationManager::UnblockAllAnimations()
     m_BlockingCount--;
 }
 
-std::vector<AnimationManager::AnimationInfo>::iterator AnimationManager::GetAnimationInfoForAnimatable(Animatable* pAnimatable)
+std::vector<AnimationManager::AnimationInfo>::iterator AnimationManager::FindAnimationInfoForAnimatable(Animatable* pAnimatable)
 {
     auto it = std::find_if(
         m_Animations.rbegin(),
         m_Animations.rend(),
-        [pAnimatable] (auto&& x)
+        [pAnimatable](auto&& x)
         {
             return x.pAnimatable == pAnimatable;
         }
@@ -147,10 +136,45 @@ std::vector<AnimationManager::AnimationInfo>::iterator AnimationManager::GetAnim
 
     if (it == m_Animations.rend())
     {
+        return m_Animations.end();
+    }
+    else
+    {
+        return std::prev(it.base());
+    }
+}
+
+std::vector<AnimationManager::AnimationInfo>::const_iterator AnimationManager::FindAnimationInfoForAnimatable(Animatable* pAnimatable) const
+{
+    auto it = std::find_if(
+        m_Animations.rbegin(),
+        m_Animations.rend(),
+        [pAnimatable](auto&& x)
+        {
+            return x.pAnimatable == pAnimatable;
+        }
+    );
+
+    if (it == m_Animations.rend())
+    {
+        return m_Animations.end();
+    }
+    else
+    {
+        return std::prev(it.base());
+    }
+}
+
+std::vector<AnimationManager::AnimationInfo>::iterator AnimationManager::GetAnimationInfoForAnimatable(Animatable* pAnimatable)
+{
+    auto it = FindAnimationInfoForAnimatable(pAnimatable);
+
+    if (it == m_Animations.end())
+    {
         throw std::invalid_argument("Sirius::AnimationManager::GetAnimationInfoForAnimatable(): unregistered Animatable object");
     }
 
-    return std::prev(it.base());
+    return it;
 }
 
 void AnimationManager::AbortAnimation(std::vector<AnimationInfo>::const_iterator it)

--- a/src/event.cpp
+++ b/src/event.cpp
@@ -1,234 +1,474 @@
 // Copyright 2018 Starg
 // Distributed under the 3-Clause BSD License.
 
-#include "sirius/event.hpp"
-
 #include <cassert>
 
-#include "sirius/uicontext.hpp"
+#include <algorithm>
+#include <exception>
+#include <iterator>
+
+#include "sirius/event.hpp"
 
 namespace Sirius
 {
 
-bool EventHandler::InvokeEvent(Event ev)
+void EventManager::InvokeEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs* pArgs /* = nullptr */)
 {
-    if (!ev.pTarget)
+    // First, invoke local listeners
+    if (pTarget)
     {
-        ev.pTarget = this;
+        pTarget->InvokeEventListeners(pTarget, id, pArgs);
     }
 
-    // First, invoke local event listeners.
-    for (auto&& pListener : m_LocalEventListeners)
-    {
-        if (pListener->OnEvent(ev))
-        {
-            return true;
-        }
-    }
+    // Next, invoke global listeners
+    InvokeEventListeners(pTarget, id, pArgs);
 
-    // Next, invoke global event listeners.
-    if (m_pUIContext->GetGlobalEventListenerManager().InvokeGlobalEventListeners(ev))
+    // Finally, invoke the handler
+    if (pTarget)
     {
-        return true;
+        pTarget->OnEvent(id, pArgs);
     }
-
-    // Finally, dispatch the event.
-    for (EventHandler* pHandler = ev.pTarget; pHandler; pHandler = pHandler->GetNextEventDestination())
-    {
-        if (pHandler->OnEvent(ev))
-        {
-            return true;
-        }
-    }
-
-    return false;
 }
 
-void EventHandler::PostEvent(Event ev)
+void EventManager::InvokeEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs& args)
 {
-    if (!ev.pTarget)
-    {
-        ev.pTarget = this;
-    }
+    InvokeEvent(pTarget, id, std::addressof(args));
+}
 
-    m_pUIContext->GetEventQueue().PostEvent(std::move(ev));
+void EventManager::InvokeEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs&& args)
+{
+    InvokeEvent(pTarget, id, std::addressof(args));
 }
 
-void EventHandler::PostEventDelayed(Event ev, std::chrono::steady_clock::duration duration)
+void EventManager::InvokeEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, const std::unique_ptr<EventArgs>& pArgs)
 {
-    if (!ev.pTarget)
-    {
-        ev.pTarget = this;
-    }
+    InvokeEvent(pTarget, id, pArgs.get());
+}
 
-    m_pUIContext->GetEventQueue().PostEventDelayed(std::move(ev), std::chrono::steady_clock::now() + duration);
+void EventManager::PostEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, std::unique_ptr<EventArgs> pArgs /* = nullptr */)
+{
+    m_EventQueue.emplace_back(pTarget, id, std::move(pArgs));
 }
 
-void EventHandler::PostEventDelayed(Event ev, std::chrono::steady_clock::time_point time)
+void EventManager::PostEventThreadSafe(const std::shared_ptr<EventHandler>& pTarget, EventID id, std::unique_ptr<EventArgs> pArgs /* = nullptr */)
 {
-    if (!ev.pTarget)
-    {
-        ev.pTarget = this;
-    }
+    std::scoped_lock lock(m_MutexForThreadSafeEventQueues);
+    m_ThreadSafeEventQueue.emplace_back(pTarget, id, std::move(pArgs));
+    m_HasItemsInThreadSafeEventQueues = true;
+}
 
-    m_pUIContext->GetEventQueue().PostEventDelayed(std::move(ev), time);
+void EventManager::PostEventOnTime(
+    const std::shared_ptr<EventHandler>& pTarget,
+    EventID id,
+    std::chrono::steady_clock::duration duration
+)
+{
+    PostEventOnTime(pTarget, id, nullptr, duration);
 }
 
-const Event* EventHandler::PeekFirstEvent(Event::EventKindType kind)
+void EventManager::PostEventOnTime(
+    const std::shared_ptr<EventHandler>& pTarget,
+    EventID id,
+    std::unique_ptr<EventArgs> pArgs,
+    std::chrono::steady_clock::duration duration
+)
 {
-    return m_pUIContext->GetEventQueue().PeekFirstEvent(
-        [kind, this] (auto&& x)
-        {
-            return x.pTarget == this && x.Kind == kind;
-        }
-    );
+    PostEventOnTime(pTarget, id, std::move(pArgs), std::chrono::steady_clock::now() + duration);
 }
 
-void EventHandler::RemoveEvents(Event::EventKindType kind)
+void EventManager::PostEventOnTime(
+    const std::shared_ptr<EventHandler>& pTarget,
+    EventID id,
+    std::chrono::steady_clock::time_point time
+)
 {
-    return m_pUIContext->GetEventQueue().RemoveEvents(
-        [kind, this] (auto&& x)
-        {
-            return x.pTarget == this && x.Kind == kind;
-        }
-    );
+    PostEventOnTime(pTarget, id, nullptr, time);
 }
 
-void EventHandler::RemoveAllEvents()
+void EventManager::PostEventOnTime(
+    const std::shared_ptr<EventHandler>& pTarget,
+    EventID id,
+    std::unique_ptr<EventArgs> pArgs,
+    std::chrono::steady_clock::time_point time
+)
 {
-    return m_pUIContext->GetEventQueue().RemoveEvents(
-        [this] (auto&& x)
-        {
-            return x.pTarget == this;
-        }
+    m_EventQueueWithTime.emplace_back(pTarget, id, std::move(pArgs), time);
+
+    std::push_heap(
+        m_EventQueueWithTime.begin(),
+        m_EventQueueWithTime.end(),
+        [] (auto&& a, auto&& b) { return a.FireTime > b.FireTime; }
     );
 }
 
-bool EventHandler::OnEvent(const Event&)
+void EventManager::PostEventOnTaskComplete(
+    const std::shared_ptr<EventHandler>& pTarget,
+    EventID id,
+    std::future<void> f
+)
 {
-    return false;
+    PostEventOnTaskComplete(pTarget, id, nullptr, std::move(f));
 }
 
-EventHandler* EventHandler::GetNextEventDestination() const
+void EventManager::PostEventOnTaskComplete(
+    const std::shared_ptr<EventHandler>& pTarget,
+    EventID id,
+    std::unique_ptr<EventArgs> pArgs,
+    std::future<void> f
+)
 {
-    return nullptr;
+    m_EventQueueWithFuture.emplace_back(pTarget, id, std::move(pArgs), std::move(f));
 }
 
-void EventHandler::AddEventListener(EventListener* pEventListener)
+void EventManager::PostEventOnFutureReady(
+    const std::shared_ptr<EventHandler>& pTarget,
+    EventID id,
+    std::future<std::unique_ptr<EventArgs>> f
+)
 {
-    assert(!HasEventListener(pEventListener));
-    m_LocalEventListeners.push_back(pEventListener);
+    m_EventQueueWithFuture.emplace_back(pTarget, id, std::move(f));
 }
 
-void EventHandler::RemoveEventListener(EventListener* pEventListener)
+void EventManager::SendEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs* pArgs /* = nullptr */)
 {
-    auto it = std::find(m_LocalEventListeners.begin(), m_LocalEventListeners.end(), pEventListener);
+    std::future<std::unique_ptr<EventArgs>> f;
 
-    if (it != m_LocalEventListeners.end())
     {
-        m_LocalEventListeners.erase(it);
+        std::scoped_lock lock(m_MutexForThreadSafeEventQueues);
+        f = m_ThreadSafeSentEventQueue.emplace_back(pTarget, id, pArgs).Promise.get_future();
     }
+
+    f.get();
 }
 
-bool EventHandler::HasEventListener(EventListener* pEventListener) const
+void EventManager::SendEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs& args)
 {
-    auto it = std::find(m_LocalEventListeners.begin(), m_LocalEventListeners.end(), pEventListener);
-    return it != m_LocalEventListeners.end();
+    SendEvent(pTarget, id, std::addressof(args));
 }
 
-void GlobalEventListenerManager::AddGlobalEventListener(EventListener* pEventListener)
+void EventManager::SendEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs&& args)
 {
-    assert(!HasGlobalEventListener(pEventListener));
-    m_GlobalEventListeners.push_back(pEventListener);
+    SendEvent(pTarget, id, std::addressof(args));
 }
 
-void GlobalEventListenerManager::RemoveGlobalEventListener(EventListener* pEventListener)
+void EventManager::SendEvent(const std::shared_ptr<EventHandler>& pTarget, EventID id, const std::unique_ptr<EventArgs>& pArgs)
 {
-    auto it = std::find(m_GlobalEventListeners.begin(), m_GlobalEventListeners.end(), pEventListener);
+    SendEvent(pTarget, id, pArgs.get());
+}
 
-    if (it != m_GlobalEventListeners.end())
+std::future<std::unique_ptr<EventArgs>> EventManager::SendEventAsync(
+    const std::shared_ptr<EventHandler>& pTarget,
+    EventID id,
+    std::unique_ptr<EventArgs> pArgs /* = nullptr */
+)
+{
+    std::scoped_lock lock(m_MutexForThreadSafeEventQueues);
+    return m_ThreadSafeSentEventQueue.emplace_back(pTarget, id, std::move(pArgs)).Promise.get_future();
+}
+
+void EventListenerManager::AddEventListener(EventListener* pListener)
+{
+    assert(pListener);
+    m_Listeners.emplace_back(pListener);
+}
+
+void EventListenerManager::AddEventListenerUnique(std::unique_ptr<EventListener> pListener)
+{
+    assert(pListener);
+    m_Listeners.emplace_back(std::move(pListener));
+}
+
+void EventListenerManager::AddEventListenerShared(std::shared_ptr<EventListener> pListener)
+{
+    assert(pListener);
+    m_Listeners.emplace_back(std::move(pListener));
+}
+
+void EventListenerManager::AddEventListenerWeak(std::weak_ptr<EventListener> pListener)
+{
+    m_Listeners.emplace_back(std::move(pListener));
+}
+
+void EventListenerManager::RemoveEventListener(EventListener* pListener)
+{
+    auto it = std::find_if(
+        m_Listeners.begin(),
+        m_Listeners.end(),
+        [pListener] (auto&& v)
+        {
+            return std::visit(
+                [pListener] (auto&& p)
+                {
+                    using Type = std::decay_t<decltype(p)>;
+
+                    if constexpr (std::is_same_v<Type, EventListener*>)
+                    {
+                        return p == pListener;
+                    }
+                    else if constexpr (std::is_same_v<Type, std::weak_ptr<EventListener>>)
+                    {
+                        return p.lock().get() == pListener;
+                    }
+                    else
+                    {
+                        return p.get() == pListener;
+                    }
+                },
+                v
+            );
+        }
+    );
+
+    if (it != m_Listeners.end())
     {
-        m_GlobalEventListeners.erase(it);
+        m_Listeners.erase(it);
     }
 }
 
-bool GlobalEventListenerManager::HasGlobalEventListener(EventListener* pEventListener) const
+void EventListenerManager::RemoveAllEventListeners()
 {
-    auto it = std::find(m_GlobalEventListeners.begin(), m_GlobalEventListeners.end(), pEventListener);
-    return it != m_GlobalEventListeners.end();
+    m_Listeners.clear();
 }
 
-bool GlobalEventListenerManager::InvokeGlobalEventListeners(const Event& ev)
+void EventListenerManager::InvokeEventListeners(const std::shared_ptr<EventHandler>& pTarget, EventID id, EventArgs* pArgs)
 {
-    for (auto&& pListener : m_GlobalEventListeners)
+    for (auto it = m_Listeners.begin(); it != m_Listeners.end(); ++it)
     {
-        if (pListener->OnEvent(ev))
+        bool expired = std::visit(
+            [&pTarget, id, pArgs] (auto&& p)
+            {
+                using Type = std::decay_t<decltype(p)>;
+
+                if constexpr (std::is_same_v<Type, std::weak_ptr<EventListener>>)
+                {
+                    if (auto pLocked = p.lock())
+                    {
+                        pLocked->OnEvent(pTarget, id, pArgs);
+                        return false;
+                    }
+                    else
+                    {
+                        return true;
+                    }
+                }
+                else
+                {
+                    p->OnEvent(pTarget, id, pArgs);
+                    return false;
+                }
+            },
+            *it
+        );
+
+        if (expired)
         {
-            return true;
+            it = m_Listeners.erase(it);
         }
     }
-
-    return false;
 }
 
-void EventQueue::PostEvent(Event ev)
+void EventManager::RemoveAllEvents()
 {
-    m_Events.push_back(std::move(ev));
+    if (m_HasItemsInThreadSafeEventQueues)
+    {
+        std::scoped_lock lock(m_MutexForThreadSafeEventQueues);
+        m_ThreadSafeEventQueue.clear();
+        m_ThreadSafeSentEventQueue.clear();
+    }
+
+    m_EventQueue.clear();
+    m_EventQueueWithTime.clear();
+    m_EventQueueWithFuture.clear();
 }
 
-void EventQueue::PostEventDelayed(Event ev, std::chrono::steady_clock::time_point time)
+void EventManager::ProcessEvents()
 {
-    auto it = std::upper_bound(
-        m_DelayedEvents.begin(),
-        m_DelayedEvents.end(),
-        time,
-        [] (auto&& x, auto&& y)
+    if (m_HasItemsInThreadSafeEventQueues)
+    {
+        std::unique_lock lock(m_MutexForThreadSafeEventQueues, std::try_to_lock);
+
+        if (lock.owns_lock())
         {
-            return x < y.FireTime;
+            m_EventQueue.reserve(m_EventQueue.size() + m_ThreadSafeEventQueue.size());
+            std::move(m_ThreadSafeEventQueue.begin(), m_ThreadSafeEventQueue.end(), std::back_inserter(m_EventQueue));
+            m_ThreadSafeEventQueue.clear();
+
+            m_SentEvents.reserve(m_SentEvents.size() + m_ThreadSafeSentEventQueue.size());
+            std::move(m_ThreadSafeSentEventQueue.rbegin(), m_ThreadSafeSentEventQueue.rend(), std::back_inserter(m_SentEvents));
+            m_ThreadSafeSentEventQueue.clear();
         }
-    );
+    }
 
-    m_DelayedEvents.insert(it, {std::move(ev), time});
+    ProcessEventQueueWithFuture();
+    ProcessEventQueue();
+    ProcessEventQueueWithTime();
+    ProcessSentEvents();
 }
 
-void EventQueue::RemoveAllEvents()
+std::variant<DesiredEventLoopTime, std::chrono::steady_clock::time_point> EventManager::GetDesiredEventLoopTime() const
 {
-    m_Events.clear();
-    m_DelayedEvents.clear();
+    if (!m_EventQueue.empty() || !m_EventQueueWithFuture.empty() || m_HasItemsInThreadSafeEventQueues)
+    {
+        return DesiredEventLoopTime::Now;
+    }
+    else if (m_EventQueueWithTime.empty())
+    {
+        return DesiredEventLoopTime::NotSoon;
+    }
+    else
+    {
+        return m_EventQueueWithTime.front().FireTime;
+    }
 }
 
-void EventQueue::ProcessEvents()
+void EventManager::TryInvokeQueuedEvent(QueuedEvent& ev)
 {
-    while (!m_Events.empty())
+    if (!ev.pHandler)
     {
-        auto ev = std::move(m_Events.front());
-        m_Events.pop_front();
-        EventHandler* pHandler = ev.pTarget;
-        pHandler->InvokeEvent(std::move(ev));
+        InvokeEvent({}, ev.ID, ev.pArgs);
     }
+    else if (auto pLocked = ev.pWeakHandler.lock())
+    {
+        InvokeEvent(pLocked, ev.ID, ev.pArgs);
+    }
+}
+
+void EventManager::ProcessEventQueue()
+{
+    std::size_t i = 0;
+    std::size_t length = m_EventQueue.size();
+
+    class AutoEraser
+    {
+    public:
+        AutoEraser(decltype(m_EventQueue)& eventQueue, std::size_t& offset)
+            : m_EventQueue(eventQueue), m_Offset(offset)
+        {
+        }
+
+        ~AutoEraser()
+        {
+            m_EventQueue.erase(m_EventQueue.begin(), m_EventQueue.begin() + m_Offset);
+        }
+
+    private:
+        decltype(m_EventQueue)& m_EventQueue;
+        std::size_t& m_Offset;
+    };
+
+    AutoEraser ae(m_EventQueue, i);
 
-    while (!m_DelayedEvents.empty() && m_DelayedEvents.front().FireTime <= std::chrono::steady_clock::now())
+    while (i < length)
     {
-        auto ev = std::move(m_DelayedEvents.front().Ev);
-        m_DelayedEvents.pop_front();
-        EventHandler* pHandler = ev.pTarget;
-        pHandler->InvokeEvent(std::move(ev));
+        auto& ev = m_EventQueue[i];
+        ++i;
+        TryInvokeQueuedEvent(ev);
     }
 }
 
-std::optional<std::chrono::steady_clock::time_point> EventQueue::GetNextEventFireTime() const
+void EventManager::ProcessEventQueueWithTime()
 {
-    if (!m_Events.empty())
+    auto now = std::chrono::steady_clock::now();
+
+    while (!m_EventQueueWithTime.empty())
     {
-        return std::chrono::steady_clock::now();
+        auto& evt = m_EventQueueWithTime.front();
+
+        if (evt.FireTime > now)
+        {
+            break;
+        }
+
+        QueuedEvent ev(evt.pHandler, std::move(evt.pWeakHandler), evt.ID, std::move(evt.pArgs));
+
+        std::pop_heap(
+            m_EventQueueWithTime.begin(),
+            m_EventQueueWithTime.end(),
+            [] (auto&& a, auto&& b)
+            {
+                return a.FireTime > b.FireTime;
+            }
+        );
+        m_EventQueueWithTime.pop_back();
+
+        TryInvokeQueuedEvent(ev);
     }
-    else if (!m_DelayedEvents.empty())
+}
+
+void EventManager::ProcessEventQueueWithFuture()
+{
+    for (auto it = m_EventQueueWithFuture.begin(); it != m_EventQueueWithFuture.end(); ++it)
     {
-        return m_DelayedEvents.front().FireTime;
+        using namespace std::chrono_literals;
+
+        std::visit(
+            [this, &it, &eventQueueWithFuture = m_EventQueueWithFuture] (auto&& f)
+            {
+                using Type = std::decay_t<decltype(f)>;
+
+                if (f.wait_for(1ms) != std::future_status::timeout)
+                {
+                    auto ev = std::move(*it);
+                    it = eventQueueWithFuture.erase(it);
+
+                    if constexpr (std::is_same_v<Type, std::future<std::unique_ptr<EventArgs>>>)
+                    {
+                        ev.pArgs = f.get();
+                    }
+
+                    TryInvokeQueuedEvent(ev);
+                }
+            },
+            it->Future
+        );
+
     }
-    else
+}
+
+void EventManager::ProcessSentEvents()
+{
+    while (!m_SentEvents.empty())
     {
-        return std::nullopt;
+        auto ev = std::move(m_SentEvents.back());
+        m_SentEvents.pop_back();
+
+        try
+        {
+            InvokeEvent(
+                ev.pHandler,
+                ev.ID,
+                std::visit(
+                    [] (auto&& p)
+                    {
+                        using Type = std::decay_t<decltype(p)>;
+
+                        if constexpr (std::is_same_v<Type, EventArgs*>)
+                        {
+                            return p;
+                        }
+                        else
+                        {
+                            return p.get();
+                        }
+                    },
+                    ev.pArgs
+                )
+            );
+        }
+        catch (...)
+        {
+            ev.Promise.set_exception(std::current_exception());
+            continue;
+        }
+
+        if (auto ppArgs = std::get_if<std::unique_ptr<EventArgs>>(std::addressof(ev.pArgs)))
+        {
+            ev.Promise.set_value(std::move(*ppArgs));
+        }
+        else
+        {
+            ev.Promise.set_value(nullptr);
+        }
     }
 }
 

--- /dev/null
+++ b/src/renderer.cpp
@@ -0,0 +1,92 @@
+// Copyright 2018 Starg
+// Distributed under the 3-Clause BSD License.
+
+#include "sirius/renderer.hpp"
+
+#include <cassert>
+
+#include <algorithm>
+
+namespace Sirius
+{
+
+void Renderer::BeginDraw()
+{
+    OnBeginDraw();
+
+    for (auto&& p : m_Listeners)
+    {
+        p->OnBeginDraw(this);
+    }
+}
+
+void Renderer::EndDraw()
+{
+    for (auto&& p : m_Listeners)
+    {
+        p->OnEndDraw(this);
+    }
+
+    OnEndDraw();
+}
+
+void Renderer::AddListener(RendererListener* pListener)
+{
+    assert(!HasListener(pListener));
+    m_Listeners.push_back(pListener);
+}
+
+void Renderer::RemoveListener(RendererListener* pListener)
+{
+    auto it = std::find(m_Listeners.begin(), m_Listeners.end(), pListener);
+
+    if (it != m_Listeners.end())
+    {
+        m_Listeners.erase(it);
+    }
+}
+
+bool Renderer::HasListener(RendererListener* pListener) const
+{
+    auto it = std::find(m_Listeners.begin(), m_Listeners.end(), pListener);
+    return it != m_Listeners.end();
+}
+
+void Renderer::InvokeCreateDevice()
+{
+    for (auto&& p : m_Listeners)
+    {
+        p->OnCreateDevice(this);
+    }
+}
+
+void Renderer::InvokeDestroyDevice()
+{
+    for (auto&& p : m_Listeners)
+    {
+        p->OnDestroyDevice(this);
+    }
+}
+
+void Renderer::DrawEllipse(Vec2<float> center, float radiusX, float radiusY, const Paint& paint)
+{
+    DrawEllipse(
+        Rect<float>::FromPoints(Vec2<float>(center.X - radiusX, center.Y - radiusY), Vec2<float>(center.X + radiusX, center.Y + radiusY)),
+        paint
+    );
+}
+
+void Renderer::FillEllipse(Vec2<float> center, float radiusX, float radiusY, const Paint& paint)
+{
+    FillEllipse(
+        Rect<float>::FromPoints(Vec2<float>(center.X - radiusX, center.Y - radiusY), Vec2<float>(center.X + radiusX, center.Y + radiusY)),
+        paint
+    );
+}
+
+void Renderer::DrawBitmap(const std::unique_ptr<Bitmap>& pBitmap, const Rect<float>& srcRect, const Rect<float>& destRect)
+{
+    DrawBitmap(pBitmap.get(), srcRect, destRect);
+}
+
+} // namespace Sirius

--- a/src/uicontext.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2018 Starg
-// Distributed under the 3-Clause BSD License.
-
-#include "sirius/uicontext.hpp"
-
-namespace Sirius
-{
-
-} // namespace Sirius

--- a/src/widget.cpp
+++ b/src/widget.cpp
@@ -3,7 +3,242 @@
 
 #include "sirius/widget.hpp"
 
+#include <cassert>
+
+#include <algorithm>
+#include <stdexcept>
+#include <utility>
+
+#include "sirius/renderer.hpp"
+#include "sirius/uimanager.hpp"
+
 namespace Sirius
 {
 
+EventManager& Widget::GetEventManager()
+{
+    return GetUIManager().GetEventManager();
+}
+
+std::weak_ptr<Widget> Widget::GetRoot()
+{
+    auto p = shared_from_this();
+
+    while (auto pParent = p->m_pParent.lock())
+    {
+        p = pParent;
+    }
+
+    return p;
+}
+
+void Widget::AddChild(std::shared_ptr<Widget> pWidget)
+{
+    AddChild(std::move(pWidget), m_Children.empty() ? nullptr : m_Children.front().get());
+}
+
+void Widget::AddChild(std::shared_ptr<Widget> pWidget, Widget* pInsertBeforeThisWidget)
+{
+    if (!pWidget)
+    {
+        throw std::invalid_argument("Sirius::Widget::AddChild() : pWidget is nullptr");
+    }
+
+    if (pInsertBeforeThisWidget)
+    {
+        auto it = FindChild(pInsertBeforeThisWidget);
+
+        if (it == m_Children.end())
+        {
+            throw std::invalid_argument("Sirius::Widget::AddChild() : pInsertBeforeThisWidget is not a child of this widget");
+        }
+
+        m_Children.insert(it, pWidget);
+    }
+    else
+    {
+        m_Children.push_back(pWidget);
+    }
+
+    pWidget->m_pParent = weak_from_this();
+    pWidget->InvokeEvent(WidgetEvent::Added, nullptr);
+
+    InvokeEvent(WidgetEvent::ChildAdded, WidgetEvent::ChildWidgetEventArgs(pWidget));
+}
+
+void Widget::RemoveChild(Widget* pChild)
+{
+    if (!pChild || FindChild(pChild) == m_Children.end())
+    {
+        throw std::invalid_argument("Sirius::Widget::RemoveChild() : pWChild is not a child of this widget");
+    }
+
+    InvokeEvent(WidgetEvent::ChildRemove, WidgetEvent::ChildWidgetEventArgs(pChild->weak_from_this()));
+    pChild->InvokeEvent(WidgetEvent::Remove, nullptr);
+
+    // ChildRemove/Remove events might have added/removed another widget, so we have to find the child again.
+    auto it = FindChild(pChild);
+
+    if (it != m_Children.end())
+    {
+        m_Children.erase(it);
+    }
+
+    pChild->m_pParent.reset();
+}
+
+void Widget::SetIsVisible(bool b)
+{
+    if (m_Flags.IsVisible != b)
+    {
+        m_Flags.IsVisible = b;
+        InvokeEvent(WidgetEvent::VisibilityChanged, nullptr);
+    }
+}
+
+void Widget::SetIsEnabled(bool b)
+{
+    if (m_Flags.IsEnabled != b)
+    {
+        m_Flags.IsEnabled = b;
+        InvokeEvent(WidgetEvent::EnabledOrDisabled, nullptr);
+    }
+}
+
+void Widget::SetRect(const Rect<float>& rect)
+{
+    if (m_Rect != rect)
+    {
+        m_Rect = rect;
+        InvokeEvent(WidgetEvent::RectChanged, nullptr);
+    }
+}
+
+void Widget::SetOpacity(float opacity)
+{
+    float clampedOpacity = std::clamp(opacity, 0.0f, 1.0f);
+
+    if (m_Opacity != clampedOpacity)
+    {
+        m_Opacity = clampedOpacity;
+        InvokeEvent(WidgetEvent::OpacityChanged, nullptr);
+    }
+}
+
+bool Widget::CanFocus() const
+{
+    return GetIsFocusable() && GetIsEnabled() && GetIsVisible();
+}
+
+bool Widget::IsFocused() const
+{
+    return GetUIManager().GetFocusedWidget().lock().get() == this;
+}
+
+bool Widget::SetFocus()
+{
+    if (!CanFocus())
+    {
+        if (auto pParent = m_pParent.lock())
+        {
+            return pParent->SetFocus();
+        }
+
+        return false;
+    }
+
+    auto pWThis = weak_from_this();
+    auto pOldFocus = GetUIManager().GetFocusedWidget().lock();
+
+    if (pOldFocus)
+    {
+        pOldFocus->InvokeEvent(WidgetEvent::FocusKilled);
+    }
+
+    InvokeEvent(WidgetEvent::FocusSet);
+    GetUIManager().SetFocusedWidget(pWThis);
+    return true;
+}
+
+std::shared_ptr<Widget> Widget::FindWidgetAt(Vec2<float> pt)
+{
+    auto rect = GetRect();
+
+    if (rect.Includes(pt))
+    {
+        Vec2<float> childPoint(pt.X - rect.Left, pt.Y - rect.Top);
+
+        for (auto&& pChild : m_Children)
+        {
+            if (auto pAt = pChild->FindWidgetAt(childPoint))
+            {
+                return pAt;
+            }
+        }
+
+        return shared_from_this();
+    }
+
+    return nullptr;
+}
+
+void Widget::InvokeRender(Renderer& renderer, bool renderFrontToBack /* = false */)
+{
+    auto pParent = m_pParent.lock();
+    assert(renderer.GetGlobalTranslation() == (pParent ? pParent->m_Rect.GetLeftTop() : Vec2<float>(0, 0)));
+ 
+    if (GetIsVisible())
+    {
+        AutoRestoreRendererStates arrs(renderer);
+        Rect<float> rect = GetRect();
+        Rect<float> oldClipRect = renderer.GetClipRect();
+        renderer.SetClipRect(oldClipRect.Clip(rect.Translate(oldClipRect.GetLeftTop())));
+        renderer.SetGlobalTranslation(renderer.GetGlobalTranslation() + Vec2<float>(rect.Left, rect.Top));
+
+        auto renderChild = [&renderer, renderFrontToBack] (auto&& pWidget)
+        {
+            pWidget->InvokeRender(renderer, renderFrontToBack);
+        };
+
+        if (renderFrontToBack)
+        {
+            std::for_each(m_Children.begin(), m_Children.end(), renderChild);
+            OnRender(renderer);
+        }
+        else
+        {
+            OnRender(renderer);
+            std::for_each(m_Children.rbegin(), m_Children.rend(), renderChild);
+        }
+    }
+}
+
+void Widget::OnRender(Renderer&)
+{
+}
+
+std::vector<std::shared_ptr<Widget>>::iterator Widget::FindChild(Widget* pWidget)
+{
+    return std::find_if(
+        m_Children.begin(),
+        m_Children.end(),
+        [pWidget] (auto&& x)
+        {
+            return x.get() == pWidget;
+        }
+    );
+}
+
+std::vector<std::shared_ptr<Widget>>::const_iterator Widget::FindChild(Widget* pWidget) const
+{
+    return std::find_if(
+        m_Children.begin(),
+        m_Children.end(),
+        [pWidget] (auto&& x)
+        {
+            return x.get() == pWidget;
+        }
+    );
+}
+
 } // namespace Sirius