gauge.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_GAUGE_H
#define EGT_GAUGE_H
 
#include <egt/color.h>
#include <egt/detail/math.h>
#include <egt/detail/meta.h>
#include <egt/frame.h>
#include <egt/image.h>
#include <egt/widget.h>
#include <memory>
#include <vector>
 
namespace egt
{
inline namespace v1
{
namespace experimental
{
class Gauge;
 
class EGT_API GaugeLayer : public Widget
{
public:
 
    explicit GaugeLayer(const Image& image = {}) noexcept;
 
    explicit GaugeLayer(Gauge& gauge, const Image& image = {}) noexcept;
 
    void draw(Painter& painter, const Rect& rect) override;
 
    void image(const Image& image)
    {
        m_image = image;
        resize(m_image.size());
        damage();
    }
 
    void mask_color(const Color& color)
    {
        if (detail::change_if_diff<>(m_mask_color, color))
            damage();
    }
 
    EGT_NODISCARD Gauge* gauge() const { return m_gauge; }
 
protected:
 
    virtual void gauge(Gauge* gauge)
    {
        if (!m_gauge || !gauge)
        {
            if (detail::change_if_diff<>(m_gauge, gauge))
                damage();
        }
    }
 
    Image m_image;
 
    Gauge* m_gauge{nullptr};
 
    Color m_mask_color;
 
    friend class Gauge;
};
 
class EGT_API NeedleLayer : public GaugeLayer
{
public:
 
    Signal<> on_value_changed;
    using GaugeLayer::GaugeLayer;
 
    explicit NeedleLayer(const Image& image,
                         float min,
                         float max,
                         float angle_start = 0,
                         float angle_stop = 360,
                         bool clockwise = true) noexcept;
 
    void draw(Painter& painter, const Rect& rect) override;
 
    EGT_NODISCARD float angle_start() const { return m_angle_start; }
 
    float angle_start(float angle_start)
    {
        float orig = m_angle_start;
        if (detail::change_if_diff<float>(m_angle_start, angle_start))
            damage();
        return orig;
    }
 
    EGT_NODISCARD float angle_stop() const { return m_angle_stop; }
 
    float angle_stop(float angle_stop)
    {
        float orig = m_angle_stop;
        if (detail::change_if_diff<float>(m_angle_stop, angle_stop))
            damage();
        return orig;
    }
 
    EGT_NODISCARD float min() const { return m_min; }
 
    float min(float min)
    {
        float orig = m_min;
        if (detail::change_if_diff<float>(m_min, min))
        {
            value(m_value);
            damage();
        }
 
        return orig;
    }
 
    EGT_NODISCARD float max() const { return m_max; }
 
    float max(float max)
    {
        float orig = m_max;
        if (detail::change_if_diff<float>(m_max, max))
        {
            value(m_value);
            damage();
        }
 
        return orig;
    }
 
    EGT_NODISCARD float value() const { return m_value; }
 
    float value(float value)
    {
        auto orig = m_value;
 
        value = std::round(detail::clamp<float>(value, m_min, m_max));
 
        if (!detail::float_equal(m_value, value))
        {
            damage(rectangle_of_rotated());
            m_value = value;
            on_value_changed.invoke();
            damage(rectangle_of_rotated());
        }
 
        return orig;
    }
 
    EGT_NODISCARD PointF needle_point() const { return m_point; }
 
    void needle_point(const PointF& point)
    {
        if (detail::change_if_diff<PointF>(m_point, point))
        {
            auto dim = std::max(m_image.width(), m_image.height());
            auto circle = Circle(Point(m_point.x(), m_point.y()), dim);
            auto superrect = circle.rect();
 
            // real widget size is the big rect, center is a common point
            resize(superrect.size());
            move_to_center(superrect.center());
        }
    }
 
    EGT_NODISCARD PointF needle_center() const { return m_center; }
 
    void needle_center(const PointF& center)
    {
        if (detail::change_if_diff<PointF>(m_center, center))
            damage();
    }
 
    EGT_NODISCARD bool clockwise() const { return m_clockwise; }
 
    void clockwise(bool value)
    {
        if (detail::change_if_diff<>(m_clockwise, value))
            damage();
    }
 
protected:
 
    Rect rectangle_of_rotated();
 
    void gauge(Gauge* gauge) override;
 
    float m_min{0.0};
 
    float m_max{0.0};
 
    float m_value{0.0};
 
    float m_angle_start{0.0};
 
    float m_angle_stop{360.0};
 
    bool m_clockwise{true};
 
    PointF m_center;
 
    PointF m_point;
};
 
// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
class EGT_API Gauge : public Frame
{
public:
 
    explicit Gauge(const Rect& rect = {},
                   const Flags& flags = {}) noexcept;
 
    Gauge(Frame& parent, const Rect& rect,
          const Flags& flags = {}) noexcept;
 
    using Frame::add;
 
    void add(const std::shared_ptr<GaugeLayer>& layer);
 
    void add(GaugeLayer& layer)
    {
        // Nasty, but it gets the job done.  If a widget is passed in as a
        // reference, we don't own it, so create a "pointless" shared_ptr that
        // will not delete it.
        auto w = std::shared_ptr<GaugeLayer>(&layer, [](GaugeLayer*) {});
        add(w);
    }
 
    using Frame::remove;
 
    void remove(GaugeLayer* layer);
 
    ~Gauge() noexcept override;
 
protected:
 
    EGT_NODISCARD Size super_size() const
    {
        Rect result = content_area().size();
        for (const auto& layer : m_layers)
            result = Rect::merge(result, layer->box() + Size(moat() * 2, moat() * 2));
        return result.size();
    }
 
    using LayerArray = std::vector<std::shared_ptr<GaugeLayer>>;
 
    LayerArray m_layers;
};
 
}
}
}
 
#endif