component_view.h

Go to the documentation of this file.

#pragma once
#include <functional>
#include <optional>
#include <unordered_map>
#include <vector>
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
#include "webcface/common/val_adaptor.h"
#include "webcface/text.h"
 
#ifdef min
// clang-format off
#pragma message("warning: Disabling macro definition of 'min' and 'max', since they conflicts in webcface/component_view.h.")
// clang-format on
#undef min
#undef max
#endif
 
extern "C" {
typedef struct wcfViewComponent wcfViewComponent;
typedef struct wcfViewComponentW wcfViewComponentW;
typedef struct wcfMultiVal wcfMultiVal;
typedef struct wcfMultiValW wcfMultiValW;
}
WEBCFACE_NS_BEGIN
namespace message {
struct ViewComponentData;
}
namespace internal {
struct TemporalViewComponentData;
struct ClientData;
class ViewBuf;
} // namespace internal
class Func;
class FuncListener;
 
enum class ViewColor {
    inherit = 0,
    black = 1,
    white = 2,
    // slate = 3,
    gray = 4,
    // zinc = 5,
    // neutral = 6,
    // stone = 7,
    red = 8,
    orange = 9,
    // amber = 10,
    yellow = 11,
    // lime = 12,
    green = 13,
    // emerald = 14,
    teal = 15,
    cyan = 16,
    // sky = 17,
    blue = 18,
    indigo = 19,
    // violet = 20,
    purple = 21,
    // fuchsia = 22,
    pink = 23,
    // rose = 24,
};
WEBCFACE_DLL ViewColor colorFromRGB(double r, double g, double b);
 
enum class ViewComponentType {
    text = 0,
    new_line = 1,
    button = 2,
    text_input = 3,
    decimal_input = 4,
    number_input = 5,
    toggle_input = 6,
    select_input = 7,
    slider_input = 8,
    check_input = 9,
};
 
class WEBCFACE_DLL ViewComponent {
    std::shared_ptr<message::ViewComponentData> msg_data;
    std::weak_ptr<internal::ClientData> data_w;
    SharedString id_;
 
    // for cData()
    mutable std::unique_ptr<wcfMultiVal[]> options_s;
    mutable std::unique_ptr<wcfMultiValW[]> options_sw;
 
    void checkData() const;
 
    template <typename CComponent, typename CVal, std::size_t v_index>
    CComponent cDataT() const;
 
  public:
    ViewComponent();
 
    ViewComponent(const std::shared_ptr<message::ViewComponentData> &msg_data,
                  const std::weak_ptr<internal::ClientData> &data_w,
                  const SharedString &id);
 
    ViewComponent(const ViewComponent &);
    ViewComponent &operator=(const ViewComponent &);
    ViewComponent(ViewComponent &&) noexcept;
    ViewComponent &operator=(ViewComponent &&) noexcept;
    ~ViewComponent() noexcept;
 
    wcfViewComponent cData() const;
    wcfViewComponentW cDataW() const;
 
    std::string id() const;
    std::wstring idW() const;
 
    bool operator==(const ViewComponent &other) const;
    bool operator!=(const ViewComponent &other) const {
        return !(*this == other);
    }
 
    ViewComponentType type() const;
    std::string text() const;
    std::wstring textW() const;
    template <WEBCFACE_COMPLETE(Func)>
    std::optional<Func_> onClick() const;
    template <WEBCFACE_COMPLETE(Func)>
    std::optional<Func_> onChange() const;
    template <WEBCFACE_COMPLETE(Variant)>
    std::optional<Variant_> bind() const;
 
    ViewColor textColor() const;
    ViewColor bgColor() const;
    std::optional<double> min() const;
 
    std::optional<double> max() const;
    std::optional<double> step() const;
    std::vector<ValAdaptor> option() const;
    int width() const;
    int height() const;
};
extern template std::optional<Func>
ViewComponent::onClick<Func, true>() const;
extern template std::optional<Func>
ViewComponent::onChange<Func, true>() const;
extern template std::optional<Variant>
ViewComponent::bind<Variant, true>() const;
 
class WEBCFACE_DLL TemporalViewComponent {
    std::unique_ptr<internal::TemporalViewComponentData> msg_data;
 
  public:
    explicit TemporalViewComponent(std::nullptr_t = nullptr);
    explicit TemporalViewComponent(ViewComponentType type);
    TemporalViewComponent(const TemporalViewComponent &other);
    TemporalViewComponent &operator=(const TemporalViewComponent &other);
    TemporalViewComponent(TemporalViewComponent &&other) noexcept;
    TemporalViewComponent &operator=(TemporalViewComponent &&other) noexcept;
    ~TemporalViewComponent() noexcept;
 
    friend class View;
    friend class internal::ViewBuf;
 
    std::unique_ptr<internal::TemporalViewComponentData>
    lockTmp(const std::shared_ptr<internal::ClientData> &data,
            const SharedString &view_name,
            std::unordered_map<ViewComponentType, int> *idx_next = nullptr);
 
    TemporalViewComponent &id(std::string_view id);
    TemporalViewComponent &id(std::wstring_view id);
    TemporalViewComponent &text(std::string_view text) &;
    TemporalViewComponent &&text(std::string_view text) && {
        this->text(text);
        return std::move(*this);
    }
    TemporalViewComponent &text(std::wstring_view text) &;
    TemporalViewComponent &&text(std::wstring_view text) && {
        this->text(text);
        return std::move(*this);
    }
    TemporalViewComponent &onClick(const Func &func) &;
    TemporalViewComponent &&onClick(const Func &func) && {
        this->onClick(func);
        return std::move(*this);
    }
    TemporalViewComponent &onClick(const FuncListener &func) &;
    TemporalViewComponent &&onClick(const FuncListener &func) && {
        this->onClick(func);
        return std::move(*this);
    }
    template <typename T, decltype(std::declval<T>()(), nullptr) = nullptr>
    TemporalViewComponent &onClick(T func) & {
        return onClick(std::make_shared<std::function<void WEBCFACE_CALL_FP()>>(
            std::move(func)));
    }
    template <typename T, decltype(std::declval<T>()(), nullptr) = nullptr>
    TemporalViewComponent &&onClick(T func) && {
        this->onClick(std::move(func));
        return std::move(*this);
    }
    TemporalViewComponent &onClick(
        const std::shared_ptr<std::function<void WEBCFACE_CALL_FP()>> &func);
 
    TemporalViewComponent &bind(const InputRef &ref) &;
    TemporalViewComponent &&bind(const InputRef &ref) && {
        this->bind(ref);
        return std::move(*this);
    }
    template <typename T>
    TemporalViewComponent &onChange(T func) & {
        InputRef ref;
        return onChange(
            std::make_shared<std::function<void WEBCFACE_CALL_FP(ValAdaptor)>>(
                [ref, func = std::move(func)](ValAdaptor val) {
                    ref.lockedField().set(val);
                    return func(val);
                }),
            ref);
    }
    template <typename T>
    TemporalViewComponent &&onChange(T func) && {
        this->onChange(std::move(func));
        return std::move(*this);
    }
    TemporalViewComponent &onChange(
        const std::shared_ptr<std::function<void WEBCFACE_CALL_FP(ValAdaptor)>>
            &func,
        const InputRef &ref);
 
    TemporalViewComponent &textColor(ViewColor c) &;
    TemporalViewComponent &&textColor(ViewColor c) && {
        this->textColor(c);
        return std::move(*this);
    }
    TemporalViewComponent &bgColor(ViewColor c) &;
    TemporalViewComponent &&bgColor(ViewColor c) && {
        this->bgColor(c);
        return std::move(*this);
    }
    template <typename T>
    TemporalViewComponent &init(const T &init) & {
        return this->init(ValAdaptor{init});
    }
    template <typename T>
    TemporalViewComponent &&init(const T &init) && {
        this->init(init);
        return std::move(*this);
    }
 
  protected:
    TemporalViewComponent &init(const ValAdaptor &init);
 
  public:
    TemporalViewComponent &min(double min) &;
    TemporalViewComponent &&min(double min) && {
        this->min(min);
        return std::move(*this);
    }
    TemporalViewComponent &max(double max) &;
    TemporalViewComponent &&max(double max) && {
        this->max(max);
        return std::move(*this);
    }
    TemporalViewComponent &step(double step) &;
    TemporalViewComponent &&step(double step) && {
        this->step(step);
        return std::move(*this);
    }
 
    template <typename T>
    TemporalViewComponent &option(std::initializer_list<T> option) & {
        std::vector<ValAdaptor> option_v;
        for (const auto &v : option) {
            option_v.emplace_back(ValAdaptor(v));
        }
        return this->option(std::move(option_v));
    }
    template <typename T>
    TemporalViewComponent &&option(std::initializer_list<T> option) && {
        this->option(option);
        return std::move(*this);
    }
 
    TemporalViewComponent &option(std::vector<ValAdaptor> option) &;
    TemporalViewComponent &&option(std::vector<ValAdaptor> option) && {
        this->option(std::move(option));
        return std::move(*this);
    }
 
    TemporalViewComponent &width(int width) &;
    TemporalViewComponent &&width(int width) && {
        this->width(width);
        return std::move(*this);
    }
    TemporalViewComponent &height(int height) &;
    TemporalViewComponent &&height(int height) && {
        this->height(height);
        return std::move(*this);
    }
};
 
WEBCFACE_NS_END