spk_numeric_spin_box.hpp

#pragma once
 
#include <algorithm>
#include <charconv>
#include <limits>
#include <sstream>
#include <string>
#include <type_traits>
 
#include "structure/container/spk_expected.hpp"
#include "structure/math/spk_vector2.hpp"
#include "structure/widget/spk_icon_button.hpp"
#include "structure/widget/spk_linear_layout.hpp"
#include "structure/widget/spk_text_edit.hpp"
#include "structure/widget/spk_widget.hpp"
 
namespace spk
{
    template <typename TType>
    class NumericSpinBox : public spk::Widget
    {
        static_assert(std::is_arithmetic_v<TType>, "NumericSpinBox requires an arithmetic type.");
 
    public:
        using value_type = TType;

        using ValidationState = spk::TextEdit::ValidationState;
        using ValidationStatus = spk::TextEdit::ValidationStatus;
        using ValidationCallback = spk::TextEdit::ValidationCallback;

        using EditionJob = spk::ObservableValue<value_type>::Job;
        using EditionContract = spk::ObservableValue<value_type>::Contract;

        using ParseResult = spk::Expected<value_type, ValidationState>;
 
    private:
        spk::HorizontalLayout _layout;
        TextEdit _valueEdit;
        TextEdit::EditionContract _onTextEditionContract;
 
        IconButton _raiseButton;
        IconButton _lowerButton;
        IconButton::Contract _raiseContract;
        IconButton::Contract _lowerContract;
 
        spk::ObservableValue<value_type> _value{};
        value_type _step{1};
 
        uint32_t _minimalTextEditSize = 0;
 
    private:
        static bool _isEmptyOrSignOnly(const std::wstring &p_text)
        {
            if (p_text.empty() == true)
            {
                return true;
            }
 
            if (p_text == L"-" || p_text == L"+")
            {
                return true;
            }
 
            if constexpr (std::is_floating_point_v<value_type>)
            {
                if (p_text == L"." || p_text == L"-." || p_text == L"+.")
                {
                    return true;
                }
            }
 
            return false;
        }
 
        static bool _hasError(const ParseResult &p_result)
        {
            return (p_result.reportStatus().value() != ValidationState::Valid);
        }
 
        static ParseResult _makeParseError(ValidationState p_state, const std::wstring &p_message)
        {
            return ParseResult::generateReport(p_state, p_message);
        }
 
        ValidationStatus _validateTextForTextEdit(const std::wstring &p_text) const
        {
            const ParseResult parsed = _parseValue(p_text);
 
            return ValidationStatus(
                parsed.reportStatus().value(),
                parsed.reportStatus().status());
        }
 
        static ParseResult _parseValue(const std::wstring &p_text)
        {
            if (_isEmptyOrSignOnly(p_text) == true)
            {
                return _makeParseError(ValidationState::Undefined, L"NumericSpinBox value is undefined.");
            }
 
            if constexpr (std::is_unsigned_v<value_type>)
            {
                if (p_text.empty() == false && p_text.front() == L'-')
                {
                    return _makeParseError(ValidationState::Invalid, L"Unsigned NumericSpinBox does not accept negative values.");
                }
            }
 
            // Integers: prefer from_chars (fast, strict).
            if constexpr (std::is_integral_v<value_type>)
            {
                std::string narrow;
                narrow.reserve(p_text.size());
                for (wchar_t c : p_text)
                {
                    if (c > 127)
                    {
                        return _makeParseError(ValidationState::Invalid, L"NumericSpinBox value contains invalid characters.");
                    }
                    narrow.push_back(static_cast<char>(c));
                }
 
                value_type v{};
                const char *begin = narrow.data();
                const char *end = narrow.data() + narrow.size();
 
                auto [ptr, ec] = std::from_chars(begin, end, v, 10);
                if (ec != std::errc() || ptr != end)
                {
                    return _makeParseError(ValidationState::Invalid, L"Failed to parse NumericSpinBox value.");
                }
 
                return ParseResult(v, ValidationState::Valid, L"");
            }
            // Floating: use strict stream parse and ensure full consumption.
            else
            {
                std::wistringstream stream(p_text);
                value_type v{};
                stream >> v;
 
                if (stream.fail() == true)
                {
                    return _makeParseError(ValidationState::Invalid, L"Failed to parse NumericSpinBox value.");
                }
 
                stream >> std::ws;
                if (stream.eof() == false)
                {
                    return _makeParseError(ValidationState::Invalid, L"NumericSpinBox value contains invalid characters.");
                }
 
                return ParseResult(v, ValidationState::Valid, L"");
            }
        }
 
        static std::wstring _formatValue(const value_type &p_value)
        {
            // std::to_wstring is fine; if you later want nicer formatting, change it here.
            return std::to_wstring(p_value);
        }
 
        void _syncValueFromTextIfValid()
        {
            const ParseResult parsed = _parseValue(_valueEdit.text());
            if (_hasError(parsed) == false)
            {
                _value = parsed.value();
            }
        }
 
    protected:
        void _onGeometryChange() override
        {
            _raiseButton.sizeHint().setDesired({geometry().size.y, geometry().size.y});
            _lowerButton.sizeHint().setDesired({geometry().size.y, geometry().size.y});
 
            _layout.setGeometry(geometry().atOrigin());
        }
 
    public:
        NumericSpinBox(const std::wstring &p_name, spk::Widget *p_parent) :
            spk::Widget(p_name, p_parent),
            _valueEdit(p_name + L"/TextEdit", this),
            _raiseButton(p_name + L"/RaiseButton", this),
            _lowerButton(p_name + L"/LowerButton", this)
        {
            _layout.addElement(&_valueEdit, spk::Layout::SizePolicy::Extend);
            _layout.addElement(&_lowerButton, spk::Layout::SizePolicy::Desired);
            _layout.addElement(&_raiseButton, spk::Layout::SizePolicy::Desired);
 
            _valueEdit.activate();
            _raiseButton.activate();
            _lowerButton.activate();
 
            _raiseButton.setIconTexture(Widget::Style::defaultIconset);
            _lowerButton.setIconTexture(Widget::Style::defaultIconset);
 
            _raiseButton.setIconSpriteID({5, 0});
            _lowerButton.setIconSpriteID({4, 0});
 
            _raiseButton.setIconPadding({2, 2});
            _lowerButton.setIconPadding({2, 2});
 
            _valueEdit.setValidationCallback([this](const std::wstring &p_text) {
                return _validateTextForTextEdit(p_text);
            });
 
            _onTextEditionContract = _valueEdit.subscribeToEdition([this](const std::wstring &) {
                _syncValueFromTextIfValid();
            });
 
            _raiseContract = _raiseButton.subscribe([this]() {
                increase();
            });
            _lowerContract = _lowerButton.subscribe([this]() {
                decrease();
            });
 
            setValue(_value);
 
            sizeHint().configureMinimalGenerator([&]() {
                return _layout.sizeHint().minimal();
            });
 
            sizeHint().configureMaximalGenerator([&]() {
                return _layout.sizeHint().maximal();
            });
 
            sizeHint().configureDesiredGenerator([&]() {
                return _layout.sizeHint().desired();
            });
        }

        EditionContract subscribeToEdition(const EditionJob &p_job)
        {
            return _value.onEdition().subscribe(p_job);
        }

        void setMinimalTextEditSize(uint32_t p_minimalTextEditSize)
        {
            _valueEdit.sizeHint().release();
            spk::Vector2UInt minimalTextSize = _valueEdit.sizeHint().minimal();
            _valueEdit.sizeHint().setMinimal({std::max(minimalTextSize.x, p_minimalTextEditSize), minimalTextSize.y});
 
            _layout.sizeHint().release();
            sizeHint().release();
        }

        void setValue(const value_type &p_value)
        {
            _value = p_value;
 
            // Keep TextEdit as the single source of display.
            _valueEdit.setText(_formatValue(_value));
 
            _layout.sizeHint().release();
            sizeHint().release();
        }

        const value_type &value() const
        {
            return _value.get();
        }

        void setStep(const value_type &p_step)
        {
            _step = p_step;
        }

        const value_type &step() const
        {
            return _step;
        }

        void increase()
        {
            setValue(static_cast<value_type>(_value + _step));
        }

        void decrease()
        {
            setValue(static_cast<value_type>(_value - _step));
        }

        TextEdit &valueEdit()
        {
            return _valueEdit;
        }

        const TextEdit &valueEdit() const
        {
            return _valueEdit;
        }

        IconButton &raiseButton()
        {
            return _raiseButton;
        }

        IconButton &lowerButton()
        {
            return _lowerButton;
        }
    };
 
    using FloatSpinBox = NumericSpinBox<float>;
    using IntSpinBox = NumericSpinBox<int>;
    using UnsignedIntSpinBox = NumericSpinBox<unsigned int>;
}