class Fl_Group : public Fl_Widget

Fl_Group::Fl_Group(int,int,int,int, const char* = 0);

The constructor sets the boxtype to FL_NO_BOX. You may want to change this to draw a frame around your widgets.

virtual Fl_Group::~Fl_Group();

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. A kludge has been done so the Fl_Group and all of it's children can be automatic (local) variables, but you must declare the Fl_Group first, so that it is destroyed last.

int Fl_Group::children() const;

Returns how many child widgets the group has.

Fl_Widget* Fl_Group::child(int n) const;

Returns child n (n must be less than children()).

Fl_Widget*const* Fl_Group::array() const;

Returns a pointer to the array of children. This pointer can change when children are added or removed!

int Fl_Group::find(const Fl_Widget*) const;
int Fl_Group::find(const Fl_Widget&) const;

Search the array for the widget and return the index. Returns Fl_Group::children() if the widget is null or not found.

void Fl_Group::add(Fl_Widget&);
void Fl_Group::add(Fl_Widget*);

Add this widget to the group, at the end of the array (making it one longer).

void Fl_Group::insert(Fl_Widget&, int n);
void Fl_Group::insert(Fl_Widget&, Fl_Widget* beforethis);

Insert this widget into the array. It is put at index n (which must be less or equal to children()). The second version does find(beforethis) and inserts the new widget there.

void Fl_Group::remove(Fl_Widget&);

Remove this widget from the group, making children() be one less. This does nothing if the widget is not currently a child of this group.

void Fl_Group::begin();
void Fl_Group::end();
static Fl_Group* Fl_Group::current();
static void Fl_Group::current(Fl_Group*);

The Fl_Widget constructor automatically does Fl_Group::current()->add(this) if current() is not null. This allows you to build the widget tree by just constructing the widgets. Fl_Group::begin() is automatically called by the constructor for Fl_Group (and thus for Fl_Window as well). Don't forget to Fl_Group::end() the group or window!

Fl_Group::begin() does Fl_Group::current(this). Fl_Group::end() does Fl_Group::current(this->parent()). You can also directly get and set the current value (useful for forcing it to zero so you can prevent the constructor from adding an object).

class Fl_End;

This is a dummy class who's constructor does Fl_Group::current()->end(). This allows you to end a group in a constructor list of a class:

class MyClass {
  Fl_Group group;
  Fl_Button button_in_group;
  Fl_End end;
  Fl_Button button_outside_group;
  MyClass();
};
MyClass::MyClass() :
  group(10,10,100,100),
  button_in_group(20,20,60,30),
  end(),
  button_outside_group(10,120,60,30)
{}

void Fl_Group::resizable(Fl_Widget*);
void Fl_Group::resizable(Fl_Widget&);
Fl_Group& Fl_Group::add_resizable(Fl_Widget&);
Fl_Widget* Fl_Group::resizable() const;

The resizable controls the groups behavior when it is resized. When the group is resized it calculates a new size and position for all its children. Widgets that are horizontally or vertically inside the dimensions of the resizable are scaled to the new size. Widgets to the right or below the resizable are moved.

In these examples the gray area is the resizable:



The resizable may be set to the group itself (this is the default value for an Fl_Group, although NULL is the default for an Fl_Window), in which case all the contents are resized. If the resizable is NULL then all widgets remain a fixed size and distance from the top-left corner.

It should be 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_Groups.

(back to contents)