| Century Embedded Technologies Nano-X SDK and Developer's Guide | ||
|---|---|---|
| Prev | Chapter 13. Extending and Adding Widgets | Next |
The following methods are provided for subclasses to use:
void Fl_Widget::damage(uchar mask) void Fl_Widget::damage(uchar mask, int x, int y, int w, int h) uchar Fl_Widget::damage()
The first form indicates that a partial update of the object is needed. The bits in mask are OR'd into damage(). Your draw() routine can examine these bits to limit what it is drawing. The public method Fl_Widget::redraw() simply does Fl_Widget::damage(FL_DAMAGE_ALL), but the implementation of your widget can call the private damage(n).
The second form indicates that a region is damaged. If only these calls are done in a window (no calls to damage(n)) then FLTK will clip to the union of all these calls before drawing anything. This can greatly speed up incremental displays. The mask bits are OR'd into damage() unless this is a Fl_Window widget.
The third form returns the bitwise-OR of all damage(n) calls done since the last draw().
When redrawing your widgets you should look at the damage bits to see what parts of your widget need redrawing. The handle() method can then set individual damage bits to limit the amount of drawing that needs to be done:
MyClass::handle(int event) { ... if (change_to_part1) damage(1); if (change_to_part2) damage(2); if (change_to_part3) damage(4); } MyClass::draw() { if (damage() & FL_DAMAGE_ALL) { ... draw frame/box and other static stuff ... } if (damage() & (FL_DAMAGE_ALL | 1)) draw_part1(); if (damage() & (FL_DAMAGE_ALL | 2)) draw_part2(); if (damage() & (FL_DAMAGE_ALL | 4)) draw_part3(); }
void Fl_Widget::draw_box() const void Fl_Widget::draw_box(Fl_Boxtype b, ulong c) const
The first form draws this widget's box(), using the dimensions of the widget. The second form uses b as the box type and c as the color for the box.
void Fl_Widget::draw_label() const void Fl_Widget::draw_label(int x, int y, int w, int h) const void Fl_Widget::draw_label(int x, int y, int w, int h, Fl_Align align) const
This is the usual function for a draw() method to call to draw the widget's label. It does not draw the label if it is supposed to be outside the box (on the assumption that the enclosing group will draw those labels).
The second form uses the passed bounding box instead of the widget's bounding box. This is useful so "centered" labels are aligned with some feature, like a moving slider.
The third form draws the label anywhere. It acts as though FL_ALIGN_INSIDE has been forced on so the label will appear inside the passed bounding box. This is designed for parent groups to draw labels with.
void Fl_Widget::set_flag(SHORTCUT_LABEL)
Modifies draw_label() so that '&' characters cause an underscore to be printed under the next letter.
void Fl_Widget::set_visible() void Fl_Widget::clear_visible()
Fast inline versions of Fl_Widget::hide() and Fl_Widget::show(). These do not send the FL_HIDE and FL_SHOW events to the widget.
int Fl_Widget::test_shortcut() const static int Fl_Widget::test_shortcut(const char *s)
The first version tests Fl_Widget::label() against the current event (which should be a FL_SHORTCUT event). If the label contains a '&' character and the character after it matches the key press, this returns true. This returns false if the SHORTCUT_LABEL flag is off, if the label is NULL or does not have a '&' character in it, or if the keypress does not match the character.
The second version lets you do this test against an arbitrary string.
uchar Fl_Widget::type() const void Fl_Widget::type(uchar t)
The property Fl_Widget::type() can return an arbitrary 8-bit identifier, and can be set with the protected method type(uchar t). This value had to be provided for Forms compatibility, but you can use it for any purpose you want. Try to keep the value less than 100 to not interfere with reserved values.
FLTK does not use RTTI (Run Time Typing Infomation), to enhance portability. But this may change in the near future if RTTI becomes standard everywhere.
If you don't have RTTI you can use the clumsy FLTK mechanisim, by having type() use a unique value. These unique values must be greater than the symbol FL_RESERVED_TYPE (which is 100). Look through the header files for FL_RESERVED_TYPE to find an unused number. If you make a subclass of Fl_Window you must use FL_WINDOW + n (n must be in the range 1 to 7).