Fl_Window Binding Map

Back to Index
Package name
Fl_Window FLTK.Widgets.Groups.Windows
Types
Fl_Window Window
  Window_Reference
  Modal_State
Static Protected Attributes
static Fl_Window * current_;
Intentionally left unbound.
Protected Attributes
shape_data_type * shape_data_;
Intentionally left unbound.
Constructors
Fl_Window(int w, int h, const char *title=0);

function Create
       (W, H : in Integer;
        Text : in String := "")
    return Window;
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;
        W, H   : in     Integer;
        Text   : in     String := "")
    return Window;

Fl_Window(int x, int y, int w, int h, const char *title=0);

function Create
       (X, Y, W, H : in Integer;
        Text       : in String := "")
    return Window;
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 Window;
Static Functions and Procedures
static Fl_Window * current();

function Last_Made_Current
    return access Window'Class;

static void default_callback(Fl_Window *, void *v);
Back compatibility only, see default_atclose / Default_Window_Close in FLTK. 
static void default_icon(const Fl_RGB_Image *);

procedure Set_Default_Icon
       (Pic : in FLTK.Images.RGB.RGB_Image'Class);

static void default_icons(const Fl_RGB_Image *[], int);

procedure Set_Default_Icons
       (Pics : in FLTK.Images.RGB.RGB_Image_Array);

procedure Reset_Default_Icons;

static const char * default_xclass();

function Get_Default_X_Class
    return String;

static void default_xclass(const char *);

procedure Set_Default_X_Class
       (Value : in String);
Functions and Procedures
virtual Fl_Window * as_window();
Use view conversion and tag membership tests instead. 
unsigned int border() const;

function Has_Border
       (This : in Window)
    return Boolean;

void border(int b);

procedure Set_Border
       (This  : in out Window;
        Value : in     Boolean := True);

void clear_border();

procedure Clear_Border
       (This : in out Window);

void clear_modal_states();

procedure Clear_Modal_State
       (This : in out Window);

void copy_label(const char *a);

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

void cursor(Fl_Cursor);

procedure Set_Cursor
       (This : in out Window;
        To   : in     Mouse_Cursor);

void cursor(const Fl_RGB_Image *, int, int);

procedure Set_Cursor
       (This         : in out Window;
        Pic          : in     FLTK.Images.RGB.RGB_Image'Class;
        Hot_X, Hot_Y : in     Integer);

void cursor(Fl_Cursor c, Fl_Color, Fl_Color=FL_WHITE);
Use cursor(Fl_Cursor) / Set_Cursor instead. 
int decorated_h();

function Get_Decorated_H
       (This : in Window)
    return Integer;

int decorated_w();

function Get_Decorated_W
       (This : in Window)
    return Integer;

void default_cursor(Fl_Cursor);

procedure Set_Default_Cursor
       (This : in out Window;
        To   : in     Mouse_Cursor);

void default_cursor(Fl_Cursor c, Fl_Color, Fl_Color=FL_WHITE);
Use default_cursor(Fl_Cursor) / Set_Default_Cursor instead. 
void free_position();
Marked as deprecated. 
void fullscreen();

procedure Fullscreen_On
       (This : in out Window);

unsigned int fullscreen_active() const;

function Is_Fullscreen
       (This : in Window)
    return Boolean;

void fullscreen_off();

procedure Fullscreen_Off
       (This : in out Window);

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

procedure Fullscreen_Off
       (This       : in out Window;
        X, Y, W, H : in     Integer);

void fullscreen_screens(int top, int bottom, int left, int right);

procedure Fullscreen_Screens
       (This                     : in out Window;
        Top, Bottom, Left, Right : in     Natural);

virtual int handle(int);

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

virtual void hide();

procedure Hide
       (This : in out Window);

void hotspot(int x, int y, int offscreen=0);

procedure Hotspot
       (This      : in out Window;
        X, Y      : in     Integer;
        Offscreen : in     Boolean := False);

void hotspot(const Fl_Widget *, int offscreen=0);

void hotspot(const Fl_Widget &p, int offscreen=0);

procedure Hotspot
       (This      : in out Window;
        Item      : in     Widget'Class;
        Offscreen : in     Boolean := False);

void icon(const Fl_RGB_Image *);

procedure Set_Icon
       (This : in out Window;
        Pic  : in     FLTK.Images.RGB.RGB_Image'Class);

const void * icon() const;
Marked as deprecated. 
void icon(const void *ic);
Marked as deprecated. 
void iconize();

procedure Iconify
       (This : in out Window);

const char * iconlabel() const;

function Get_Icon_Label
       (This : in Window)
    return String;

void iconlabel(const char *);

procedure Set_Icon_Label
       (This : in out Window;
        To   : in     String);

void icons(const Fl_RGB_Image *[], int);

procedure Set_Icons
       (This : in out Window;
        Pics : in     FLTK.Images.RGB.RGB_Image_Array);

procedure Reset_Icons
       (This : in out Window);

const char * label() const;

function Get_Label
       (This : in Window)
    return String;

void label(const char *);
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(const char *label, const char *iconlabel);

procedure Set_Labels
       (This            : in out Window;
        Text, Icon_Text : in     String);

void make_current();

procedure Make_Current
       (This : in out Window);

unsigned int menu_window() const;

function Is_Menu_Window
       (This : in Window)
    return Boolean;

unsigned int modal() const;

function Is_Modal
       (This : in Window)
    return Boolean;
Use modal, non_modal as appropriate. 
function Get_Modal_State
       (This : in Window)
    return Modal_State;

unsigned int non_modal() const;

function Is_Non_Modal
       (This : in Window)
    return Boolean;

unsigned int override() const;

function Is_Override
       (This : in Window)
    return Boolean;

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

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

void set_menu_window();
Intended for internal use only. 
void set_modal();

procedure Set_Modal
       (This : in out Window);
Use clear_modal_states, set_modal, set_non_modal as appropriate. 
procedure Set_Modal_State
       (This  : in out Window;
        Value : in     Modal_State);

void set_non_modal();

procedure Set_Non_Modal
       (This : in out Window);

void set_override();

procedure Set_Override
       (This : in out Window);

void set_tooltip_window();
Intended for internal use only. 
void shape(const Fl_Image *img);

void shape(const Fl_Image &b);

procedure Shape
       (This : in out Window;
        Pic  : in     FLTK.Images.Image'Class);

virtual void show();

procedure Show
       (This : in out Window);

void show(int argc, char **argv);

procedure Show_With_Args
       (This : in out Window);

int shown();

function Is_Shown
       (This : in Window)
    return Boolean;

void size_range(int minw, int minh, int maxw=0, int maxh=0,
    int dw=0, int dh=0, int aspect=0);

procedure Set_Size_Range
       (This                           : in out Window;
        Min_W, Min_H                   : in     Integer;
        Max_W, Max_H, Incre_W, Incre_H : in     Integer := 0;
        Keep_Aspect                    : in     Boolean := False);

unsigned int tooltip_window() const;

function Is_Tooltip_Window
       (This : in Window)
    return Boolean;

void wait_for_expose();

procedure Wait_For_Expose
       (This : in out Window);

int x_root() const;

function Get_X_Root
       (This : in Window)
    return Integer;

const char * xclass() const;

function Get_X_Class
       (This : in Window)
    return String;

void xclass(const char *c);

procedure Set_X_Class
       (This  : in out Window;
        Value : in     String);

int y_root() const;

function Get_Y_Root
       (This : in Window)
    return Integer;
Protected Functions and Procedures
virtual void draw();

procedure Draw
       (This : in out Window);

virtual void flush();

procedure Flush
       (This : in out Window);

int force_position() const;

function Is_Position_Forced
       (This : in Window)
    return Boolean;

void force_position(int force);

procedure Force_Position
       (This  : in out Window;
        State : in     Boolean := True);

void free_icons();
Intentionally left unbound.