FLTK 1.4.4: Fl_Grid Class Reference

FLTK 1.4.4

Loading...
Searching...
No Matches
Fl_Grid Class Reference

Fl_Grid is a container (layout) widget with multiple columns and rows. More...

`#include <Fl_Grid.H>`

Inheritance diagram for Fl_Grid:

## Classes
class | Cell

## Public Member Functions
Fl_Grid::Cell * | cell (Fl_Widget *widget) const
| Get the grid cell of widget `widget`.
Fl_Grid::Cell * | cell (int row, int col) const
| Get the grid cell of row `row` and column `col`.
virtual void | clear_layout ()
| Reset the layout w/o removing widgets.
void | col_gap (const int *value, size_t size)
| Set more than one column gaps at once.
int | col_gap (int col) const
void | col_gap (int col, int value)
| Set the gap of column `col`.
void | col_weight (const int *value, size_t size)
| Set the weight of more than one column.
int | col_weight (int col) const
void | col_weight (int col, int value)
| Set the weight of a column.
void | col_width (const int *value, size_t size)
| Set minimal widths of more than one column.
int | col_width (int col) const
void | col_width (int col, int value)
| Set the minimal width of a column.
short | cols () const
int | computed_col_width (int col) const
int | computed_row_height (int row) const
void | debug (int level=127)
| Output layout information of this Fl_Grid to stderr.
| Fl_Grid (int X, int Y, int W, int H, const char *L=0)
| Create a new Fl_Grid widget.
void | gap (int *row_gap, int *col_gap) const
| Get the default gaps for rows and columns.
virtual void | gap (int row_gap, int col_gap=-1)
| Set default gaps for rows and columns.
virtual void | layout ()
| Calculate the grid layout and resize and position all widgets.
virtual void | layout (int rows, int cols, int margin=-1, int gap=-1)
| Set the basic layout parameters of the Fl_Grid widget.
int | margin (int *left, int *top, int *right, int *bottom) const
| Returns all outside margin sizes of the grid.
virtual void | margin (int left, int top=-1, int right=-1, int bottom=-1)
| Set all margins (left, top, right, bottom).
bool | need_layout () const
| Return whether layout calculation is required.
void | need_layout (int set)
| Request or reset the request to calculate the layout of children.
virtual void | resize (int X, int Y, int W, int H) FL_OVERRIDE
| Recalculate the layout and position and resize all widgets.
void | row_gap (const int *value, size_t size)
| Set more than one row gaps at once.
int | row_gap (int row) const
void | row_gap (int row, int value)
| Set the gap of row `row`.
void | row_height (const int *value, size_t size)
| Set the minimal row height of more than one row.
int | row_height (int row) const
void | row_height (int row, int value)
| Set the minimal row height of row `row`.
void | row_weight (const int *value, size_t size)
| Set the weight of more than one row.
int | row_weight (int row) const
void | row_weight (int row, int value)
| Set the row weight of row `row`.
short | rows () const
void | show_grid (int set)
| Enable or disable drawing of the grid helper lines for visualization.
void | show_grid (int set, Fl_Color col)
| Enable or disable drawing of the grid helper lines for visualization.
Fl_Grid::Cell * | widget (Fl_Widget *wi, int row, int col, Fl_Grid_Align align=FL_GRID_FILL)
| Assign a widget to a grid cell and set its alignment.
Fl_Grid::Cell * | widget (Fl_Widget *wi, int row, int col, int rowspan, int colspan, Fl_Grid_Align align=FL_GRID_FILL)
| Assign a widget to a grid cell and set cell spanning and alignment.
Public Member Functions inherited from Fl_Group
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.
Fl_Group const * | as_group () const FL_OVERRIDE
Fl_Group * | as_group () FL_OVERRIDE
| 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_Widget * | child (int n) const
| Returns the n'th child.
int | children () const
| Returns how many child widgets the group has.
void | clear ()
| Deletes all child widgets from memory recursively.
unsigned int | clip_children ()
| Returns the current clipping mode.
void | clip_children (int c)
| Controls whether the group widget clips the drawing of child widgets to its bounding box.
virtual int | delete_child (int n)
| Removes the widget at `index` from the group and deletes it.
void | end ()
| Exactly the same as current(this->parent()).
int | find (const Fl_Widget &o) const
| See int Fl_Group::find(const Fl_Widget *w) const.
int | find (const Fl_Widget *) const
| Searches the child array for the widget and returns the index.
| 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) FL_OVERRIDE
| 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 (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 | remove (int index)
| Removes the widget at `index` from the group but does not delete it.
Fl_Widget * | resizable () const
| Returns the group's resizable widget.
void | resizable (Fl_Widget &o)
| Sets the group's resizable widget.
void | resizable (Fl_Widget *o)
| The resizable widget defines both the resizing box and the resizing behavior of the group and its children.
void | resize (int, int, int, int) FL_OVERRIDE
| Resizes the Fl_Group widget and all of its children.
virtual | ~Fl_Group ()
| The destructor also deletes all the children.
Public Member Functions inherited from Fl_Widget
void | _clear_fullscreen ()
void | _set_fullscreen ()
void | activate ()
| Activates the widget.
unsigned int | active () const
| Returns whether the widget is active.
int | active_r () const
| Returns whether the widget and all of its parents are active.
Fl_Align | align () const
| Gets the label alignment.
void | align (Fl_Align alignment)
| Sets the label alignment.
long | argument () const
| Gets the current user data (long) argument that is passed to the callback function.
void | argument (long v)
| Sets the current user data (long) argument that is passed to the callback function.
virtual class Fl_Gl_Window * | as_gl_window ()
| Returns an Fl_Gl_Window pointer if this widget is an Fl_Gl_Window.
virtual class Fl_Gl_Window const * | as_gl_window () const
virtual Fl_Window * | as_window ()
| Returns an Fl_Window pointer if this widget is an Fl_Window.
virtual Fl_Window const * | as_window () const
void | bind_deimage (Fl_Image *img)
| Sets the image to use as part of the widget label when in the inactive state.
void | bind_deimage (int f)
| Bind the inactive image to the widget, so the widget will delete the image when it is no longer needed.
void | bind_image (Fl_Image *img)
| Sets the image to use as part of the widget label when in the active state.
void | bind_image (int f)
| Bind the image to the widget, so the widget will delete the image when it is no longer needed.
Fl_Boxtype | box () const
| Gets the box type of the widget.
void | box (Fl_Boxtype new_box)
| Sets the box type for the widget.
Fl_Callback_p | callback () const
| Gets the current callback function for the widget.
void | callback (Fl_Callback *cb)
| Sets the current callback function for the widget.
void | callback (Fl_Callback *cb, Fl_Callback_User_Data *p, bool auto_free)
| Sets the current callback function and managed user data for the widget.
void | callback (Fl_Callback *cb, void *p)
| Sets the current callback function and data for the widget.
void | callback (Fl_Callback0 *cb)
| Sets the current callback function for the widget.
void | callback (Fl_Callback1 *cb, long p=0)
| Sets the current callback function for the widget.
unsigned int | changed () const
| Checks if the widget value changed since the last callback.
void | clear_active ()
| Marks the widget as inactive without sending events or changing focus.
void | clear_changed ()
| Marks the value of the widget as unchanged.
void | clear_damage (uchar c=0)
| Clears or sets the damage flags.
void | clear_output ()
| Sets a widget to accept input.
void | clear_visible ()
| Hides the widget.
void | clear_visible_focus ()
| Disables keyboard focus navigation with this widget.
Fl_Color | color () const
| Gets the background color of the widget.
void | color (Fl_Color bg)
| Sets the background color of the widget.
void | color (Fl_Color bg, Fl_Color sel)
| Sets the background and selection color of the widget.
Fl_Color | color2 () const
| For back compatibility only.
void | color2 (unsigned a)
| For back compatibility only.
int | contains (const Fl_Widget *w) const
| Checks if w is a child of this widget.
void | copy_label (const char *new_label)
| Sets the current label.
void | copy_tooltip (const char *text)
| Sets the current tooltip text.
uchar | damage () const
| Returns non-zero if draw() needs to be called.
void | damage (uchar c)
| Sets the damage bits for the widget.
void | damage (uchar c, int x, int y, int w, int h)
| Sets the damage bits for an area inside the widget.
int | damage_resize (int, int, int, int)
| Internal use only.
void | deactivate ()
| Deactivates the widget.
Fl_Image * | deimage ()
| Gets the image that is used as part of the widget label when in the inactive state.
const Fl_Image * | deimage () const
| Gets the image that is used as part of the widget label when in the inactive state.
void | deimage (Fl_Image &img)
| Sets the image to use as part of the widget label when in the inactive state.
void | deimage (Fl_Image *img)
| Sets the image to use as part of the widget label when in the inactive state.
int | deimage_bound () const
| Returns whether the inactive image is managed by the widget.
void | do_callback (Fl_Callback_Reason reason=FL_REASON_UNKNOWN)
| Calls the widget callback function with default arguments.
void | do_callback (Fl_Widget *widget, long arg, Fl_Callback_Reason reason=FL_REASON_UNKNOWN)
| Calls the widget callback function with arbitrary arguments.
void | do_callback (Fl_Widget *widget, void *arg=0, Fl_Callback_Reason reason=FL_REASON_UNKNOWN)
| Calls the widget callback function with arbitrary arguments.
void | draw_label (int, int, int, int, Fl_Align) const
| Draws the label in an arbitrary bounding box with an arbitrary alignment.
int | h () const
| Gets the widget height.
virtual void | hide ()
| Makes a widget invisible.
int | horizontal_label_margin ()
| Get the spacing between the label and the horizontal edge of the widget.
void | horizontal_label_margin (int px)
| Set the spacing between the label and the horizontal edge of the widget.
Fl_Image * | image ()
| Gets the image that is used as part of the widget label when in the active state.
const Fl_Image * | image () const
| Gets the image that is used as part of the widget label when in the active state.
void | image (Fl_Image &img)
| Sets the image to use as part of the widget label when in the active state.
void | image (Fl_Image *img)
| Sets the image to use as part of the widget label when in the active state.
int | image_bound () const
| Returns whether the image is managed by the widget.
int | inside (const Fl_Widget *wgt) const
| Checks if this widget is a child of `wgt`.
int | is_label_copied () const
| Returns whether the current label was assigned with copy_label().
const char * | label () const
| Gets the current label text.
void | label (const char *text)
| Sets the current label pointer.
void | label (Fl_Labeltype a, const char *b)
| Shortcut to set the label text and type in one call.
int | label_image_spacing ()
| Return the gap size between the label and the image.
void | label_image_spacing (int gap)
| Set the gap between the label and the image in pixels.
Fl_Color | labelcolor () const
| Gets the label color.
void | labelcolor (Fl_Color c)
| Sets the label color.
Fl_Font | labelfont () const
| Gets the font to use.
void | labelfont (Fl_Font f)
| Sets the font to use.
Fl_Fontsize | labelsize () const
| Gets the font size in pixels.
void | labelsize (Fl_Fontsize pix)
| Sets the font size in pixels.
Fl_Labeltype | labeltype () const
| Gets the label type.
void | labeltype (Fl_Labeltype a)
| Sets the label type.
void | measure_label (int &ww, int &hh) const
| Sets width ww and height hh accordingly with the label size.
bool | needs_keyboard () const
| Returns whether this widget needs a keyboard.
void | needs_keyboard (bool needs)
| Sets whether this widget needs a keyboard.
unsigned int | output () const
| Returns if a widget is used for output only.
Fl_Group * | parent () const
| Returns a pointer to the parent widget.
void | parent (Fl_Group *p)
| Internal use only - "for hacks only".
void | position (int X, int Y)
| Repositions the window or widget.
void | redraw ()
| Schedules the drawing of the widget.
void | redraw_label ()
| Schedules the drawing of the label.
Fl_Color | selection_color () const
| Gets the selection color.
void | selection_color (Fl_Color a)
| Sets the selection color.
void | set_active ()
| Marks the widget as active without sending events or changing focus.
void | set_changed ()
| Marks the value of the widget as changed.
void | set_output ()
| Sets a widget to output only.
void | set_visible ()
| Makes the widget visible.
void | set_visible_focus ()
| Enables keyboard focus navigation with this widget.
int | shortcut_label () const
| Returns whether the widget's label uses '&' to indicate shortcuts.
void | shortcut_label (int value)
| Sets whether the widget's label uses '&' to indicate shortcuts.
virtual void | show ()
| Makes a widget visible.
void | size (int W, int H)
| Changes the size of the widget.
int | take_focus ()
| Gives the widget the keyboard focus.
unsigned int | takesevents () const
| Returns if the widget is able to take events.
int | test_shortcut ()
| Returns true if the widget's label contains the entered '&x' shortcut.
const char * | tooltip () const
| Gets the current tooltip text.
void | tooltip (const char *text)
| Sets the current tooltip text.
Fl_Window * | top_window () const
| Returns a pointer to the top-level window for the widget.
Fl_Window * | top_window_offset (int &xoff, int &yoff) const
| Finds the x/y offset of the current widget relative to the top-level window.
uchar | type () const
| Gets the widget type.
void | type (uchar t)
| Sets the widget type.
int | use_accents_menu ()
| Returns non zero if MAC_USE_ACCENTS_MENU flag is set, 0 otherwise.
void * | user_data () const
| Gets the user data for this widget.
void | user_data (Fl_Callback_User_Data *v, bool auto_free)
| Sets the user data for this widget.
void | user_data (void *v)
| Sets the user data for this widget.
int | vertical_label_margin ()
| Get the spacing between the label and the vertical edge of the widget.
void | vertical_label_margin (int px)
| Set the spacing between the label and the vertical edge of the widget.
unsigned int | visible () const
| Returns whether a widget is visible.
unsigned int | visible_focus () const
| Checks whether this widget has a visible focus.
void | visible_focus (int v)
| Modifies keyboard focus navigation.
int | visible_r () const
| Returns whether a widget and all its parents are visible.
int | w () const
| Gets the widget width.
Fl_When | when () const
| Returns the conditions under which the callback is called.
void | when (uchar i)
| Sets the flags used to decide when a callback is called.
Fl_Window * | window () const
| Returns a pointer to the nearest parent window up the widget hierarchy.
int | x () const
| Gets the widget position in its window.
int | y () const
| Gets the widget position in its window.
virtual | ~Fl_Widget ()
| Destroys the widget.

## Protected Member Functions
Cell * | add_cell (int row, int col)
virtual void | draw () FL_OVERRIDE
| Draws the Fl_Grid widget and all children.
virtual void | draw_grid ()
| Draws the grid helper lines for design and debugging purposes.
void | init ()
void | on_remove (int) FL_OVERRIDE
| Fl_Group calls this method when a child widget is about to be removed.
void | remove_cell (int row, int col)
Protected Member Functions inherited from Fl_Group
Fl_Rect * | bounds ()
| Returns the internal array of widget sizes and positions.
void | draw () FL_OVERRIDE
| 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.
virtual int | on_insert (Fl_Widget *, int)
| Allow derived groups to act when a widget is added as a child.
virtual int | on_move (int, int)
| Allow derived groups to act when a widget is moved within the group.
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.
Protected Member Functions inherited from Fl_Widget
void | clear_flag (unsigned int c)
| Clears a flag in the flags mask.
void | draw_backdrop () const
| If FL_ALIGN_IMAGE_BACKDROP is set, the image or deimage will be drawn.
void | draw_box () const
| Draws the widget box according its box style.
void | draw_box (Fl_Boxtype t, Fl_Color c) const
| Draws a box of type t, of color c at the widget's position and size.
void | draw_box (Fl_Boxtype t, int x, int y, int w, int h, Fl_Color c) const
| Draws a box of type t, of color c at the position X,Y and size W,H.
void | draw_focus () const
| Draws a focus rectangle around the widget.
void | draw_focus (Fl_Boxtype t, int X, int Y, int W, int H) const
| Draws a focus rectangle around the widget.
void | draw_focus (Fl_Boxtype t, int x, int y, int w, int h, Fl_Color bg) const
| Draws a focus box for the widget at the given position and size.
void | draw_label () const
| Draws the widget's label at the defined label position.
void | draw_label (int, int, int, int) const
| Draws the label in an arbitrary bounding box.
| Fl_Widget (int x, int y, int w, int h, const char *label=0L)
| Creates a widget at the given position and size.
unsigned int | flags () const
| Gets the widget flags mask.
void | h (int v)
| Internal use only.
void | set_flag (unsigned int c)
| Sets a flag in the flags mask.
void | w (int v)
| Internal use only.
void | x (int v)
| Internal use only.
void | y (int v)
| Internal use only.

## Protected Attributes
bool | draw_grid_
Fl_Color | grid_color

## Friends
class | Fl_Grid_Type

## Additional Inherited Members
Static Public Member Functions inherited from Fl_Group
static Fl_Group * | current ()
| Returns the currently active group.
static void | current (Fl_Group *g)
| Sets the current group.
Static Public Member Functions inherited from Fl_Widget
static void | default_callback (Fl_Widget *widget, void *data)
| The default callback for all widgets that don't set a callback.
static unsigned int | label_shortcut (const char *t)
| Returns the Unicode value of the '&x' shortcut in a given text.
static int | test_shortcut (const char *, const bool require_alt=false)
| Returns true if the given text `t` contains the entered '&x' shortcut.
Protected Types inherited from Fl_Widget
enum | { INACTIVE = 1<<0 , INVISIBLE = 1<<1 , OUTPUT = 1<<2 , NOBORDER = 1<<3 , FORCE_POSITION = 1<<4 , NON_MODAL = 1<<5 , SHORTCUT_LABEL = 1<<6 , CHANGED = 1<<7 , OVERRIDE = 1<<8 , VISIBLE_FOCUS = 1<<9 , COPIED_LABEL = 1<<10 , CLIP_CHILDREN = 1<<11 , MENU_WINDOW = 1<<12 , TOOLTIP_WINDOW = 1<<13 , MODAL = 1<<14 , NO_OVERLAY = 1<<15 , GROUP_RELATIVE = 1<<16 , COPIED_TOOLTIP = 1<<17 , FULLSCREEN = 1<<18 , MAC_USE_ACCENTS_MENU = 1<<19 , NEEDS_KEYBOARD = 1<<20 , IMAGE_BOUND = 1<<21 , DEIMAGE_BOUND = 1<<22 , AUTO_DELETE_USER_DATA = 1<<23 , MAXIMIZED = 1<<24 , POPUP = 1<<25 , USERFLAG3 = 1<<29 , USERFLAG2 = 1<<30 , USERFLAG1 = 1<<31 }
| flags possible values enumeration. More...

## Detailed Description

Fl_Grid is a container (layout) widget with multiple columns and rows.

This container widget features very flexible layouts in columns and rows w/o the need to position each child widget in x/y coordinates.

Widgets are assigned to grid cells (column, row) with their minimal sizes in `w()` and `h()`. The `x()` and `y()` positions are ignored and can be (0, 0). Fl_Grid calculates widget positions and resizes the widgets to fit into the grid. It is possible to create a single row or column of widgets with Fl_Grid.

You should design your grid with the smallest possible sizes of all widgets in mind. Fl_Grid will automatically assign additional space to cells according to some rules (described later) when resizing the Fl_Grid widget.

Hint: You should set a minimum window size to make sure the Fl_Grid is never resized below its minimal sizes. Resizing below the given widget sizes results in undefined behavior.

Fl_Grid and other container widgets (e.g. Fl_Group) can be nested. One main advantage of this usage is that widget coordinates in embedded Fl_Group widgets become relative to the group and will be positioned as expected.

Todo
  This (relative group coordinates of nested groups of Fl_Grid) needs explanation and maybe an example.

Fl_Grid child widgets are handled by its base class Fl_Group but Fl_Grid stores additional data corresponding to each widget in internal grid cells.

Fl_Grid children are allowed to span multiple columns and rows like HTML <table> cells. Individual children can have fixed sizes or be aligned inside their cells (left, right, top, bottom, and more) and/or follow their cell sizes when the Fl_Grid container is resized.

Note to resizing: since Fl_Grid uses its own layout algorithm the normal Fl_Group::resizable() widget is ignored (if set). Calling init_sizes() is not necessary.

Note
  Fl_Grid is, as of FLTK 1.4.x, still in experimental state and should be used with caution. The API can still be changed although it is assumed to be almost stable - as stable as possible for a first release.

Example: Simple 3x3 Fl_Grid with five buttons:

#include <FL/Fl.H>
#include <FL/Fl_Double_Window.H>
#include <FL/Fl_Grid.H>
#include <FL/Fl_Button.H>
int main(int argc, char **argv) {
Fl_Double_Window *win = new Fl_Double_Window(320, 180, "3x3 Fl_Grid with Buttons");
// create the Fl_Grid container with five buttons
Fl_Grid *grid = new Fl_Grid(0, 0, win->w(), win->h());
grid->layout(3, 3, 10, 10);
grid->color(FL_WHITE);
Fl_Button *b0 = new Fl_Button(0, 0, 0, 0, "New");
Fl_Button *b1 = new Fl_Button(0, 0, 0, 0, "Options");
Fl_Button *b3 = new Fl_Button(0, 0, 0, 0, "About");
Fl_Button *b4 = new Fl_Button(0, 0, 0, 0, "Help");
Fl_Button *b6 = new Fl_Button(0, 0, 0, 0, "Quit");
// assign buttons to grid positions
grid->widget(b0, 0, 0);
grid->widget(b1, 0, 2);
grid->widget(b3, 1, 1);
grid->widget(b4, 2, 0);
grid->widget(b6, 2, 2);
grid->show_grid(0); // 1 to display grid helper lines
grid->end();
win->end();
win->resizable(grid);
win->size_range(300, 100);
win->show(argc, argv);
return Fl::run();
}
Fl.H
Fl static class.
Fl_Grid.H
Fl_Grid container widget.
Fl_Button
Buttons generate callbacks when they are clicked by the user.
Definition Fl_Button.H:76
Fl_Double_Window
The Fl_Double_Window provides a double-buffered window.
Definition Fl_Double_Window.H:31
Fl_Double_Window::show
void show() FL_OVERRIDE
Makes a widget visible.
Definition Fl_Double_Window.cxx:45
Fl_Grid::Fl_Grid
Fl_Grid(int X, int Y, int W, int H, const char *L=0)
Create a new Fl_Grid widget.
Definition Fl_Grid.cxx:109
Fl_Grid::show_grid
void show_grid(int set)
Enable or disable drawing of the grid helper lines for visualization.
Definition Fl_Grid.H:379
Fl_Grid::layout
virtual void layout(int rows, int cols, int margin=-1, int gap=-1)
Set the basic layout parameters of the Fl_Grid widget.
Definition Fl_Grid.cxx:177
Fl_Grid::widget
Fl_Grid::Cell * widget(Fl_Widget *wi, int row, int col, Fl_Grid_Align align=FL_GRID_FILL)
Assign a widget to a grid cell and set its alignment.
Definition Fl_Grid.cxx:798
Fl_Group::end
void end()
Exactly the same as current(this->parent()).
Definition Fl_Group.cxx:73
Fl_Group::resizable
void resizable(Fl_Widget &o)
Sets the group's resizable widget.
Definition Fl_Group.H:156
Fl_Widget::color
Fl_Color color() const
Gets the background color of the widget.
Definition Fl_Widget.H:455
Fl_Widget::w
void w(int v)
Internal use only.
Definition Fl_Widget.H:154
Fl_Widget::h
void h(int v)
Internal use only.
Definition Fl_Widget.H:156
Fl_Window::size_range
void size_range(int minw, int minh, int maxw=0, int maxh=0, int dw=0, int dh=0, int aspect=0)
Sets the allowable range to which the user can resize this window.
Definition Fl_Window.cxx:667
Fl::run
static int run()
Calls Fl::wait()repeatedly as long as any windows are displayed.
Definition Fl.cxx:651

## Constructor & Destructor Documentation

## ◆ Fl_Grid()

Fl_Grid::Fl_Grid | ( | int | X,
|  | int | Y,
|  | int | W,
|  | int | H,
|  | const char * | L = 0 )

Create a new Fl_Grid widget.

Todo
  More documentation of Fl_Grid constructor?

## Member Function Documentation

## ◆ cell() [1/2]

Fl_Grid::Cell * Fl_Grid::cell | ( | Fl_Widget * | widget | ) | const

Get the grid cell of widget `widget`.

The pointer to the cell can be used for further assignment of properties like alignment etc.

Hint: If you know the row and column index of the cell you should use Fl_Grid::cell(int row, int col) instead because it is much faster.

Please see Fl_Grid::cell(int row, int col) for details and the validity of cell pointers.

Parameters

  [in] | widget | widget whose cell is requested

Return values

  NULL | if `widget` is not assigned to a cell

## ◆ cell() [2/2]

Fl_Grid::Cell * Fl_Grid::cell | ( | int | row,
|  | int | col ) const

Get the grid cell of row `row` and column `col`.

Widgets and other attributes are organized in cells (Fl_Grid::Cell).

This cell is an opaque structure (class) with some public methods. Don't assume anything about grid cell sizes and ordering in memory. These are implementation details that can be changed without notice.

The validity of an Fl_Grid::Cell pointer is limited. It will definitely be invalidated when the overall grid layout is changed, for instance by calling layout(int, int).

Adding new cells beyond the current layout limits will also invalidate cell pointers but this is not (yet) implemented. Attempts to assign widgets to out-of-bounds cells are currently ignored.

The only well-defined usage of cell pointers is to set one or more properties like widget alignment of a cell after retrieving the cell pointer. Don't store cell pointers in your program for later reference.

Parameters

  [in] | row | row index
  [in] | col | column index

Returns
  pointer to cell

Return values

  NULL | if `row` or `col` is out of bounds or no widget was assigned

## ◆ clear_layout()

void Fl_Grid::clear_layout | ( |  | ) |
| virtual

Reset the layout w/o removing widgets.

Removes all cells and sets rows and cols to zero. Existing widgets are kept as children of the Fl_Group (base class) but are hidden.

This method should be rarely used. You may want to call Fl_Grid::clear() to remove all widgets and reset the layout to zero rows and columns.

You must call layout(int rows, int cols, ...) to set a new layout, allocate new cells, and assign widgets to new cells.

Todo
  Fl_Grid::clear() needs to be implemented as documented above!

## ◆ col_gap() [1/2]

void Fl_Grid::col_gap | ( | const int * | value,
|  | size_t | size )

Set more than one column gaps at once.

See also
  Fl_Grid::col_weight(const int *value, size_t size) for handling of the value array and `size`.

## ◆ col_gap() [2/2]

void Fl_Grid::col_gap | ( | int | col,
|  | int | value )

Set the gap of column `col`.

Note that the gap is right of each column except the last one which is ignored. Use margin() for the right most column.

Parameters

  [in] | col | column
  [in] | value | gap size after the column

## ◆ col_weight() [1/2]

void Fl_Grid::col_weight | ( | const int * | value,
|  | size_t | size )

Set the weight of more than one column.

The values are taken from the array `value` and assigned sequentially to columns, starting from column 0. If the array `size` is too large extraneous values are ignored.

Negative values in the `array` are not assigned to their columns, i.e. the existing value for the corresponding column is not changed.

Example:

int val[] = { 0, 0, 50, -1, -1, 50, 0 };
grid->col_weight(val, sizeof(val)/sizeof(val[0]));

Parameters

  [in] | value | an array of column weights
  [in] | size | the size of the array (number of values)

## ◆ col_weight() [2/2]

void Fl_Grid::col_weight | ( | int | col,
|  | int | value )

Set the weight of a column.

Column and row weights are used to distribute additional space when the grid is resized beyond its defined (minimal) size. All weight values are relative and can be chosen freely. Suggested weights are in the range {0 .. 100}, 0 (zero) disables resizing of the column.

How does it work?

Whenever additional space (say: `SPACE` in pixels) is to be distributed to a set of columns the weights of all columns are added to a value `SUM`, then every single column width is increased by the value (in pseudo code):

col.width += SPACE * col.weight / SUM

Resulting pixel values are rounded to the next integer and rounding differences are added to or subtracted from the column with the highest weight. If more columns have the same weight one of them is chosen.

Note
  If none of the columns considered for resizing have weights > 0 then Fl_Grid assigns the remaining space to an arbitrary column or to all considered columns evenly. This is implementation defined and can be changed without notice. You can avoid this situation by designing your grid with sensible sizes and weights.

Parameters

  [in] | col | column number (counting from 0)
  [in] | value | weight, must be >= 0

## ◆ col_width() [1/2]

void Fl_Grid::col_width | ( | const int * | value,
|  | size_t | size )

Set minimal widths of more than one column.

The values are taken from the array `value` and assigned sequentially to columns, starting from column 0. If the array `size` is too large extraneous values are ignored.

Negative values in the `array` are not assigned to their columns, i.e. the existing value for the corresponding column is not changed.

Example:

int widths[] = { 0, 0, 50, -1, -1, 50, 0 };
grid->col_width(widths, sizeof(width)/sizeof(width[0]));

Parameters

  [in] | value | an array of column widths
  [in] | size | the size of the array (number of values)

## ◆ col_width() [2/2]

void Fl_Grid::col_width | ( | int | col,
|  | int | value )

Set the minimal width of a column.

Column widths are calculated by using the maximum of all widget widths in that column and the given column width. After calculating the width additional space is added when resizing according to the `weight` of the column.

You can set one or more column widths in one call by using Fl_Grid::col_width(const int *value, size_t size).

Parameters

  [in] | col | column number (counting from 0)
  [in] | value | minimal column width, must be >= 0

See also
  Fl_Grid::col_width(const int *value, size_t size)

## ◆ debug()

void Fl_Grid::debug | ( | int | level = 127 | ) |

Output layout information of this Fl_Grid to stderr.

Parameter `level` will be used to define the amount of output.

- 0 = nothing
- 127 = everything
- other values not yet defined

Note
  It is not yet defined which kind of values `level` will have, either a numerical value (127 = maximum, 0 = nothing) or a bit mask that determines what to output.

Todo

  Add more information about cells and children.

  Control output by using `level`.

Parameters

  [in] | level | not yet used (0-127, default = 127)

## ◆ draw()

void Fl_Grid::draw | ( | void |  | ) |
| protectedvirtual

Draws the Fl_Grid widget and all children.

If the layout has been changed layout() is called before the widget is drawn so all children are arranged as designed.

See also
  layout()
  need_layout()

Implements Fl_Widget.

## ◆ draw_grid()

void Fl_Grid::draw_grid | ( |  | ) |
| protectedvirtual

Draws the grid helper lines for design and debugging purposes.

This method is protected so it can be modified in subclasses.

## ◆ gap() [1/2]

void Fl_Grid::gap | ( | int * | row_gap,
|  | int * | col_gap ) const

Get the default gaps for rows and columns.

Parameters

  [out] | row_gap | pointer to int to receive column gap, may be NULL
  [out] | col_gap | pointer to int to receive column gap, may be NULL

## ◆ gap() [2/2]

void Fl_Grid::gap | ( | int | row_gap,
|  | int | col_gap = -1 )
| virtual

Set default gaps for rows and columns.

All gaps are positioned below the rows and right of their columns.

The bottom row and the right-most column don't have a gap, i.e. the gap sizes of these columns and rows are ignored. You can use a right or bottom margin instead.

You have to specify at least one argument, `col_gap` is optional. If you don't specify an argument or use a negative value (e.g. -1) then that margin is not affected.

You can also initialize the default gaps with layout(int, int, int, int).

Parameters

  [in] | row_gap | default gap for all rows
  [in] | col_gap | default gap for all columns

See also
  Fl_Grid::layout(int rows, int cols, int margin, int gap)

## ◆ layout() [1/2]

void Fl_Grid::layout | ( |  | ) |
| virtual

Calculate the grid layout and resize and position all widgets.

This is called automatically when the Fl_Grid is resized. You need to call it once after you added widgets or moved widgets between cells.

Calling it once after all modifications are completed is enough.

Todo
  Document when and why to call layout() w/o args. See Fl_Flex::layout()

See also
  Fl_Grid::layout(int rows, int cols, int margin, int gap)

## ◆ layout() [2/2]

void Fl_Grid::layout | ( | int | rows,
|  | int | cols,
|  | int | margin = -1,
|  | int | gap = -1 )
| virtual

Set the basic layout parameters of the Fl_Grid widget.

You need to specify at least `rows` and `cols` to define a layout before you can add widgets to the grid.

Parameters `margin` and `gap` are optional.

You can call layout(int rows, int cols, int margin, int gap) again to change the layout but this is inefficient since all cells are reallocated if the layout changed.

Calling this with the same values of `rows` and `cols` is fast and can be used to change `margin` and `gap` w/o reallocating the cells.

`margin` sets all margins (left, top, right, bottom) to the same value. Negative values (e.g. -1) don't change the established margins. The default value set by the constructor is 0.

`gap` sets row and column gaps to the same value. Negative values (e.g. -1) do not affect the established gaps. The default value set by the constructor is 0.

After you added all widgets you must call layout() once without arguments to calculate the actual layout and to position and resize all widgets.

Todo
  Document when and why to call layout() w/o args. See Fl_Flex::layout()

Parameters

  [in] | rows | number of rows
  [in] | cols | number of columns
  [in] | margin | margin size inside the Fl_Grid's border
  [in] | gap | gap size between cells

See also
  Fl_Grid::layout()

## ◆ margin() [1/2]

int Fl_Grid::margin | ( | int * | left,
|  | int * | top,
|  | int * | right,
|  | int * | bottom ) const

Returns all outside margin sizes of the grid.

All margin sizes are returned in the given arguments. If any argument is `NULL` the respective value is not returned.

Parameters

  [out] | left | returns left margin if not `NULL`
  [out] | top | returns top margin if not `NULL`
  [out] | right | returns right margin if not `NULL`
  [out] | bottom | returns bottom margin if not `NULL`

Returns
  whether all margins are equal

Return values

  1 | all margins have the same size
  0 | at least one margin has a different size

## ◆ margin() [2/2]

void Fl_Grid::margin | ( | int | left,
|  | int | top = -1,
|  | int | right = -1,
|  | int | bottom = -1 )
| virtual

Set all margins (left, top, right, bottom).

All margins are measured in pixels inside the box borders. You need to specify at least one argument, all other arguments are optional. If you don't specify an argument or use a negative value (e.g. -1) then that particular margin is not affected.

Parameters

  [in] | left | left margin
  [in] | top | top margin
  [in] | right | right margin
  [in] | bottom | bottom margin

## ◆ need_layout()

void Fl_Grid::need_layout | ( | int | set | ) |
| inline

Request or reset the request to calculate the layout of children.

If called with `true` (1) this calls redraw() to schedule a full draw(). When draw is eventually called, the layout is (re)calculated before actually drawing the widget.

Parameters

  [in] | set | 1 to request layout calculation, 0 to reset the request

## ◆ on_remove()

void Fl_Grid::on_remove | ( | int | index | ) |
| protectedvirtual

Fl_Group calls this method when a child widget is about to be removed.

Make sure that the widget is also removed from our internal list of children.

Reimplemented from Fl_Group.

## ◆ resize()

void Fl_Grid::resize | ( | int | X,
|  | int | Y,
|  | int | W,
|  | int | H )
| virtual

Recalculate the layout and position and resize all widgets.

This method overrides Fl_Group::resize() and calculates all positions and sizes of its children according to its own rules.

Parameters

  [in] | X,Y | new widget position
  [in] | W,H | new widget size

Reimplemented from Fl_Widget.

## ◆ row_gap() [1/2]

void Fl_Grid::row_gap | ( | const int * | value,
|  | size_t | size )

Set more than one row gaps at once.

See also
  Fl_Grid::col_weight(const int *value, size_t size) for handling of the value array and `size`.

## ◆ row_gap() [2/2]

void Fl_Grid::row_gap | ( | int | row,
|  | int | value )

Set the gap of row `row`.

Note that the gap is below each row except the last one which is ignored. Use margin() for the bottom row.

Parameters

  [in] | row | row
  [in] | value | gap size below the row

## ◆ row_height() [1/2]

void Fl_Grid::row_height | ( | const int * | value,
|  | size_t | size )

Set the minimal row height of more than one row.

Parameters

  [in] | value | array of height values
  [in] | size | size of array `value`

See also
  Fl_Grid::col_weight(const int *value, size_t size) for handling of the value array and `size`.

## ◆ row_height() [2/2]

void Fl_Grid::row_height | ( | int | row,
|  | int | value )

Set the minimal row height of row `row`.

Parameters

  [in] | row | row
  [in] | value | minimal height of the row

## ◆ row_weight() [1/2]

void Fl_Grid::row_weight | ( | const int * | value,
|  | size_t | size )

Set the weight of more than one row.

Parameters

  [in] | value | array of height values
  [in] | size | size of array `value`

See also
  Fl_Grid::col_weight(const int *value, size_t size) for handling of the `value` array and `size`.

## ◆ row_weight() [2/2]

void Fl_Grid::row_weight | ( | int | row,
|  | int | value )

Set the row weight of row `row`.

Parameters

  [in] | row | row
  [in] | value | weight of the row

## ◆ show_grid() [1/2]

void Fl_Grid::show_grid | ( | int | set | ) |
| inline

Enable or disable drawing of the grid helper lines for visualization.

Use this method during the design stage of your Fl_Grid widget or for debugging if widgets are not positioned as intended.

The default is a light green color but you can change it for better contrast if needed, see show_grid(int set, Fl_Color col).

Note
  You can define the environment variable `FLTK_GRID_DEBUG=1` to set show_grid(1) for all Fl_Grid widgets at construction time. This enables you to debug the grid layout w/o changing code.

Parameters

  [in] | set | 1 (true) = draw, 0 = don't draw the grid

See also
  show_grid(int set, Fl_Color col)

## ◆ show_grid() [2/2]

void Fl_Grid::show_grid | ( | int | set,
|  | Fl_Color | col )
| inline

Enable or disable drawing of the grid helper lines for visualization.

This method also sets the color used for the helper lines.

The default is a light green color but you can change it to any color for better contrast if needed.

Parameters

  [in] | set | 1 (true) = draw, 0 = don't draw the grid
  [in] | col | color to use for the grid helper lines

See also
  show_grid(int set)

## ◆ widget() [1/2]

Fl_Grid::Cell * Fl_Grid::widget | ( | Fl_Widget * | wi,
|  | int | row,
|  | int | col,
|  | Fl_Grid_Align | align = FL_GRID_FILL )

Assign a widget to a grid cell and set its alignment.

This short form sets row and column spanning attributes to (1, 1).

For more information see Fl_Grid::widget(Fl_Widget *wi, int row, int col, int rowspan, int colspan, Fl_Grid_Align align)

Parameters

  [in] | wi | widget to be assigned to the cell
  [in] | row | row
  [in] | col | column
  [in] | align | widget alignment inside the cell

Returns
  assigned cell

Return values

  NULL | if `row` or `col` is out of bounds

See also
  Fl_Grid::widget(Fl_Widget *wi, int row, int col, int rowspan, int colspan, Fl_Grid_Align align)

## ◆ widget() [2/2]

Fl_Grid::Cell * Fl_Grid::widget | ( | Fl_Widget * | wi,
|  | int | row,
|  | int | col,
|  | int | rowspan,
|  | int | colspan,
|  | Fl_Grid_Align | align = FL_GRID_FILL )

Assign a widget to a grid cell and set cell spanning and alignment.

Default alignment is `FL_GRID_FILL` which stretches the widget in horizontal and vertical directions to fill the whole cell(s) given by `colspan` and `rowspan`.

You can use this method to move a widget from one cell to another; it is automatically removed from its old cell. If the new cell is already assigned to another widget that widget is deassigned but kept as a child of the group.

Before you can assign a widget to a cell it must have been created as a child of the Fl_Grid widget (i.e. its Fl_Group).

Parameters

  [in] | wi | widget to be assigned to the cell
  [in] | row | row
  [in] | col | column
  [in] | rowspan | vertical span in cells, default 1
  [in] | colspan | horizontal span in cells, default 1
  [in] | align | widget alignment inside the cell

Returns
  assigned cell

Return values

  NULL | if `row` or `col` is out of bounds or `wi` is not a child

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

- Fl_Grid.H
- Fl_Grid.cxx