From 367f908d8ed5a3464b9676223a26ddf4e11bdb5b Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Thu, 7 Jan 1999 16:36:11 +0000 Subject: "Final" changes for first draft of 1.0 documentation. git-svn-id: file:///fltk/svn/fltk/trunk@187 ea41ed52-d2ee-0310-a9c1-e6b18d33e121 --- documentation/subclassing.html | 668 +++++++++++++++++++---------------------- 1 file changed, 303 insertions(+), 365 deletions(-) (limited to 'documentation/subclassing.html') diff --git a/documentation/subclassing.html b/documentation/subclassing.html index 414cca67b..7ed03ed7a 100644 --- a/documentation/subclassing.html +++ b/documentation/subclassing.html @@ -1,427 +1,338 @@ -

5 - Adding and Extending Widgets

7 - Adding and Extending Widgets

-This chapter describes how to add your own widgets or extend existing widgets in FLTK. +This chapter describes how to add your own widgets or extend existing +widgets in FLTK.

Subclassing

Adding Syntax Highlighting to the Fl_Input Widget

+New widgets are created by subclassing an existing FLTK widget, +typically Fl_Widget for controls and Fl_Group for +containers. -

Drawing Functions

A control widget typically interacts with the user to receive and/or +display a value of some sort. -

Lines, Rectangles, and Curves, Oh, My!

A container widget holds a list of child widgets and handles moving, +sizing, showing, or hiding them as needed. Fl_Group is the +main container widget class in FLTK, and all of the other containers +(Fl_Pack, Fl_Scroll, Fl_Tabs, Fl_Tile, +and Fl_Window) are subclasses of it. -

Colors

You can also subclass other existing widgets to provide a different look +or user-interface. For example, the button widgets are all subclasses of +Fl_Button since they all interact with the user via a mouse button +click. The only difference is the code that draws the face of the button. -

Fonts

Making a Subclass of Fl_Widget

Images

+Your subclasses can directly descend from Fl_Widget or any +subclass of Fl_Widget. Fl_Widget has only four +virtual methods, and overriding some or all of these may be necessary. -

Writing a Table Widget

The Constructor

Methods

+The constructor should access the following arguments: -

Cut and Paste Support

- - - -Cut & paste -

Cut & paste

- -Fltk provides routines to cut and paste ASCII text (in the future this -may be UTF-8) between applications. It may be possible to cut/paste -non-ascii data under X by using Fl::add_handler(). - -

`void Fl::paste(Fl_Widget *receiver)`

Set things up so the receiver widget will be called with an FL_PASTE event some time in the future. -The reciever should be prepared to be called directly by this, -or for it to happen later, or possibly not at all. This -allows the window system to take as long as necessary to retrieve the -paste buffer (or even to screw up completely) without complex and -error-prone synchronization code in fltk. +

+MyClass(int x, int y, int w, int h, const char *label = 0);
+

`void Fl::selection(Fl_Widget owner, const char stuff, int len); -`

Fluid

Change the current selection. The block of text is copied to an -internal buffer by Fltk (be careful if doing this in response to an -FL_PASTE as this may be the same buffer returned by -event_text()). The selection_owner is set to the passed owner -(possibly sending FL_SELECTIONCLEAR to the previous owner). +

The constructor must call the constructor for the base class and +pass the same arguments: -

`const char* Fl::selection(); - int Fl::selection_length();`

+MyClass::MyClass(int x, int y, int w, int h, const char *label)
+: Fl_Widget(x, y, w, h, label) {
+// do initialization stuff...
+}
+

Fl_Widget

x()

y()

w()

h()

label()

+type(0);
+box(FL_NO_BOX);
+color(FL_GRAY);
+selection_color(FL_GRAY);
+labeltype(FL_NORMAL_LABEL);
+labelstyle(FL_NORMAL_STYLE);
+labelsize(FL_NORMAL_SIZE);
+labelcolor(FL_BLACK);
+align(FL_ALIGN_CENTER);
+callback(default_callback,0);
+flags(ACTIVE|VISIBLE);
+

`Fl_Widget Fl::selection_owner() const; - void Fl::selection_owner(Fl_Widget );`

Protected Methods of Fl_Widget

The single-argument selection_owner(x) call can be used to move the -selection to another widget or to set the owner to NULL, without -changing the actual text of the selection. FL_SELECTIONCLEAR is sent -to the old selection owner, if any. +The following methods are provided for subclasses to use: +

clear_visible +
damage +
draw_box +
draw_label +
set_flag +
set_visible +
test_shortcut +
type

Copying the buffer every time the selection is changed is -obviously wasteful, especially for large selections. I expect an -interface will be added in a future version to allow the selection to -be made by a callback function. The current interface will be -emulated on top of this. +

void Fl_Widget::damage(uchar mask)
+void Fl_Widget::damage(uchar mask, int x, int y, int w, int h)
+uchar Fl_Widget::damage()

Making a subclass of Fl_Widget

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

Your subclasses can directly descend from Fl_Widget or any -subclass of Fl_Widget. Fl_Widget has only four virtual methods, and -overriding some or all of these may be necessary. +

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

Parts of this document: +

The third form returns the bitwise-OR of all damage(n) +calls done since the last draw(). The public method +redraw() does damage(FL_DAMAGE_ALL), but the +implementation of your widget can call the private damage(n). -

void Fl_Widget::draw_box() const
+void Fl_Widget::draw_box(Fl_Boxtype b, ulong c) const

Constructing your Fl_Widget +The first form draws this widget's box(), using the dimensions +of the widget. -
Protected methods of Fl_Widget +The second form uses b as the box type and c as the +color for the box. -
Virtual functions to override: - -
- int Fl_Widget::handle(int -event); - -
- void Fl_Widget::draw(); +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). -
- void -Fl_Widget::resize(int,int,int,int); +
  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, such as a moving slider. -
- Fl_Widget::~Fl_Widget(); +
  The third form draws the label anywhere. It acts as though +FL_ALIGN_INSIDE has been forced on, 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)
-
Making a Composite/Group Widget +If your constructor calls this it modifies draw_label() so +that '&' characters cause an underscore to be printed under the next +letter. -
Making a subclass of Fl_Window +
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. - -

Constructing your Fl_Widget

int Fl_Widget::test_shortcut() const
+static int Fl_Widget::test_shortcut(const char *s)

-I recommend your constructor be of this form: +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. -

-    Class(int x, int y, int w, int h, const char* label = 0);
-

The second version lets you do this test against an arbitrary string. -

This will allow the class name to be typed into fluid and it will produce the correct call. +

uchar Fl_Widget::type() const
+void Fl_Widget::type(uchar t)

The constructor must call the constructor for the base class and -pass the same arguments. Fl_Widget's protected constructor sets x(), -y(), w(), h(), and label() to the passed values and initializes the -other instance variables to: - -

-    type(0);
-    box(FL_NO_BOX);
-    color(FL_GRAY);
-    selection_color(FL_GRAY);
-    labeltype(FL_NORMAL_LABEL);
-    labelstyle(FL_NORMAL_STYLE);
-    labelsize(FL_NORMAL_SIZE);
-    labelcolor(FL_BLACK);
-    align(FL_ALIGN_CENTER);
-    callback(default_callback,0);
-    flags(ACTIVE|VISIBLE);
-

- - -

Protected methods of Fl_Widget

- -

These methods are provided for subclasses to use. - -

`uchar Fl_Widget::type() const; - void Fl_Widget::type(uchar); -`

- -The property Fl_Widget::type() can return an arbitrary 8-bit -identifier, and can be set with the protected method type(uchar). -This value had to be provided for Forms compatability, but you can use +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 +

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() have a unique value. These unique values must be -greater than the symbol FL_RESERVED_TYPE (which is 100). Grep through -the header files for "FL_RESERVED_TYPE" to find an unused number. If -you make a subclass of Fl_Group you must use FL_GROUP+n, and if you -make a subclass of Fl_Window you must use FL_WINDOW+n (in both cases n -is in the range 1-7). - - -

`void Fl_Widget::set_flag(SHORTCUT_LABEL);`

- -If your constructor calls this it modifies draw_label() so that '&' -characters cause an underscore to be printed under the next letter. - -

`int Fl_Widget::test_shortcut() const; -static int Fl_Widget::test_shortcut(const char *);`

- -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 to an arbitrary string. - -

`void Fl_Widget::x(short); - void Fl_Widget::y(short); - void Fl_Widget::w(short); - void Fl_Widget::h(short);`

- -You can directly clobber the values for

x(), y(), w(), and h()

If you don't have RTTI you can use the clumsy FLTK mechanisim, by +having type() have 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_Group you must +use FL_GROUP + n, and if you make a subclass of +Fl_Window you must use FL_WINDOW + n (in both cases +n is in the range 1 to 7). -

`void Fl_Widget::draw_box() const ;`

+Handling Events -Draw this widget's box(), using the dimensions of the widget. +The virtual method int Fl_Widget::handle(int event) is called +to handle each event passed to the widget. It can: -

`void Fl_Widget::draw_box(Fl_Boxtype b,ulong c) const -;`

- -Pretend the box()==b and the color()==c and draw this widget's box. - -

-

`void Fl_Widget::draw_label() 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). - -

`void Fl_Widget::draw_label(int x,int y,int w,int h) const -;`

- -Do the same thing except use the passed bounding box. This is useful -so "centered" labels are aligned with some feature, such as a moving -slider. - -

`void Fl_Widget::draw_label(int x,int y,int w,int -h,Fl_Align align) const ;`

- -Draw the label anywhere. It acts as though FL_ALIGN_INSIDE has been -forced on, the label will appear inside the passed bounding box. This -is designed for parent groups to draw labels with. - -

- -virtual int Fl_Widget::handle() - -The virtual method int Fl_Widget::handle(int -event) is called to handle each event passed to the widget. -It can: - -Change the state of the widget. - -Call Fl_Widget::redraw() if the widget -needs to be redisplayed. + + Change the state of the widget. - Call Fl_Widget::damage(n) if the widget needs -a partial-update (assumming you provide support for this in your -Fl_Widget::draw() method). + Call Fl_Widget::redraw() + if the widget needs to be redisplayed. - Call Fl_Widget::do_callback() if a -callback should be generated. + Call Fl_Widget::damage(n) if + the widget needs a partial-update (assumming you provide + support for this in your Fl_Widget::draw() method). - Call Fl_Widget::handle() on child widgets. + Call Fl_Widget::do_callback() + if a callback should be generated. + Call Fl_Widget::handle() on child widgets. -Events are identified the small integer argument. Other -information about the most recent event is stored in static locations -and aquired by calling Fl::event_*(). -This other information remains valid until another event is read from -the X server. +Events are identified by the integer argument. Other information about +the most recent event is stored in static locations and aquired by +calling the Fl::event_*() functions. +This information remains valid until another event is handled. - Here is a sample Fl_Widget::handle(), for a widget that acts as a + Here is a sample handle() method for a widget that acts as a pushbutton and also accepts the keystroke 'x' to cause the callback: - int Fl_Pushbutton::handle(int event) { ++int MyClass::handle(int event) { switch(event) { case FL_PUSH: - highlight = 1; redraw(); + highlight = 1; + redraw(); return 1; - case FL_DRAG: - {int t = Fl::event_inside(this); - if (t != highlight) {highlight = t; redraw();}} + case FL_DRAG: { + int t = Fl::event_inside(this); + if (t != highlight) { + highlight = t; + redraw(); + } + } return 1; case FL_RELEASE: if (highlight) { - highlight = 0; redraw(); + highlight = 0; + redraw(); do_callback(); - // never do anything after a callback, so that the callback + // never do anything after a callback, as the callback // may delete the widget! } return 1; case FL_SHORTCUT: - if (Fl::event_key() == 'x') {do_callback(); return 1;} + if (Fl::event_key() == 'x') { + do_callback(); + return 1; + } return 0; default: return 0; - } } } -You must return non-zero if your handle() method used the event. -If you return zero it indicates to the parent that it can try sending -another widget the event. +You must return non-zero if your handle() method uses the +event. If you return zero it indicates to the parent widget that it can +try sending the event to another widget. - It looks like it is best to make the handle() method public. + Drawing the Widget - -virtual void Fl_Widget::draw() +The draw() virtual method is called when FLTK wants you to +redraw your widget. It will be called if and only if damage() +is non-zero, and damage() will be cleared to zero after it +returns. draw() should be declared protected, so that it can't +be called from non-drawing code. -The virtual method Fl_Widget::draw() is called when fltk wants you -to redraw your widget. It will be called if and only if damage() is -non-zero, and damage() will be cleared to zero after it returns. -draw() should be declared protected, so that subclasses may call it -but it can't be called from non-drawing code. - - damage() contains the bitwise-or of all the damage(n) calls to this + damage() contains the bitwise-OR of all the damage(n) calls to this widget since it was last drawn. This can be used for minimal update, -by only redrawing the parts whose bits are set. Fltk will turn +by only redrawing the parts whose bits are set. FLTK will turn all the bits on if it thinks the entire widget must be redrawn -(for instance due to an expose event). It is easiest to program to -handle this by pretending a bit (usually damage()&128) draw the -non-minimal-update parts of your widget (such as the box()). - -Expose events (and the above damage(b,x,y,w,h)) will cause draw() -to be called with fltk's clipping -turned on. You can greatly speed up redrawing in some cases by -testing fl_clipped and fl_current_clip -and skipping invisible parts. - - The functions you can use to draw are described in <FL/fl_draw.H> or any of the protected -Fl_Widget::draw_* methods described above. - - - virtual void Fl_Widget::resize(int,int,int,int); - -This is called when the widget is being resized or moved. The -arguments are the new position, width, and height. x(), y(), w(), and -h() still return the old size. You must call resize() on your -base class with the same arguments to get the widget size to actually -change. +(for instance due to an expose event). -This should not call redraw(), at least if only the x() and -y() change. This is because group objects like Fl_Scroll may have a more efficient way of -drawing the new position. + Expose events (and the above damage(b,x,y,w,h)) will cause +draw() to be called with FLTK's clipping turned on. You can greatly speed up +redrawing in some cases by testing fl_clipped and +fl_current_clip and skipping invisible parts. - It may be useful to refer to the size the widget was constructed -at, these are stored in Fl_Widget::ix(), iy(), iw(), and ih(). + Besides the protected methods described above, FLTK provide a large +number of basic drawing functions, which are described below. - Resize should be declared public. + Resizing the Widget - -virtual Fl_Widget::~Fl_Widget(); +The resize(int x, int y, int w, int h) method is called when +the widget is being resized or moved. The arguments are the new +position, width, and height. x(), y(), w(), +and h() still remain the old size. You must call +resize() on your base class with the same arguments to get the +widget size to actually change. -We all know why the destructor must be virtual don't we? Don't forget -to make it public. +This should not call redraw(), at least if only the +x() and y() change. This is because group objects +like Fl_Scroll may have a more +efficient way of drawing the new position. - - Making a Composite/Group Widget +Making a Composite/Group Widget A "composite" widget contains one or more "child" widgets. To do this -you should subclass Fl_Group (it is +you should subclass Fl_Group. It is possible to make a composite object that is not a subclass of -Fl_Group, but this is very difficult). +Fl_Group, but you'll have to duplicate the code in Fl_Group +anyways. Instances of the child widgets may be included in the parent: - class MyClass : public Fl_Group { ++class MyClass : public Fl_Group { Fl_Button the_button; Fl_Slider the_slider; ... }; -The constructor has to initialize these instances. They are -automatically add()ed to the group, since the Fl_Group constructor -does begin(). Don't forget to call end(): - - MyClass::MyClass(int x,int y,int w,int h) : - Fl_Group(x,y,w,h), - the_button(x+5,y+5,100,20), - the_slider(x,y+50,w,20) +The constructor has to initialize these instances. They are +automatically add()ed to the group, since the +Fl_Group constructor does begin(). Don't forget +to call end() or use the Fl_End +pseudo-class: + ++MyClass::MyClass(int x, int y, int w, int h) : + Fl_Group(x, y, w, h), + the_button(x + 5, y + 5, 100, 20), + the_slider(x, y + 50, w, 20) { ...(you could add dynamically created child widgets here)... end(); // don't forget to do this! } -The child widgets need callbacks. These will be called with a -pointer to the children, but the widget itself may be found in the -parent() pointer of the child. Usually these callbacks can be static -private methods, with a matching private method: +The child widgets need callbacks. These will be called with a pointer +to the children, but the widget itself may be found in the +parent() pointer of the child. Usually these callbacks can be +static private methods, with a matching private method: - void MyClass::slider_cb(Fl_Widget* v, void *) { // static method ++void MyClass::slider_cb(Fl_Widget* v, void *) { // static method ((MyClass*)(v->parent())->slider_cb(); } void MyClass::slider_cb() { // normal method @@ -429,31 +340,33 @@ void MyClass::slider_cb() { // normal method } -If you make the handle() method, you can quickly pass all the -events to the children (notice that you don't need to override -handle() if your composite widget does nothing other than pass events -to the children): +If you make the handle() method, you can quickly pass all the +events to the children using the Fl_Group::handle() method. +Note that you don't need to override handle() if your +composite widget does nothing other than pass events to the children: - int MyClass::handle(int event) { ++int MyClass::handle(int event) { if (Fl_Group::handle(event)) return 1; ... handle events that children don't want ... } -If you override draw() you need to draw all the children. If -redraw() or damage() is called on a child, damage(1) is done to the -group. Thus the 1 bit of damage() can be used to indicate that a -child needs to be drawn. It is fastest if you avoid drawing anything -else in this case: - - int MyClass::draw() { - Fl_Widget*const* a = array(); - if (damage()==1) { // only redraw some children - for (int i=children(); i--; a++) update_child(**a); +If you override draw() you need to draw all the children. If +redraw() or damage() is called on a child, +damage(FL_DAMAGE_CHILD) is done to the group, so this bit of +damage() can be used to indicate that a child needs to be +drawn. It is fastest if you avoid drawing anything else in this case: + ++int MyClass::draw() { + Fl_Widget *const*a = array(); + if (damage() == FL_DAMAGE_CHILD) { // only redraw some children + for (int i = children(); i --; a ++) update_child(**a); } else { // total redraw ... draw background graphics ... // now draw all the children atop the background: - for (int i=children_; i--; a++) { + for (int i = children_; i --; a ++) { draw_child(**a); draw_outside_label(**a); // you may not want to do this } @@ -461,59 +374,84 @@ else in this case: } -Fl_Group provides some protected methods to make drawing easier: +Fl_Group provides some protected methods to make drawing easier: + + + draw_child + draw_outside_label + update_child + - void Fl_Group::draw_outside_label(Fl_Widget&) const; +void Fl_Group::draw_child(Fl_Widget&) -Draw the labels that are not drawn by draw_label(). If you want more control over the -label positions you might want to call child->draw_label(x,y,w,h,a). +This will force the child's damage() bits all to one and call +draw() on it, then clear the damage(). You should +call this on all children if a total redraw of your widget is +requested, or if you draw something (like a background box) that +damages the child. Nothing is done if the child is not +visible() or if it is clipped. - void Fl_Group::draw_child(Fl_Widget&); +void Fl_Group::draw_outside_label(Fl_Widget&) const -This will force the child's damage() bits all to one and call draw() -on it, then clear the damage(). You should call this on all children -if a total redraw of your widget is requested, or if you draw -something (like a background box) that damages the child. Nothing is -done if the child is not visible() or if it is clipped. +Draw the labels that are not drawn by +draw_label(). If you want more control +over the label positions you might want to call +child->draw_label(x,y,w,h,a). - void Fl_Group::update_child(Fl_Widget&); +void Fl_Group::update_child(Fl_Widget&) -Draws the child only if it's damage() is non-zero. You should call -this on all the children if your own damage is equal to 1. Nothing is -done if the child is not visible() or if it is clipped. +Draws the child only if it's damage() is non-zero. You should +call this on all the children if your own damage is equal to +FL_DAMAGE_CHILD. Nothing is done if the child is not +visible() or if it is clipped. +Cut and Paste Support + +FLTK provides routines to cut and paste ASCII text (in the future this +may be UTF-8) between applications: + + + Fl::paste + Fl::selection + Fl::selection_length + Fl::selection_owner - -Making a subclass of Fl_Window -You may want your widget to be a subclass of Fl_Window. This can -be useful if your widget wants to occupy an entire window, and can +It may be possible to cut/paste non-ASCII data by using Fl::add_handler(). + + Making a subclass of Fl_Window + +You may want your widget to be a subclass of Fl_Window. This +can be useful if your widget wants to occupy an entire window, and can also be used to take advantage of system-provided clipping, or to work with a library that expects a system window id to indicate where to draw. -Subclassing Fl_Window is almost exactly like subclassing Fl_Widget, -in fact you can easily switch a subclass back and forth. Watch out -for the following differences: + Subclassing Fl_Window is almost exactly like subclassing +Fl_Widget, in fact you can easily switch a subclass back and +forth. Watch out for the following differences: -Fl_Window is a subclass of Fl_Group so make sure your constructor -calls end() (unless you actually want children added to your -window). - - When handling events and drawing, the lower-left corner is at 0,0, -not x(),y() as in other Fl_Widgets. For instance, to draw a box -around the widget, call draw_box(0,0,w(),h()), rather than -draw_box(x(),y(),w(),h()). + Fl_Window is a subclass of Fl_Group so + make sure your constructor calls end() (unless + you actually want children added to your window). + When handling events and drawing, the upper-left corner is + at 0,0, not x(),y() as in other Fl_Widgets. + For instance, to draw a box around the widget, call + draw_box(0, 0, w(), h()), rather than + draw_box( x(), y(), w(), h()). -You may also want to subclass Fl_Window in order to get access to -different X visuals or to change other X attributes of the windows, -See here for details. +You may also want to subclass Fl_Window in order to get access to +different visuals or to change other attributes of the windows. See +Appendix F - Operating System Issues for more +information. + + + - (back to contents) -- cgit v1.2.3

Subclassing

Adding Syntax Highlighting to the Fl_Input Widget

Drawing Functions

Lines, Rectangles, and Curves, Oh, My!

Colors

Fonts

Making a Subclass of Fl_Widget

Images

The Constructor

Methods

Cut and Paste Support

Cut & paste

void Fl::paste(Fl_Widget *receiver)

void Fl::selection(Fl_Widget *owner, const char *stuff, int len); -

const char* Fl::selection(); -int Fl::selection_length();

Fl_Widget *Fl::selection_owner() const; -void Fl::selection_owner(Fl_Widget *);

Protected Methods of Fl_Widget

Making a subclass of Fl_Widget

void Fl_Widget::draw_box() const +void Fl_Widget::draw_box(Fl_Boxtype b, ulong c) const

void Fl_Widget::set_visible() +void Fl_Widget::clear_visible()

Constructing your Fl_Widget

Protected methods of Fl_Widget

uchar Fl_Widget::type() const; -void Fl_Widget::type(uchar); -

Handling Events

virtual int Fl_Widget::handle()

Drawing the Widget

virtual void Fl_Widget::draw()

Resizing the Widget

virtual Fl_Widget::~Fl_Widget();

Making a Composite/Group Widget

void Fl_Group::draw_outside_label(Fl_Widget&) const;

void Fl_Group::draw_child(Fl_Widget&);

void Fl_Group::update_child(Fl_Widget&);

Cut and Paste Support

Making a subclass of Fl_Window

Making a subclass of Fl_Window

`void Fl::paste(Fl_Widget *receiver)`

`void Fl::selection(Fl_Widget owner, const char stuff, int len); -`

`const char* Fl::selection(); - int Fl::selection_length();`

`Fl_Widget Fl::selection_owner() const; - void Fl::selection_owner(Fl_Widget );`

void Fl_Widget::draw_box() const
+void Fl_Widget::draw_box(Fl_Boxtype b, ulong c) const

void Fl_Widget::set_visible()
+void Fl_Widget::clear_visible()

`uchar Fl_Widget::type() const; - void Fl_Widget::type(uchar); -`

`void Fl_Group::draw_outside_label(Fl_Widget&) const;`

`void Fl_Group::draw_child(Fl_Widget&);`

`void Fl_Group::update_child(Fl_Widget&);`