class Fl_Group : public Fl_Object

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

virtual ~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 children() const;

Returns how many child objects the group has.

Fl_Object* child(int n) const;

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

Fl_Object*const* array() const;

Returns a pointer to the current array of children (this pointer will change when children are added or removed).

int find(const Fl_Object*) const;
int find(const Fl_Object&) const;

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

void add(Fl_Object&);
void add(Fl_Object*);

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

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

The Fl_Object constructor automatically does Fl_Group::current()->add(this) if current() is not null. This allows you to build the object tree by just constructing the objects. However I have had trouble with compilers producing warning messages about unused objects, and possibly even optimizing the constructors out (allowed by C++) and so you may not want to use this.

begin() does current(this). end() does current(this->parent()). You can also directly get and set the current value.

void insert(Fl_Object&, int n);
void insert(Fl_Object&, Fl_Object* beforethis);

Insert this object 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 object there.

void remove(Fl_Object&);

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

void resize();

Set the x(), y(), w(), h() to the bounding box of all the children.

void resizable(Fl_Object*);
void resizable(Fl_Object&);
Fl_Group& add_resizable(Fl_Object&);
Fl_Object* 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. Objects that are horizontally or vertically inside the dimensions of the resizable are scaled to the new size. Objects 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 objects 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)