From 87dd7f0d23eba5c09e71ec6efeb34c6844f5e95f Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Tue, 29 Dec 1998 14:21:17 +0000 Subject: Revised documentation files. git-svn-id: file:///fltk/svn/fltk/trunk@177 ea41ed52-d2ee-0310-a9c1-e6b18d33e121 --- documentation/Fl_Widget.html | 380 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 380 insertions(+) create mode 100644 documentation/Fl_Widget.html (limited to 'documentation/Fl_Widget.html') diff --git a/documentation/Fl_Widget.html b/documentation/Fl_Widget.html new file mode 100644 index 000000000..5509a8f85 --- /dev/null +++ b/documentation/Fl_Widget.html @@ -0,0 +1,380 @@ + + + +
+ +

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

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 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. + + + -- cgit v1.2.3