static int abi_check(const int val=FL_ABI_VERSION);

function ABI_Check
       (ABI_Ver : in Version_Number)
    return Boolean;

static int abi_version();

function ABI_Version
    return Version_Number;

static int add_awake_handler_(Fl_Awake_Handler, void *);

procedure Add_Awake_Handler
       (Func : in Awake_Handler);

static void add_check(Fl_Timeout_Handler, void *=0);

procedure Add_Check
       (Func : in Timeout_Handler);

static void add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void *data=0);

procedure Add_Clipboard_Notify
       (Func : in Clipboard_Notify_Handler);

static void add_fd(int fd, int when, Fl_FD_Handler cb, void *=0);

procedure Add_File_Descriptor
       (FD   : in File_Descriptor;
        Mode : in File_Mode;
        Func : in File_Handler);

static void add_fd(int fd, Fl_FD_Handler cb, void *=0);

procedure Add_File_Descriptor
       (FD   : in File_Descriptor;
        Func : in File_Handler);

static void add_handler(Fl_Event_Handler h);

procedure Add_Handler
       (Func : in Event_Handler);

static void add_idle(Fl_Idle_Handler cb, void *data=0);

procedure Add_Idle
       (Func : in Idle_Handler);

static void add_system_handler(Fl_System_Handler h, void *data);

static void add_timeout(double t, Fl_Timeout_Handler, void *=0);

procedure Add_Timeout
       (Seconds : in Long_Float;
        Func    : in Timeout_Handler);

static int api_version();

function API_Version
    return Version_Number;

static int arg(int argc, char **argv, int &i);

static int args(int argc, char **argv, int &i, Fl_Args_Handler cb=0);

static void args(int argc, char **argv);

static void awake(void *message=0);

procedure Awake;

static int awake(Fl_Awake_Handler cb, void *message=0);

static void background(uchar, uchar, uchar);

procedure Set_Background
       (R, G, B : in Color_Component);

static void background2(uchar, uchar, uchar);

procedure Set_Alt_Background
       (R, G, B : in Color_Component);

static Fl_Widget * belowmouse();

function Get_Below_Mouse
    return access FLTK.Widgets.Widget'Class;

static void belowmouse(Fl_Widget *);

procedure Set_Below_Mouse
       (To : in FLTK.Widgets.Widget'Class);

static Fl_Color box_color(Fl_Color);

static int box_dh(Fl_Boxtype);

function Get_Box_Height_Offset
       (Kind : in Box_Kind)
    return Integer;

static int box_dw(Fl_Boxtype);

function Get_Box_Width_Offset
       (Kind : in Box_Kind)
    return Integer;

static int box_dx(Fl_Boxtype);

function Get_Box_X_Offset
       (Kind : in Box_Kind)
    return Integer;

static int box_dy(Fl_Boxtype);

function Get_Box_Y_Offset
       (Kind : in Box_Kind)
    return Integer;

static void cairo_autolink_context(bool alink);

static bool cairo_autolink_context();

static cairo_t * cairo_cc();

static void cairo_cc(cairo_t *c, bool own=false);

static cairo_t * cairo_make_current(Fl_Window *w);

static int check();

function Check
    return Boolean;

static void clear_widget_pointer(Fl_Widget const *w);

static int clipboard_contains(const char *type);

static int compose(int &del);

function Compose
       (Del : out Natural)
    return Boolean;

static void compose_reset();

procedure Compose_Reset;

static void copy
   (const char *stuff, int len, int destination=0,
    const char *type=Fl::clipboard_plain_text);

procedure Copy
       (Text : in String;
        Dest : in Buffer_Kind);

static void damage(int d);

procedure Set_Damaged
       (To : in Boolean);

static int damage();

function Is_Damaged
    return Boolean;

static void default_atclose(Fl_Window *, void *);

procedure Default_Window_Close
       (Item : in out FLTK.Widgets.Widget'Class);

static void delete_widget(Fl_Widget *w);

static void disable_im();

procedure Disable_System_Input;

static void display(const char *);

static int dnd();

procedure Drag_Drop_Start;

static void dnd_text_ops(int v);

procedure Set_Drag_Drop_Text_Support
       (To : in Boolean);

static int dnd_text_ops();

function Get_Drag_Drop_Text_Support
    return Boolean;

static void do_widget_deletion();

procedure Do_Widget_Deletion;

static int draw_box_active();

function Draw_Box_Active
    return Boolean;

static void enable_im();

procedure Enable_System_Input;

static int event();

function Last
    return Event_Kind;

static int event_alt();

function Key_Alt
    return Boolean;

static int event_button();

function Last_Button
    return Mouse_Button;

static int event_button1();

function Mouse_Left
    return Boolean;

static int event_button2();

function Mouse_Middle
    return Boolean;

static int event_button3();

function Mouse_Right
    return Boolean;

static int event_buttons();

static int event_clicks();

function Is_Multi_Click
    return Boolean;

static void event_clicks(int i);

procedure Set_Clicks
       (To : in Natural);

static void * event_clipboard();

static const char * event_clipboard_type();

static int event_command();

function Key_Command
    return Boolean;

static int event_ctrl();

function Key_Ctrl
    return Boolean;

static void event_dispatch(Fl_Event_Dispatch d);

procedure Set_Dispatch
       (Func : in Event_Dispatch);

static Fl_Event_Dispatch event_dispatch();

function Get_Dispatch
    return Event_Dispatch;

static int event_dx();

function Mouse_DX
    return Integer;

static int event_dy();

function Mouse_DY
    return Integer;

static int event_inside(int, int, int, int);

function Is_Inside
       (X, Y, W, H : in Integer)
    return Boolean;

static int event_inside(const Fl_Widget *);

static int event_is_click();

function Is_Click
    return Boolean;

static void event_is_click(int i);

static int event_key();

function Last_Key
    return Keypress;

static int event_key(int key);

function Pressed_During
       (Key : in Keypress)
    return Boolean;

static int event_length();

function Text_Length
    return Natural;

static int event_original_key();

function Original_Last_Key
    return Keypress;

static int event_shift();

function Key_Shift
    return Boolean;

static int event_state();

function Last_Modifier
    return Modifier;

static int event_state(int mask);

function Last_Modifier
       (Had : in Modifier)
    return Boolean;

static const char * event_text();

function Text
    return String;

static int event_x();

function Mouse_X
    return Integer;

static int event_x_root();

function Mouse_X_Root
    return Integer;

static int event_y();

function Mouse_Y
    return Integer;

static int event_y_root();

function Mouse_Y_Root
    return Integer;

static Fl_Window * first_window();

function Get_First_Window
    return access FLTK.Widgets.Groups.Windows.Window'Class;

static void first_window(Fl_Window *);

procedure Set_First_Window
       (To : in FLTK.Widgets.Groups.Windows.Window'Class);

static void flush();

procedure Flush;

static Fl_Widget * focus();

function Get_Focus
    return access FLTK.Widgets.Widget'Class;

static void focus(Fl_Widget *);

procedure Set_Focus
       (To : in FLTK.Widgets.Widget'Class);

static void foreground(uchar, uchar, uchar);

procedure Set_Foreground
       (R, G, B : in Color_Component);

static void free_color(Fl_Color i, int overlay=0);

procedure Free_Color
       (Value   : in Color;
        Overlay : in Boolean := False);

static int get_awake_handler_(Fl_Awake_Handler &, void *&);

function Get_Awake_Handler
    return Awake_Handler;

static Fl_Box_Draw_F * get_boxtype(Fl_Boxtype);

static unsigned get_color(Fl_Color i);

static void get_color(Fl_Color i, uchar &red, uchar &green, uchar &blue);

procedure Get_Color
       (From    : in     Color;
        R, G, B :    out Color_Component);

static const char * get_font(Fl_Font);

function Font_Image
       (Kind : in Font_Kind)
    return String;

static const char * get_font_name(Fl_Font, int *attributes=0);

function Font_Family_Image
       (Kind : in Font_Kind)
    return String;

static int get_font_sizes(Fl_Font, int *&sizep);

function Font_Sizes
       (Kind : in Font_Kind)
    return Font_Size_Array;

static int get_key(int key);

function Key_Now
       (Key : in Keypress)
    return Boolean;

static void get_mouse(int &, int &);

procedure Get_Mouse
       (X, Y : out Integer);

static void get_system_colors();

procedure System_Colors;

static int gl_visual(int, int *alist=0);

static Fl_Window * grab();

function Get_Grab
    return access FLTK.Widgets.Groups.Windows.Window'Class;

static void grab(Fl_Window *);
static void grab(Fl_Window &win);

procedure Set_Grab
       (To : in FLTK.Widgets.Groups.Windows.Window'Class);

static int h();

function Get_H
    return Integer;

static int handle(int, Fl_Window *);
static int handle_(int, Fl_Window *);

static int has_check(Fl_Timeout_Handler, void *=0);

function Has_Check
       (Func : in Timeout_Handler)
    return Boolean;

static int has_idle(Fl_Idle_Handler cb, void *data=0);

function Has_Idle
       (Func : in Idle_Handler)
    return Boolean;

static int has_timeout(Fl_Timeout_Handler, void *=0);

function Has_Timeout
       (Func : in Timeout_Handler)
    return Boolean;

static int is_scheme(const char *name);

function Is_Scheme
       (Scheme : in String)
    return Boolean;

static int lock();

procedure Lock;

static Fl_Window * modal();

function Get_Top_Modal
    return access FLTK.Widgets.Groups.Windows.Window'Class;

static Fl_Window * next_window(const Fl_Window *);

function Get_Next_Window
       (From : in FLTK.Widgets.Groups.Windows.Window'Class)
    return access FLTK.Widgets.Groups.Windows.Window'Class;

static bool option(Fl_Option opt);

function Get_Option
       (Opt : in Option)
    return Boolean;

static void option(Fl_Option opt, bool val);

procedure Set_Option
       (Opt : in Option;
        To  : in Boolean);

static void own_colormap();

procedure Own_Colormap;

static void paste
   (Fl_Widget &receiver, int source,
    const char *type=Fl::clipboard_plain_text);

procedure Paste
       (Receiver : in FLTK.Widgets.Widget'Class;
        Source   : in Buffer_Kind);

static void paste(Fl_Widget &receiver);

static Fl_Widget * pushed();

function Get_Pushed
    return access FLTK.Widgets.Widget'Class;

static void pushed(Fl_Widget *);

procedure Set_Pushed
       (To : in FLTK.Widgets.Widget'Class);

static Fl_Widget * readqueue();

function Read_Queue
    return access FLTK.Widgets.Widget'Class;

static int ready();

function Ready
    return Boolean;

static void redraw();

procedure Redraw;

static void release();

procedure Release_Grab;

static void release_widget_pointer(Fl_Widget *&w);

static int reload_scheme();

procedure Reload_Scheme;

static void remove_check(Fl_Timeout_Handler, void *=0);

procedure Remove_Check
       (Func : in Timeout_Handler);

static void remove_clipboard_notify(Fl_Clipboard_Notify_Handler h);

procedure Remove_Clipboard_Notify
       (Func : in Clipboard_Notify_Handler);

static void remove_fd(int, int when);

procedure Remove_File_Descriptor
       (FD   : in File_Descriptor;
        Mode : in File_Mode);

static void remove_fd(int);

procedure Remove_File_Descriptor
       (FD : in File_Descriptor);

static void remove_handler(Fl_Event_Handler h);

procedure Remove_Handler
       (Func : in Event_Handler);

static void remove_idle(Fl_Idle_Handler cb, void *data=0);

procedure Remove_Idle
       (Func : in Idle_Handler);

static void remove_system_handler(Fl_System_Handler h);

static void remove_timeout(Fl_Timeout_Handler, void *=0);

procedure Remove_Timeout
       (Func : in Timeout_Handler);

static repeat_timeout(double t, Fl_Timeout_Handler, void *=0);

procedure Repeat_Timeout
       (Seconds : in Long_Float;
        Func    : in Timeout_Handler);

static int run();

function Run
    return Integer;

static int scheme(const char *name);

procedure Set_Scheme
       (To : in String);

static const char * scheme();

function Get_Scheme
    return String;

static int screen_count();

function Count
    return Integer;

static void screen_dpi(float &h, float &v, int n=0);

procedure DPI
       (Horizontal, Vertical :    out Float;
        Screen_Number        : in     Integer := 1);

static int screen_num(int x, int y);

function Containing
       (X, Y : in Integer)
    return Integer;

static int screen_num(int x, int y, int w, int h);

function Containing
       (X, Y, W, H : in Integer)
    return Integer;

static void screen_work_area(int &X, int &Y, int &W, int &H, int mx, int my);

procedure Work_Area
       (X, Y, W, H   :    out Integer;
        Pos_X, Pos_Y : in     Integer);

static void screen_work_area(int &X, int &Y, int &W, int &H, int n);

procedure Work_Area
       (X, Y, W, H :    out Integer;
        Screen_Num : in     Integer);

static void screen_work_area(int &X, int &Y, int &W, int &H);

procedure Work_Area
       (X, Y, W, H : out Integer);

static void screen_xywh(int &X, int &Y, int &W, int &H);

procedure Bounding_Rect
       (X, Y, W, H : out Integer);

static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my);

procedure Bounding_Rect
       (X, Y, W, H   :    out Integer;
        Pos_X, Pos_Y : in     Integer);

static void screen_xywh(int &X, int &Y, int &W, int &H, int n);

procedure Bounding_Rect
       (X, Y, W, H :    out Integer;
        Screen_Num : in     Integer);

static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my, int mw, int mh);

procedure Bounding_Rect
       (X, Y, W, H     :    out Integer;
        PX, PY, PW, PH : in     Integer);

static int scrollbar_size();

function Get_Default_Scrollbar_Size
    return Natural;

static void scrollbar_size(int W);

procedure Set_Default_Scrollbar_Size
       (To : in Natural);

static void selection(Fl_Widget &owner, const char *, int len);

procedure Selection
       (Owner : in FLTK.Widgets.Widget'Class;
        Text  : in String);

static Fl_Widget * selection_owner();

static void selection_owner(Fl_Widget *);

static void set_abort(Fl_Abort_Handler f);

static void set_atclose(Fl_Atclose_Handler f);

static void set_box_color(Fl_Color);

static void set_boxtype(Fl_Boxtype, Fl_Box_Draw_F *, uchar, uchar, uchar, uchar);

static void set_boxtype(Fl_Boxtype, Fl_Boxtype from);

procedure Set_Box_Kind
       (To, From : in Box_Kind);

static void set_color(Fl_Color, uchar, uchar, uchar, uchar);

procedure Set_Color
       (To      : in Color;
        R, G, B : in Color_Component);

static void set_color(Fl_Color i, unsigned c);

static void set_font(Fl_Font, const char *);

static void set_font(Fl_Font, Fl_Font);

procedure Set_Font_Kind
       (To, From : in Font_Kind);

static Fl_Font set_fonts(const char *=0);

procedure Setup_Fonts
       (How_Many_Set_Up : out Natural);

static void set_idle(Fl_Old_Idle_Handler cb);

static void set_labeltype(Fl_Labeltype, Fl_Label_Draw_F *, FL_Label_Measure_F *);

static void set_labeltype(Fl_Labeltype, Fl_Labeltype from);

static int test_shortcut(Fl_Shortcut);

static void * thread_message();

static void unlock();

procedure Unlock;

static void use_high_res_GL(int val);

static int use_high_res_GL();

static double version();

function Version
    return Version_Number;

static void visible_focus(int v);

procedure Set_Visible_Focus
       (To : in Boolean);

static int visible_focus();

function Has_Visible_Focus
    return Boolean;

static int visual(int);

static int w();

function Get_W
    return Integer;

static int wait();

function Wait
    return Integer;

static double wait(double time);

function Wait
       (Seconds : in Long_Float)
    return Integer;

static void watch_widget_pointer(Fl_Widget *&w);

static int x();

function Get_X
    return Integer;

static int y();

function Get_Y
    return Integer;