element.hpp

浏览该文件的文档.

#ifndef NEFORCE_TUI_DOM_ELEMENT_HPP__
#define NEFORCE_TUI_DOM_ELEMENT_HPP__

 
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/memory/shared_ptr.hpp"
#include "NeForce/tui/dom/layout_types.hpp"
#include "NeForce/tui/dom/style.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_TUI__


template <typename T>
class state;
 

class NEFORCE_API element {
public:
    enum class kind : uint8_t {
        empty,       
        vbox,        
        hbox,        
        zstack,      
        text,        
        spacer,      
        separator,   
        button,      
        text_input,  
        checkbox,    
        scroll_view, 
        canvas,      
        when,        
        each,        
        flexbox,     
        gridbox,     
    };
 
    element();
    ~element();
 
    element(const element& other);
    element& operator=(const element& other);
    element(element&& other) noexcept;
    element& operator=(element&& other) noexcept;

    element& with_key(size_t k);
 
    NEFORCE_NODISCARD kind kind() const noexcept;
    NEFORCE_NODISCARD size_t key() const noexcept;
    NEFORCE_NODISCARD const vector<element>& children() const;
    NEFORCE_NODISCARD vector<element>& children();
    NEFORCE_NODISCARD const tui::style& style() const;
    NEFORCE_NODISCARD const box_props& layout() const;
    NEFORCE_NODISCARD const string& text() const;
    NEFORCE_NODISCARD const function<void()>& on_click() const;
    NEFORCE_NODISCARD int flex() const noexcept;
    NEFORCE_NODISCARD void* state_ref() const noexcept;
    NEFORCE_NODISCARD style::variant variant() const noexcept;
    NEFORCE_NODISCARD const function<void(int, int, int, int)>& draw_function() const;
 
    NEFORCE_NODISCARD void* owner() const noexcept;
    void set_owner(void* o);
 
    NEFORCE_NODISCARD int scroll_x() const noexcept;
    NEFORCE_NODISCARD int scroll_y() const noexcept;
 
    NEFORCE_NODISCARD int grid_columns() const noexcept;
 
    NEFORCE_NODISCARD const string& placeholder() const noexcept;
 
    NEFORCE_NODISCARD bool cursor_visible() const noexcept;
    element& with_cursor_visible(bool v);
 
    NEFORCE_NODISCARD size_t cursor_pos() const noexcept;
    element& with_cursor_pos(size_t pos);
 
    NEFORCE_NODISCARD style::wrap_mode wrap_mode() const noexcept;
 
    NEFORCE_NODISCARD void* scroll_x_state() const noexcept;
    element& with_scroll_x_state(void* s);
    NEFORCE_NODISCARD void* scroll_y_state() const noexcept;
    element& with_scroll_y_state(void* s);
 
    NEFORCE_NODISCARD bool is_layout_dirty() const noexcept;
    void set_layout_dirty(bool dirty);
 
    NEFORCE_NODISCARD const vector<layout_rect>& cached_layout() const noexcept;
    void set_cached_layout(const vector<layout_rect>& layout, int constraint_w, int constraint_h) const;
    NEFORCE_NODISCARD int cached_constraint_w() const noexcept;
    NEFORCE_NODISCARD int cached_constraint_h() const noexcept;
 
    static element empty();
    static element vbox(vector<element> children, box_props props = {});
    static element hbox(vector<element> children, box_props props = {});
    static element zstack(vector<element> children);
    static element text(string content, tui::style style = {}, style::wrap_mode wrap = style::wrap_mode::none);
    static element spacer(int flex = 1);
    static element separator();
    static element button(string label, function<void()> on_click, tui::style style = {},
                          tui::style::variant variant = tui::style::variant::default_);
    static element text_input(state<string>& text, tui::style style = {}, string placeholder = "");
    static element checkbox(string label, state<bool>& checked, tui::style style = {});
    static element scroll_view(element child, tui::style style = {}, int scroll_x = 0, int scroll_y = 0);

    element& with_style(const tui::style& s);

    static element canvas(function<void(int, int, int, int)> draw_function, tui::style style = {});

    static element flexbox(vector<element> children, box_props config = {});

    static element gridbox(vector<vector<element>> grid);

    static element
    when(bool cond, function<element()> then, function<element()> otherwise = []() { return element::empty(); });

    template <typename T>
    static element each(const vector<T>& items, function<element(const T&, size_t)> render) {
        element el;
        el.init_kind(kind::each);
        el.reserve_children(items.size());
        for (size_t i = 0; i < items.size(); ++i) {
            el.add_child(render(items[i], i));
        }
        return el;
    }
 
private:
    struct node;
    shared_ptr<node> node_;
 
    void ensure_node();
    void init_kind(enum kind k);
    void reserve_children(size_t n);
    void add_child(element child);
};

using decorator = function<element(element)>;

using elements = vector<element>;
 

inline element operator|(element e, const decorator& d) { return d(move(e)); }

inline element& operator|=(element& e, const decorator& d) {
    e = d(move(e));
    return e;
}

inline vector<element> operator|(const vector<element>& es, const decorator& d) {
    vector<element> result;
    result.reserve(es.size());
    for (const auto& e: es) {
        result.push_back(d(e));
    }
    return result;
}

inline decorator operator|(decorator a, decorator b) {
    return [a = move(a), b = move(b)](element e) { return a(b(move(e))); };
}
 

inline decorator bold() {
    return [](element e) {
        style s;
        s.bold = true;
        return e.with_style(s);
    };
}

inline decorator dim() {
    return [](element e) {
        style s;
        s.dim = true;
        return e.with_style(s);
    };
}

inline decorator italic() {
    return [](element e) {
        style s;
        s.italic = true;
        return e.with_style(s);
    };
}

inline decorator underlined() {
    return [](element e) {
        style s;
        s.underline = true;
        return e.with_style(s);
    };
}

inline decorator underlined_double() {
    return [](element e) {
        style s;
        s.underlined_double = true;
        return e.with_style(s);
    };
}

inline decorator blink() {
    return [](element e) {
        style s;
        s.blink = true;
        return e.with_style(s);
    };
}

inline decorator strikethrough() {
    return [](element e) {
        style s;
        s.strikethrough = true;
        return e.with_style(s);
    };
}

inline decorator inverted() {
    return [](element e) {
        style s;
        s.reverse = true;
        return e.with_style(s);
    };
}

inline decorator color(color c) {
    return [c = move(c)](element e) {
        style s;
        s.fg = c;
        return e.with_style(s);
    };
}

inline decorator bgcolor(_NEFORCE color c) {
    return [c = move(c)](element e) {
        style s;
        s.bg = c;
        return e.with_style(s);
    };
}

inline decorator border(enum style::border b) {
    return [b](element e) {
        style s;
        s.border = b;
        return e.with_style(s);
    };
}

inline decorator flex_grow_el(float factor) {
    return [factor](element e) {
        style s;
        s.flex_grow = factor;
        return e.with_style(s);
    };
}

inline decorator flex_shrink_el(float factor) {
    return [factor](element e) {
        style s;
        s.flex_shrink = factor;
        return e.with_style(s);
    };
}

inline decorator flex_el(float grow, float shrink) {
    return [grow, shrink](element e) {
        style s;
        s.flex_grow = grow;
        s.flex_shrink = shrink;
        return e.with_style(s);
    };
}

inline decorator text_wrap(style::wrap_mode wm) {
    return [wm](element e) {
        style s;
        s.text_wrap = wm;
        return e.with_style(s);
    };
}
 // TUI
 
NEFORCE_END_TUI__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_TUI_DOM_ELEMENT_HPP__