From d7b88a3bcc7e76f38ee5799be7722fd5a10781ef Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Wed, 13 Jan 1999 19:28:54 +0000 Subject: Updated all links so they work between files. Revision 1. git-svn-id: file:///fltk/svn/fltk/trunk@219 ea41ed52-d2ee-0310-a9c1-e6b18d33e121 --- documentation/Fl_Widget.html | 659 +++++++++++++++++++------------------------ 1 file changed, 292 insertions(+), 367 deletions(-) (limited to 'documentation/Fl_Widget.html') diff --git a/documentation/Fl_Widget.html b/documentation/Fl_Widget.html index 933e1ef7e..1009a0726 100644 --- a/documentation/Fl_Widget.html +++ b/documentation/Fl_Widget.html @@ -1,368 +1,293 @@ - - - -
- -

class Fl_Widget

- -
- -

Class Hierarchy

- - +

Include Files

+ +

Description

+Fl_Widget is the base class for all 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(), +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, the property setting methods such as +color(n) or label(s) are also trivial inline functions, +even if they change the widget's appearance. It is up to the user code +to call redraw() after these.

+

Methods

+
+ + +
+ + + + + + + + + +
+
+

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) +.

+

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 Box Types for the +available types. The default depends on the widget, but is usually +FL_NO_BOX or FL_UP_BOX. +

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. 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 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 FL_ALIGN_CENTER, which centers the label. The value +can be any of these constants or'd together: + + +

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. +

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 typefaces. The default value uses a +Helvetica typeface (Arial for Microsoft® Windows®). The function +Fl::set_font() can define new typefaces. +

uchar Fl_Widget::labelsize() const +
void Fl_Widget::labelsize(uchar)

+ Fonts are further identified by a point size. 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() +

+Fl_Widget::active() returns whether the widget is active. An +inactive widget does not get any events, but it does get redrawn. A +widget is active if active() is true on it and all it's +parents. Changing this value will send FL_ACTIVATE or +FL_DEACTIVATE to the widget. Do not change it if the parent is +not active, as this will send false FL_ACTIVATE or +FL_DEACTIVATE events to the widget. +

Currently you cannot deactivate Fl_Window widgets.

+

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 +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. +

int Fl_Widget::take_focus()

+ Tries to make this widget be the Fl::focus() widget, by first +sending it an FL_FOCUS event, and if it returns non-zero, +setting Fl::focus() to this widget. You should use this +method to assign the focus to an widget. Returns true if the widget +accepted the focus. \ No newline at end of file -- cgit v1.2.3