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;

void _clear_fullscreen();

void _set_fullscreen();

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;

void argument(long v);

virtual class Fl_Gl_Window * as_gl_window();

virtual Fl_Group * as_group();

virtual Fl_Window * as_window();

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);

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);

unsigned int changed() const;

function Has_Changed
       (This : in Widget)
    return Boolean;

void clear_active();

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

void clear_changed();

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

void clear_damage(uchar c=0);

void clear_output();

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

void clear_visible();

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

void clear_visible_focus();

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

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);

Fl_Color color2() const;

void color2(unsigned a);

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;

void damage(uchar c);

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

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

procedure Set_Damaged
       (This       : in out Widget;
        To         : in     Boolean;
        X, Y, W, H : in     Integer);

int damage_resize(int, int, int, int);

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);

virtual void draw()=0;

procedure Draw
       (This : in out Widget) is null;

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

procedure Draw_Label
       (This       : in 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();

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;

const char * label() const;

function Get_Label
       (This : in Widget)
    return String;

void label(const char *text);

void label(Fl_Labeltype a, const char *b);

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_Type
       (This : in Widget)
    return Label_Kind;

void labeltype(Fl_Labeltype a);

procedure Set_Label_Type
       (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);

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);

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();

void set_changed();

void set_output();

void set_visible();

void set_visible_focus();

virtual void show();

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();

const char * tooltip() const;

function Get_Tooltip
       (This : in Widget)
    return String;

void tooltip(const char *text);

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;

void type(uchar t);

int use_accents_menu();

void * user_data() const;

void user_data(void *v);

unsigned int visible() const;

function Is_Visible
       (This : in Widget)
    return Boolean;

void visible_focus(int v);

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;