radio_button_widget.hpp

Go to the documentation of this file.

// Copyright Take Vos 2021-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "abstract_button_widget.hpp"
 
namespace hi { inline namespace v1 {
 
template<fixed_string Name = "">
class radio_button_widget final : public abstract_button_widget<Name / "radio-button"> {
public:
    using super = abstract_button_widget<Name / "radio-button">;
    using delegate_type = typename super::delegate_type;
    constexpr static auto prefix = super::prefix;
 
    radio_button_widget(
        widget *parent,
        std::shared_ptr<delegate_type> delegate,
        button_widget_attribute auto&&...attributes) noexcept :
        super(parent, std::move(delegate))
    {
        this->alignment = alignment::top_left();
        this->set_attributes<0>(hi_forward(attributes)...);
    }
 
    template<
        different_from<std::shared_ptr<delegate_type>> Value,
        forward_of<observer<observer_decay_t<Value>>> OnValue,
        button_widget_attribute... Attributes>
    radio_button_widget(widget *parent, Value&& value, OnValue&& on_value, Attributes&&...attributes) noexcept
        requires requires { make_default_radio_button_delegate(hi_forward(value), hi_forward(on_value)); }
        :
        radio_button_widget(
            parent,
            make_default_radio_button_delegate(hi_forward(value), hi_forward(on_value)),
            hi_forward(attributes)...)
    {
    }
 
    [[nodiscard]] box_constraints update_constraints() noexcept override
    {
        _label_constraints = super::update_constraints();
 
        // Make room for button and margin.
        _button_size = theme<prefix>.size(this);
        hi_axiom(button_size.width() == button_size.height());
 
        hilet extra_size = extent2i{theme<prefix>.horizontal_spacing(this) + _button_size.width(), 0};
 
        auto constraints = max(_label_constraints + extra_size, _button_size);
        constraints.margins = theme<prefix>.margin(this);
        constraints.alignment = *this->alignment;
        return constraints;
    }
 
    void set_layout(widget_layout const& context) noexcept override
    {
        if (compare_store(this->layout, context)) {
            auto alignment_ = os_settings::left_to_right() ? *this->alignment : mirror(*this->alignment);
 
            if (alignment_ == horizontal_alignment::left or alignment_ == horizontal_alignment::right) {
                _button_rectangle = align(context.rectangle(), _button_size, alignment_);
            } else {
                hi_not_implemented();
            }
 
            hilet inner_margin = theme<prefix>.horizontal_spacing(this);
            hilet cap_height = theme<prefix>.cap_height(this);
 
            hilet label_width = context.width() - (_button_rectangle.width() + inner_margin);
            if (alignment_ == horizontal_alignment::left) {
                hilet label_left = _button_rectangle.right() + inner_margin;
                hilet label_rectangle = aarectanglei{label_left, 0, label_width, context.height()};
                this->_on_label_shape = this->_off_label_shape = this->_other_label_shape =
                    box_shape{_label_constraints, label_rectangle, cap_height};
 
            } else if (alignment_ == horizontal_alignment::right) {
                hilet label_rectangle = aarectanglei{0, 0, label_width, context.height()};
                this->_on_label_shape = this->_off_label_shape = this->_other_label_shape =
                    box_shape{_label_constraints, label_rectangle, cap_height};
 
            } else {
                hi_not_implemented();
            }
 
            _button_circle = circle{narrow_cast<aarectangle>(_button_rectangle)};
 
            _pip_size = theme<prefix / "pip">.size(this);
            hi_axiom(_pip_size.width() == _pip_size.height());
 
            _pip_circle =
                align(narrow_cast<aarectangle>(_button_rectangle), circle{_pip_size.width() / 2}, alignment::middle_center());
        }
        super::set_layout(context);
    }
 
    void draw(widget_draw_context const& context) noexcept override
    {
        if (*this->mode > widget_mode::invisible and overlaps(context, this->layout)) {
            draw_radio_button(context);
            draw_radio_pip(context);
            this->draw_button(context);
        }
    }
private:
    static constexpr std::chrono::nanoseconds _animation_duration = std::chrono::milliseconds(150);
 
    box_constraints _label_constraints;
 
    extent2i _button_size;
    aarectanglei _button_rectangle;
    circle _button_circle;
 
    animator<float> _animated_value = _animation_duration;
    circle _pip_circle;
 
    void draw_radio_button(widget_draw_context const& context) noexcept
    {
        context.draw_circle(
            this->layout,
            _button_circle * 1.02f,
            theme<prefix>.background_color(this),
            theme<prefix>.border_color(this),
            theme<prefix>.border_width(this),
            border_side::inside);
    }
 
    void draw_radio_pip(widget_draw_context const& context) noexcept
    {
        _animated_value.update(this->state != widget_state::off ? 1.0f : 0.0f, context.display_time_point);
        if (_animated_value.is_animating()) {
            this->request_redraw();
        }
 
        // draw pip
        auto float_value = _animated_value.current_value();
        if (float_value > 0.0f) {
            context.draw_circle(
                this->layout,
                _pip_circle * 1.02f * float_value,
                theme<prefix / "pip">.background_color(this),
                theme<prefix / "pip">.border_color(this),
                theme<prefix / "pip">.border_width(this));
        }
    }
};
 
}} // namespace hi::v1