component.hpp

浏览该文件的文档.

#ifndef NEFORCE_TUI_COMPONENT_COMPONENT_HPP__
#define NEFORCE_TUI_COMPONENT_COMPONENT_HPP__

 
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
#include "NeForce/tui/dom/element.hpp"
#include "NeForce/tui/dom/state.hpp"
#include "NeForce/tui/events.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_TUI__


struct empty_props {};

class component_base {
public:
    virtual ~component_base() = default;

    virtual element render() = 0;

    virtual bool on_key(const key_event& e) {
        ignore = e;
        return false;
    }

    virtual bool on_mouse(const mouse_event& e) {
        ignore = e;
        return false;
    }

    virtual void on_mouse_leave() {}

    void set_pass_through(bool v) noexcept { pass_through_ = v; }

    NEFORCE_NODISCARD bool pass_through() const noexcept { return pass_through_; }

    NEFORCE_NODISCARD bool has_focus() const noexcept { return has_focus_; }

    void set_has_focus(bool v) noexcept { has_focus_ = v; }

    virtual void on_animation(int64_t delta) { ignore = delta; }

    virtual void setup() {}

    virtual void cleanup() noexcept {}

    virtual bool should_update() { return true; }

    NEFORCE_NODISCARD component_base* parent() const noexcept { return parent_; }

    NEFORCE_NODISCARD size_t child_count() const noexcept { return children_.size(); }

    NEFORCE_NODISCARD component_base* child_at(size_t i) const noexcept { return children_[i].get(); }

    NEFORCE_NODISCARD int index() const noexcept {
        if (parent_ == nullptr) {
            return -1;
        }
        for (size_t i = 0; i < parent_->children_.size(); ++i) {
            if (parent_->children_[i].get() == this) {
                return static_cast<int>(i);
            }
        }
        return -1;
    }

    void add_child(unique_ptr<component_base> child) {
        child->parent_ = this;
        child->strand_ = strand_;
        child->ctx_ = ctx_;
        child->schedule_render_cb_ = schedule_render_cb_;
        auto* raw = child.get();
        children_.push_back(move(child));
        raw->setup();
    }

    unique_ptr<component_base> remove_child(component_base* child) {
        child->cleanup();
        child->parent_ = nullptr;
        for (auto it = children_.begin(); it != children_.end(); ++it) {
            if (it->get() == child) {
                auto owned = move(*it);
                children_.erase(it);
                return owned;
            }
        }
        return nullptr;
    }

    NEFORCE_NODISCARD unique_ptr<component_base> detach() {
        if (parent_ != nullptr) {
            return parent_->remove_child(this);
        }
        return nullptr;
    }

    void detach_all_children() {
        while (!children_.empty()) {
            remove_child(children_.back().get());
        }
    }

    NEFORCE_NODISCARD virtual bool focusable() const { return false; }

    NEFORCE_NODISCARD component_base* active_child() noexcept { return active_child_; }

    NEFORCE_NODISCARD const component_base* active_child() const noexcept { return active_child_; }

    void set_active_child(component_base* child) noexcept { active_child_ = child; }

    NEFORCE_NODISCARD bool active() const noexcept { return parent_ == nullptr || parent_->active_child() == this; }

    NEFORCE_NODISCARD bool focused() const noexcept {
        if (parent_ == nullptr) {
            return true;
        }
        if (!active()) {
            return false;
        }
        return parent_->focused();
    }

    virtual void take_focus() {
        auto* focus = this;
        for (auto* p = parent_; p != nullptr; p = p->parent_) {
            p->set_active_child(focus);
            focus = p;
        }
    }

    void schedule_render() {
        if (schedule_render_cb_) {
            schedule_render_cb_(this);
        }
    }

    template <typename Ctx>
    void provide_context(Ctx value) {
        contexts_[typeid(Ctx).hash_code()] = _NEFORCE make_shared<Ctx>(_NEFORCE move(value));
    }

    template <typename Ctx>
    NEFORCE_NODISCARD const Ctx& context() const {
        for (const auto* p = this; p != nullptr; p = p->parent_) {
            auto it = p->contexts_.find(typeid(Ctx).hash_code());
            if (it != p->contexts_.end()) {
                return *static_cast<const Ctx*>(it->second.get());
            }
        }
        NEFORCE_THROW_EXCEPTION(value_exception("Context not found in component tree"));
    }
 
protected:
    friend class reconciler;
    friend class focus_manager;
    friend class application;
 
    component_base* parent_ = nullptr;            
    component_base* active_child_ = nullptr;      
    bool has_focus_ = false;                      
    bool pass_through_ = false;                   
    strand* strand_ = nullptr;                    
    io_context* ctx_ = nullptr;                   
    vector<unique_ptr<component_base>> children_; 
 
    virtual void collect_focusable(vector<component_base*>& out) {
        if (focusable()) {
            out.push_back(this);
        }
        for (const auto& child: children_) {
            child->collect_focusable(out);
        }
    }
 
private:
    function<void(component_base*)> schedule_render_cb_; 
    unordered_map<size_t, shared_ptr<void>> contexts_;   
};

template <typename P = empty_props>
class component : public component_base {
public:
    using props_type = P;
 
    component() = default;
    ~component() override = default;
    component(const component&) = delete;
    component& operator=(const component&) = delete;
    component(component&&) = delete;
    component& operator=(component&&) = delete;
 
protected:
    NEFORCE_NODISCARD const props_type& props() const noexcept { return props_; }

    template <typename T>
    state<T>& create_state(T initial) {
        auto s = _NEFORCE make_shared<state<T>>(this, *strand_, _NEFORCE move(initial));
        states_.push_back(s);
        return *s;
    }

    void set_props(props_type p) { props_ = _NEFORCE move(p); }
 
private:
    friend class reconciler;
    friend class focus_manager;
    friend class application;
 
    props_type props_;
    vector<shared_ptr<void>> states_; 
};
 

template <typename T>
void state<T>::schedule_render() {
    if (owner_ != nullptr) {
        owner_->schedule_render();
    }
}
 // TUI
 
NEFORCE_END_TUI__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_TUI_COMPONENT_COMPONENT_HPP__