Fl_Grid.H

Go to the documentation of this file.

//
// Fl_Grid widget header for the Fast Light Tool Kit (FLTK).
//
// Copyright 2021-2022 by Albrecht Schlosser.
// Copyright 2022-2025 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file.  If this
// file is missing or damaged, see the license at:
//
//     https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
//     https://www.fltk.org/bugs.php
//
 
#ifndef _FL_FL_GRID_H_
#define _FL_FL_GRID_H_
 
#include <FL/Fl_Group.H>
#include <FL/Fl_Rect.H>
 
typedef unsigned short Fl_Grid_Align;
 
const Fl_Grid_Align  FL_GRID_CENTER          = 0x0000;
 
const Fl_Grid_Align  FL_GRID_TOP             = 0x0001;
 
const Fl_Grid_Align  FL_GRID_BOTTOM          = 0x0002;
 
const Fl_Grid_Align  FL_GRID_LEFT            = 0x0004;
 
const Fl_Grid_Align  FL_GRID_RIGHT           = 0x0008;
 
const Fl_Grid_Align  FL_GRID_HORIZONTAL      = 0x0010;
 
const Fl_Grid_Align  FL_GRID_VERTICAL        = 0x0020;
 
const Fl_Grid_Align  FL_GRID_FILL            = 0x0030;
 
const Fl_Grid_Align  FL_GRID_PROPORTIONAL    = 0x0040;
 
const Fl_Grid_Align  FL_GRID_TOP_LEFT        =  FL_GRID_TOP |  FL_GRID_LEFT;
const Fl_Grid_Align  FL_GRID_TOP_RIGHT       =  FL_GRID_TOP |  FL_GRID_RIGHT;
const Fl_Grid_Align  FL_GRID_BOTTOM_LEFT     =  FL_GRID_BOTTOM |  FL_GRID_LEFT;
const Fl_Grid_Align  FL_GRID_BOTTOM_RIGHT    =  FL_GRID_BOTTOM |  FL_GRID_RIGHT;
 
class FL_EXPORT Fl_Grid : public Fl_Group {
  friend class Fl_Grid_Type;
 
public:
  class Cell {
    friend class Fl_Grid;
  private:
    Cell *next_;                // next cell in the same row
    short row_;                 // row number
    short col_;                 // column number
    short rowspan_;             // row span (1 - n)
    short colspan_;             // column span (1 - n)
    Fl_Grid_Align align_;       // widget alignment in its cell
    Fl_Widget *widget_;         // assigned widget
    int w_;                     // minimal widget width
    int h_;                     // minimal widget height
 
  public:
 
    void Cell_() {              // common initialization
      next_ = NULL;
      row_ = 0;
      col_ = 0;
      rowspan_ = 1;
      colspan_ = 1;
      widget_ = NULL;
      w_ = 0;
      h_ = 0;
      align_ = 0;
    }
 
    Cell(int row, int col) {    // constructor
      Cell_();
      row_ = row;
      col_ = col;
    }
 
    Cell(Fl_Widget *w, int row, int col) {  // widget assignment
      Cell_();
      widget_ = w;
      row_ = row;
      col_ = col;
    }
 
    ~Cell() {}
 
    Cell *next() {
      return next_;
    }
 
    void next(Cell *c) {
      next_ = c;
    }
 
    Fl_Widget *widget() const { return widget_; }
 
    short row() const { return row_; }
    short col() const { return col_; }
 
    void rowspan(short v) { rowspan_ = v; }
    void colspan(short v) { colspan_ = v; }
    short rowspan() const { return rowspan_; }
    short colspan() const { return colspan_; }
 
    void align(Fl_Grid_Align align) { align_ = align; }
    Fl_Grid_Align align() const { return align_; }
 
    void minimum_size(int w, int h) { if (w>=0) w_ = w; if (h>=0) h_ = h; }
    void minimum_size(int *w, int *h) const { if (w) *w = w_; if (h) *h = h_; }
  }; // class Cell
 
private:
  class Row;
  class Col;
  short rows_;
  short cols_;
 
  short margin_left_;         // left margin
  short margin_top_;          // top margin
  short margin_right_;        // right margin
  short margin_bottom_;       // bottom margin
  short gap_row_;             // gap between rows
  short gap_col_;             // gap between columns
  Fl_Rect old_size;           // only for resize callback (TBD)
  Col  *Cols_;                // array of columns
  Row  *Rows_;                // array of rows
  bool need_layout_;          // true if layout needs to be calculated
 
protected:
  Fl_Color grid_color;        // color for drawing the grid lines (design helper)
  bool draw_grid_;            // draw the grid for testing / design
 
protected:
  void init();
  Cell *add_cell(int row, int col);
  void remove_cell(int row, int col);
 
public:
  Fl_Grid(int X, int Y, int W, int H, const char *L = 0);
  virtual ~Fl_Grid();
 
  // define and manage the layout and resizing
 
  virtual void layout(int rows, int cols, int margin = -1, int gap = -1);
  virtual void layout();
  virtual void clear_layout();
  virtual void resize(int X, int Y, int W, int H) FL_OVERRIDE;
 
  short rows() const { return rows_; }
  short cols() const { return cols_; }
 
  void need_layout(int set) {
    if (set) {
      need_layout_ = true;
      redraw();
    }
    else {
      need_layout_ = false;
    }
  }
 
  bool need_layout() const {
    return need_layout_;
  }
 
protected:
  virtual void draw() FL_OVERRIDE;
  void on_remove(int) FL_OVERRIDE;
  virtual void draw_grid();           // draw grid lines for debugging
 
public:
 
  // get and set individual margins
 
  virtual void margin(int left, int top = -1, int right = -1, int bottom = -1);
  int margin(int *left, int *top, int *right, int *bottom) const;
 
  // get and set default row and column gaps for all rows and columns, respectively
 
  virtual void gap(int row_gap, int col_gap = -1);   // set default row and column gap(s)
  void gap(int *row_gap, int *col_gap) const;
 
  // find cells, get cell pointers
 
  Fl_Grid::Cell* cell(int row, int col) const;
  Fl_Grid::Cell* cell(Fl_Widget *widget) const;
 
  // assign a widget to a cell
 
  Fl_Grid::Cell* widget(Fl_Widget *wi, int row, int col, Fl_Grid_Align align = FL_GRID_FILL);
  Fl_Grid::Cell* widget(Fl_Widget *wi, int row, int col, int rowspan, int colspan, Fl_Grid_Align align = FL_GRID_FILL);
 
  // set minimal column and row sizes (widths and heights, respectively),
  // set row and column specific gaps and weights
 
  void col_width(int col, int value);
  void col_width(const int *value, size_t size);
  int col_width(int col) const;
 
  void col_weight(int col, int value);
  void col_weight(const int *value, size_t size);
  int col_weight(int col) const;
 
  void col_gap(int col, int value);
  void col_gap(const int *value, size_t size);
  int col_gap(int col) const;
 
  void row_height(int row, int value);
  void row_height(const int *value, size_t size);
  int row_height(int row) const;
 
  void row_weight(int row, int value);
  void row_weight(const int *value, size_t size);
  int row_weight(int row) const;
 
  void row_gap(int row, int value);
  void row_gap(const int *value, size_t size);
  int row_gap(int row) const;
 
  int computed_col_width(int col) const;
  int computed_row_height(int row) const;
 
  void show_grid(int set) {
    draw_grid_ = set ? true : false;
  }
 
  void show_grid(int set, Fl_Color col) {
    draw_grid_ = set ? true : false;
    grid_color = col;
  }
 
  void debug(int level = 127);
 
}; // class Fl_Grid
 
#endif // _FL_FL_GRID_H_