table.hpp

Go to the documentation of this file.

#pragma once
 
// TableListBox — sortable, scrollable table with columns and cell renderers.
// Each column has a header, width, and renderer. Rows are provided by a data model.
 
#include <pulp/view/view.hpp>
#include <string>
#include <vector>
#include <functional>
#include <optional>
#include <algorithm>
 
namespace pulp::view {

struct TableColumn {
    std::string header;          // Column header text
    float width = 100.0f;       // Column width in pixels
    bool sortable = true;       // Whether the column can be sorted
    bool resizable = true;      // Whether the user can resize the column
 
    enum class Align { left, center, right };
    Align align = Align::left;
};

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

    virtual int row_count() const = 0;

    virtual std::string cell_text(int row, int column) const = 0;

    virtual bool sort(int column, bool ascending) { (void)column; (void)ascending; return false; }

    virtual void row_selected(int row) { (void)row; }

    virtual void row_double_clicked(int row) { (void)row; }
};

class SimpleTableModel : public TableModel {
public:
    void set_data(std::vector<std::vector<std::string>> rows) {
        rows_ = std::move(rows);
    }
 
    void add_row(std::vector<std::string> row) {
        rows_.push_back(std::move(row));
    }
 
    int row_count() const override { return static_cast<int>(rows_.size()); }
 
    std::string cell_text(int row, int column) const override {
        if (row < 0 || row >= row_count()) return "";
        auto& r = rows_[static_cast<size_t>(row)];
        if (column < 0 || column >= static_cast<int>(r.size())) return "";
        return r[static_cast<size_t>(column)];
    }
 
    bool sort(int column, bool ascending) override {
        if (column < 0) return false;
        auto col = static_cast<size_t>(column);
        std::sort(rows_.begin(), rows_.end(),
            [col, ascending](const auto& a, const auto& b) {
                std::string va = col < a.size() ? a[col] : "";
                std::string vb = col < b.size() ? b[col] : "";
                return ascending ? va < vb : va > vb;
            });
        return true;
    }
 
private:
    std::vector<std::vector<std::string>> rows_;
};

class TableListBox : public View {
public:
    // No AccessRole::table here, deliberately. Rows and cells are PAINTED, not
    // child Views, so a `table` role would export an AXTable / UIA Table with
    // zero rows: assistive tech announces "table, 0 rows" and its grid
    // navigation lands on nothing. A container role is only true once the
    // children that make it true exist (per-row `row` / `cell` elements — the
    // follow-up recorded in docs/guides/modules/view.md). Until then the widget
    // stays out of the tree, exactly as it was before. VirtualList, which DOES
    // hold child Views, exposes list/list_item today.
    TableListBox() { set_focusable(true); }

    void set_model(TableModel* model) { model_ = model; }

    void add_column(TableColumn column) { columns_.push_back(std::move(column)); }

    void clear_columns() { columns_.clear(); }

    void set_selected_row(int row) { selected_row_ = row; }
    int selected_row() const { return selected_row_; }

    void set_row_height(float h) { row_height_ = h; }
    float row_height() const { return row_height_; }

    void set_header_height(float h) { header_height_ = h; }

    int column_count() const { return static_cast<int>(columns_.size()); }

    std::function<void(int row)> on_selection_changed;
 
    void paint(canvas::Canvas& canvas) override;
    void on_mouse_down(Point pos) override;
    bool wants_mouse_input() const override { return true; }
 
private:
    TableModel* model_ = nullptr;
    std::vector<TableColumn> columns_;
    int selected_row_ = -1;
    int sort_column_ = -1;
    bool sort_ascending_ = true;
    float row_height_ = 24.0f;
    float header_height_ = 28.0f;
    float scroll_offset_ = 0.0f;
};

using Table = TableListBox;
 
}  // namespace pulp::view