class Fl_Table

Class Hierarchy

  Fl_Group
     |
     +----Fl_Table
	     |
	     +----Fl_Table_Row

Include Files

  #include <FL/Fl_Table.H>

Description

This is the base class for table widgets. (eg. Fl_Table_Row). To be useful it must be subclassed and several virtual functions defined. Normally applications use widgets derived from this widget, and do not this widget itself; this widget is usually too low level to be used directly by applications.

This widget does not handle the data in the table. The draw_cell() method must be overridden by a subclass to manage drawing the contents of the cells.

Events on the cells and/or headings generate callbacks when they are clicked by the user. You control when events are generated based on the values you supply for when().

virtual void draw_cell(TableContext context, int row, int col, int x, int y, int w, int h)

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

context will be one of the following:

Fl_Table::CONTEXT_NEWPAGE - when table is about to be redrawn. Use to initialize static data.
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

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 dimension of the cell.

A minimal draw_cell() override might look like the following. 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_NEWPAGE:
		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
    }

virtual void callback(TableContext context, int row, int col)

Subclass should override this method to handle events generated in the table. This method will be called depending on the setting of

when()

context will be one of the following:

Fl_Table::CONTEXT_ROW_HEADER - whenever someone clicked on a row header
Fl_Table::CONTEXT_COL_HEADER - whenever someone clicked on a column header
Fl_Table::CONTEXT_CELL - whenever someone clicked on a cell

row and col will be set to the row and column number the user clicked on. If someone clicked on a row header, col will be 0. If someone clicked on a column header, row will be 0.

int Fl_Table::cols() void Fl_Table::cols(int n)

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

int Fl_Table::col_header() void Fl_Table::col_header(int n)

The second form sets if column headers should be enabled; 1=enabled, 0=disabled. If changed, the table is redrawn.

int Fl_Table::col_resize() void Fl_Table::col_resize(int n)

The second form sets if columns can be resized by the user; 1=enabled, 0=disabled.

int Fl_Table::col_width(int col) void Fl_Table::col_width(int col, int new_width)

The second form sets the width of the specified column in pixels, and the table is redrawn.

int Fl_Table::rows() void Fl_Table::rows(int n)

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

int Fl_Table::row_header() void Fl_Table::row_header(int n)

NOTE: Row headers (along left) are not yet supported.

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

The second form sets if row headers should be enabled; 1=enabled, 0=disabled. If changed, the table is redrawn.

int Fl_Table::row_resize() void Fl_Table::row_resize(int n)

NOTE: Row resizing is not yet supported.

The first form returns if rows can be resized by the user by dragging the row borders in the row's header. row_header() must also be enabled for this to be useful. 1=resizable, 0=disabled.

The second form sets if rows can be resized by the user; 1=enabled, 0=disabled.

int Fl_Table::row_height(int row) void Fl_Table::row_height(int row, int new_height)

NOTE: Row height affects all rows. Individual row height control not yet supported.

The first form returns the current height of the specified row in pixels.

The second form sets the height of the specified row in pixels, and the table is redrawn.

int Fl_Table::top_row() void Fl_Table::top_row(int row)

The second 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.

Fl_When Fl_Table::when() int Fl_Table::when(Fl_When val)