Fl_Widget Binding Map

Back to Index
Package name
Fl_Widget FLTK.Widgets
Types
Fl_Widget Widget
  Widget_Reference
Fl_Callback_p Widget_Callback
Fl_When Callback_Flag
uchar Damage_Mask
Constructors
Fl_Widget(int x, int y, int w, int h, const char *label=0L);

function Create
       (X, Y, W, H : in Integer;
        Text       : in String := "")
    return Widget;
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 FLTK.Widgets.Groups.Group'Class;
        X, Y, W, H : in     Integer;
        Text       : in     String := "")
    return Widget;
Static Functions and Procedures
static void default_callback(Fl_Widget *cb, void *d);

procedure Default_Callback
       (This : in out Widget'Class);

static unsigned int label_shortcut(const char *t);
Marked as internal use only. 
static int test_shortcut(const char *, const bool require_alt=false);
Marked as internal use only.
Functions and Procedures
void _clear_fullscreen();
Marked as internal use only. 
void _set_fullscreen();
Marked as internal use only. 
void activate();

procedure Activate
       (This : in out Widget);

unsigned int active() const;

function Is_Active
       (This : in Widget)
    return Boolean;

int active_r() const;

function Is_Tree_Active
       (This : in Widget)
    return Boolean;

Fl_Align align() const;

function Get_Alignment
       (This : in Widget)
    return Alignment;

void align(Fl_Align alignment);

procedure Set_Alignment
       (This      : in out Widget;
        New_Align : in     Alignment);

long argument() const;
Intentionally left unbound. 
void argument(long v);
Intentionally left unbound. 
virtual class Fl_Gl_Window * as_gl_window();
Use runtime tag checks and view conversions instead. 
virtual Fl_Group * as_group();
Use runtime tag checks and view conversions instead. 
virtual Fl_Window * as_window();
Use runtime tag checks and view conversions instead. 
Fl_Boxtype box() const;

function Get_Box
       (This : in Widget)
    return Box_Kind;

void box(Fl_Boxtype new_box);

procedure Set_Box
       (This : in out Widget;
        Box  : in     Box_Kind);

Fl_Callback_p callback() const;

function Get_Callback
       (This : in Widget)
    return Widget_Callback;

void callback(Fl_Callback *cb, void *p);
Use callback(Fl_Callback *cb) / Set_Callback instead. 
void callback(Fl_Callback *cb);

void callback(Fl_Callback0 *cb);

procedure Set_Callback
       (This : in out Widget;
        Func : in     Widget_Callback);

void callback(Fl_Callback1 *cb, long p=0);
Use callback(Fl_Callback *cb) / Set_Callback instead. 
unsigned int changed() const;

function Has_Changed
       (This : in Widget)
    return Boolean;

void clear_active();

procedure Clear_Active
       (This : in out Widget);

void clear_changed();

procedure Clear_Changed
       (This : in out Widget);

void clear_damage(uchar c=0);

procedure Clear_Damage
       (This : in out Widget;
        Mask : in     Damage_Mask := Damage_None);

void clear_output();

procedure Clear_Output_Only
       (This : in out Widget);

void clear_visible();

procedure Clear_Visible
       (This : in out Widget);

void clear_visible_focus();

procedure Clear_Visible_Focus
       (This : in out Widget);

Fl_Color color() const;

function Get_Background_Color
       (This : in Widget)
    return Color;

void color(Fl_Color bg);

procedure Set_Background_Color
       (This : in out Widget;
        To   : in     Color);

void color(Fl_Color bg, Fl_Color sel);

procedure Set_Colors
       (This      : in out Widget;
        Back, Sel : in     Color);

Fl_Color color2() const;
Deprecated, use selection_color / Get_Selection_Color instead. 
void color2(unsigned a);
Deprecated, use selection_color / Set_Selection_Color instead. 
int contains(const Fl_Widget *w) const;

function Contains
       (This : in Widget;
        Item : in Widget'Class)
    return Boolean;

void copy_label(const char *new_label);

procedure Set_Label
       (This : in out Widget;
        Text : in     String);

void copy_tooltip(const char *text);

procedure Set_Tooltip
       (This : in out Widget;
        Text : in     String);

uchar damage() const;

function Is_Damaged
       (This : in Widget)
    return Boolean;

function Get_Damage
       (This : in Widget)
    return Damage_Mask;

void damage(uchar c);

procedure Set_Damage
       (This : in out Widget;
        Mask : in     Damage_Mask);

void damage(uchar c, int x, int y, int w, int h);

procedure Set_Damage
       (This       : in out Widget;
        Mask       : in     Damage_Mask;
        X, Y, W, H : in     Integer);

int damage_resize(int, int, int, int);
Marked as internal use only. 
void deactivate();

procedure Deactivate
       (This : in out Widget);

Fl_Image * deimage();

const Fl_Image * deimage() const;

function Get_Inactive_Image
       (This : in Widget)
    return access FLTK.Images.Image'Class;

void deimage(Fl_Image *img);

void deimage(Fl_Image &img);

procedure Set_Inactive_Image
       (This : in out Widget;
        Pic  : in out FLTK.Images.Image'Class);

void do_callback();

procedure Do_Callback
       (This : in out Widget);

void do_callback(Fl_Widget *o, long arg);

void do_callback(Fl_Widget *o, void *arg=0);

procedure Do_Callback
       (This  : in     Widget;
        Using : in out Widget);

virtual void draw()=0;

procedure Draw
       (This : in out Widget);

void draw_label(int, int, int, int, Fl_Align) const;

procedure Draw_Label
       (This       : in out Widget;
        X, Y, W, H : in     Integer;
        Align      : in     Alignment);

int h() const;

function Get_H
       (This : in Widget)
    return Integer;

virtual int handle(int event);

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

virtual void hide();

procedure Hide
       (This : in out Widget);

Fl_Image * image();

const Fl_Image * image() const;

function Get_Image
       (This : in Widget)
    return access FLTK.Images.Image'Class;

void image(Fl_Image *img);

void image(Fl_Image &img);

procedure Set_Image
       (This : in out Widget;
        Pic  : in out FLTK.Images.Image'Class);

int inside(const Fl_Widget *wgt) const;

function Inside
       (This   : in Widget;
        Parent : in Widget'Class)
    return Boolean;

int is_label_copied() const;
Due to the marshalling between String and char * this would always return true, so left unbound. 
const char * label() const;

function Get_Label
       (This : in Widget)
    return String;

void label(const char *text);
Due to the marshalling between String and char * using this method would be pointless, so its functionality is subsumed by copy_label / Set_Label. 
void label(Fl_Labeltype a, const char *b);

procedure Set_Label
       (This : in out Widget;
        Kind : in     Label_Kind;
        Text : in     String);

Fl_Color labelcolor() const;

function Get_Label_Color
       (This : in Widget)
    return Color;

void labelcolor(Fl_Color c);

procedure Set_Label_Color
       (This  : in out Widget;
        Value : in     Color);

Fl_Font labelfont() const;

function Get_Label_Font
       (This : in Widget)
    return Font_Kind;

void labelfont(Fl_Font f);

procedure Set_Label_Font
       (This : in out Widget;
        Font : in     Font_Kind);

Fl_Fontsize labelsize() const;

function Get_Label_Size
       (This : in Widget)
    return Font_Size;

void labelsize(Fl_Fontsize pix);

procedure Set_Label_Size
       (This : in out Widget;
        Size : in     Font_Size);

Fl_Labeltype labeltype() const;

function Get_Label_Kind
       (This : in Widget)
    return Label_Kind;

void labeltype(Fl_Labeltype a);

procedure Set_Label_Kind
       (This  : in out Widget;
        Label : in     Label_Kind);

void measure_label(int &ww, int &hh) const;

procedure Measure_Label
       (This : in     Widget;
        W, H :    out Integer);

unsigned int output() const;

function Is_Output_Only
       (This : in Widget)
    return Boolean;

Fl_Group * parent() const;

function Parent
       (This : in Widget)
    return access FLTK.Widgets.Groups.Group'Class;

void parent(Fl_Group *p);
Marked as internal use only. 
void position(int X, int Y);

procedure Reposition
       (This : in out Widget;
        X, Y : in     Integer);

void redraw();

procedure Redraw
       (This : in out Widget);

void redraw_label();

procedure Redraw_Label
       (This : in out Widget);

virtual void resize(int x, int y, int w, int h);

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

Fl_Color selection_color() const;

function Get_Selection_Color
       (This : in Widget)
    return Color;

void selection_color(Fl_Color a);

procedure Set_Selection_Color
       (This : in out Widget;
        To   : in     Color);

void set_active();

procedure Set_Active
       (This : in out Widget);

void set_changed();

procedure Set_Changed
       (This : in out Widget);

void set_output();

procedure Set_Output_Only
       (This : in out Widget);

void set_visible();

procedure Set_Visible
       (This : in out Widget);

void set_visible_focus();

procedure Set_Visible_Focus
       (This : in out Widget);

virtual void show();

procedure Show
       (This : in out Widget);

void size(int W, int H);

procedure Resize
       (This : in out Widget;
        W, H : in     Integer);

int take_focus();

function Take_Focus
       (This : in out Widget)
    return Boolean;

unsigned int takesevents() const;

function Takes_Events
       (This : in Widget)
    return Boolean;

int test_shortcut();
Marked as internal use only. 
const char * tooltip() const;

function Get_Tooltip
       (This : in Widget)
    return String;

void tooltip(const char *text);
Due to the marshalling between String and char * using this method would be pointless, so its functionality is subsumed by copy_tooltip / Set_Tooltip. 
Fl_Window * top_window() const;

function Top_Window
       (This : in Widget)
    return access FLTK.Widgets.Groups.Windows.Window'Class;

Fl_Window * top_window_offset(int &xoff, int &yoff) const;

function Top_Window_Offset
       (This               : in     Widget;
        Offset_X, Offset_Y :    out Integer)
    return access FLTK.Widgets.Groups.Windows.Window'Class;

uchar type() const;
See Get_Kind subprograms in Fl_Counter, Fl_Dial, Fl_Input_, Fl_Pack, Fl_Scroll, Fl_Slider, Fl_Spinner. 
void type(uchar t);
See Set_Kind subprograms in Fl_Counter, Fl_Dial, Fl_Input_, Fl_Pack, Fl_Scroll, Fl_Slider, Fl_Spinner. 
int use_accents_menu();

function Uses_Accents_Menu
       (This : in Widget)
    return Boolean;

void * user_data() const;
Used internally by the binding. 
void user_data(void *v);
Used internally by the binding. 
unsigned int visible() const;

function Is_Visible
       (This : in Widget)
    return Boolean;

void visible_focus(int v);

procedure Set_Visible_Focus
       (This : in out Widget;
        To   : in     Boolean);

unsigned int visible_focus();

function Has_Visible_Focus
       (This : in Widget)
    return Boolean;

int visible_r() const;

function Is_Tree_Visible
       (This : in Widget)
    return Boolean;

int w() const;

function Get_W
       (This : in Widget)
    return Integer;

Fl_When when() const;

function Get_When
       (This : in Widget)
    return Callback_Flag;

void when(uchar i);

procedure Set_When
       (This : in out Widget;
        To   : in     Callback_Flag);

Fl_Window * window() const;

function Nearest_Window
       (This : in Widget)
    return access FLTK.Widgets.Groups.Windows.Window'Class;

int x() const;

function Get_X
       (This : in Widget)
    return Integer;

int y() const;

function Get_Y
       (This : in Widget)
    return Integer;
Protected Functions and Procedures
void clear_flag(unsigned int c);
Intentionally left unbound. 
void draw_backdrop() const;

procedure Draw_Backdrop
       (This : in out Widget);

void draw_box() const;

procedure Draw_Box
       (This : in out Widget);

void draw_box(Fl_Boxtype t, Fl_Color c) const;

procedure Draw_Box
       (This : in out Widget;
        Kind : in     Box_Kind;
        Hue  : in     Color);

void draw_box(Fl_Boxtype t, int x, int y, int w, int h,
    Fl_Color c) const;

procedure Draw_Box
       (This       : in out Widget;
        Kind       : in     Box_Kind;
        X, Y, W, H : in     Integer;
        Hue        : in     Color);

void draw_focus();

procedure Draw_Focus
       (This : in out Widget);

void draw_focus(Fl_Boxtype t, int x, int y, int w, int h) const;

procedure Draw_Focus
       (This       : in out Widget;
        Kind       : in     Box_Kind;
        X, Y, W, H : in     Integer);

void draw_label() const;

procedure Draw_Label
       (This : in out Widget);

void draw_label(int, int, int, int) const;

procedure Draw_Label
       (This       : in out Widget;
        X, Y, W, H : in     Integer);

unsigned int flags() const;
Intentionally left unbound. 
void h(int v);
Marked as internal use only. 
void set_flag(unsigned int c);
Intentionally left unbound. 
void w(int v);
Marked as internal use only. 
void x(int v);
Marked as internal use only. 
void y(int v);
Marked as internal use only.