valuewidget.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_VALUEWIDGET_H
#define EGT_VALUEWIDGET_H
 
#include <egt/signal.h>
#include <egt/widget.h>
 
namespace egt
{
inline namespace v1
{
 
template<class T>
class ValueWidget : public Widget
{
public:
 
    Signal<> on_value_changed;
    ValueWidget() = delete;
 
    explicit ValueWidget(const Rect& rect, T value = T()) noexcept
        : Widget(rect),
          m_value(value)
    {}
 
    T value(T v)
    {
        T orig = m_value;
        if (detail::change_if_diff<T>(m_value, v))
        {
            damage();
            on_value_changed.invoke();
        }
        return orig;
    }
 
    T value() const { return m_value; }
 
protected:
 
    T m_value;
};
 
template<class T>
class ValueRangeWidget : public Widget
{
public:
 
    Signal<> on_value_changed;
    ValueRangeWidget() = delete;
 
    ValueRangeWidget(const Rect& rect, T start, T end,
                     T value = T(), T step = T()) noexcept
        : Widget(rect),
          m_start(start),
          m_end(end),
          m_value(value),
          m_step(step)
    {
        set_value(m_value);
    }
 
    explicit ValueRangeWidget(Serializer::Properties& props)
        : ValueRangeWidget(props, false)
    {
    }
 
protected:
 
    explicit ValueRangeWidget(Serializer::Properties& props, bool is_derived)
        : Widget(props, true)
    {
        deserialize(props);
 
        if (!is_derived)
            deserialize_leaf(props);
    }
 
public:
 
    virtual T value(T value)
    {
        T orig = m_value;
 
        if (set_value(value))
        {
            damage();
            on_value_changed.invoke();
        }
 
        return orig;
    }
 
    EGT_NODISCARD T starting() const { return m_start; }
 
    EGT_NODISCARD T ending() const { return m_end; }
 
    EGT_NODISCARD T stepping() const { return m_step; }
 
    void starting(T v)
    {
        if (detail::change_if_diff<>(m_start, v))
        {
            damage();
            if (set_value(m_value))
                on_value_changed.invoke();
        }
    }
 
    void ending(T v)
    {
        if (detail::change_if_diff<>(m_end, v))
        {
            damage();
            if (set_value(m_value))
                on_value_changed.invoke();
        }
    }
 
    void stepping(T v)
    {
        if (detail::change_if_diff<>(m_step, v))
        {
            damage();
            if (set_value(m_value))
                on_value_changed.invoke();
        }
    }
 
    EGT_NODISCARD T value() const
    {
        return m_value;
    }
 
    void serialize(Serializer& serializer) const override;
 
protected:
 
    bool set_value(T v)
    {
        T value = v;
 
        if (!detail::float_equal(static_cast<float>(m_step), 0.f))
            value = std::round(static_cast<float>(value) / m_step) * m_step;
 
        if (m_start < m_end)
            value = detail::clamp<T>(value, m_start, m_end);
        else
            value = detail::clamp<T>(value, m_end, m_start);
 
        return detail::change_if_diff<>(m_value, value);
    }
 
    T m_start;
 
    T m_end;
 
    T m_value;
 
    T m_step;
 
private:
 
    void deserialize(Serializer::Properties& props);
};
 
template <class T>
void ValueRangeWidget<T>::serialize(Serializer& serializer) const
{
    Widget::serialize(serializer);
 
    Serializer::Attributes attrs =
    {
        {"starting", detail::to_string(starting())},
        {"ending", detail::to_string(ending())},
    };
 
    if (!detail::float_equal(static_cast<float>(m_step), 0.f))
        attrs.emplace_back("stepping", detail::to_string(stepping()));
 
    serializer.add_property("value", this->value(), attrs);
}
 
template <class T>
void ValueRangeWidget<T>::deserialize(Serializer::Properties& props)
{
    props.erase(std::remove_if(props.begin(), props.end(), [&](auto & p)
    {
        if (std::get<0>(p) == "value")
        {
            float starting_value = 0, ending_value = 100, stepping_value = 0;
            auto attrs = std::get<2>(p);
            for (auto& a : attrs)
            {
                switch (detail::hash(a.first))
                {
                case detail::hash("starting"):
                    starting_value = std::stof(a.second);
                    break;
                case detail::hash("ending"):
                    ending_value = std::stof(a.second);
                    break;
                case detail::hash("stepping"):
                    stepping_value = std::stof(a.second);
                    break;
                }
            }
 
            this->stepping(stepping_value);
            this->ending(ending_value);
            this->starting(starting_value);
            this->value(std::stof(std::get<1>(p)));
 
            return true;
        }
        return false;
    }), props.end());
}
 
}
}
 
#endif