Fl_Table Binding Map

Back to Index
Package name
Fl_Table FLTK.Widgets.Groups.Tables

Note:

This Table type should really be abstract but cannot be for technical binding reasons. If you try to use it directly you will get issues with the draw_cell method. Either extend it and override that subprogram or use types already extended from it.

Types
Fl_Table Table
  Table_Reference
TableContext Table_Context
ResizeFlag Resize_Flag
int Tab_Navigation
Errors
int Range_Error
Protected Attributes
int botrow;
Intentionally left unbound. 
int current_col;
Intentionally left unbound. 
int current_row;
Intentionally left unbound. 
Fl_Scrollbar * hscrollbar;

function H_Bar
       (This : in out Table)
    return Valuators.Sliders.Scrollbars.Scrollbar_Reference;

int leftcol;
Intentionally left unbound. 
int leftcol_scrollpos;
Intentionally left unbound. 
int rightcol;
Intentionally left unbound. 
int select_col;
Intentionally left unbound. 
int select_row;
Intentionally left unbound. 
Fl_Scroll * table;

function Scroll_Area
       (This : in out Table)
    return Scrolls.Scroll_Reference;

int table_h;
Intentionally left unbound. 
int table_w;
Intentionally left unbound. 
int tih;
Intentionally left unbound. 
int tiw;
Intentionally left unbound. 
int tix;
Intentionally left unbound. 
int tiy;
Intentionally left unbound. 
int toh;
Intentionally left unbound. 
int toprow;
Intentionally left unbound. 
int toprow_scrollpos;
Intentionally left unbound. 
int tow;
Intentionally left unbound. 
int tox;
Intentionally left unbound. 
int toy;
Intentionally left unbound. 
Fl_Scrollbar * vscrollbar;

function V_Bar
       (This : in out Table)
    return Valuators.Sliders.Scrollbars.Scrollbar_Reference;

int wih;
Intentionally left unbound. 
int wiw;
Intentionally left unbound. 
int wix;
Intentionally left unbound. 
int wiy;
Intentionally left unbound.
Constructors
Fl_Table(int X, int Y, int W, int H, const char *l=0);

function Create
       (X, Y, W, H : in Integer;
        Text       : in String := "")
    return Table;
Rely on the automatic use of begin when a group is created, or use begin/end explicitly, or add each widget to its intended parent group manually. 
function Create
       (Parent     : in out Groups.Group'Class;
        X, Y, W, H : in     Integer;
        Text       : in     String := "")
    return Table;
Functions and Procedures
void add(Fl_Widget &wgt);

void add(Fl_Widget *wgt);

procedure Add
       (This : in out Table;
        Item : in out Widget'Class);

Fl_Widget * const * array();
Use iterators instead. 
void begin();

procedure Begin_Current
       (This : in out Table);

void callback(Fl_Widget *, void *);
(This signature is wrong due to Doxygen weirdness.)		 
procedure Set_Callback
       (This : in out Table;
        Func : in     Widget_Callback);

int callback_col();

function Callback_Column
       (This : in Table)
    return Positive;

TableContext callback_context();

function Callback_Context
       (This : in Table)
    return Table_Context;

int callback_row();

function Callback_Row
       (This : in Table)
    return Positive;
Check if the index value is in range manually. 
function Has_Child
       (This  : in Table;
        Place : in Index)
    return Boolean;
  
function Has_Child
       (Place : in Cursor)
    return Boolean;

Fl_Widget * child(int n) const;

function Child
       (This  : in Table;
        Place : in Index)
    return Widget_Reference
with Pre => This.Has_Child (Place);
  
function Child
       (This  : in Table;
        Place : in Cursor)
    return Widget_Reference;

int children() const;

function Number_Of_Children
       (This : in Table)
    return Natural;

virtual void clear();

procedure Clear
       (This : in out Table);

int col_header();

function Column_Headers_Enabled
       (This : in Table)
    return Boolean;

void col_header(int flag);

procedure Set_Column_Headers
       (This  : in out Table;
        Value : in     Boolean);

Fl_Color col_header_color();

function Get_Column_Header_Color
       (This : in Table)
    return Color;

void col_header_color(Fl_Color val);

procedure Set_Column_Header_Color
       (This  : in out Table;
        Value : in     Color);

int col_header_height();

function Get_Column_Header_Height
       (This : in Table)
    return Positive;

void col_header_height(int height);

procedure Set_Column_Header_Height
       (This  : in out Table;
        Value : in     Positive);

int col_position();

function Get_Column_Position
       (This : in Table)
    return Positive;

void col_position(int col);

procedure Set_Column_Position
       (This  : in out Table;
        Value : in     Positive);

int col_resize();

function Column_Resize_Allowed
       (This : in Table)
    return Boolean;

void col_resize(int flag);

procedure Set_Column_Resize
       (This  : in out Table;
        Value : in     Boolean);

int col_resize_min();

function Get_Column_Resize_Minimum
       (This : in Table)
    return Positive;

void col_resize_min(int val);

procedure Set_Column_Resize_Minimum
       (This  : in out Table;
        Value : in     Positive);

int col_width(int col);

function Get_Column_Width
       (This   : in Table;
        Column : in Positive)
    return Positive;

void col_width(int col, int width);

procedure Set_Column_Width
       (This   : in out Table;
        Column : in     Positive;
        Value  : in     Positive);

void col_width_all(int width);

procedure Set_All_Columns_Width
       (This  : in out Table;
        Value : in     Positive);

int cols();

function Get_Columns
       (This : in Table)
    return Natural;

virtual void cols(int val);

procedure Set_Columns
       (This  : in out Table;
        Value : in     Natural);

void do_callback(TableContext context, int row, int col);

procedure Do_Callback
       (This        : in out Table;
        Context     : in     Table_Context;
        Row, Column : in     Positive);

void draw(void);

procedure Draw
       (This : in out Table);

void end();

procedure End_Current
       (This : in out Table);

int find(const Fl_Widget &wgt) const;

int find(const Fl_Widget *wgt) const;

function Find
       (This : in Table;
        Item : in Widget'Class)
    return Extended_Index;

void get_selection(int &row_top, int &col_left,
    int &row_bot, int &col_right);

procedure Get_Selection
       (This         : in     Table;
        Row_Top      :    out Positive;
        Column_Left  :    out Positive;
        Row_Bottom   :    out Positive;
        Column_Right :    out Positive);

void init_sizes();

procedure Reset_Sizes
       (This : in out Table);

void insert(Fl_Widget &wgt, Fl_Widget &w2);

procedure Insert
       (This   : in out Table;
        Item   : in out Widget'Class;
        Before : in     Widget'Class);

void insert(Fl_Widget &wgt, int n);

procedure Insert
       (This  : in out Table;
        Item  : in out Widget'Class;
        Place : in     Index);

int is_interactive_resize();

function Is_Interactive_Resize
       (This : in Table)
    return Boolean;

int is_selected(int r, int c);

function Is_Selected
       (This        : in Table;
        Row, Column : in Positive)
    return Boolean;

int move_cursor(int R, int C);

int move_cursor(int R, int C, int shiftselect);

procedure Move_Cursor
       (This         : in out Table;
        Row, Column  : in     Positive;
        Shift_Select : in     Boolean := True);

function Move_Cursor
       (This         : in out Table;
        Row, Column  : in     Positive;
        Shift_Select : in     Boolean := True)
    return Boolean;

void remove(Fl_Widget &wgt);

procedure Remove
       (This : in out Table;
        Item : in out Widget'Class);

void resize(int X, int Y, int W, int H);

procedure Resize
       (This       : in out Table;
        X, Y, W, H : in     Integer);

int row_header();

function Row_Headers_Enabled
       (This : in Table)
    return Boolean;

void row_header(int flag);

procedure Set_Row_Headers
       (This  : in out Table;
        Value : in     Boolean);

Fl_Color row_header_color();

function Get_Row_Header_Color
       (This : in Table)
    return Color;

void row_header_color(Fl_Color val);

procedure Set_Row_Header_Color
       (This  : in out Table;
        Value : in     Color);

int row_header_width();

function Get_Row_Header_Width
       (This : in Table)
    return Positive;

void row_header_width(int width);

procedure Set_Row_Header_Width
       (This  : in out Table;
        Value : in     Positive);

int row_height(int row);

function Get_Row_Height
       (This : in Table;
        Row  : in Positive)
    return Positive;

void row_height(int row, int height);

procedure Set_Row_Height
       (This  : in out Table;
        Row   : in     Positive;
        Value : in     Positive);

void row_height_all(int height);

procedure Set_All_Rows_Height
       (This  : in out Table;
        Value : in     Positive);

int row_position();

function Get_Row_Position
       (This : in Table)
    return Positive;

void row_position(int row);

procedure Set_Row_Position
       (This  : in out Table;
        Value : in     Positive);

int row_resize();

function Row_Resize_Allowed
       (This : in Table)
    return Boolean;

void row_resize(int flag);

procedure Set_Row_Resize
       (This  : in out Table;
        Value : in     Boolean);

int row_resize_min();

function Get_Row_Resize_Minimum
       (This : in Table)
    return Positive;

void row_resize_min(int val);

procedure Set_Row_Resize_Minimum
       (This  : in out Table;
        Value : in     Positive);

int rows();

function Get_Rows
       (This : in Table)
    return Natural;

virtual void rows(int val);

procedure Set_Rows
       (This  : in out Table;
        Value : in     Natural);

int scrollbar_size() const;

function Get_Scrollbar_Size
       (This : in Table)
    return Integer;

void scrollbar_size(int newSize);

procedure Set_Scrollbar_Size
       (This  : in out Table;
        Value : in     Integer);

void set_selection(int row_top, int col_left,
    int row_bot, int col_right);

procedure Set_Selection
       (This         : in out Table;
        Row_Top      : in     Positive;
        Column_Left  : in     Positive;
        Row_Bottom   : in     Positive;
        Column_Right : in     Positive);

int tab_cell_nav() const;

function Get_Tab_Mode
       (This : in Table)
    return Tab_Navigation;

void tab_cell_nav(int val);

procedure Set_Tab_Mode
       (This  : in out Table;
        Value : in     Tab_Navigation);

void table_box(Fl_Boxtype val);

procedure Set_Table_Box
       (This : in out Table;
        Box  : in     Box_Kind);

Fl_Boxtype table_box(void);

function Get_Table_Box
       (This : in Table)
    return Box_Kind;

int top_row();

function Get_Top_Row
       (This : in Table)
    return Positive;

void top_row(int row);

procedure Set_Top_Row
       (This  : in out Table;
        Value : in     Positive);

void visible_cells(int &r1, int &r2, int &c1, int &c2);

procedure Get_Visible_Cells
       (This         : in     Table;
        Row_Top      :    out Positive;
        Column_Left  :    out Positive;
        Row_Bottom   :    out Natural;
        Column_Right :    out Natural);

void when(Fl_When flags);

procedure Set_When
       (This  : in out Table;
        Value : in     Callback_Flag);
Static Protected Functions and Procedures
static void scroll_cb(Fl_Widget *, void *);

procedure Scroll_Callback
       (Item : in out Widget'Class);
Protected Functions and Procedures
void change_cursor(Fl_Cursor newcursor);

procedure Set_Cursor_Kind
       (This : in out Table;
        Kind : in     Mouse_Cursor_Kind);

long col_scroll_position(int col);

function Get_Column_Scroll_Position
       (This   : in Table;
        Column : in Positive)
    return Long_Integer;

TableContext cursor2rowcol(int &R, int &C, ResizeFlag &resizeflag);

procedure Cursor_To_Row_Column
       (This        : in     Table;
        Row, Column :    out Positive;
        Context     :    out Table_Context;
        Resize      :    out Resize_Flag);

void damage_zone(int r1, int c1, int r2, int c2, int r3=0, int c3=0);

procedure Damage_Zone
       (This         : in out Table;
        Row_Top      : in     Positive;
        Column_Left  : in     Positive;
        Row_Bottom   : in     Positive;
        Column_Right : in     Positive;
        Reach_Row    : in     Positive := 1;
        Reach_Column : in     Positive := 1);

virtual void draw_cell(TableContext context, int R=0, int C=0,
    int X=0, int Y=0, int W=0, int H=0);

procedure Draw_Cell
       (This        : in out Table;
        Context     : in     Table_Context;
        Row, Column : in     Natural := 0;
        X, Y, W, H  : in     Integer := 0);

int find_cell(TableContext context, int R, int C,
    int &X, int &Y, int &W, int &H);

procedure Cell_Dimensions
       (This        : in     Table;
        Context     : in     Table_Context;
        Row, Column : in     Positive;
        X, Y, W, H  :    out Integer);

void get_bounds(TableContext context, int &X, int &Y, int &W, int &H);

procedure Bounding_Region
       (This       : in     Table;
        Context    : in     Table_Context;
        X, Y, W, H :    out Integer);

int handle(int e);

function Handle
       (This  : in out Table;
        Event : in     Event_Kind)
    return Event_Outcome;

int is_fltk_container();

function Used_As_Container
       (This : in Table)
    return Boolean;

void recalc_dimensions();

procedure Recalculate_Dimensions
       (This : in out Table);

void redraw_range(int topRow, int botRow, int leftCol, int rightCol);

procedure Redraw_Range
       (This         : in out Table;
        Row_Top      : in     Positive;
        Column_Left  : in     Positive;
        Row_Bottom   : in     Positive;
        Column_Right : in     Positive);

int row_col_clamp(TableContext context, int &R, int &C);

procedure Row_Column_Clamp
       (This        : in     Table;
        Context     : in     Table_Context;
        Row, Column : in out Integer);

function Row_Column_Clamp
       (This        : in     Table;
        Context     : in     Table_Context;
        Row, Column : in out Integer)
    return Boolean;

long row_scroll_position(int row);

function Get_Row_Scroll_Position
       (This : in Table;
        Row  : in Positive)
    return Long_Integer;

void table_resized();

procedure Table_Resized
       (This : in out Table);

void table_scrolled();

procedure Table_Scrolled
       (This : in out Table);