widget.hpp

#ifndef TERMOX_WIDGET_WIDGET_HPP
#define TERMOX_WIDGET_WIDGET_HPP
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <set>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <signals_light/signal.hpp>
 
#include <termox/common/fps.hpp>
#include <termox/common/transform_view.hpp>
#include <termox/painter/brush.hpp>
#include <termox/painter/color.hpp>
#include <termox/painter/glyph.hpp>
#include <termox/painter/painter.hpp>
#include <termox/system/key.hpp>
#include <termox/system/mouse.hpp>
#include <termox/widget/area.hpp>
#include <termox/widget/cursor.hpp>
#include <termox/widget/focus_policy.hpp>
#include <termox/widget/point.hpp>
#include <termox/widget/size_policy.hpp>
 
namespace ox {
 
class Widget {
   public:
    struct Parameters {
        std::string name            = std::string{};
        Focus_policy focus_policy   = Focus_policy::None;
        Size_policy width_policy    = Size_policy{};
        Size_policy height_policy   = Size_policy{};
        Brush brush                 = Brush{};
        Glyph wallpaper             = Glyph{U' '};
        bool brush_paints_wallpaper = true;
        Cursor cursor               = Cursor{};
    };
 
   private:
    template <typename Signature>
    using Signal = sl::Signal<Signature>;
 
   public:
    // Event Signals - Alternatives to overriding virtual event handlers.
    /* Called after event handlers are invoked. Parameters are in same order as
     * matching event handler function's parameters. */
    Signal<void()> enabled;
    Signal<void()> disabled;
    Signal<void(Widget&)> child_added;
    Signal<void(Widget&)> child_removed;
    Signal<void(Widget&)> child_polished;
    Signal<void(Point, Point)> moved;
    Signal<void(Area, Area)> resized;
    Signal<void(Mouse const&)> mouse_pressed;
    Signal<void(Mouse const&)> mouse_released;
    Signal<void(Mouse const&)> mouse_wheel_scrolled;
    Signal<void(Mouse const&)> mouse_moved;
    Signal<void(Key)> key_pressed;
    Signal<void(Key)> key_released;
    Signal<void()> focused_in;
    Signal<void()> focused_out;
    Signal<void()> deleted;
    Signal<void(Painter&)> painted;
    Signal<void()> timer;
 
    // Event filter Signals. The first parameter is the original receiver.
    Signal<bool(Widget&)> enabled_filter;
    Signal<bool(Widget&)> disabled_filter;
    Signal<bool(Widget&, Widget&)> child_added_filter;
    Signal<bool(Widget&, Widget&)> child_removed_filter;
    Signal<bool(Widget&, Widget&)> child_polished_filter;
    Signal<bool(Widget&, Point, Point)> moved_filter;
    Signal<bool(Widget&, Area, Area)> resized_filter;
    Signal<bool(Widget&, Mouse const&)> mouse_pressed_filter;
    Signal<bool(Widget&, Mouse const&)> mouse_released_filter;
    Signal<bool(Widget&, Mouse const&)> mouse_wheel_scrolled_filter;
    Signal<bool(Widget&, Mouse const&)> mouse_moved_filter;
    Signal<bool(Widget&, Key)> key_pressed_filter;
    Signal<bool(Widget&, Key)> key_released_filter;
    Signal<bool(Widget&)> focused_in_filter;
    Signal<bool(Widget&)> focused_out_filter;
    Signal<bool(Widget&)> deleted_filter;
    Signal<bool(Widget&, Painter&)> painted_filter;
    Signal<bool(Widget&)> timer_filter;
 
   public:
    Focus_policy focus_policy;
 
    Cursor cursor;
 
    Size_policy width_policy;
 
    Size_policy height_policy;
 
    Brush brush;
 
    sl::Lifetime lifetime;
 
   public:
    explicit Widget(std::string name            = "",
                    Focus_policy focus_policy_  = Focus_policy::None,
                    Size_policy width_policy_   = Size_policy{},
                    Size_policy height_policy_  = Size_policy{},
                    Brush brush_                = Brush{},
                    Glyph wallpaper             = U' ',
                    bool brush_paints_wallpaper = true,
                    Cursor cursor               = Cursor{});
 
    explicit Widget(Parameters p);
 
    virtual ~Widget() = default;
 
    // Widgets are exclusively owned by std::unique_ptrs and sl::Slots often
    // depend on Widget references to remain valid, copying and moving would
    // invalidate those references.
    Widget(Widget const&) = delete;
    Widget(Widget&&)      = delete;
    Widget& operator=(Widget const&) = delete;
    Widget& operator=(Widget&&) = delete;
 
   public:
    void set_name(std::string name);
 
    [[nodiscard]] auto name() const -> std::string const&;
 
    [[nodiscard]] auto unique_id() const -> std::uint16_t;
 
    void set_wallpaper(Glyph g);
 
    [[nodiscard]] auto get_wallpaper() const -> Glyph;
 
 
    void enable(bool enable = true);
 
 
    void disable(bool disable = true);
 
    [[nodiscard]] auto is_enabled() const -> bool;
 
 
    [[nodiscard]] auto parent() const -> Widget*;
 
    [[nodiscard]] auto top_left() const -> Point;
 
    [[nodiscard]] auto area() const -> Area;
 
    virtual void update();
 
    [[nodiscard]] virtual auto is_layout_type() const -> bool;
 
 
    void install_event_filter(Widget& filter);
 
 
    void remove_event_filter(Widget& filter);
 
    [[nodiscard]] auto get_event_filters() const -> std::set<Widget*> const&;
 
 
    void enable_animation(std::chrono::milliseconds interval);
 
    void enable_animation(FPS fps);
 
 
    void disable_animation();
 
    [[nodiscard]] auto is_animated() const -> bool;
 
    [[nodiscard]] auto get_children()
    {
        auto constexpr dereference = [](auto& widg_ptr) -> Widget& {
            return *widg_ptr;
        };
        return Transform_view(children_, dereference);
    }
 
    [[nodiscard]] auto get_children() const
    {
        auto constexpr dereference = [](auto const& widg_ptr) -> Widget const& {
            return *widg_ptr;
        };
        return Transform_view(children_, dereference);
    }
 
    [[nodiscard]] auto get_descendants() const -> std::vector<Widget*>;
 
    void paint_wallpaper_with_brush(bool paints = true);
 
    [[nodiscard]] auto paints_wallpaper_with_brush() const -> bool;
 
 
    [[nodiscard]] auto generate_wallpaper() const -> Glyph;
 
    [[nodiscard]] auto get_child_offset() const -> std::size_t;
 
    [[nodiscard]] auto child_count() const -> std::size_t;
 
    // - - - - - - - - - - - - - Event Handlers - - - - - - - - - - - - - - - -
    virtual auto enable_event() -> bool;
 
    virtual auto disable_event() -> bool;
 
    virtual auto child_added_event(Widget& child) -> bool;
 
    virtual auto child_removed_event(Widget& child) -> bool;
 
    virtual auto child_polished_event(Widget& child) -> bool;
 
    virtual auto move_event(Point new_position, Point old_position) -> bool;
 
    virtual auto resize_event(Area new_size, Area old_size) -> bool;
 
    virtual auto mouse_press_event(Mouse const& m) -> bool;
 
    virtual auto mouse_release_event(Mouse const& m) -> bool;
 
    virtual auto mouse_wheel_event(Mouse const& m) -> bool;
 
    virtual auto mouse_move_event(Mouse const& m) -> bool;
 
    virtual auto key_press_event(Key k) -> bool;
 
 
    virtual auto key_release_event(Key k) -> bool;
 
    virtual auto focus_in_event() -> bool;
 
    virtual auto focus_out_event() -> bool;
 
    virtual auto delete_event() -> bool;
 
    virtual auto paint_event(Painter& p) -> bool;
 
    virtual auto timer_event() -> bool;
 
    // - - - - - - - - - - - Event Filter Handlers - - - - - - - - - - - - - - -
    virtual auto enable_event_filter(Widget& receiver) -> bool;
 
    virtual auto disable_event_filter(Widget& receiver) -> bool;
 
    virtual auto child_added_event_filter(Widget& receiver, Widget& child)
        -> bool;
 
    virtual auto child_removed_event_filter(Widget& receiver, Widget& child)
        -> bool;
 
    virtual auto child_polished_event_filter(Widget& receiver, Widget& child)
        -> bool;
 
    virtual auto move_event_filter(Widget& receiver,
                                   Point new_position,
                                   Point old_position) -> bool;
 
    virtual auto resize_event_filter(Widget& receiver,
                                     Area new_size,
                                     Area old_size) -> bool;
 
    virtual auto mouse_press_event_filter(Widget& receiver, Mouse const& m)
        -> bool;
 
    virtual auto mouse_release_event_filter(Widget& receiver, Mouse const& m)
        -> bool;
 
    virtual auto mouse_wheel_event_filter(Widget& receiver, Mouse const& m)
        -> bool;
 
    virtual auto mouse_move_event_filter(Widget& receiver, Mouse const& m)
        -> bool;
 
    virtual auto key_press_event_filter(Widget& receiver, Key k) -> bool;
 
    virtual auto key_release_event_filter(Widget& receiver, Key k) -> bool;
 
    virtual auto focus_in_event_filter(Widget& receiver) -> bool;
 
    virtual auto focus_out_event_filter(Widget& receiver) -> bool;
 
    virtual auto delete_event_filter(Widget& receiver) -> bool;
 
    virtual auto paint_event_filter(Widget& receiver, Painter& p) -> bool;
 
    virtual auto timer_event_filter(Widget& receiver) -> bool;
 
   private:
    bool enabled_ = false;
    bool brush_paints_wallpaper_;
    bool is_animated_ = false;
 
   protected:
    using Children_t = std::vector<std::unique_ptr<Widget>>;
    Children_t children_;
    std::size_t child_offset_ = 0;
 
   private:
    std::string name_;
    Widget* parent_ = nullptr;
    Glyph wallpaper_;
    std::set<Widget*> event_filters_;
 
    // Top left point of *this, relative to the top left of the screen.
    Point top_left_position_ = {0, 0};
 
    // The entire area of the widget.
    Area area_ = {0, 0};
 
    std::uint16_t const unique_id_;
 
   public:
    void set_top_left(Point p);
 
    void set_area(Area a);
 
    void set_parent(Widget* parent);
};
 
[[nodiscard]] auto widget(std::string name            = "",
                          Focus_policy focus_policy   = Focus_policy::None,
                          Size_policy width_policy    = Size_policy{},
                          Size_policy height_policy   = Size_policy{},
                          Brush brush                 = Brush{},
                          Glyph wallpaper             = U' ',
                          bool brush_paints_wallpaper = true,
                          Cursor cursor = Cursor{}) -> std::unique_ptr<Widget>;
 
[[nodiscard]] auto widget(Widget::Parameters parameters)
    -> std::unique_ptr<Widget>;
 
template <typename Widget_t, typename... Args>
[[nodiscard]] auto make(Args&&... args) -> std::unique_ptr<Widget_t>
{
    static_assert(std::is_base_of_v<Widget, Widget_t>,
                  "Must make a Widget derived type.");
    return std::make_unique<Widget_t>(std::forward<Args>(args)...);
}
 
}  // namespace ox
#endif  // TERMOX_WIDGET_WIDGET_HPP