label.hpp

Go to the documentation of this file.

// Copyright Take Vos 2020-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 "utility/module.hpp"
#include "strings.hpp"
#include "l10n/module.hpp"
#include "unicode/gstring.hpp"
#include "image/module.hpp"
#include "font/module.hpp"
#include <string>
#include <type_traits>
#include <memory>
#include <variant>
 
namespace hi::inline v1 {
 
class text : public std::variant<std::monostate, std::string, gstring, translate> {
    using std::variant<std::monostate, std::string, gstring, translate>::variant;
 
    [[nodiscard]] constexpr friend bool to_bool(text const& rhs) noexcept
    {
        return not std::holds_alternative<std::monostate>(rhs);
    }
 
    
 
    [[nodiscard]] constexpr friend gstring to_gstring(hi::text const& rhs) noexcept
    {
        // clang-format off
        return std::visit(
            overloaded{
                [](std::monostate const &) { return gstring{}; },
                [](std::string const &x) { return to_gstring(std::string_view{x}); },
                [](gstring const &x) { return x; },
                [](translate const &x) { return x(); }
            },
            rhs);
        // clang-format on
    }
 
    [[nodiscard]] constexpr friend std::string to_string(hi::text const& rhs) noexcept
    {
        return to_string(to_gstring(rhs));
    }
};
 
class icon : public std::variant<std::monostate, elusive_icon, hikogui_icon, glyph_ids, pixmap<sfloat_rgba16>>
{
    using std::variant<std::monostate, elusive_icon, hikogui_icon, glyph_ids, pixmap<sfloat_rgba16>>::variant;
 
    [[nodiscard]] constexpr friend bool to_bool(icon const& rhs) noexcept
    {
        return not std::holds_alternative<std::monostate>(rhs);
    }
};
 
} // namespace hi::inline v1
 
template<typename CharT>
struct std::formatter<hi::text, CharT> : std::formatter<std::string_view, CharT> {
    auto format(hi::text const& t, auto& fc)
    {
        return std::formatter<std::string_view, CharT>::format(to_string(t), fc);
    }
};
 
namespace hi::inline v1 {
 
class label {
public:
    hi::icon icon;
 
    hi::text text;
 
    constexpr label(std::convertible_to<hi::icon> auto&& icon, std::convertible_to<hi::text> auto&& text) noexcept :
        icon(hi_forward(icon)), text(hi_forward(text))
    {
    }
 
    constexpr label(std::convertible_to<hi::text> auto&& text) noexcept : icon(), text(hi_forward(text)) {}
 
    constexpr label(std::convertible_to<hi::icon> auto&& icon) noexcept : icon(hi_forward(icon)), text() {}
 
    constexpr label() noexcept : icon(), text() {}
 
    constexpr label(label const& other) noexcept = default;
    constexpr label& operator=(label const& other) noexcept = default;
    constexpr label(label&& other) noexcept = default;
    constexpr label& operator=(label&& other) noexcept = default;
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return not(to_bool(icon) or to_bool(text));
    }
 
    constexpr explicit operator bool() const noexcept
    {
        return not empty();
    }
 
    [[nodiscard]] constexpr friend bool operator==(label const& lhs, label const& rhs) noexcept = default;
};
 
template<>
struct selector<label> {
    template<fixed_string>
    [[nodiscard]] auto& get(label&) const noexcept;
 
    template<>
    [[nodiscard]] auto& get<"text">(label& rhs) const noexcept
    {
        return rhs.text;
    }
 
    template<>
    [[nodiscard]] auto& get<"icon">(label& rhs) const noexcept
    {
        return rhs.icon;
    }
};
 
} // namespace hi::inline v1
 
template<typename CharT>
struct std::formatter<hi::label, CharT> : std::formatter<hi::text, CharT> {
    auto format(hi::label const& t, auto& fc)
    {
        return std::formatter<hi::text, CharT>::format(t.text, fc);
    }
};