Fl_Group
|
+----Fl_Table
|
+----Fl_Table_Row
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.
This widget can be used in several ways:
When acting as part of a custom widget, 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 setting for Fl_Table::when().
When acting as a container for FLTK widgets, the FLTK widgets maintain themselves. Although the draw_cell() method must be overridden, its contents can be very simple.
The callback function should use the following functions to determine the context/row/column:
callback_row() and callback_col() will be set to the row and column number the event occurred on. If someone clicked on a row header, col will be 0. If someone clicked on a column header, row will be 0.
callback_context() will return one of the following:
| Fl_Table.CONTEXT_ROW_HEADER | Someone clicked on a row header. Excludes resizing. |
| Fl_Table.CONTEXT_COL_HEADER | Someone clicked on a column header. Excludes resizing. |
| Fl_Table.CONTEXT_CELL |
Someone clicked on a cell. To receive callbacks for FL_RELEASE events, you must set when(FL_WHEN_RELEASE). |
| Fl_Table.CONTEXT_RC_RESIZE |
Someone is resizing rows/columns either interactively,
or via the col_width() or
row_height() API.
Use is_interactive_resize() to determine interactive resizing. If resizing a column, R=0 and C=column being resized. If resizing a row, C=0 and R=row being resized. NOTE: To receive resize events, you must set when(FL_WHEN_CHANGED). |
Example:
class MyTable(Fl_Table):
def __init__(self,...): # Constructor
Fl_Table.__init__(self,...)
self.callback(self.event_callback, self)
self.when(FL_WHEN_CHANGED|FL_WHEN_RELEASE)
def event_callback(self, widget, data):
R = self.callback_row()
C = self.callback_col()
context = self.callback_context()
print "callback: Row=%d Col=%d Context=%d Event=%d\n"%(R,C, int(context), int(Fl.event()))
callback_row() returns the current row the event occurred on.
callback_col() returns the current column the event occurred on.
callback_context() returns the current 'table context'. See possible contexts.
Typically used in loops, eg:
for i in range(self.children()):
w = self.child(i);
[..]
See Also: child(), which has an example loop showing how these methods should be used.
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'.
def draw_cell(self, context, R=0, C=0, X=0, Y=0, W=0, H=0:
s="%d/%d"%(R, C) # text for each cell
if context==self.CONTEXT_STARTPAGE:
fl_font(FL_HELVETICA, 16)
return
elif context==self.CONTEXT_ROW_HEADER or context==self.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
elif context==self.CONTEXT_CELL:
fl_push_clip(X, Y, W, H)
# BG COLOR
if self.row_selected(R):
fl_color(self.selection_color())
else:
fl_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
The second form returns the number of columns in the table.
The second form returns if column headers are enabled or not; 1=enabled, 0=disabled.
The second form returns the current column header color.
The second form returns the current column header height (in pixels).
The second form returns the current column minimum resize value.
The second form returns the current column scroll position as a column number.
The second form returns the current value of this flag.
The second form returns the current width of the specified column in pixels and causes the screen to redraw.
The second form returns the number of rows in the table.
The second form returns the value of this flag.
The second form returns the current row header color.
The second form returns the current row header width (in pixels).
The second form returns the current row minimum resize value.
The second form returns the current row scroll position as a row number.
The second form returns the current value of this flag.
The second form returns the current height of the specified row as a value in pixels.
The second form returns the current box type used for the data table.
The second form returns the current top row shown in the table. This row may be partially obscured.
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:
The second form returns the current value of when().
These are the only values currently supported:
| FL_WHEN_CHANGED | callback() will be called when rows or columns are resized (interactively or via col_width() or row_height()), passing CONTEXT_RC_RESIZE via callback_context(). |
| FL_WHEN_RELEASE | callback() will be called during FL_RELEASE events, such as when someone releases a mouse button somewhere on the table. |
The callback() routine is sent a TableContext that indicates the context the event occurred in, such as in a cell, in a header, or elsewhere on the table. When an event occurs in a cell or header, callback_row() and callback_col() can be used to determine the row and column. The callback can also look at the regular fltk event values (ie. Fl.event() and Fl.button()) to determine what kind of event is occurring.