canvas2d.h

Go to the documentation of this file.

#pragma once
#include <memory>
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
#include "field.h"
#include "components.h"
 
WEBCFACE_NS_BEGIN
namespace internal {
template <typename Component>
class DataSetBuffer;
class Canvas2DDataBuf;
} // namespace internal
 
class WEBCFACE_DLL Canvas2D : protected Field {
    std::shared_ptr<internal::Canvas2DDataBuf> sb;
 
  public:
    Canvas2D();
    Canvas2D(const Field &base);
    Canvas2D(const Field &base, const SharedString &field)
        : Canvas2D(Field{base, field}) {}
    Canvas2D(const Field &base, const SharedString &field, double width,
             double height)
        : Canvas2D(Field{base, field}) {
        init(width, height);
    }
 
    friend internal::DataSetBuffer<Canvas2DComponent>;
 
    using Field::lastName;
    using Field::member;
    using Field::name;
    using Field::nameW;
    Canvas2D child(std::string_view field) const {
        return this->Field::child(field);
    }
    Canvas2D child(std::wstring_view field) const {
        return this->Field::child(field);
    }
    Canvas2D child(int index) const { return this->Field::child(index); }
    Canvas2D operator[](std::string_view field) const { return child(field); }
    Canvas2D operator[](std::wstring_view field) const { return child(field); }
    Canvas2D operator[](const char *field) const { return child(field); }
    Canvas2D operator[](const wchar_t *field) const { return child(field); }
    Canvas2D operator[](int index) const { return child(index); }
    Canvas2D parent() const { return this->Field::parent(); }
 
    const Canvas2D &
    onChange(std::function<void WEBCFACE_CALL_FP(Canvas2D)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Canvas2D &onChange(F callback) const {
        return onChange(
            [callback = std::move(callback)](const auto &) { callback(); });
    }
    template <typename T>
    [[deprecated]] void appendListener(T &&callback) const {
        onChange(std::forward<T>(callback));
    }
 
    const Canvas2D &request() const;
    std::optional<std::vector<Canvas2DComponent>> tryGet() const;
    std::vector<Canvas2DComponent> get() const {
        return tryGet().value_or(std::vector<Canvas2DComponent>{});
    }
    bool exists() const;
 
    [[deprecated]] std::chrono::system_clock::time_point time() const;
 
    const Canvas2D &free() const;
 
    const Canvas2D &init(double width, double height) const;
 
    const Canvas2D &operator<<(TemporalCanvas2DComponent cc) const;
 
    template <typename T>
    const Canvas2D &add(T &&cc) const {
        *this << std::forward<T>(cc);
        return *this;
    }
    template <bool V, bool C3>
    const Canvas2D &operator<<(TemporalComponent<V, true, C3> cc) const {
        *this << std::move(cc.component_2d);
        return *this;
    }
    const Canvas2D &sync() const;
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Canvas2D>,
                                                    std::nullptr_t> = nullptr>
    bool operator==(const T &other) const {
        return static_cast<Field>(*this) == static_cast<Field>(other);
    }
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Canvas2D>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
};
WEBCFACE_NS_END