screen.hpp

浏览该文件的文档.

#ifndef NEFORCE_TUI_SCREEN_HPP__
#define NEFORCE_TUI_SCREEN_HPP__

 
#include "NeForce/core/utility/color.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_TUI__


class screen;

struct dimensions {
    int dimx; 
    int dimy; 
};

struct cell {
    string character;           
    _NEFORCE color foreground;  
    _NEFORCE color background;  
    bool bold : 1;              
    bool dim : 1;               
    bool italic : 1;            
    bool inverted : 1;          
    bool underlined : 1;        
    bool underlined_double : 1; 
    bool blink : 1;             
    bool strikethrough : 1;     
    bool automerge : 1;         
    uint8_t hyperlink = 0;      
 
    cell() noexcept :
    bold(false),
    dim(false),
    italic(false),
    inverted(false),
    underlined(false),
    underlined_double(false),
    blink(false),
    strikethrough(false),
    automerge(false) {}

    void reset() noexcept {
        bold = dim = italic = inverted = underlined = underlined_double = blink = strikethrough = automerge = false;
        hyperlink = 0;
        foreground = _NEFORCE color{};
        background = _NEFORCE color{};
        character.clear();
    }

    NEFORCE_NODISCARD bool visually_equal(const cell& other) const noexcept {
        return character == other.character && bold == other.bold && dim == other.dim && italic == other.italic &&
               inverted == other.inverted && underlined == other.underlined &&
               underlined_double == other.underlined_double && blink == other.blink &&
               strikethrough == other.strikethrough && hyperlink == other.hyperlink && foreground == other.foreground &&
               background == other.background;
    }
};

struct cursor {
    enum class shape : uint8_t {
        Hidden,            
        BlockBlinking,     
        Block,             
        UnderlineBlinking, 
        Underline,         
        BarBlinking,       
        Bar,               
    };
 
    int x = 0;                   
    int y = 0;                   
    shape shape = shape::Hidden; 
};

class NEFORCE_API surface {
public:
    surface(int dimx, int dimy);
 
    virtual ~surface() = default;

    NEFORCE_NODISCARD int dimx() const noexcept { return dimx_; }

    NEFORCE_NODISCARD int dimy() const noexcept { return dimy_; }

    NEFORCE_NODISCARD string& at(int x, int y);

    NEFORCE_NODISCARD cell& cell_at(int x, int y);

    NEFORCE_NODISCARD cell& fast_cell_at(int x, int y) noexcept { return cells_[static_cast<size_t>(y) * dimx_ + x]; }

    virtual void clear();
 
protected:
    int dimx_;
    int dimy_;
    vector<cell> cells_;
};

// NOLINTNEXTLINE(bugprone-exception-escape)
class NEFORCE_API screen final : public surface {
public:
    screen(int dimx, int dimy);

    void resize(int dimx, int dimy);

    NEFORCE_NODISCARD const tui::cursor& cursor() const noexcept { return cursor_; }

    void set_cursor(const tui::cursor& c) noexcept { cursor_ = c; }

    uint8_t register_hyperlink(const string& link);

    NEFORCE_NODISCARD const string& hyperlink(uint8_t id) const;

    NEFORCE_NODISCARD string to_string(const screen& prev) const;

    NEFORCE_NODISCARD string to_plaintext() const;

    void reset_position(bool clear = false);

    void clear() override;
 
private:
    tui::cursor cursor_;
    vector<string> hyperlinks_;
 
    void update_cell_style(string& ss, const cell& prev, const cell& next) const;
};
 // TUI
 
NEFORCE_END_TUI__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_TUI_SCREEN_HPP__