#include <FL/Fl_Widget.H>
class Fl_Widget
This is the base class for Fl_Window, Fl_Group, and all the ui widgets
in fltk. You can't create one of these because the constructor is not
public. However you can subclass it.
All "property" accessing methods, such as color() or parent() or
argument() are implemented as trivial inline functions and thus are as
fast and small as accessing fields in a structure. Unless otherwise
noted (by saying the method causes a redraw()), the property setting
methods such as color(n) or label(s) are also trivial inline
functions, even if they change the widgets appearance. It is up to
the user code to call redraw() after these.
Fl_Widget::Fl_Widget(int x, int y, int w, int h, const char* label=0);
This is the protected constructor for an Fl_Widget, but all derived
widgets have a matching public constructor. It takes a value for
x(), y(), w(), h(), and an optional value for label().
virtual Fl_Widget::~Fl_Widget();
Destroying single widgets is not very common. It is your
responsibility to either remove() them from any enclosing group, or to
destroy that group immediately after destroying the children.
uchar Fl_Widget::type() const;
This value is used for Forms compatability and to simulate RTTI.
short Fl_Widget::x() const;
short Fl_Widget::y() const;
short Fl_Widget::w() const;
short Fl_Widget::h() const;
The position of the upper-left corner of the widget in its enclosing
Fl_Window (not its parent if that is not an Fl_Window), and its
width and height.
virtual void Fl_Widget::resize(int,int,int,int);
void Fl_Widget::position(short x,short y);
void Fl_Widget::size(short w,short h);
Change the size or position of the widget. This is a virtual function
so the widget may implement it's own handling of resizing. The
default version does not do redraw(), that is the parent
widget's responsibility (this is because the parent may know a faster
way to update the display, such as scrolling from the old position).
position(x,y) is a shortcut for resize(x,y,w(),h()), and size(w,h)
is a shortcut for resize(x(),y(),w,h).
short Fl_Widget::ix() const;
short Fl_Widget::iy() const;
short Fl_Widget::iw() const;
short Fl_Widget::ih() const;
void Fl_Widget::init_size(int,int,int,int);
The initial size and position of the widget. This is a copy of the
arguments that the constructor was called with. This information is
used by Fl_Group to calculate new sizes of
the children when they are resized.
init_size() calls resize() with the passed sizes, and then replaces
the initial size with the new values. If this widget is a group you
will have to init_size all the children as well or unpredictable
results will occur.
Fl_Window* Fl_Widget::window() const;
Return a pointer to the Fl_Window that this
widget is in (it will skip any and all parent widgets between this
and the window). Returns NULL if none. Note: for an Fl_Window, this
returns it's parent window (if any), not this window.
Fl_Boxtype Fl_Widget::box() const;
void Fl_Widget::box(Fl_Boxtype);
The box() identifies a routine that draws the background of the
widget. See Boxtypes for the available
types. The default depends on the widget, but is usually FL_NO_BOX
(0) or FL_UP_BOX (2).
Fl_Color Fl_Widget::color() const;
void Fl_Widget::color(Fl_Color);
This color is passed to the box routine. Color is an index into an
internal table of rgb colors. For most widgets this defaults to
FL_GRAY (49). See the enumeration list
for predefined colors. Use Fl::set_color() to redefine colors.
Fl_Color Fl_Widget::selection_color() const;
void Fl_Widget::selection_color(Fl_Color);
void Fl_Widget::color(Fl_Color, Fl_Color);
For Forms compatibility a second color is defined. This is usually
used to color the widget when it is selected, although some widgets
use this color for other purposes. You can set both colors at once
with color(a,b).
const char* Fl_Widget::label() const;
void Fl_Widget::label(const char*);
The label is printed somewhere on the widget or next to it. The
string is not copied, the passed pointer is stored unchanged in
the widget.
void Fl_Widget::label(Fl_Labeltype, const char*);
uchar Fl_Widget::labeltype() const;
void Fl_Widget::labeltype(Fl_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 (0) prints the
label as text.
Fl_Align Fl_Widget::align() const;
void Fl_Widget::align(Fl_Align);
How the label is printed next to or inside the widget. The default
value is zero, which centers the label. The value can be any of these
constants or'd together:
- FL_ALIGN_CENTER (0)
- FL_ALIGN_TOP (1)
- FL_ALIGN_BOTTOM (2)
- FL_ALIGN_LEFT (4)
- FL_ALIGN_RIGHT (8)
- FL_ALIGN_INSIDE (16)
(turns off Fl_Group's outside labelling)
- FL_ALIGN_CLIP (64)
- FL_ALIGN_WRAP (128)
Fl_Color Fl_Widget::labelcolor() const;
void Fl_Widget::labelcolor(Fl_Color);
This color is passed to the labeltype routine, and is typically the
color of the label text. This defaults to FL_BLACK (0).
Fl_Font Fl_Widget::labelfont() const;
void Fl_Widget::labelfont(Fl_Font);
Fonts are identified by small 8-bit indexes into a table. See the enumeration list for predefined fonts.
The default value (0) uses a Helvetica font. The function
Fl::set_font() can define new fonts.
uchar Fl_Widget::labelsize() const;
void Fl_Widget::labelsize(uchar);
Fonts are further identified by a point size. This sets the actual
point size field of the X font name. The default is 14.
typedef void (Fl_Callback)(Fl_Widget*, void*);
Fl_Callback* Fl_Widget::callback() const;
void Fl_Widget::callback(Fl_Callback*, void* = 0);
Each widget has a single callback. You can set it or examine it with
these methods.
void* Fl_Widget::user_data() const;
void Fl_Widget::user_data(void*);
You can also just change the void* second argument to the callback
with the user_data methods.
void Fl_Widget::callback(void (*)(Fl_Widget*, long), long = 0);
long Fl_Widget::argument() const;
void Fl_Widget::argument(long);
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 Fl_Widget::callback(void (*)(Fl_Widget*));
For convenience you can also define the callback as taking only one
argument. This is implemented by casting this to a Fl_Callback and
may not be portable to some machines.
void Fl_Widget::do_callback();
void Fl_Widget::do_callback(Fl_Widget*, void* = 0);
void Fl_Widget::do_callback(Fl_Widget*, long);
You can cause a widget to do its callback at any time, and even pass
arbitrary arguments.
int Fl_Widget::changed() const;
void Fl_Widget::set_changed();
void Fl_Widget::clear_changed();
Fl_Widget::changed() is a flag that is turned on when the user changes
the value stored in the widget. This is only used by subclasses of
Fl_Widget that store values, but is in the base class so it is easier
to scan all the widgets in a panel and do_callback() on the changed
ones in response to an "OK" button.
Most widgets turn this flag off when they do the callback, and when
the program sets the stored value.
Fl_When Fl_Widget::when() const;
void Fl_Widget::when(Fl_When);
Fl_Widget::when() is a set of bitflags used by subclasses of Fl_Widget
to decide when to do the callback. If the value is zero then the
callback is never done. Other values are described in the individual
widgets. This field is in the base class so that you can scan a panel
and do_callback() on all the ones that don't do their own callbacks in
response to an "OK" button.
static void
Fl_Widget::default_callback(Fl_Widget*, void*);
The default callback, which puts a pointer to the widget on the queue
returned by Fl::readqueue(). You
may want to call this from your own callback.
int Fl_Widget::visible() const;
void Fl_Widget::show();
void Fl_Widget::hide();
An invisible widget never gets redrawn and does not get events. An
widget is really visible if visible() is true on it and all it's
parents. Changing it will send FL_SHOW or FL_HIDE events to the
widget. Do not change it if the parent is not visible, as this
will send false FL_SHOW or FL_HIDE events to the widget. redraw()
is called if necessary on this or the parent.
int Fl_Widget::active() const;
void Fl_Widget::activate();
void Fl_Widget::deactivate();
int Fl_Widget::activevisible() const;
This is the same as active()&&visible() but is faster.
void Fl_Widget::redraw();
Mark the widget as needing its draw() routine called.
uchar Fl_Widget::damage() const;
Non-zero if draw() needs to be called. Actually this is a bit field
that the widget subclass can use to figure out what parts to draw.
Fl_Widget* Fl_Widget::parent() const;
Returns a pointer to the parent widget. Usually this is a Fl_Group or Fl_Window. Returns null if none.
int Fl_Widget::contains(Fl_Widget* b) const;
Returns true if b is a child of this widget, or is equal to this
widget. Returns false if b is null.
int Fl_Widget::inside(const Fl_Widget* a) const;
Returns true if this is a child of a, or is equal to a. Returns false
if a is null.
(back to contents)