Fl_Menu_ Binding Map

Back to Index
Package name
Fl_Menu_ FLTK.Widgets.Menus

Note:

This Menu 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 and handle methods. Either extend it and override those subprograms or use types already extended from it.

Types
Fl_Menu_ Menu
  Menu_Reference
int Index
int Extended_Index
  Cursor
Errors
NULL No_Reference_Error
Protected Attributes
uchar alloc;
Intentionally left unbound. 
uchar down_box_;
Intentionally left unbound. 
Fl_Color textcolor_;
Intentionally left unbound. 
Fl_Font textfont_;
Intentionally left unbound. 
Fl_Fontsize textsize_;
Intentionally left unbound.
Constructors
Fl_Menu_(int, int, int, int, const char *=0);

function Create
       (X, Y, W, H : in Integer;
        Text       : in String := "")
    return Menu;
Functions and Procedures
int add(const char *);

procedure Add
       (This : in out Menu;
        Text : in     String);

function Add
       (This : in out Menu;
        Text : in     String)
    return Index;

int add(const char *, int shortcut, Fl_Callback *,
    void *=0, int=0);

procedure Add
       (This     : in out Menu;
        Text     : in     String;
        Action   : in     Widget_Callback := null;
        Shortcut : in     Key_Combo := No_Key;
        Flags    : in     Menu_Flag := Flag_Normal);

function Add
       (This     : in out Menu;
        Text     : in     String;
        Action   : in     Widget_Callback := null;
        Shortcut : in     Key_Combo := No_Key;
        Flags    : in     Menu_Flag := Flag_Normal)
    return Index;

int add(const char *a, const char *b, Fl_Callback *c,
    void *d=0, int e=0);

procedure Add
       (This     : in out Menu;
        Text     : in     String;
        Action   : in     Widget_Callback := null;
        Shortcut : in     String;
        Flags    : in     Menu_Flag := Flag_Normal);

function Add
       (This     : in out Menu;
        Text     : in     String;
        Action   : in     Widget_Callback := null;
        Shortcut : in     String;
        Flags    : in     Menu_Flag := Flag_Normal)
    return Index;

void clear();

procedure Clear
       (This : in out Menu);

int clear_submenu(int index);

procedure Clear_Submenu
       (This  : in out Menu;
        Place : in     Index);

void copy(const Fl_Menu_Item *m, void *user_data=0);

procedure Set_Items
       (This  : in out Menu;
        Items : in     FLTK.Menu_Items.Menu_Item_Array);

Fl_Boxtype down_box() const;

function Get_Down_Box
       (This : in Menu)
    return Box_Kind;

void down_box(Fl_Boxtyep b);

procedure Set_Down_Box
       (This : in out Menu;
        To   : in     Box_Kind);

Fl_Color down_color() const;
See selection_color / Get_Selection_Color from Fl_Widget. 
void down_color(unsigned c);
See selection_color / Set_Selection_Color from Fl_Widget.
See draw method in Fl_Menu_Item. 
procedure Draw_Item
       (This       : in out Menu;
        Item       : in     Index;
        X, Y, W, H : in     Integer;
        Selected   : in     Boolean := False);

int find_index(const char *name) const;

function Find_Index
       (This : in Menu;
        Name : in String)
    return Extended_Index;

int find_index(const Fl_Menu_Item *item) const;

function Find_Index
       (This : in Menu;
        Item : in FLTK.Menu_Items.Menu_Item)
    return Extended_Index;

int find_index(Fl_Callback *cb) const;

function Find_Index
       (This   : in Menu;
        Action : in Widget_Callback)
    return Extended_Index;

const Fl_Menu_Item * find_item(const char *name);

function Find_Item
       (This : in Menu;
        Name : in String)
    return FLTK.Menu_Items.Menu_Item_Reference;

const Fl_Menu_Item * find_item(Fl_Callback *);

function Find_Item
       (This   : in Menu;
        Action : in Widget_Callback)
    return FLTK.Menu_Items.Menu_Item_Reference;
See find_shortcut in Fl_Menu_Item. 
function Find_Shortcut
       (This        : in Menu;
        Require_Alt : in Boolean := False)
    return access FLTK.Menu_Items.Menu_Item'Class;

function Find_Shortcut
       (This        : in     Menu;
        Place       :    out Extended_Index;
        Require_Alt : in     Boolean := False)
    return access FLTK.Menu_Items.Menu_Item'Class;

void global();

procedure Make_Global
       (This : in out Menu);
Check index values against the size method manually. 
function Has_Item
       (This  : in Menu;
        Place : in Index)
    return Boolean;
  
function Has_Item
       (Place : in Cursor)
    return Boolean;

int insert(int index, const char *, int shortcut,
    Fl_Callback *, void *=0, int=0);

procedure Insert
       (This     : in out Menu;
        Place    : in     Index;
        Text     : in     String;
        Action   : in     Widget_Callback := null;
        Shortcut : in     Key_Combo := No_Key;
        Flags    : in     Menu_Flag := Flag_Normal);

function Insert
       (This     : in out Menu;
        Place    : in     Index;
        Text     : in     String;
        Action   : in     Widget_Callback := null;
        Shortcut : in     Key_Combo := No_Key;
        Flags    : in     Menu_Flag := Flag_Normal)
    return Index;

int insert(int index, const char *a, const char *b,
    Fl_Callback *c, void *d=0, int e=0);

procedure Insert
       (This     : in out Menu;
        Place    : in     Index;
        Text     : in     String;
        Action   : in     Widget_Callback := null;
        Shortcut : in     String;
        Flags    : in     Menu_Flag := Flag_Normal);

function Insert
       (This     : in out Menu;
        Place    : in     Index;
        Text     : in     String;
        Action   : in     Widget_Callback := null;
        Shortcut : in     String;
        Flags    : in     Menu_Flag := Flag_Normal)
    return Index;
Use the menu method to access the menu item array and index it directly. 
function Item
       (This  : in Menu;
        Place : in Index)
    return FLTK.Menu_Items.Menu_Item_Reference;
  
function Item
       (This  : in Menu;
        Place : in Cursor)
    return FLTK.Menu_Items.Menu_Item_Reference;

int item_pathname(char *name, int namelen,
    const Fl_Menu_Item *finditem=0) const;

function Item_Pathname
       (This : in Menu)
    return String;

function Item_Pathname
       (This : in Menu;
        Item : in FLTK.Menu_Items.Menu_Item)
    return String;
  
function Iterate
       (This : in Menu)
    return Menu_Iterators.Reversible_Iterator'Class;
See measure method in Fl_Menu_Item. 
procedure Measure_Item
       (This : in     Menu;
        Item : in     Index;
        W, H :    out Integer);

const Fl_Menu_Item * menu() const;
Use Item or Iterate as necessary to access specific items or walk the array. 
void menu(const Fl_Menu_Item *m);

procedure Use_Same_Items
       (This  : in out Menu;
        Donor : in     Menu'Class);

int mode(int i) const;

function Get_Flags
       (This  : in Menu
        Place : in Index)
    return Menu_Flag;

void mode(int i, int fl);

procedure Set_Flags
       (This  : in out Menu;
        Place : in     Index;
        Flags : in     Menu_Flag);

const Fl_Menu_Item * mvalue() const;

function Chosen
       (This : in Menu)
    return FLTK.Menu_Items.Menu_Item_Reference;

const Fl_Menu_Item * picked(const Fl_Menu_Item *);

procedure Picked
       (This : in out Menu;
        Item : in out FLTK.Menu_Items.Menu_Item);
See popup method in Fl_Menu_Item. 
function Popup
       (This    : in Menu;
        X, Y    : in Integer;
        Title   : in String := "";
        Initial : in Extended_Index := No_Index)
    return Extended_Index;
See pulldown method in Fl_Menu_Item. 
function Pulldown
       (This       : in Menu;
        X, Y, W, H : in Integer;
        Initial    : in Extended_Index := No_Index)
    return Extended_Index;

void remove(int);

procedure Remove
       (This  : in out Menu;
        Place : in     Index);

void replace(int, const char *);

procedure Set_Label
       (This  : in out Menu;
        Place : in     Index;
        Text  : in     String);

void setonly(Fl_Menu_Item *item);

procedure Set_Only
       (This : in out Menu;
        Item : in out Menu_Item);

void shortcut(int i, int s);

procedure Set_Shortcut
       (This  : in out Menu;
        Place : in     Index;
        Press : in     Key_Combo);

int size() const;

function Number_Of_Items
       (This : in Menu)
    return Natural;

void size(int W, int H);

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

const Fl_Menu_Item * test_shortcut();

function Test_Shortcut
       (This : in out Menu)
    return access FLTK.Menu_Items.Menu_Item'Class;

const char * text() const;

function Chosen_Label
       (This : in Menu)
    return String;

const char * text(int i) const;

function Get_Label
       (This  : in Menu;
        Place : in Index)
    return String;

Fl_Color textcolor() const;

function Get_Text_Color
       (This : in Menu)
    return Color;

void textcolor(Fl_Color c);

procedure Set_Text_Color
       (This : in out Menu;
        To   : in     Color);

Fl_Font textfont() const;

function Get_Text_Font
       (This : in Menu)
    return Font_Kind;

void textfont(Fl_Font c);

procedure Set_Text_Font
       (This : in out Menu;
        To   : in     Font_Kind);

Fl_Fontsize textsize() const;

function Get_Text_Size
       (This : in Menu)
    return Font_Size;

void textsize(Fl_Fontsize c);

procedure Set_Text_Size
       (This : in out Menu;
        To   : in     Font_Size);

int value() const;

function Chosen_Index
       (This : in Menu)
    return Extended_Index;

int value(const Fl_Menu_Item *);

procedure Set_Chosen
       (This : in out Menu;
        Item : in     FLTK.Menu_Items.Menu_Item);

function Set_Chosen
       (This : in out Menu;
        Item : in     FLTK.Menu_Items.Menu_Item)
    return Boolean;

int value(int i);

procedure Set_Chosen
       (This  : in out Menu;
        Place : in     Index);

function Set_Chosen
       (This  : in out Menu;
        Place : in     Index)
    return Boolean;
Protection Functions and Procedures
int item_pathname_(char *name, int namelen,
    const Fl_Menu_Item *finditem, const Fl_Menu_Item *menu=0) const;
Intentionally left unbound.