FLTK 1.3.0
Fl_Group Class Reference

The Fl_Group class is the FLTK container widget. More...

#include <Fl_Group.H>

Inheritance diagram for Fl_Group:
Fl_Widget Fl_Browser_ Fl_Color_Chooser Fl_Help_View Fl_Input_Choice Fl_Pack Fl_Scroll Fl_Spinner Fl_Table Fl_Tabs Fl_Text_Display Fl_Tile Fl_Tree Fl_Window Fl_Wizard

List of all members.

Public Member Functions

Fl_Widget *& _ddfdesign_kludge ()
 This is for forms compatibility only.
void add (Fl_Widget &)
 The widget is removed from its current group (if any) and then added to the end of this group.
void add (Fl_Widget *o)
 See void Fl_Group::add(Fl_Widget &w)
void add_resizable (Fl_Widget &o)
 Adds a widget to the group and makes it the resizable widget.
Fl_Widget *const * array () const
 Returns a pointer to the array of children.
virtual Fl_Groupas_group ()
 Returns an Fl_Group pointer if this widget is an Fl_Group.
void begin ()
 Sets the current group so you can build the widget tree by just constructing the widgets.
Fl_Widgetchild (int n) const
 Returns array()[n].
int children () const
 Returns how many child widgets the group has.
void clear ()
 Deletes all child widgets from memory recursively.
void clip_children (int c)
 Controls whether the group widget clips the drawing of child widgets to its bounding box.
unsigned int clip_children ()
 Returns the current clipping mode.
void end ()
 Exactly the same as current(this->parent()).
int find (const Fl_Widget *) const
 Searches the child array for the widget and returns the index.
int find (const Fl_Widget &o) const
 See int Fl_Group::find(const Fl_Widget *w) const.
 Fl_Group (int, int, int, int, const char *=0)
 Creates a new Fl_Group widget using the given position, size, and label string.
void focus (Fl_Widget *W)
void forms_end ()
 This is for forms compatibility only.
int handle (int)
 Handles the specified event.
void init_sizes ()
 Resets the internal array of widget sizes and positions.
void insert (Fl_Widget &, int i)
 The widget is removed from its current group (if any) and then inserted into this group.
void insert (Fl_Widget &o, Fl_Widget *before)
 This does insert(w, find(before)).
void remove (int index)
 Removes the widget at index from the group but does not delete it.
void remove (Fl_Widget &)
 Removes a widget from the group but does not delete it.
void remove (Fl_Widget *o)
 Removes the widget o from the group.
void resizable (Fl_Widget &o)
 See void Fl_Group::resizable(Fl_Widget *box)
void resizable (Fl_Widget *o)
 The resizable widget defines the resizing box for the group.
Fl_Widgetresizable () const
 See void Fl_Group::resizable(Fl_Widget *box)
void resize (int, int, int, int)
 Resizes the Fl_Group widget and all of its children.
virtual ~Fl_Group ()
 The destructor also deletes all the children.

Static Public Member Functions

static Fl_Groupcurrent ()
 Returns the currently active group.
static void current (Fl_Group *g)
 Sets the current group.

Protected Member Functions

void draw ()
 Draws the widget.
void draw_child (Fl_Widget &widget) const
 Forces a child to redraw.
void draw_children ()
 Draws all children of the group.
void draw_outside_label (const Fl_Widget &widget) const
 Parents normally call this to draw outside labels of child widgets.
int * sizes ()
 Returns the internal array of widget sizes and positions.
void update_child (Fl_Widget &widget) const
 Draws a child only if it needs it.

Detailed Description

The Fl_Group class is the FLTK container widget.

It maintains an array of child widgets. These children can themselves be any widget including Fl_Group. The most important subclass of Fl_Group is Fl_Window, however groups can also be used to control radio buttons or to enforce resize behavior.


Constructor & Destructor Documentation

Fl_Group::Fl_Group ( int  X,
int  Y,
int  W,
int  H,
const char *  l = 0 
)

Creates a new Fl_Group widget using the given position, size, and label string.

The default boxtype is FL_NO_BOX.

Fl_Group::~Fl_Group ( ) [virtual]

The destructor also deletes all the children.

This allows a whole tree to be deleted at once, without having to keep a pointer to all the children in the user code.

It is allowed that the Fl_Group and all of its children are automatic (local) variables, but you must declare the Fl_Group first, so that it is destroyed last.

If you add static or automatic (local) variables to an Fl_Group, then it is your responsibility to remove (or delete) all such static or automatic child widgets before destroying the group - otherwise the child widgets' destructors would be called twice!


Member Function Documentation

Fl_Widget *const * Fl_Group::array ( ) const

Returns a pointer to the array of children.

This pointer is only valid until the next time a child is added or removed.

virtual Fl_Group* Fl_Group::as_group ( ) [inline, virtual]

Returns an Fl_Group pointer if this widget is an Fl_Group.

Use this method if you have a widget (pointer) and need to know whether this widget is derived from Fl_Group. If it returns non-NULL, then the widget in question is derived from Fl_Group, and you can use the returned pointer to access its children or other Fl_Group-specific methods.

Example:

      void my_callback (Fl_Widget *w, void *) {
        Fl_Group *g = w->as_group();
        if (g)
          printf ("This group has %d children\n",g->children());
        else
          printf ("This widget is not a group!\n");
      }
Return values:
NULLif this widget is not derived from Fl_Group.
Note:
This method is provided to avoid dynamic_cast.
See also:
Fl_Widget::as_window(), Fl_Widget::as_gl_window()

Reimplemented from Fl_Widget.

void Fl_Group::begin ( )

Sets the current group so you can build the widget tree by just constructing the widgets.

begin() is automatically called by the constructor for Fl_Group (and thus for Fl_Window as well). begin() is exactly the same as current(this). Don't forget to end() the group or window!

Reimplemented in Fl_Table.

Fl_Widget* Fl_Group::child ( int  n) const [inline]

Returns array()[n].

No range checking is done!

Reimplemented in Fl_Table.

void Fl_Group::clear ( )

Deletes all child widgets from memory recursively.

This method differs from the remove() method in that it affects all child widgets and deletes them from memory.

Reimplemented in Fl_Table, Fl_Tree, Fl_Table_Row, Fl_Input_Choice, Fl_Scroll, Fl_Browser, and Fl_Check_Browser.

void Fl_Group::clip_children ( int  c) [inline]

Controls whether the group widget clips the drawing of child widgets to its bounding box.

Set c to 1 if you want to clip the child widgets to the bounding box.

The default is to not clip (0) the drawing of child widgets.

unsigned int Fl_Group::clip_children ( ) [inline]

Returns the current clipping mode.

Returns:
true, if clipping is enabled, false otherwise.
See also:
void Fl_Group::clip_children(int c)
Fl_Group * Fl_Group::current ( ) [static]

Returns the currently active group.

The Fl_Widget constructor automatically does current()->add(widget) if this is not null. To prevent new widgets from being added to a group, call Fl_Group::current(0).

Reimplemented in Fl_Window.

void Fl_Group::current ( Fl_Group g) [static]

Sets the current group.

See also:
Fl_Group::current()
void Fl_Group::draw ( ) [protected, virtual]

Draws the widget.

Never call this function directly. FLTK will schedule redrawing whenever needed. If your widget must be redrawn as soon as possible, call redraw() instead.

Override this function to draw your own widgets.

If you ever need to call another widget's draw method from within your own draw() method, e.g. for an embedded scrollbar, you can do it (because draw() is virtual) like this:

        Fl_Widget *s = &scroll;         // scroll is an embedded Fl_Scrollbar
        s->draw();                      // calls Fl_Scrollbar::draw()

Implements Fl_Widget.

Reimplemented in Fl_Table, Fl_Tree, Fl_Text_Display, Fl_Gl_Window, Fl_Browser_, Fl_Scroll, Fl_Window, Fl_Tabs, Fl_Cairo_Window, Fl_Pack, and Fl_Glut_Window.

void Fl_Group::draw_child ( Fl_Widget widget) const [protected]

Forces a child to redraw.

This draws a child widget, if it is not clipped. The damage bits are cleared after drawing.

void Fl_Group::draw_children ( ) [protected]

Draws all children of the group.

This is useful, if you derived a widget from Fl_Group and want to draw a special border or background. You can call draw_children() from the derived draw() method after drawing the box, border, or background.

void Fl_Group::draw_outside_label ( const Fl_Widget widget) const [protected]

Parents normally call this to draw outside labels of child widgets.

void Fl_Group::end ( )

Exactly the same as current(this->parent()).

Any new widgets added to the widget tree will be added to the parent of the group.

Reimplemented in Fl_Table.

int Fl_Group::find ( const Fl_Widget o) const

Searches the child array for the widget and returns the index.

Returns children() if the widget is NULL or not found.

Reimplemented in Fl_Table.

void Fl_Group::focus ( Fl_Widget W) [inline]
Deprecated:
This is for backwards compatibility only.

You should use W->take_focus() instead.

See also:
Fl_Widget::take_focus();
int Fl_Group::handle ( int  event) [virtual]

Handles the specified event.

You normally don't call this method directly, but instead let FLTK do it when the user interacts with the widget.

When implemented in a widget, this function must return 0 if the widget does not use the event or 1 otherwise.

Most of the time, you want to call the inherited handle() method in your overridden method so that you don't short-circuit events that you don't handle. In this last case you should return the callee retval.

Parameters:
[in]eventthe kind of event received
Return values:
0if the event was not used or understood
1if the event was used and can be deleted
See also:
Fl_Event

Reimplemented from Fl_Widget.

Reimplemented in Fl_Tree, Fl_Table, Fl_Browser_, Fl_Window, Fl_Spinner, Fl_Scroll, Fl_Table_Row, Fl_Text_Display, Fl_Check_Browser, Fl_Gl_Window, Fl_Tile, Fl_Tabs, Fl_Text_Editor, and Fl_Glut_Window.

Resets the internal array of widget sizes and positions.

The Fl_Group widget keeps track of the original widget sizes and positions when resizing occurs so that if you resize a window back to its original size the widgets will be in the correct places. If you rearrange the widgets in your group, call this method to register the new arrangement with the Fl_Group that contains them.

If you add or remove widgets, this will be done automatically.

Note:
The internal array of widget sizes and positions will be allocated and filled when the next resize() occurs.
See also:
sizes()

Reimplemented in Fl_Table.

void Fl_Group::insert ( Fl_Widget o,
int  index 
)

The widget is removed from its current group (if any) and then inserted into this group.

It is put at index n - or at the end, if n >= children(). This can also be used to rearrange the widgets inside a group.

Reimplemented in Fl_Table.

void Fl_Group::insert ( Fl_Widget o,
Fl_Widget before 
) [inline]

This does insert(w, find(before)).

This will append the widget if before is not in the group.

Reimplemented in Fl_Table.

void Fl_Group::remove ( int  index)

Removes the widget at index from the group but does not delete it.

This method does nothing if index is out of bounds.

This method differs from the clear() method in that it only affects a single widget and does not delete it from memory.

Since:
FLTK 1.3.0

Reimplemented in Fl_Browser, and Fl_Check_Browser.

void Fl_Group::remove ( Fl_Widget o)

Removes a widget from the group but does not delete it.

This method does nothing if the widget is not a child of the group.

This method differs from the clear() method in that it only affects a single widget and does not delete it from memory.

Note:
If you have the child's index anyway, use remove(int index) instead, because this doesn't need a child lookup in the group's table of children. This can be much faster, if there are lots of children.

Reimplemented in Fl_Table.

void Fl_Group::remove ( Fl_Widget o) [inline]

Removes the widget o from the group.

See also:
void remove(Fl_Widget&)
void Fl_Group::resizable ( Fl_Widget o) [inline]

The resizable widget defines the resizing box for the group.

When the group is resized it calculates a new size and position for all of its children. Widgets that are horizontally or vertically inside the dimensions of the box are scaled to the new size. Widgets outside the box are moved.

In these examples the gray area is the resizable:

resizebox1.png
resizebox2.png

The resizable may be set to the group itself, in which case all the contents are resized. This is the default value for Fl_Group, although NULL is the default for Fl_Window and Fl_Pack.

If the resizable is NULL then all widgets remain a fixed size and distance from the top-left corner.

It is possible to achieve any type of resize behavior by using an invisible Fl_Box as the resizable and/or by using a hierarchy of child Fl_Group's.

void Fl_Group::resize ( int  X,
int  Y,
int  W,
int  H 
) [virtual]

Resizes the Fl_Group widget and all of its children.

The Fl_Group widget first resizes itself, and then it moves and resizes all its children according to the rules documented for Fl_Group::resizable(Fl_Widget*)

See also:
Fl_Group::resizable(Fl_Widget*)
Fl_Group::resizable()
Fl_Widget::resize(int,int,int,int)

Reimplemented from Fl_Widget.

Reimplemented in Fl_Table, Fl_Help_View, Fl_Text_Display, Fl_Browser_, Fl_Window, Fl_Input_Choice, Fl_Spinner, Fl_Scroll, Fl_Tile, Fl_Gl_Window, Fl_Overlay_Window, and Fl_Double_Window.

int * Fl_Group::sizes ( ) [protected]

Returns the internal array of widget sizes and positions.

If the sizes() array does not exist, it will be allocated and filled with the current widget sizes and positions.

Note:
You should never need to use this method directly, unless you have special needs to rearrange the children of a Fl_Group. Fl_Tile uses this to rearrange its widget positions.
See also:
init_sizes()
Todo:
Should the internal representation of the sizes() array be documented?
void Fl_Group::update_child ( Fl_Widget widget) const [protected]

Draws a child only if it needs it.

This draws a child widget, if it is not clipped and if any damage() bits are set. The damage bits are cleared after drawing.

See also:
Fl_Group::draw_child(Fl_Widget& widget) const

The documentation for this class was generated from the following files: