screen.h

Go to the documentation of this file.

#pragma once
#include "di/bit/bitset/prelude.h"
#include "di/container/string/string_view.h"
#include "di/container/view/cache_last.h"
#include "di/reflect/prelude.h"
#include "scroll_region.h"
#include "ttx/graphics_rendition.h"
#include "ttx/size.h"
#include "ttx/terminal/cursor.h"
#include "ttx/terminal/escapes/osc_66.h"
#include "ttx/terminal/hyperlink.h"
#include "ttx/terminal/multi_cell_info.h"
#include "ttx/terminal/row.h"
#include "ttx/terminal/row_group.h"
#include "ttx/terminal/scroll_back.h"
#include "ttx/terminal/selection.h"
 
namespace ttx::terminal {
enum class AutoWrapMode {
    Disabled,
    Enabled,
};

enum class OriginMode {
    Disabled,
    Enabled,
};

struct SavedCursor {
    u32 row { 0 };                           
    u32 col { 0 };                           
    bool overflow_pending { false };         
    GraphicsRendition graphics_rendition {}; 
    OriginMode origin_mode { OriginMode::Disabled }; 
 
    auto operator==(SavedCursor const&) const -> bool = default;
    auto operator<=>(SavedCursor const&) const = default;
 
    constexpr friend auto tag_invoke(di::Tag<di::reflect>, di::InPlaceType<SavedCursor>) {
        return di::make_fields<"SavedCursor">(di::field<"row", &SavedCursor::row>, di::field<"col", &SavedCursor::col>,
                                              di::field<"overflow_pending", &SavedCursor::overflow_pending>,
                                              di::field<"graphics_rendition", &SavedCursor::graphics_rendition>,
                                              di::field<"origin_mode", &SavedCursor::origin_mode>);
    }
};

class Screen {
public:
    enum class ScrollBackEnabled { No, Yes };
 
    explicit Screen(Size const& size, ScrollBackEnabled scroll_back_enabled);
 
    void resize(Size const& size);
    void set_scroll_region(ScrollRegion const& region);
 
    auto max_height() const -> u32 { return m_size.rows; }
    auto max_width() const -> u32 { return m_size.cols; }
    auto size() const -> Size const& { return m_size; }
    auto scroll_region() const -> ScrollRegion const& { return m_scroll_region; }
 
    auto current_graphics_rendition() const -> GraphicsRendition const&;
    auto current_hyperlink() const -> di::Optional<Hyperlink const&>;
 
    void set_current_graphics_rendition(GraphicsRendition const& rendition);
    void set_current_hyperlink(di::Optional<Hyperlink const&> hyperlink);
 
    auto cursor() const -> Cursor { return m_cursor; }
    auto origin_mode() const -> OriginMode { return m_origin_mode; }
 
    auto save_cursor() const -> SavedCursor;
    void restore_cursor(SavedCursor const& cursor);
 
    void set_origin_mode(OriginMode mode);
    void set_cursor_relative(u32 row, u32 col);
    void set_cursor(u32 row, u32 col);
    void set_cursor(u32 row, u32 col, bool overflow_pending);
    void set_cursor_row_relative(u32 row);
    void set_cursor_row(u32 row);
    void set_cursor_col_relative(u32 col);
    void set_cursor_col(u32 col);
 
    void insert_blank_characters(u32 count);
    void insert_blank_lines(u32 count);
 
    void delete_characters(u32 count);
    void delete_lines(u32 count);
 
    void clear();
    void clear_after_cursor();
    void clear_before_cursor();
 
    void clear_row();
    void clear_row_after_cursor();
    void clear_row_before_cursor();
    void erase_characters(u32 n);
 
    void scroll_down();
    void put_code_point(c32 code_point, AutoWrapMode auto_wrap_mode);
    void put_osc66(OSC66 const& sized_text, AutoWrapMode auto_wrap_mode);
 
    void invalidate_all() { m_whole_screen_dirty = true; }
    auto whole_screen_dirty() const -> bool { return m_whole_screen_dirty; }
    void clear_whole_screen_dirty_flag() { m_whole_screen_dirty = false; }
    void clear_damage_tracking();
 
    auto absolute_row_start() const -> u64 { return m_scroll_back.absolute_row_start(); }
    auto absolute_row_screen_start() const -> u64 { return m_scroll_back.absolute_row_end(); }
    auto absolute_row_end() const -> u64 { return absolute_row_screen_start() + max_height(); }
    auto total_rows() const -> usize { return m_scroll_back.total_rows() + m_active_rows.total_rows(); }
 
    void clear_scroll_back();
 
    auto visual_scroll_offset() const -> u64 {
        ASSERT_GT_EQ(m_visual_scroll_offset, absolute_row_start());
        ASSERT_LT_EQ(m_visual_scroll_offset, absolute_row_screen_start());
        return m_visual_scroll_offset;
    }
    auto visual_scroll_at_bottom() const -> bool { return visual_scroll_offset() == absolute_row_screen_start(); }
    void visual_scroll_up();
    void visual_scroll_down();
    void visual_scroll_to_bottom();
 
    enum class BeginSelectionMode {
        Single,
        Word,
        Line,
    };
 
    auto selection() const -> di::Optional<Selection> { return m_selection; }
    void clear_selection();
    void begin_selection(SelectionPoint const& point, BeginSelectionMode mode);
    void update_selection(SelectionPoint const& point);
    auto in_selection(SelectionPoint const& point) const -> bool;
    auto selected_text() const -> di::String;
 
    auto find_row(u64 row) const -> di::Tuple<u32, RowGroup const&>;
    auto iterate_row(u64 row) const {
        auto [r, group] = find_row(row);
        return group.iterate_row(r);
    }

    auto state_as_escape_sequences() const -> di::String;
 
    void put_cell(di::StringView text, MultiCellInfo const& multi_cell_info, AutoWrapMode auto_wrap_mode,
                  bool explicitly_sized, bool complex_grapheme_cluster);
 
private:
    void put_single_cell(di::StringView text, MultiCellInfo const& multi_cell_info, AutoWrapMode auto_wrap_mode,
                         bool explicitly_sized, bool complex_grapheme_cluster);
    void put_wide_cell(di::StringView text, MultiCellInfo const& multi_cell_info, AutoWrapMode auto_wrap_mode,
                       bool explicitly_sized, bool complex_grapheme_cluster);
 
    // Row/column helper functions for dealing with origin mode.
    auto translate_row(u32 row) const -> u32;
    auto translate_col(u32 col) const -> u32;
    auto min_row() const -> u32;
    auto max_row_inclusive() const -> u32;
    auto min_col() const -> u32;
    auto max_col_inclusive() const -> u32;
 
    auto cursor_in_scroll_region() const -> bool;
 
    // Clamp the selection to be within bounds, after adding/removing rows from scrollback.
    void clamp_selection();
 
    // Clamp a selection point to only refer to actual cells (and the top-left of any multi cell).
    // Also return the corresponding row information, for efficiency.
    auto clamp_selection_point(SelectionPoint const& point) const -> di::Tuple<SelectionPoint, RowGroup const&, u32>;
 
    // Invalidate a region of rows and cells, as specified by the selection region.
    void invalidate_region(Selection const& region);
 
    auto begin_row_iterator() { return rows().begin() + m_scroll_region.start_row; }
    auto end_row_iterator() { return rows().begin() + m_scroll_region.end_row; }
 
    auto rows() -> di::Ring<Row>& { return m_active_rows.rows(); }
    auto rows() const -> di::Ring<Row> const& { return m_active_rows.rows(); }
 
    // Screen state.
    RowGroup m_active_rows;
    bool m_whole_screen_dirty { true };
 
    // Scroll back
    ScrollBack m_scroll_back;
    ScrollBackEnabled m_scroll_back_enabled { ScrollBackEnabled::No };
    u64 m_visual_scroll_offset { 0 };
    bool m_never_got_input { true };
 
    // Visual selection
    di::Optional<Selection> m_selection;
 
    // Mutable state for writing cells.
    Cursor m_cursor;
    OriginMode m_origin_mode { OriginMode::Disabled };
    u16 m_graphics_id { 0 };
    u16 m_hyperlink_id { 0 };
 
    // Terminal size information.
    Size m_size {};
    ScrollRegion m_scroll_region;
};
}