widget.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_WIDGET_H
#define EGT_WIDGET_H
 
#include <egt/app.h>
#include <egt/detail/enum.h>
#include <egt/detail/meta.h>
#include <egt/detail/range.h>
#include <egt/event.h>
#include <egt/flags.h>
#include <egt/font.h>
#include <egt/geometry.h>
#include <egt/imagegroup.h>
#include <egt/object.h>
#include <egt/palette.h>
#include <egt/screen.h>
#include <egt/serialize.h>
#include <egt/signal.h>
#include <egt/theme.h>
#include <egt/widgetflags.h>
#include <iosfwd>
#include <memory>
#include <string>
 
namespace egt
{
inline namespace v1
{
class Painter;
class Frame;
class Screen;
 
class EGT_API Widget : public Object
{
public:
 
    enum class Flag : uint32_t
    {
        plane_window = detail::bit(0),
 
        window = detail::bit(1),
 
        frame = detail::bit(2),
 
        disabled = detail::bit(3),
 
        readonly = detail::bit(4),
 
        active = detail::bit(5),
 
        invisible = detail::bit(6),
 
        grab_mouse = detail::bit(7),
 
        no_clip = detail::bit(8),
 
        no_layout = detail::bit(9),
 
        no_autoresize = detail::bit(10),
 
        checked = detail::bit(11),
 
        component = detail::bit(12),
 
        user_drag = detail::bit(13),
 
        user_track_drag = detail::bit(14),
    };
 
    using Flags = egt::Flags<Widget::Flag>;
 
    Signal<> on_checked_changed;
 
    Signal<> on_gain_focus;
 
    Signal<> on_lost_focus;
 
    Signal<> on_show;
 
    Signal<> on_hide;
    explicit Widget(const Rect& rect = {},
                    const Widget::Flags& flags = {}) noexcept;
 
    explicit Widget(Frame& parent, const Rect& rect = {},
                    const Widget::Flags& flags = {}) noexcept;
 
    explicit Widget(Serializer::Properties& props) noexcept
        : Widget(props, false)
    {
    }
 
protected:
 
    explicit Widget(Serializer::Properties& props, bool is_derived) noexcept;
 
public:
 
    Widget(const Widget&) = delete;
    Widget& operator=(const Widget&) = delete;
    Widget(Widget&&) noexcept = default;
    Widget& operator=(Widget&&) noexcept = default;
 
    virtual void draw(Painter& painter, const Rect& rect);
 
    virtual void handle(Event& event);
 
    void continue_drag(Event& event);
 
    virtual void resize(const Size& size);
 
    void resize_by_ratio(DefaultDim hratio, DefaultDim vratio);
 
    void resize_by_ratio(DefaultDim ratio)
    {
        resize_by_ratio(ratio, ratio);
    }
 
    virtual void scale(float hscale, float vscale)
    {
        detail::ignoreparam(hscale);
        detail::ignoreparam(vscale);
    }
 
    void scale(float scale)
    {
        this->scale(scale, scale);
    }
 
    void width(DefaultDim w)
    {
        if (!parent_in_layout() && !in_layout())
            m_user_requested_box.width(w);
 
        resize(Size(w, height()));
    }
 
    void height(DefaultDim h)
    {
        if (!parent_in_layout() && !in_layout())
            m_user_requested_box.height(h);
 
        resize(Size(width(), h));
    }
 
    virtual void move(const Point& point);
 
    void x(DefaultDim x)
    {
        if (!parent_in_layout() && !in_layout())
            m_user_requested_box.x(x);
 
        move(Point(x, y()));
    }
 
    void y(DefaultDim y)
    {
        if (!parent_in_layout() && !in_layout())
            m_user_requested_box.y(y);
 
        move(Point(x(), y));
    }
 
    void move_to_center(const Point& point);
 
    void move_to_center();
 
    virtual void hide();
 
    virtual void show();
 
    EGT_NODISCARD bool visible() const
    {
        return !flags().is_set(Widget::Flag::invisible);
    }
 
    void visible(bool value);
 
    void visible_toggle()
    {
        if (visible())
            hide();
        else
            show();
    }
 
    EGT_NODISCARD bool active() const;
 
    void active(bool value);
 
    EGT_NODISCARD bool readonly() const
    {
        return flags().is_set(Widget::Flag::readonly);
    }
 
    void readonly(bool value);
 
    void readonly_toggle()
    {
        readonly(!readonly());
    }
 
    void disable();
 
    void enable();
 
    EGT_NODISCARD bool disabled() const
    {
        return flags().is_set(Widget::Flag::disabled);
    }
 
    void disable_toggle()
    {
        if (disabled())
            enable();
        else
            disable();
    }
 
    void disabled(bool value)
    {
        if (value)
            disable();
        else
            enable();
    }
 
    EGT_NODISCARD bool user_drag() const
    {
        return flags().is_set(Widget::Flag::user_drag);
    }
 
    void user_drag(bool value)
    {
        if (flags().is_set(Widget::Flag::user_drag) != value)
        {
            if (value)
                flags().set(Widget::Flag::user_drag);
            else
                flags().clear(Widget::Flag::user_drag);
        }
    }
 
    EGT_NODISCARD bool user_track_drag() const
    {
        return flags().is_set(Widget::Flag::user_track_drag);
    }
 
    void user_track_drag(bool value)
    {
        if (flags().is_set(Widget::Flag::user_track_drag) != value)
        {
            if (value)
                flags().set(Widget::Flag::user_track_drag);
            else
                flags().clear(Widget::Flag::user_track_drag);
        }
    }
 
    bool can_handle_event() const
    {
        return !m_widget_flags.is_set(Flag::readonly) &&
               !m_widget_flags.is_set(Flag::invisible) &&
               !m_widget_flags.is_set(Flag::disabled);
    }
 
    EGT_NODISCARD bool hit(const DisplayPoint& point) const
    {
        auto pos = display_to_local(point);
        return local_box().intersect(pos);
    }
 
    void grab_mouse(bool value);
 
    EGT_NODISCARD bool grab_mouse() const;
 
    EGT_NODISCARD bool plane_window() const;
 
    void autoresize(bool value);
 
    EGT_NODISCARD bool autoresize() const;
 
    EGT_NODISCARD bool frame() const;
 
    EGT_NODISCARD bool clip() const;
 
    void no_layout(bool value);
 
    EGT_NODISCARD bool no_layout() const;
 
    EGT_NODISCARD float alpha() const
    {
        return m_alpha;
    }
 
    void alpha(float alpha);
 
    virtual void damage();
 
    virtual void damage(const Rect& rect);
 
    EGT_NODISCARD const Rect& box() const
    {
        return m_box;
    }
 
    void box(const Rect& rect);
 
    EGT_NODISCARD const Rect& user_requested_box() const
    {
        return m_user_requested_box;
    }
 
    EGT_NODISCARD const Size& size() const
    {
        return box().size();
    }
 
    EGT_NODISCARD const Point& point() const
    {
        return box().point();
    }
 
    EGT_NODISCARD DefaultDim width() const { return m_box.width(); }
 
    EGT_NODISCARD DefaultDim height() const { return m_box.height(); }
 
    EGT_NODISCARD DefaultDim x() const { return m_box.x(); }
 
    EGT_NODISCARD DefaultDim y() const { return m_box.y(); }
 
    EGT_NODISCARD Point center() const { return box().center(); }
 
    EGT_NODISCARD Palette::GroupId group() const;
 
    void palette(const Palette& palette);
 
    EGT_NODISCARD const Palette& palette() const;
 
    void reset_palette();
 
    EGT_NODISCARD bool has_palette() const { return (bool)m_palette; }
 
    EGT_NODISCARD const Pattern& color(Palette::ColorId id) const;
 
    EGT_NODISCARD const Pattern& color(Palette::ColorId id, Palette::GroupId group) const;
 
    void color(Palette::ColorId id,
               const Pattern& color,
               Palette::GroupId group = Palette::GroupId::normal);
 
    EGT_NODISCARD Image* background(bool allow_fallback = false) const;
 
    EGT_NODISCARD Image* background(Palette::GroupId group,
                                    bool allow_fallback = false) const;
 
    void background(const Image& image,
                    Palette::GroupId group = Palette::GroupId::normal);
 
    void reset_background(Palette::GroupId group = Palette::GroupId::normal);
 
    Widget* parent();
 
    EGT_NODISCARD const Widget* parent() const;
 
    EGT_NODISCARD virtual Screen* screen() const;
 
    EGT_NODISCARD virtual bool has_screen() const { return false; }
 
    void align(const AlignFlags& a);
 
    EGT_NODISCARD const AlignFlags& align() const { return m_align; }
 
    AlignFlags& align() { return m_align; }
 
    void padding(DefaultDim padding)
    {
        if (detail::change_if_diff<>(m_padding, padding))
        {
            damage();
            parent_layout();
        }
    }
 
    EGT_NODISCARD DefaultDim padding() const { return m_padding; }
 
    void margin(DefaultDim margin)
    {
        if (detail::change_if_diff<>(m_margin, margin))
        {
            damage();
            parent_layout();
        }
    }
 
    EGT_NODISCARD DefaultDim margin() const { return m_margin; }
 
    void border(DefaultDim border)
    {
        if (detail::change_if_diff<>(m_border, border))
        {
            damage();
            parent_layout();
        }
    }
 
    EGT_NODISCARD DefaultDim border() const { return m_border; }
 
    void border_radius(float radius)
    {
        if (detail::change_if_diff<>(m_border_radius, radius))
            damage();
    }
 
    EGT_NODISCARD float border_radius() const { return m_border_radius; }
 
    void border_flags(const Theme::BorderFlags& flags)
    {
        if (detail::change_if_diff<>(m_border_flags, flags))
            damage();
    }
 
    EGT_NODISCARD Theme::BorderFlags border_flags() const { return m_border_flags; }
 
    void ratio(DefaultDim ratio)
    {
        this->ratio(ratio, ratio);
    }
 
    void ratio(DefaultDim horizontal,
               DefaultDim vertical)
    {
        auto a = detail::change_if_diff<>(m_horizontal_ratio, horizontal);
        auto b = detail::change_if_diff<>(m_vertical_ratio, vertical);
        if (a || b)
            parent_layout();
    }
 
    void vertical_ratio(DefaultDim vertical)
    {
        if (detail::change_if_diff<>(m_vertical_ratio, vertical))
            parent_layout();
    }
 
    EGT_NODISCARD DefaultDim vertical_ratio() const { return m_vertical_ratio; }
 
    void horizontal_ratio(DefaultDim horizontal)
    {
        if (detail::change_if_diff<>(m_horizontal_ratio, horizontal))
            parent_layout();
    }
 
    EGT_NODISCARD DefaultDim horizontal_ratio() const { return m_horizontal_ratio; }
 
    void yratio(DefaultDim yratio)
    {
        if (detail::change_if_diff<>(m_yratio, yratio))
            parent_layout();
    }
 
    EGT_NODISCARD DefaultDim yratio() const { return m_yratio; }
 
    void xratio(DefaultDim xratio)
    {
        if (detail::change_if_diff<>(m_xratio, xratio))
            parent_layout();
    }
 
    EGT_NODISCARD DefaultDim xratio() const { return m_xratio; }
 
    EGT_NODISCARD virtual Size min_size_hint() const;
 
    void min_size_hint(const Size& size)
    {
        if (detail::change_if_diff<>(m_min_size, size))
            parent_layout();
    }
 
    virtual void paint(Painter& painter);
 
    virtual void paint_to_file(const std::string& filename = {});
 
    using WalkCallback = std::function<bool(Widget* widget, int level)>;
 
    virtual void walk(const WalkCallback& callback, int level = 0);
 
    void focus(bool value);
 
    EGT_NODISCARD bool focus() const { return m_focus; }
 
    void fill_flags(const Theme::FillFlags& flags)
    {
        if (detail::change_if_diff<>(m_fill_flags, flags))
            damage();
    }
 
    EGT_NODISCARD const Theme::FillFlags& fill_flags() const
    {
        return m_fill_flags;
    }
 
    Theme::FillFlags& fill_flags()
    {
        return m_fill_flags;
    }
 
    EGT_NODISCARD const Theme& theme() const;
 
    virtual void zorder_down();
 
    virtual void zorder_up();
 
    virtual void zorder_bottom();
 
    virtual void zorder_top();
 
    EGT_NODISCARD virtual size_t zorder() const;
 
    virtual void zorder(size_t rank);
 
    void detach();
 
    EGT_NODISCARD Point to_parent(const Point& r) const;
 
    EGT_NODISCARD Rect to_parent(const Rect& r) const
    {
        return Rect(to_parent(r.point()), r.size());
    }
 
    DisplayPoint display_origin();
 
    EGT_NODISCARD size_t moat() const;
 
    EGT_NODISCARD virtual Rect content_area() const;
 
    EGT_NODISCARD bool in_layout() const
    {
        return m_in_layout;
    }
 
    virtual void layout();
 
    void draw_box(Painter& painter, Palette::ColorId bg,
                  Palette::ColorId border) const;
 
    void draw_circle(Painter& painter, Palette::ColorId bg,
                     Palette::ColorId border) const;
 
    DisplayPoint local_to_display(const Point& p) const;
 
    virtual Point display_to_local(const DisplayPoint& p) const;
 
    EGT_NODISCARD const Font& font() const;
 
    void font(const Font& font)
    {
        if (m_font && *m_font == font)
            return;
 
        m_font = std::make_unique<Font>(font);
        damage();
        layout();
        parent_layout();
    }
 
    void reset_font()
    {
        if (m_font)
        {
            m_font.reset();
            damage();
            layout();
            parent_layout();
        }
    }
 
    bool has_font() const { return (bool)m_font; }
 
    EGT_NODISCARD bool checked() const
    {
        return flags().is_set(Widget::Flag::checked);
    }
 
    virtual void checked(bool value);
 
    EGT_NODISCARD virtual std::string type() const;
 
    using WidgetId = uint64_t;
 
    EGT_NODISCARD WidgetId widgetid() const
    {
        return m_widgetid;
    }
 
    virtual void on_screen_resized();
 
    virtual void serialize(Serializer& serializer) const;
 
    virtual void serialize_children(Serializer& serializer) const { detail::ignoreparam(serializer); }
 
    virtual void deserialize_children(const Deserializer& deserializer) { detail::ignoreparam(deserializer); }
 
    virtual void post_deserialize(Serializer::Properties& props) { detail::ignoreparam(props); }
 
    ~Widget() noexcept override;
 
protected:
 
    virtual void damage_from_subordinate(const Rect& rect)
    {
        damage(rect);
    }
 
    virtual Point point_from_subordinate(const Widget& subordinate) const
    {
        detail::ignoreparam(subordinate);
        return point();
    }
 
    virtual void begin_draw()
    {
        assert(0);
    }
 
    void begin_draw(Widget* parent)
    {
        parent->begin_draw();
    }
 
    EGT_NODISCARD virtual Point to_subordinate(const Point& p) const
    {
        return p - point();
    }
 
    EGT_NODISCARD Rect to_subordinate(Rect rect) const
    {
        rect.point(to_subordinate(rect.point()));
        return rect;
    }
 
    virtual Point to_panel(const Point& p);
 
    void zorder_down(const Widget* widget);
 
    void zorder_up(const Widget* widget);
 
    void zorder_bottom(const Widget* widget);
 
    void zorder_top(const Widget* widget);
 
    size_t zorder(const Widget* widget) const;
 
    void zorder(const Widget* widget, size_t rank);
 
    void add_damage(const Rect& rect);
 
    using ChildDrawCallback = std::function<void(Painter& painter, Widget* widget)>;
 
    EGT_NODISCARD ChildDrawCallback special_child_draw_callback() const
    {
        return m_special_child_draw_callback;
    }
 
    EGT_NODISCARD ChildDrawCallback special_child_draw_callback(Widget* parent) const
    {
        return parent->special_child_draw_callback();
    }
 
    void special_child_draw_callback(ChildDrawCallback func)
    {
        m_special_child_draw_callback = std::move(func);
    }
 
    void special_child_draw(Painter& painter, Widget* widget)
    {
        if (m_special_child_draw_callback)
            m_special_child_draw_callback(painter, widget);
        else if (parent())
            parent()->special_child_draw(painter, widget);
    }
 
    Widget* find_screen()
    {
        if (has_screen())
            return this;
 
        if (parent())
            return parent()->find_screen();
 
        return nullptr;
    }
 
    EGT_NODISCARD const Widget* find_screen() const
    {
        if (has_screen())
            return this;
 
        if (parent())
            return parent()->find_screen();
 
        return nullptr;
    }
 
    EGT_NODISCARD const Widget::Flags& flags() const { return m_widget_flags; }
 
    Widget::Flags& flags() { return m_widget_flags; }
 
    EGT_NODISCARD virtual bool top_level() const { return false; }
 
    virtual void set_parent(Widget* parent);
 
    EGT_NODISCARD Rect local_box() const
    {
        return size();
    }
 
    void start_drag(Event& event);
 
    bool accept_drag() const { return internal_drag() || user_drag(); }
 
    virtual bool internal_drag() const { return false; }
 
    bool track_drag() const { return internal_track_drag() || user_track_drag(); }
 
    virtual bool internal_track_drag() const { return false; }
 
    Rect m_box;
 
    Rect m_user_requested_box;
 
    Widget* m_parent{nullptr};
 
    WidgetId m_widgetid{0};
 
    EGT_NODISCARD bool parent_in_layout();
 
    void parent_layout();
 
    Size m_min_size;
 
    bool m_in_layout{false};
 
    void deserialize_leaf(Serializer::Properties& props);
 
    void draw_subordinate(Painter& painter, const Rect& crect, Widget* child);
 
    ChildDrawCallback m_special_child_draw_callback;
 
    using SubordinatesArray = std::list<std::shared_ptr<Widget>>;
 
    SubordinatesArray m_subordinates;
 
    EGT_NODISCARD const detail::Range<SubordinatesArray>& children() const
    {
        return m_children;
    }
 
    EGT_NODISCARD detail::Range<SubordinatesArray>& children()
    {
        return m_children;
    }
 
    detail::Range<SubordinatesArray> m_children;
 
    EGT_NODISCARD const detail::Range<SubordinatesArray>& components() const
    {
        return m_components;
    }
 
    EGT_NODISCARD detail::Range<SubordinatesArray>& components()
    {
        return m_components;
    }
 
    detail::Range<SubordinatesArray> m_components;
 
    void update_subordinates_ranges()
    {
        m_children.begin(m_subordinates.begin());
        m_children.end(m_components_begin);
        m_components.begin(m_components_begin);
        m_components.end(m_subordinates.end());
    }
 
    EGT_NODISCARD detail::Range<SubordinatesArray>& range_from_widget(const Widget& widget)
    {
        return widget.component() ? components() : children();
    }
 
    EGT_NODISCARD const detail::Range<SubordinatesArray>& range_from_widget(const Widget& widget) const
    {
        return widget.component() ? components() : children();
    }
 
    void add_component(Widget& widget);
 
    void remove_component(Widget* widget);
 
    void component(bool value);
 
    EGT_NODISCARD bool component() const;
    SubordinatesArray::iterator m_components_begin;
 
    Screen::DamageArray m_damage;
 
    bool m_in_draw{false};
 
private:
 
    std::unique_ptr<Palette> m_palette;
 
    ImageGroup m_backgrounds{"bg"};
 
    Widget::Flags m_widget_flags{};
 
    AlignFlags m_align{};
 
    DefaultDim m_padding{0};
 
    DefaultDim m_border{0};
 
    float m_border_radius{};
 
    Theme::BorderFlags m_border_flags{};
 
    DefaultDim m_margin{0};
 
    DefaultDim m_xratio{0};
 
    DefaultDim m_yratio{0};
 
    DefaultDim m_horizontal_ratio{0};
 
    DefaultDim m_vertical_ratio{0};
 
    bool m_focus{false};
 
    float m_alpha{1.0f};
 
    Theme::FillFlags m_fill_flags{};
 
    void init(void);
 
    std::unique_ptr<Font> m_font;
 
    void deserialize(Serializer::Properties& props);
 
    friend class Frame;
};
 
template<>
EGT_API const std::pair<Widget::Flag, char const*> detail::EnumStrings<Widget::Flag>::data[15];
 
EGT_API std::ostream& operator<<(std::ostream& os, const Widget::Flag& flag);
EGT_API std::ostream& operator<<(std::ostream& os, const Widget::Flags& flags);
 
}
}
 
#endif