d018dd0971
git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3@6855 ea41ed52-d2ee-0310-a9c1-e6b18d33e121
419 lines
15 KiB
C++
419 lines
15 KiB
C++
//
|
|
// "$Id$"
|
|
//
|
|
// Menu item header file for the Fast Light Tool Kit (FLTK).
|
|
//
|
|
// Copyright 1998-2009 by Bill Spitzak and others.
|
|
//
|
|
// This library is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Library General Public
|
|
// License as published by the Free Software Foundation; either
|
|
// version 2 of the License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Library General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Library General Public
|
|
// License along with this library; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
|
// USA.
|
|
//
|
|
// Please report all bugs and problems on the following page:
|
|
//
|
|
// http://www.fltk.org/str.php
|
|
//
|
|
|
|
#ifndef Fl_Menu_Item_H
|
|
#define Fl_Menu_Item_H
|
|
|
|
# include "Fl_Widget.H"
|
|
# include "Fl_Image.H"
|
|
|
|
# if defined(__APPLE__) && defined(check)
|
|
# undef check
|
|
# endif
|
|
|
|
enum { // values for flags:
|
|
FL_MENU_INACTIVE = 1, ///< Deactivate menu item (gray out)
|
|
FL_MENU_TOGGLE= 2, ///< Item is a checkbox toggle (shows checkbox for on/off state)
|
|
FL_MENU_VALUE = 4, ///< The on/off state for checkbox/radio buttons (if set, state is 'on')
|
|
FL_MENU_RADIO = 8, ///< Item is a radio button (one checkbox of many can be on)
|
|
FL_MENU_INVISIBLE = 0x10, ///< Item will not show up (shortcut will work)
|
|
FL_SUBMENU_POINTER = 0x20, ///< Indicates user_data() is a pointer to another menu array
|
|
FL_SUBMENU = 0x40, ///< This item is a submenu to other items
|
|
FL_MENU_DIVIDER = 0x80, ///< Creates divider line below this item. Also ends a group of radio buttons.
|
|
FL_MENU_HORIZONTAL = 0x100 ///< ??? -- reserved
|
|
};
|
|
|
|
extern FL_EXPORT int fl_old_shortcut(const char*);
|
|
|
|
class Fl_Menu_;
|
|
|
|
/**
|
|
The Fl_Menu_Item structure defines a single menu item that
|
|
is used by the Fl_Menu_ class.
|
|
\code
|
|
struct Fl_Menu_Item {
|
|
const char* text; // label()
|
|
ulong shortcut_;
|
|
Fl_Callback* callback_;
|
|
void* user_data_;
|
|
int flags;
|
|
uchar labeltype_;
|
|
uchar labelfont_;
|
|
uchar labelsize_;
|
|
uchar labelcolor_;
|
|
};
|
|
|
|
enum { // values for flags:
|
|
FL_MENU_INACTIVE = 1, // Deactivate menu item (gray out)
|
|
FL_MENU_TOGGLE = 2, // Item is a checkbox toggle (shows checkbox for on/off state)
|
|
FL_MENU_VALUE = 4, // The on/off state for checkbox/radio buttons (if set, state is 'on')
|
|
FL_MENU_RADIO = 8, // Item is a radio button (one checkbox of many can be on)
|
|
FL_MENU_INVISIBLE = 0x10, // Item will not show up (shortcut will work)
|
|
FL_SUBMENU_POINTER = 0x20, // Indicates user_data() is a pointer to another menu array
|
|
FL_SUBMENU = 0x40, // This item is a submenu to other items
|
|
FL_MENU_DIVIDER = 0x80, // Creates divider line below this item. Also ends a group of radio buttons.
|
|
FL_MENU_HORIZONTAL = 0x100 // ??? -- reserved
|
|
};
|
|
\endcode
|
|
Typically menu items are statically defined; for example:
|
|
\code
|
|
Fl_Menu_Item popup[] = {
|
|
{"&alpha", FL_ALT+'a', the_cb, (void*)1},
|
|
{"&beta", FL_ALT+'b', the_cb, (void*)2},
|
|
{"gamma", FL_ALT+'c', the_cb, (void*)3, FL_MENU_DIVIDER},
|
|
{"&strange", 0, strange_cb},
|
|
{"&charm", 0, charm_cb},
|
|
{"&truth", 0, truth_cb},
|
|
{"b&eauty", 0, beauty_cb},
|
|
{"sub&menu", 0, 0, 0, FL_SUBMENU},
|
|
{"one"},
|
|
{"two"},
|
|
{"three"},
|
|
{0},
|
|
{"inactive", FL_ALT+'i', 0, 0, FL_MENU_INACTIVE|FL_MENU_DIVIDER},
|
|
{"invisible",FL_ALT+'i', 0, 0, FL_MENU_INVISIBLE},
|
|
{"check", FL_ALT+'i', 0, 0, FL_MENU_TOGGLE|FL_MENU_VALUE},
|
|
{"box", FL_ALT+'i', 0, 0, FL_MENU_TOGGLE},
|
|
{0}};
|
|
\endcode
|
|
produces:
|
|
|
|
\image html menu.gif
|
|
\image latex menu.eps "menu" width=10cm
|
|
|
|
A submenu title is identified by the bit FL_SUBMENU in the
|
|
flags field, and ends with a label() that is NULL.
|
|
You can nest menus to any depth. A pointer to the first item in the
|
|
submenu can be treated as an Fl_Menu array itself. It is also
|
|
possible to make separate submenu arrays with FL_SUBMENU_POINTER flags.
|
|
|
|
You should use the method functions to access structure members and
|
|
not access them directly to avoid compatibility problems with future
|
|
releases of FLTK.
|
|
*/
|
|
struct FL_EXPORT Fl_Menu_Item {
|
|
const char *text; ///< menu item text, returned by label()
|
|
int shortcut_; ///< menu item shortcut
|
|
Fl_Callback *callback_; ///< menu item callback
|
|
void *user_data_; ///< menu item user_data for 3rd party apps
|
|
int flags; ///< menu item flags like FL_MENU_TOGGLE, FL_MENU_RADIO
|
|
uchar labeltype_; ///< how the menu item text looks like
|
|
Fl_Font labelfont_; ///< which font for this menu item text
|
|
Fl_Fontsize labelsize_; ///< size of menu item text
|
|
unsigned labelcolor_; ///< menu item text color
|
|
|
|
// advance N items, skipping submenus:
|
|
const Fl_Menu_Item *next(int=1) const;
|
|
|
|
/**
|
|
Advances a pointer by n items through a menu array, skipping
|
|
the contents of submenus and invisible items. There are two calls so
|
|
that you can advance through const and non-const data.
|
|
*/
|
|
Fl_Menu_Item *next(int i=1) {
|
|
return (Fl_Menu_Item*)(((const Fl_Menu_Item*)this)->next(i));}
|
|
|
|
/** Returns the first menu item, same as next(0). */
|
|
const Fl_Menu_Item *first() const { return next(0); }
|
|
|
|
/** Returns the first menu item, same as next(0). */
|
|
Fl_Menu_Item *first() { return next(0); }
|
|
|
|
// methods on menu items:
|
|
/**
|
|
Returns the title of the item.
|
|
A NULL here indicates the end of the menu (or of a submenu).
|
|
A '&' in the item will print an underscore under the next letter,
|
|
and if the menu is popped up that letter will be a "shortcut" to pick
|
|
that item. To get a real '&' put two in a row.
|
|
*/
|
|
const char* label() const {return text;}
|
|
|
|
/** See const char* Fl_Menu_Item::label() const */
|
|
void label(const char* a) {text=a;}
|
|
|
|
/** See const char* Fl_Menu_Item::label() const */
|
|
void label(Fl_Labeltype a,const char* b) {labeltype_ = a; text = b;}
|
|
|
|
/**
|
|
A labeltype identifies a routine that draws the label of the
|
|
widget. This can be used for special effects such as emboss, or to use
|
|
the label() pointer as another form of data such as a bitmap.
|
|
The value FL_NORMAL_LABEL prints the label as text.
|
|
*/
|
|
Fl_Labeltype labeltype() const {return (Fl_Labeltype)labeltype_;}
|
|
|
|
/**
|
|
A labeltype identifies a routine that draws the label of the
|
|
widget. This can be used for special effects such as emboss, or to use
|
|
the label() pointer as another form of data such as a bitmap.
|
|
The value FL_NORMAL_LABEL prints the label as text.
|
|
*/
|
|
void labeltype(Fl_Labeltype a) {labeltype_ = a;}
|
|
|
|
/**
|
|
This color is passed to the labeltype routine, and is typically the
|
|
color of the label text. This defaults to FL_BLACK. If this
|
|
color is not black fltk will <I>not</I> use overlay bitplanes to draw
|
|
the menu - this is so that images put in the menu draw correctly.
|
|
*/
|
|
Fl_Color labelcolor() const {return (Fl_Color)labelcolor_;}
|
|
|
|
/** See Fl_Color Fl_Menu_Item::labelcolor() const */
|
|
void labelcolor(unsigned a) {labelcolor_ = a;}
|
|
/**
|
|
Fonts are identified by small 8-bit indexes into a table. See the
|
|
enumeration list for predefined fonts. The default value is a
|
|
Helvetica font. The function Fl::set_font() can define new fonts.
|
|
*/
|
|
Fl_Font labelfont() const {return labelfont_;}
|
|
|
|
/**
|
|
Fonts are identified by small 8-bit indexes into a table. See the
|
|
enumeration list for predefined fonts. The default value is a
|
|
Helvetica font. The function Fl::set_font() can define new fonts.
|
|
*/
|
|
void labelfont(Fl_Font a) {labelfont_ = a;}
|
|
|
|
/** Gets the label font pixel size/height.*/
|
|
Fl_Fontsize labelsize() const {return labelsize_;}
|
|
|
|
/** Sets the label font pixel size/height.*/
|
|
void labelsize(Fl_Fontsize a) {labelsize_ = a;}
|
|
|
|
/**
|
|
Each item has space for a callback function and an argument for that
|
|
function. Due to back compatibility, the Fl_Menu_Item itself
|
|
is not passed to the callback, instead you have to get it by calling
|
|
((Fl_Menu_*)w)->mvalue() where w is the widget argument.
|
|
*/
|
|
Fl_Callback_p callback() const {return callback_;}
|
|
|
|
/** See Fl_Callback_p Fl_MenuItem::callback() const */
|
|
void callback(Fl_Callback* c, void* p) {callback_=c; user_data_=p;}
|
|
|
|
/** See Fl_Callback_p Fl_MenuItem::callback() const */
|
|
void callback(Fl_Callback* c) {callback_=c;}
|
|
|
|
/** See Fl_Callback_p Fl_MenuItem::callback() const */
|
|
void callback(Fl_Callback0*c) {callback_=(Fl_Callback*)c;}
|
|
|
|
/** See Fl_Callback_p Fl_MenuItem::callback() const */
|
|
void callback(Fl_Callback1*c, long p=0) {callback_=(Fl_Callback*)c; user_data_=(void*)p;}
|
|
|
|
/**
|
|
Get or set the user_data argument that is sent to the
|
|
callback function.
|
|
*/
|
|
void* user_data() const {return user_data_;}
|
|
/**
|
|
Get or set the user_data argument that is sent to the
|
|
callback function.
|
|
*/
|
|
void user_data(void* v) {user_data_ = v;}
|
|
/**
|
|
For convenience you can also define the callback as taking a long
|
|
argument. This is implemented by casting this to a Fl_Callback
|
|
and casting the long to a void* and may not be
|
|
portable to some machines.
|
|
*/
|
|
long argument() const {return (long)user_data_;}
|
|
/**
|
|
For convenience you can also define the callback as taking a long
|
|
argument. This is implemented by casting this to a Fl_Callback
|
|
and casting the long to a void* and may not be
|
|
portable to some machines.
|
|
*/
|
|
void argument(long v) {user_data_ = (void*)v;}
|
|
|
|
/** Gets what key combination shortcut will trigger the menu item. */
|
|
int shortcut() const {return shortcut_;}
|
|
|
|
/**
|
|
Sets exactly what key combination will trigger the menu item. The
|
|
value is a logical 'or' of a key and a set of shift flags, for instance
|
|
FL_ALT+'a' or FL_ALT+FL_F+10 or just 'a'. A value of
|
|
zero disables the shortcut.
|
|
|
|
The key can be any value returned by Fl::event_key(), but will usually
|
|
be an ASCII letter. Use a lower-case letter unless you require the shift
|
|
key to be held down.
|
|
|
|
The shift flags can be any set of values accepted by Fl::event_state().
|
|
If the bit is on that shift key must be pushed. Meta, Alt, Ctrl,
|
|
and Shift must be off if they are not in the shift flags (zero for the
|
|
other bits indicates a "don't care" setting).
|
|
*/
|
|
void shortcut(int s) {shortcut_ = s;}
|
|
/**
|
|
Returns true if either FL_SUBMENU or FL_SUBMENU_POINTER
|
|
is on in the flags. FL_SUBMENU indicates an embedded submenu
|
|
that goes from the next item through the next one with a NULL
|
|
label(). FL_SUBMENU_POINTER indicates that user_data()
|
|
is a pointer to another menu array.
|
|
*/
|
|
int submenu() const {return flags&(FL_SUBMENU|FL_SUBMENU_POINTER);}
|
|
/**
|
|
Returns true if a checkbox will be drawn next to this item. This is
|
|
true if FL_MENU_TOGGLE or FL_MENU_RADIO is set in the flags.
|
|
*/
|
|
int checkbox() const {return flags&FL_MENU_TOGGLE;}
|
|
/**
|
|
Returns true if this item is a radio item. When a radio button is
|
|
selected all "adjacent" radio buttons are turned off. A set of radio
|
|
items is delimited by an item that has radio() false, or by an
|
|
item with FL_MENU_DIVIDER turned on.
|
|
*/
|
|
int radio() const {return flags&FL_MENU_RADIO;}
|
|
/** Returns the current value of the check or radio item. */
|
|
int value() const {return flags&FL_MENU_VALUE;}
|
|
/**
|
|
Turns the check or radio item "on" for the menu item. Note that this
|
|
does not turn off any adjacent radio items like set_only() does.
|
|
*/
|
|
void set() {flags |= FL_MENU_VALUE;}
|
|
|
|
/** Turns the check or radio item "off" for the menu item. */
|
|
void clear() {flags &= ~FL_MENU_VALUE;}
|
|
|
|
void setonly();
|
|
|
|
/** Gets the visibility of an item. */
|
|
int visible() const {return !(flags&FL_MENU_INVISIBLE);}
|
|
|
|
/** Makes an item visible in the menu. */
|
|
void show() {flags &= ~FL_MENU_INVISIBLE;}
|
|
|
|
/** Hides an item in the menu. */
|
|
void hide() {flags |= FL_MENU_INVISIBLE;}
|
|
|
|
/** Gets whether or not the item can be picked. */
|
|
int active() const {return !(flags&FL_MENU_INACTIVE);}
|
|
|
|
/** Allows a menu item to be picked. */
|
|
void activate() {flags &= ~FL_MENU_INACTIVE;}
|
|
/**
|
|
Prevents a menu item from being picked. Note that this will also cause
|
|
the menu item to appear grayed-out.
|
|
*/
|
|
void deactivate() {flags |= FL_MENU_INACTIVE;}
|
|
/** Returns non 0 if FL_INACTIVE and FL_INVISIBLE are cleared, 0 otherwise. */
|
|
int activevisible() const {return !(flags & (FL_MENU_INACTIVE|FL_MENU_INVISIBLE));}
|
|
|
|
// compatibility for FLUID so it can set the image of a menu item...
|
|
|
|
/** compatibility api for FLUID, same as a->label(this) */
|
|
void image(Fl_Image* a) {a->label(this);}
|
|
|
|
/** compatibility api for FLUID, same as a.label(this) */
|
|
void image(Fl_Image& a) {a.label(this);}
|
|
|
|
// used by menubar:
|
|
int measure(int* h, const Fl_Menu_*) const;
|
|
void draw(int x, int y, int w, int h, const Fl_Menu_*, int t=0) const;
|
|
|
|
// popup menus without using an Fl_Menu_ widget:
|
|
const Fl_Menu_Item* popup(
|
|
int X, int Y,
|
|
const char *title = 0,
|
|
const Fl_Menu_Item* picked=0,
|
|
const Fl_Menu_* = 0) const;
|
|
const Fl_Menu_Item* pulldown(
|
|
int X, int Y, int W, int H,
|
|
const Fl_Menu_Item* picked = 0,
|
|
const Fl_Menu_* = 0,
|
|
const Fl_Menu_Item* title = 0,
|
|
int menubar=0) const;
|
|
const Fl_Menu_Item* test_shortcut() const;
|
|
const Fl_Menu_Item* find_shortcut(int *ip=0) const;
|
|
|
|
/**
|
|
Calls the Fl_Menu_Item item's callback, and provides the
|
|
Fl_Widget argument (and optionally overrides the user_data()
|
|
argument). You must first check that callback() is non-zero
|
|
before calling this.
|
|
*/
|
|
void do_callback(Fl_Widget* o) const {callback_(o, user_data_);}
|
|
|
|
/**
|
|
Calls the Fl_Menu_Item item's callback, and provides the
|
|
Fl_Widget argument (and optionally overrides the user_data()
|
|
argument). You must first check that callback() is non-zero
|
|
before calling this.
|
|
*/
|
|
void do_callback(Fl_Widget* o,void* arg) const {callback_(o, arg);}
|
|
|
|
/**
|
|
Calls the Fl_Menu_Item item's callback, and provides the
|
|
Fl_Widget argument (and optionally overrides the user_data()
|
|
argument). You must first check that callback() is non-zero
|
|
before calling this.
|
|
*/
|
|
void do_callback(Fl_Widget* o,long arg) const {callback_(o, (void*)arg);}
|
|
|
|
// back-compatibility, do not use:
|
|
|
|
/** back compatibility only \deprecated. */
|
|
int checked() const {return flags&FL_MENU_VALUE;}
|
|
|
|
/** back compatibility only \deprecated. */
|
|
void check() {flags |= FL_MENU_VALUE;}
|
|
|
|
/** back compatibility only \deprecated. */
|
|
void uncheck() {flags &= ~FL_MENU_VALUE;}
|
|
|
|
int add(const char*, int shortcut, Fl_Callback*, void* =0, int = 0);
|
|
|
|
/** See int add(const char*, int shortcut, Fl_Callback*, void*, int) */
|
|
int add(const char*a, const char* b, Fl_Callback* c,
|
|
void* d = 0, int e = 0) {
|
|
return add(a,fl_old_shortcut(b),c,d,e);}
|
|
|
|
int size() const ;
|
|
};
|
|
|
|
typedef Fl_Menu_Item Fl_Menu; // back compatibility
|
|
|
|
enum { // back-compatibility enum:
|
|
FL_PUP_NONE = 0,
|
|
FL_PUP_GREY = FL_MENU_INACTIVE,
|
|
FL_PUP_GRAY = FL_MENU_INACTIVE,
|
|
FL_MENU_BOX = FL_MENU_TOGGLE,
|
|
FL_PUP_BOX = FL_MENU_TOGGLE,
|
|
FL_MENU_CHECK = FL_MENU_VALUE,
|
|
FL_PUP_CHECK = FL_MENU_VALUE,
|
|
FL_PUP_RADIO = FL_MENU_RADIO,
|
|
FL_PUP_INVISIBLE = FL_MENU_INVISIBLE,
|
|
FL_PUP_SUBMENU = FL_SUBMENU_POINTER
|
|
};
|
|
|
|
#endif
|
|
|
|
//
|
|
// End of "$Id$".
|
|
//
|