text_field_delegate.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 "../observer/observer.hpp"
#include "../utility/utility.hpp"
#include "../concurrency/concurrency.hpp"
#include "../dispatch/dispatch.hpp"
#include "../GUI/GUI.hpp"
#include "../macros.hpp"
#include "../l10n/l10n.hpp"
#include "../macros.hpp"
#include <string>
#include <string_view>
#include <optional>
#include <concepts>
 
hi_export_module(hikogui.widgets.text_field_delegate);
 
hi_export namespace hi { inline namespace v1 {
 
class text_field_delegate {
public:
    using notifier_type = notifier<void()>;
 
    virtual ~text_field_delegate() = default;
    virtual void init(widget_intf const& sender) noexcept {}
    virtual void deinit(widget_intf const& sender) noexcept {}
 
    virtual label validate(widget_intf const& sender, gstring const& text) noexcept
    {
        return {};
    }
 
    virtual gstring text(widget_intf const& sender) noexcept
    {
        return {};
    }
 
    virtual void set_text(widget_intf const& sender, gstring const& text) noexcept {}
 
    template<forward_of<void()> Func>
    callback<void()> subscribe(Func&& func, callback_flags flags = callback_flags::synchronous) noexcept
    {
        return _notifier.subscribe(std::forward<Func>(func), flags);
    }
 
protected:
    notifier_type _notifier;
};
 
template<typename T>
class default_text_field_delegate;
 
template<std::integral T>
class default_text_field_delegate<T> : public text_field_delegate {
public:
    using value_type = T;
 
    observer<value_type> value;
 
    template<forward_of<observer<value_type>> Value>
    default_text_field_delegate(Value&& value) noexcept : value(std::forward<Value>(value))
    {
        _value_cbt = this->value.subscribe([&](auto...) {
            this->_notifier();
        });
    }
 
    label validate(widget_intf const& sender, gstring const& text) noexcept override
    {
        try {
            [[maybe_unused]] auto dummy = from_string<value_type>(to_string(text), 10);
        } catch (parse_error const&) {
            return {txt("Invalid integer")};
        }
 
        return {};
    }
 
    gstring text(widget_intf const& sender) noexcept override
    {
        return to_gstring(to_string(*value));
    }
 
    void set_text(widget_intf const& sender, gstring const& text) noexcept override
    {
        try {
            value = from_string<value_type>(to_string(text), 10);
        } catch (std::exception const&) {
            // Ignore the error, don't modify the value.
            return;
        }
    }
 
private:
    callback<void(value_type)> _value_cbt;
};
 
template<std::floating_point T>
class default_text_field_delegate<T> : public text_field_delegate {
public:
    using value_type = T;
 
    observer<value_type> value;
 
    template<forward_of<observer<value_type>> Value>
    default_text_field_delegate(Value&& value) noexcept : value(std::forward<Value>(value))
    {
        _value_cbt = this->value.subscribe([&](auto...) {
            this->_notifier();
        });
    }
 
    label validate(widget_intf const& sender, gstring const& text) noexcept override
    {
        try {
            [[maybe_unused]] auto dummy = from_string<value_type>(to_string(text));
        } catch (parse_error const&) {
            return {elusive_icon::WarningSign, txt("Invalid floating point number")};
        }
 
        return {};
    }
 
    gstring text(widget_intf const& sender) noexcept override
    {
        return to_gstring(to_string(*value));
    }
 
    void set_text(widget_intf const& sender, gstring const& text) noexcept override
    {
        try {
            value = from_string<value_type>(to_string(text));
        } catch (std::exception const&) {
            // Ignore the error, don't modify the value.
            return;
        }
    }
 
private:
    callback<void(value_type)> _value_cbt;
};
 
template<typename Value>
[[nodiscard]] std::shared_ptr<text_field_delegate> make_default_text_field_delegate(Value&& value) noexcept
    requires requires { default_text_field_delegate<observer_decay_t<decltype(value)>>{std::forward<Value>(value)}; }
{
    using value_type = observer_decay_t<Value>;
    return std::make_shared<default_text_field_delegate<value_type>>(std::forward<Value>(value));
}
 
}} // namespace hi::v1