The constructor for the Fl_Table. This creates an empty table with no rows or columns, with headers and row/column resize behavior disabled.

The destructor for the Fl_Table. Destroys the table and its associated widgets.

Fl_Widget* Fl_Table::child(int n) const

When using the Fl_Table as a container for FLTK widgets, this method returns the widget pointer from the internal array of widgets in the container.

Typically used in loops, eg:

        for ( int i=0; i<children(); i++ )
	{
	    Fl_Widget *w = child(i);
	    [..]
	}
    

int Fl_Table::children()

void Fl_Table::clear()

Clears the table to zero rows, zero columns. Same as rows(0); cols(0);

Subclass should override this method to handle drawing the cells. This method will be called whenever the table is redrawn, once per cell.

Only cells that are completely (or partially) visible will be told to draw.

context will be one of the following:

Fl_Table::CONTEXT_STARTPAGE	When table, or parts of the table, are about to be redrawn. Use to initialize static data, such as font selections. r/c will be zero, x/y/w/h will be the dimensions of the table's entire data area. (Useful for locking a database before accessing; see also visible_cells())
Fl_Table::CONTEXT_ENDPAGE	When table has completed being redrawn. r/c will be zero, x/y/w/h dimensions of table's data area. (Useful for unlocking a database after accessing)
Fl_Table::CONTEXT_ROW_HEADER	Whenever a row header cell needs to be drawn.
Fl_Table::CONTEXT_COL_HEADER	Whenever a column header cell needs to be drawn.
Fl_Table::CONTEXT_CELL	Whenever a data cell in the table needs to be drawn.
Fl_Table::CONTEXT_RC_RESIZE	Whenever table or row/column is resized or scrolled, either interactively or via col_width() or row_height(). Useful for fltk containers that need to resize or move the child fltk widgets.

row and col will be set to the row and column number the user clicked on. In the case of row headers, col will be 0. In the case of column headers, row will be 0.

x/y/w/h will be the position and dimensions of where the cell should be drawn.

In the case of custom widgets, a minimal draw_cell() override might look like the following. With custom widgets it is up to the caller to handle drawing everything within the dimensions of the cell, including handling the selection color. Note all clipping must be handled as well; this allows drawing outside the dimensions of the cell if so desired for 'custom effects'.

    void MyTable::draw_cell(TableContext context, int R=0, int C=0, int X=0, int Y=0, int W=0, int H=0)
    {
	static char s[40];
	sprintf(s, "%d/%d", R, C);		// text for each cell
	switch ( context )
	{
	    case CONTEXT_STARTPAGE:
		fl_font(FL_HELVETICA, 16);
		return;

	    case CONTEXT_ROW_HEADER:
	    case CONTEXT_COL_HEADER:
		fl_push_clip(X, Y, W, H);
		{
		    fl_draw_box(FL_THIN_UP_BOX, X, Y, W, H, color());
		    fl_color(FL_BLACK);
		    fl_draw(s, X, Y, W, H, FL_ALIGN_CENTER);
		}
		fl_pop_clip();
		return;

	    case CONTEXT_CELL:
		fl_push_clip(X, Y, W, H);
		{
		    // BG COLOR
		    fl_color( row_selected(R) ? selection_color() : FL_WHITE);
		    fl_rectf(X, Y, W, H);

		    // TEXT
		    fl_color(FL_BLACK);
		    fl_draw(s, X, Y, W, H, FL_ALIGN_CENTER);

		    // BORDER
		    fl_color(FL_LIGHT2); 
		    fl_rect(X, Y, W, H);
		}
		fl_pop_clip();
		return;

	    default:
	        return;
	}
	//NOTREACHED
    }
    

The first form sets the number of columns in the table, and the table is redrawn.

The second form returns the number of columns in the table.

The first form enables/disables column headers; 1=enabled, 0=disabled. If changed, the table is redrawn.

The second form returns if column headers are enabled or not; 1=enabled, 0=disabled.

The first form sets the column header color and the table is redrawn.

The second form returns the current column header color.

The first form sets the column header height to n and causes the screen to redraw.

The second form returns the current column header height (in pixels).

The first form sets the current column minimum resize value. This is used to prevent the user from interactively resizing any column to be smaller than 'pixels'. Must be a value >=1.

The second form returns the current column minimum resize value.

The first form sets the column scroll position to column 'col', and causes the screen to redraw.

The second form returns the current column scroll position as a column number.

The first form sets the width of the specified column in pixels, and the table is redrawn. callback() will be invoked with CONTEXT_RC_RESIZE if the column's width was actually changed, and when() is FL_WHEN_CHANGED.

The second form returns the current width of the specified column in pixels and causes the screen to redraw.

Convenience method to set the width of all columns to the same value, in pixels. The screen is redrawn.

Returns 1 if someone is interactively resizing a row or column. You can currently call this only from within your callback().

Changes the size of the Fl_Table, causing it to redraw.

The first form sets the number of rows in the table, and the table is redrawn.

The second form returns the number of rows in the table.

The first form enables/disables showing the row headers; 1=enabled, 0=disabled. If changed, the table is redrawn.

The second form returns the value of this flag.

The first form sets the row header color and causes the screen to redraw.

The second form returns the current row header color.

The first form sets the row header width to n and causes the screen to redraw.

The second form returns the current row header width (in pixels).

The first form sets the current row minimum resize value. This is used to prevent the user from interactively resizing any row to be smaller than 'pixels'. Must be a value >=1.

The second form returns the current row minimum resize value.

The first form sets the row scroll position to 'row', and causes the screen to redraw.

The second form returns the current row scroll position as a row number.

The first form sets the height of the specified row in pixels, and the table is redrawn. callback() will be invoked with CONTEXT_RC_RESIZE if the row's height was actually changed, and when() is FL_WHEN_CHANGED.

The second form returns the current height of the specified row as a value in pixels.

Convenience method to set the height of all rows to the same value, in pixels. The screen is redrawn.

void Fl_Table::table_box(Fl_Boxtype type)
Fl_Boxtype Fl_Table::table_box()

The first form sets the kind of box drawn around the data table, the default being FL_NO_BOX. Changing this value will cause the table to redraw.

The second form returns the current box type used for the data table.

The first form sets which row should be at the top of the table, scrolling as necessary, and the table is redrawn. If the table cannot be scrolled that far, it is scrolled as far as possible.

The second form returns the current top row shown in the table. This row may be partially obscured.

Returns the range of row and column numbers for all the visible (and partially visible) cells in the table.

These values can be used e.g. by your draw_cell() routine during CONTEXT_STARTPAGE to figure out what cells are about to be redrawn, for the purposes of locking the data from a database before it's drawn.

	                    leftcol             rightcol
	                    :                   :
	          toprow .. .-------------------.
	                    |                   |
	                    |  V I S I B L E    |
	                    |                   |
	                    |    T A B L E      |
	                    |                   |
	          botrow .. '-------------------`
    

e.g. in a table where the visible rows are 5-20, and the visible columns are 100-120, then those variables would be:
toprow = 5
botrow = 20
leftcol = 100
rightcol = 120