theme.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_THEME_H
#define EGT_THEME_H
 
#include <egt/detail/enum.h>
#include <egt/detail/meta.h>
#include <egt/flags.h>
#include <egt/font.h>
#include <egt/geometry.h>
#include <egt/palette.h>
#include <functional>
#include <memory>
 
namespace egt
{
inline namespace v1
{
 
class Widget;
class Painter;
 
template<class T>
class Drawable
{
public:
 
    using DrawFunction = std::function<void(T& widget, Painter& painter, const Rect& rect)>;
 
    virtual void operator()(T& widget, Painter& painter, const Rect& rect) = 0;
};
 
class EGT_API DrawerReset
{
public:
    using ResetFunction = std::function<void()>;
 
    static inline void add(const ResetFunction& func)
    {
        m_reset_list.push_back(func);
    }
 
    static inline void reset()
    {
        for (auto& x : m_reset_list)
            x();
        m_reset_list.clear();
    }
 
private:
 
    static std::vector<ResetFunction> m_reset_list;
};
 
template<class T>
class Drawer
{
public:
 
    static void draw(typename Drawable<T>::DrawFunction d)
    {
        DrawerReset::add([]()
        {
            Drawer<T>::draw(T::default_draw);
        });
 
        m_drawable = d;
    }
 
    static void draw(T& widget, Painter& painter, const Rect& rect)
    {
        m_drawable(widget, painter, rect);
    }
 
private:
    static typename Drawable<T>::DrawFunction m_drawable;
};
 
template<class T>
// NOLINTNEXTLINE(cert-err58-cpp)
typename Drawable<T>::DrawFunction Drawer<T>::m_drawable = T::default_draw;
 
class Color;
 
class EGT_API Theme
{
public:
 
    enum class FillFlag : uint32_t
    {
        solid = detail::bit(0),
        blend = detail::bit(1),
    };
 
    using FillFlags = Flags<FillFlag>;
 
    enum class BorderFlag : uint32_t
    {
        top = detail::bit(0),
        right = detail::bit(1),
        bottom = detail::bit(2),
        left = detail::bit(3),
        drop_shadow = detail::bit(4),
    };
 
    using BorderFlags = Flags<BorderFlag>;
 
    Theme();
 
    Theme(const Theme&) = default;
    Theme& operator=(const Theme&) = default;
    Theme(Theme&&) noexcept = default;
    Theme& operator=(Theme&&) noexcept = default;
 
    EGT_NODISCARD const std::string& name() const { return m_name; }
 
    void name(const std::string& name) { m_name = name; }
 
    Palette& palette()
    {
        return m_palette;
    }
 
    const Palette& palette() const
    {
        return m_palette;
    }
 
    void palette(const Palette& palette)
    {
        m_palette = palette;
    }
 
    Font& font()
    {
        return m_font;
    }
 
    const Font& font() const
    {
        return m_font;
    }
 
    void font(const Font& font)
    {
        m_font = font;
    }
 
    virtual void draw_box(Painter& painter,
                          const Widget& widget,
                          Palette::ColorId bg,
                          Palette::ColorId border) const;
 
    virtual void draw_box(Painter& painter,
                          const FillFlags& type,
                          const Rect& rect,
                          const Pattern& border,
                          const Pattern& bg,
                          DefaultDim border_width = 0,
                          DefaultDim margin_width = 0,
                          float border_radius = 0.0,
                          const BorderFlags& border_flags = {},
                          Image* background = nullptr) const;
 
    virtual void draw_circle(Painter& painter,
                             const Widget& widget,
                             Palette::ColorId bg,
                             Palette::ColorId border) const;
 
    virtual void draw_circle(Painter& painter,
                             const FillFlags& type,
                             const Rect& rect,
                             const Pattern& border,
                             const Pattern& bg,
                             DefaultDim border_width = 0,
                             DefaultDim margin_width = 0) const;
 
    virtual DefaultDim default_border() const
    {
        return 2;
    }
 
    virtual float default_border_radius() const
    {
        return 4.0;
    }
 
    virtual void apply()
    {
        init_palette();
        init_font();
        init_draw();
    }
 
    virtual ~Theme() noexcept = default;
 
protected:
 
    explicit Theme(const std::string& name);
 
    inline void rounded_box(Painter& painter, const Rect& box, float border_radius) const
    {
        rounded_box(painter, RectF(box.x(), box.y(), box.width(), box.height()), border_radius);
    }
 
    virtual void rounded_box(Painter& painter, const RectF& box, float border_radius) const;
 
    Palette m_palette;
 
    std::string m_name;
 
    Font m_font;
 
    virtual void init_palette();
 
    virtual void init_font();
 
    virtual void init_draw();
};
 
inline Theme::BorderFlags operator|(Theme::BorderFlag lhs, Theme::BorderFlag rhs)
{
    return {lhs, rhs};
}
 
template<>
EGT_API const std::pair<Theme::FillFlag, char const*> detail::EnumStrings<Theme::FillFlag>::data[2];
 
template<>
EGT_API const std::pair<Theme::BorderFlag, char const*> detail::EnumStrings<Theme::BorderFlag>::data[5];
 
EGT_API Theme& global_theme();
 
EGT_API void global_theme(std::unique_ptr<Theme>&& theme);
 
}
}
 
#endif