radial.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_RADIAL_H
#define EGT_RADIAL_H
 
#include <algorithm>
#include <egt/detail/math.h>
#include <egt/detail/meta.h>
#include <egt/flags.h>
#include <egt/frame.h>
#include <egt/painter.h>
#include <egt/signal.h>
#include <egt/text.h>
#include <egt/value.h>
#include <egt/widget.h>
#include <memory>
#include <string>
#include <vector>
 
namespace egt
{
inline namespace v1
{
namespace experimental
{
 
template<class T>
class RadialType : public Widget
{
public:
 
    Signal<> on_user_input_changed;
    enum class RadialFlag
    {
        text_value = detail::bit(0),
 
        rounded_cap = detail::bit(1),
 
        input_value = detail::bit(2),
    };
 
    using RadialFlags = egt::Flags<RadialFlag>;
 
    explicit RadialType(const Rect& rect = {}) noexcept
        : Widget(rect)
    {
        this->name("Radial" + std::to_string(m_widgetid));
        this->grab_mouse(true);
    }
 
    explicit RadialType(Frame& parent, const Rect& rect = {}) noexcept
        : RadialType<T>(rect)
    {
        parent.add(*this);
    }
 
    explicit RadialType(Serializer::Properties& props) noexcept
        : RadialType(props, false)
    {
    }
 
protected:
 
    explicit RadialType(Serializer::Properties& props, bool is_derived) noexcept
        : Widget(props, true)
    {
        this->name("Radial" + std::to_string(m_widgetid));
        this->grab_mouse(true);
 
        if (!is_derived)
            deserialize_leaf(props);
    }
 
public:
 
    Object::RegisterHandle add(const std::shared_ptr<RangeValue<T>>& range,
                               const Pattern& color = {},
                               DefaultDim width = 10,
                               RadialFlags flags = {})
    {
        // TODO: m_handle_counter can wrap, making the handle non-unique
        auto handle = ++this->m_handle_counter;
        this->m_values.emplace_back(range, color, width, flags, handle);
 
        // when a value changes, damage
        range->on_value_changed([this, flags]()
        {
            this->damage();
        });
 
        damage();
 
        return handle;
    }
 
    void remove(Object::RegisterHandle handle)
    {
        auto i = std::find_if(this->m_values.begin(), this->m_values.end(),
                              [&handle](const auto & obj)
        {
            return obj->handle == handle;
        });
 
        if (i != this->m_values.end())
        {
            this->m_values.erase(i);
            damage();
        }
    }
 
    using Widget::color;
 
    void color(Object::RegisterHandle handle, const Pattern& color)
    {
        for (auto& value : this->m_values)
        {
            if (value.handle == handle)
            {
                value.color = color;
                this->damage();
                break;
            }
        }
    }
 
    EGT_NODISCARD const std::string& text() const { return m_text; }
 
    void text(const std::string& text)
    {
        if (detail::change_if_diff<>(m_text, text))
            this->damage();
    }
 
    void handle(Event& event) override
    {
        Widget::handle(event);
 
        switch (event.id())
        {
        case EventId::pointer_click:
        case EventId::pointer_drag:
        {
            bool changed = false;
            auto angle = this->touch_to_degrees(this->display_to_local(event.pointer().point));
 
            for (auto& value : this->m_values)
            {
                if (value.flags.is_set(RadialFlag::input_value))
                {
                    auto v = this->degrees_to_value(value.range->start(),
                                                    value.range->end(),
                                                    angle);
                    if (value.range->value(v))
                        changed = true;
                }
            }
 
            if (changed)
                this->on_user_input_changed.invoke();
        }
        default:
            break;
        }
    }
 
    void draw(Painter& painter, const Rect& rect) override
    {
        Drawer<RadialType<T>>::draw(*this, painter, rect);
    }
 
    static void default_draw(RadialType<T>& widget, Painter& painter, const Rect& rect)
    {
        detail::ignoreparam(rect);
 
        widget.draw_box(painter, Palette::ColorId::bg, Palette::ColorId::border);
 
        const auto b = widget.content_area();
        const auto c = b.center();
        auto text = widget.text();
        const auto smalldim = std::min(b.width(), b.height());
 
        DefaultDim maxwidth = 0;
        for (auto& value : widget.m_values)
        {
            if (value.width > maxwidth)
                maxwidth = value.width;
        }
 
        for (auto& value : widget.m_values)
        {
            const auto radius = smalldim * 0.5f - (maxwidth * 0.5f);
            const auto angle1 = detail::to_radians<float>(-90, widget.start_angle());
            const auto angle2 = detail::to_radians<float>(-90,
                                widget.value_to_degrees(value.range->start(),
                                        value.range->end(),
                                        value.range->value()));
 
            painter.set(value.color);
            painter.line_width(value.width);
            auto cr = painter.context().get();
            if (value.flags.is_set(RadialFlag::rounded_cap))
                cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
            else
                cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
 
            painter.draw(Arc(c, radius, angle1, angle2));
            painter.stroke();
 
            if (value.flags.is_set(RadialFlag::text_value))
            {
                text = std::to_string(value.range->value());
            }
        }
 
        if (!text.empty())
        {
            auto target = Rect(Size(smalldim, smalldim));
            target.move_to_center(b.center());
            auto font = TextWidget::scale_font(target.size(), text,
                                               widget.font());
 
            detail::draw_text(painter,
                              widget.content_area(),
                              text,
                              font,
                              {},
                              AlignFlag::center,
                              Justification::middle,
                              widget.color(Palette::ColorId::label_text));
        }
    }
 
    EGT_NODISCARD float touch_to_degrees(const Point& point) const
    {
        const auto b = this->content_area();
        const Point c = b.center();
        auto radians = c.angle_to<float>(point);
        float angle = detail::to_degrees(radians);
        if (angle < 0)
            angle = angle + 360.0f;
        return angle;
    }
 
    EGT_NODISCARD T value_to_degrees(T min, T max, T value) const
    {
        const auto n = (static_cast<float>(value) -
                        static_cast<float>(min)) /
                       (static_cast<float>(max) - static_cast<float>(min));
        return n * 360.0f;
    }
 
    EGT_NODISCARD T degrees_to_value(T min, T max, T degrees) const
    {
        const auto n = degrees / 360.;
        return (n * (max - min)) + min;
    }
 
    EGT_NODISCARD float start_angle() const
    {
        return m_start_angle;
    }
 
    void start_angle(float value)
    {
        m_start_angle = value;
    }
 
protected:
 
    bool internal_drag() const override { return true; }
 
    template<class T2>
    struct ValueData
    {
        ValueData(std::shared_ptr<RangeValue<T2>> r,
                  Pattern c,
                  size_t w = 10,
                  // NOLINTNEXTLINE(modernize-pass-by-value)
                  RadialFlags f = {},
                  Object::RegisterHandle h = 0) noexcept
            : range(std::move(r)),
              color(std::move(c)),
              width(w),
              flags(f),
              handle(h)
        {}
 
        std::shared_ptr<RangeValue<T2>> range;
        Pattern color;
        DefaultDim width{};
        RadialFlags flags{};
        Object::RegisterHandle handle{0};
    };
 
    std::string m_text;
 
    std::vector<ValueData<T>> m_values;
 
    Object::RegisterHandle m_handle_counter{0};
 
    float m_start_angle{0.f};
};
 
using Radial = RadialType<int>;
 
using RadialF = RadialType<float>;
 
}
 
template<>
EGT_API const std::pair<experimental::Radial::RadialFlag, char const*> detail::EnumStrings<experimental::Radial::RadialFlag>::data[3];
 
}
}
 
#endif