gtable.h

/*
 * File: gtable.h
 * --------------
 * This file exports the GTable class for a graphical editable 2D table.
 *
 * @author Marty Stepp
 * @version 2021/04/09
 * - added sgl namespace
 * @version 2021/04/03
 * - removed dependency on custom collections
 * @version 2018/08/23
 * - renamed to gtable.h to replace Java version
 * @version 2018/07/17
 * - initial version, based on gtable.h
 * @since 2018/07/17
 */


#ifndef _gtable_h
#define _gtable_h

#include <map>
#include <string>
#include <QAbstractItemModel>
#include <QBrush>
#include <QFont>
#include <QItemSelection>
#include <QStyledItemDelegate>
#include <QTableWidget>

#include "ginteractor.h"
#include "gobjects.h"
#include "gtypes.h"

namespace sgl {

struct GTableIndex;
class _Internal_QTableWidget;

class GTable : public GInteractor {
public:
    enum ColumnHeaderStyle {
        COLUMN_HEADER_NONE,     // headers will not show
        COLUMN_HEADER_EXCEL,    // A, B, ..., Z, AA, AB, ...
        COLUMN_HEADER_NUMERIC   // 1, 2, 3, ...
    };

    GTable(int rows = 0, int columns = 0, double width = 0, double height = 0,
            QWidget* parent = nullptr);

    ~GTable() override;

    virtual void autofitColumnWidths();

    virtual void clear();

    virtual void clearCell(int row, int column);

    virtual void clearFormatting();

    virtual void clearCellFormatting(int row, int column);

    virtual void clearSelection();

    virtual void fill(const string& text);

    virtual string get(int row, int column) const;

    virtual ColumnHeaderStyle getColumnHeaderStyle() const;

    virtual double getColumnWidth(int column) const;

    /* @inherit */
    _Internal_QWidget* getInternalWidget() const override;

    virtual double getRowHeight(int row) const;

    virtual GTableIndex getSelectedCell() const;

    virtual void getSelectedCell(int& row, int& column) const;

    virtual string getSelectedCellValue() const;

    virtual int getSelectedColumn() const;

    virtual int getSelectedRow() const;

    /* @inherit */
    string getType() const override;

    /* @inherit */
    QWidget* getWidget() const override;

    virtual bool hasSelectedCell() const;

    virtual int height() const;

    virtual bool inTableBounds(int row, int column) const;

    virtual bool isEditable() const;

    virtual int numCols() const;

    virtual int numRows() const;

    virtual void removeTableListener();

    /* @inherit */
    void requestFocus() override;

    virtual void resize(int numRows, int numCols);

    virtual bool rowColumnHeadersVisible() const;

    virtual void select(int row, int column);

    virtual void set(int row, int column, const string& text);

    void setBackground(int rgb) override;

    void setBackground(const string& color) override;

    virtual void setCellAlignment(int row, int column, HorizontalAlignment alignment);

    virtual void setCellBackground(int row, int column, int color);

    virtual void setCellBackground(int row, int column, const string& color);

    virtual void setCellFont(int row, int column, const string& font);

    virtual void setCellForeground(int row, int column, int color);

    virtual void setCellForeground(int row, int column, const string& color);

    void setColor(int rgb) override;

    void setColor(const string& color) override;

    virtual void setColumnAlignment(int column, HorizontalAlignment alignment);

    virtual void setColumnBackground(int column, int color);

    virtual void setColumnBackground(int column, const string& color);

    virtual void setColumnFont(int column, const string& font);

    virtual void setColumnForeground(int column, int color);

    virtual void setColumnForeground(int column, const string& color);

    virtual void setColumnWidth(int column, double width);

    virtual void setColumnHeaderStyle(ColumnHeaderStyle style);

    virtual void setEditable(bool editable);

    virtual void setEditorValue(int row, int column, const string& text);

    void setFont(const QFont& font) override;

    void setFont(const string& font) override;

    void setForeground(int rgb) override;

    void setForeground(const string& color) override;

    virtual void setHorizontalAlignment(HorizontalAlignment alignment);

    virtual void setRowAlignment(int row, HorizontalAlignment alignment);

    virtual void setRowBackground(int row, int rgb);

    virtual void setRowBackground(int row, const string& color);

    virtual void setRowFont(int row, const string& font);

    virtual void setRowForeground(int row, int rgb);

    virtual void setRowForeground(int row, const string& color);

    virtual void setRowColumnHeadersVisible(bool visible);

    virtual void setRowHeight(int row, double width);

    virtual void setSelectedCellValue(const string& text);

    virtual void setTableListener(GEventListener func);

    virtual void setTableListener(GEventListenerVoid func);

    virtual int width() const;

private:
    Q_DISABLE_COPY(GTable)

    // Represents cascading styles on a cell, row, column, or table.
    struct TableStyle {
        int background;
        int foreground;
        string font;
        HorizontalAlignment alignment;
        // TODO: borders?

        TableStyle() {
            background = 0;
            foreground = 0;
            font = "";
            alignment = ALIGN_LEFT;
        }

        bool isSet() const {
            return background >= 0
                    && foreground >= 0
                    && !font.empty()
                    && alignment >= 0;
        }

        void mergeWith(const TableStyle& other) {
            if (other.background >= 0) {
                background = other.background;
            }
            if (other.foreground >= 0) {
                foreground = other.foreground;
            }
            if (!other.font.empty()) {
                font = other.font;
            }
            if (other.alignment >= 0) {
                alignment = other.alignment;
            }
        }

        TableStyle mergedWith(const TableStyle& other) {
            TableStyle copy = *this;
            copy.mergeWith(other);
            return copy;
        }

        static TableStyle unset() {
            TableStyle style;
            style.background = -1;
            style.foreground = -1;
            style.font = "";
            style.alignment = (HorizontalAlignment) -1;
            return style;
        }
    };

    // static variables for default formatting:
    // background/foreground colors
    // font
    // alignment
    static TableStyle _defaultCellStyle;

    // member variables
    _Internal_QTableWidget* _iqtableview;
    ColumnHeaderStyle _columnHeaderStyle;

    // styles on table, rows, columns, cells
    std::map<int, TableStyle> _rowStyles;
    std::map<int, TableStyle> _columnStyles;
    TableStyle _globalCellStyle;

    void applyStyleToCell(int row, int column, const TableStyle& style);

    /*
     * @throw ErrorException if the given row/column values are out of bounds.
     */
    void checkColumn(const string& member, int column) const;
    void checkIndex(const string& member, int row, int column) const;
    void checkRow(const string& member, int row) const;

    void ensureColumnStyle(int column);
    void ensureDefaultFormatting() const;   // const hack
    void ensureGlobalCellStyle();
    void ensureRowStyle(int row);
    TableStyle getMergedStyleForCell(int row, int column);

    // Internal setters for cell formatting.
    virtual void setCellAlignmentInternal(int row, int column, HorizontalAlignment alignment);
    virtual void setCellBackgroundInternal(int row, int column, int color);
    virtual void setCellFontInternal(int row, int column, const string& font);
    virtual void setCellForegroundInternal(int row, int column, int color);

    static string toExcelColumnName(int col);

    void updateColumnHeaders();

    friend class _Internal_QTableWidget;
};

class _Internal_QItemDelegate : public QStyledItemDelegate {
    Q_OBJECT

public:
    _Internal_QItemDelegate(QObject* parent = nullptr);
    virtual QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const;
    virtual void destroyEditor(QWidget* editor, const QModelIndex& index) const;
    virtual QWidget* getEditor() const;

private:
    QWidget* _editor;
};


class _Internal_QTableWidget : public QTableWidget, public _Internal_QWidget {
    Q_OBJECT

public:
    _Internal_QTableWidget(GTable* gtable, int rows, int columns, QWidget* parent = nullptr);
    void detach() override;
    bool edit(const QModelIndex& index, QAbstractItemView::EditTrigger trigger, QEvent* event) override;
    virtual QWidget* getEditor() const;
    virtual _Internal_QItemDelegate* getItemDelegate() const;
    virtual bool isEditing() const;
    void closeEditor(QWidget* editor, QAbstractItemDelegate::EndEditHint hint) override;
    void keyPressEvent(QKeyEvent* event) override;
    QSize sizeHint() const override;

public slots:
    void handleCellChange(int row, int column);
    void handleCellDoubleClick(int row, int column);
    void handleSelectionChange(const QItemSelection& selected, const QItemSelection& deselected);

private:
    GTable* _gtable;
    _Internal_QItemDelegate* _delegate;
    int _lastKeyPressed;

    void fireTableEvent(EventType eventType, const string& eventName, int row = -1, int col = -1);

    friend class GTable;
};

struct GTableIndex {
public:

    GTableIndex(int row, int col);

    GTableIndex();

    string toString() const;

    /* row and column data - may be directly accessed or modified */
    int row;
    int col;
};

string to_string(const GTableIndex& value);

bool operator <(const GTableIndex& loc1, const GTableIndex& loc2);
bool operator <=(const GTableIndex& loc1, const GTableIndex& loc2);
bool operator ==(const GTableIndex& loc1, const GTableIndex& loc2);
bool operator !=(const GTableIndex& loc1, const GTableIndex& loc2);
bool operator >(const GTableIndex& loc1, const GTableIndex& loc2);
bool operator >=(const GTableIndex& loc1, const GTableIndex& loc2);

std::ostream& operator <<(std::ostream& out, const GTableIndex& loc);
std::istream& operator >>(std::istream& input, GTableIndex& loc);

} // namespace sgl

#endif // _gtable_h