cxGrid.h

Go to the documentation of this file.

// Copyright (c) 2026 E. Oulashin
#ifndef __CXGRID_H__
#define __CXGRID_H__
 
// cxGrid: A text-based grid/spreadsheet control derived from cxWindow.
// Similar in concept to wxGrid from wxWidgets. Each cell contains a
// std::shared_ptr<cxWindow>, defaulting to cxInput. Cells can be any
// cxWidgets control (cxInput, cxMultiLineInput, cxComboBox, cxLabel, etc.).
//
// The grid displays:
//  - Column headers (A, B, C, ... or custom labels) across the top
//  - Row headers (1, 2, 3, ... or custom labels) down the left side
//  - A scrollable grid of cells, each containing a cxWindow-derived widget
//
// Navigation: Tab/Shift+Tab or arrow keys move between cells.
 
#include "cxWindow.h"
#include "cxInput.h"
#include "cxLabel.h"
#include <string>
#include <vector>
#include <memory>
 
namespace cx {
 
class cxGrid : public cxWindow
{
   public:
 
      explicit cxGrid(cxWindow *pParentWindow = nullptr,
                      int pRow = 0, int pCol = 0,
                      int pHeight = DEFAULT_HEIGHT, int pWidth = DEFAULT_WIDTH,
                      int pNumRows = 10, int pNumCols = 5,
                      int pDefaultColWidth = 12,
                      const std::string& pTitle = "",
                      eBorderStyle pBorderStyle = eBS_SINGLE_LINE);
 
      cxGrid(const cxGrid& pThatGrid);
 
      virtual ~cxGrid();
 
      // Overridden virtual functions from cxWindow
 
      virtual long show(bool pBringToTop = false, bool pShowSubwindows = true) override;
      virtual long showModal(bool pShowSelf = true, bool pBringToTop = true, bool pShowSubwindows = true) override;
      virtual bool modalGetsKeypress() const override;
      virtual void draw() override;
      virtual void hide(bool pHideSubwindows = true) override;
      virtual void unhide(bool pUnhideSubwindows = true) override;
      virtual void erase(bool pEraseSubwindows = true) override;
      virtual bool move(int pNewRow, int pNewCol, bool pRefresh = true) override;
      virtual void resize(int pNewHeight, int pNewWidth, bool pRefresh = true) override;
      virtual void clear(bool pRefresh = false) override;
      virtual void bringToTop(bool pRefresh = true) override;
      virtual bool hasFocus() const override;
      virtual void setColor(e_WidgetItems pItem, e_cxColors pColor) override;
      virtual void setBorderStyle(eBorderStyle pBorderStyle) override;
      virtual void setLastKey(int pLastKey) override;
      virtual void quitNow() override;
      virtual void exitNow() override;
      virtual bool setKeyFunction(int pKey, const std::shared_ptr<cxFunction>& pFunction) override;
      virtual void clearKeyFunction(int pKey) override;
      virtual void clearKeyFunctions() override;
      virtual void removeQuitKey(int pKey) override;
      virtual void removeExitKey(int pKey) override;
      virtual void setEnabled(bool pEnabled) override;
      virtual void setDisableCursorOnShow(bool pDisableCursorOnShow) override;
      virtual std::string cxTypeStr() const override;
      virtual cxWindow* getParent() const override;
      virtual void addAttr(e_WidgetItems pItem, attr_t pAttr) override;
      virtual void setAttr(e_WidgetItems pItem, attr_t pAttr) override;
      virtual void removeAttr(e_WidgetItems pItem, attr_t pAttr) override;
      virtual void removeAttrs(e_WidgetItems pItem) override;
      virtual void getAttrs(e_WidgetItems pItem, std::set<attr_t>& pAttrs) const override;
      virtual void enableAttrs(WINDOW *pWin, e_WidgetItems pItem) override;
      virtual void disableAttrs(WINDOW *pWin, e_WidgetItems pItem) override;
      virtual e_cxColors getItemColor(e_WidgetItems pItem) const override;
 
      // Grid-specific functions
 
      virtual long showModal(int pFocusRow, int pFocusCol, bool pShowSelf = true, bool pBringToTop = true, bool pShowSubwindows = true);
 
      int getNumRows() const;
 
      int getNumCols() const;
 
      void setNumRows(int pNumRows);
 
      void setNumCols(int pNumCols);
 
      std::shared_ptr<cxWindow> getCell(int pRow, int pCol) const;
 
      bool setCell(int pRow, int pCol, const std::shared_ptr<cxWindow>& pWidget);
 
      std::string getCellValue(int pRow, int pCol) const;
 
      bool setCellValue(int pRow, int pCol, const std::string& pValue);
 
      void setColLabel(int pCol, const std::string& pLabel);
 
      std::string getColLabel(int pCol) const;
 
      void setRowLabel(int pRow, const std::string& pLabel);
 
      std::string getRowLabel(int pRow) const;
 
      void setColWidth(int pCol, int pWidth);
 
      int getColWidth(int pCol) const;
 
      void setRowHeaderWidth(int pWidth);
 
      int getRowHeaderWidth() const;
 
      int getFocusRow() const;
 
      int getFocusCol() const;
 
      void setFocusCell(int pRow, int pCol);
 
      void setHeaderColor(e_cxColors pColor);
 
      void setGridLineColor(e_cxColors pColor);
 
      void showColHeaders(bool pShow);
 
      bool getShowColHeaders() const;
 
      void showRowHeaders(bool pShow);
 
      bool getShowRowHeaders() const;
 
   private:
 
      // Grid dimensions (data rows/cols, not including headers)
      int mNumRows;
      int mNumCols;
 
      // The 2D grid of cell widgets. Indexed as mCells[row][col].
      std::vector<std::vector<std::shared_ptr<cxWindow>>> mCells;
 
      // Column widths (one per column)
      std::vector<int> mColWidths;
 
      // Column header labels (one per column)
      std::vector<std::string> mColLabels;
 
      // Row header labels (one per row)
      std::vector<std::string> mRowLabels;
 
      // Width of the row header column (on the left)
      int mRowHeaderWidth;
 
      // Currently focused cell
      int mFocusRow;
      int mFocusCol;
 
      // Scroll offsets (for when the grid is larger than the visible area)
      int mScrollRow; // First visible data row
      int mScrollCol; // First visible data column
 
      // Whether to show headers
      bool mShowColHeaders;
      bool mShowRowHeaders;
 
      // Colors for grid elements
      short mHeaderColorPair;
      short mGridLineColorPair;
 
      // Default column width for new columns
      int mDefaultColWidth;
 
      // Helper functions
 
      static std::string defaultColLabel(int pCol);
 
      static std::string defaultRowLabel(int pRow);
 
      std::shared_ptr<cxWindow> createDefaultCell(int pRow, int pCol);
 
      void initGrid();
 
      void drawColHeaders();
 
      void drawRowHeaders();
 
      void drawGridLines();
 
      void positionCells();
 
      int visibleRows() const;
 
      int visibleCols() const;
 
      int innerTop() const;
 
      int innerLeft() const;
 
      void ensureFocusVisible();
 
      void focusNextCell();
 
      void focusPrevCell();
 
      bool findCellAt(int pY, int pX, int& pRow, int& pCol) const;
 
      long inputLoop();
};
 
} // namespace cx
 
#endif // __CXGRID_H__