public class GridPane

GridPane lays out its children within a flexible grid of rows and columns. If a border and/or padding is set, then its content will be layed out within those insets.

A child may be placed anywhere within the grid and may span multiple rows/columns. Children may freely overlap within rows/columns and their stacking order will be defined by the order of the gridpane's children list (0th node in back, last node in front).

GridPane may be styled with backgrounds and borders using CSS. See Region superclass for details.

Grid Constraints

A child's placement within the grid is defined by it's layout constraints:

Grid Constraint Table

Constraint	Type	Description
columnIndex	integer	column where child's layout area starts.
rowIndex	integer	row where child's layout area starts.
columnSpan	integer	the number of columns the child's layout area spans horizontally.
rowSpan	integer	the number of rows the child's layout area spans vertically.

If the row/column indices are not explicitly set, then the child will be placed in the first row/column. If row/column spans are not set, they will default to 1. A child's placement constraints can be changed dynamically and the gridpane will update accordingly.

The total number of rows/columns does not need to be specified up front as the gridpane will automatically expand/contract the grid to accommodate the content.

To use the GridPane, an application needs to set the layout constraints on the children and add those children to the gridpane instance. Constraints are set on the children using static setter methods on the GridPane class:

     GridPane gridpane = new GridPane();

     // Set one constraint at a time...
     // Places the button at the first row and second column
     Button button = new Button();
     GridPane.setRowIndex(button, 0);
     GridPane.setColumnIndex(button, 1);

     // or convenience methods set more than one constraint at once...
     Label label = new Label();
     GridPane.setConstraints(label, 2, 0); // column=2 row=0

     // don't forget to add children to gridpane
     gridpane.getChildren().addAll(button, label);
 

Applications may also use convenience methods which combine the steps of setting the constraints and adding the children:

     GridPane gridpane = new GridPane();
     gridpane.add(new Button(), 1, 0); // column=1 row=0
     gridpane.add(new Label(), 2, 0);  // column=2 row=0
 

Row/Column Sizing

By default, rows and columns will be sized to fit their content; a column will be wide enough to accommodate the widest child, a row tall enough to fit the tallest child.However, if an application needs to explicitly control the size of rows or columns, it may do so by adding RowConstraints and ColumnConstraints objects to specify those metrics. For example, to create a grid with two fixed-width columns:

     GridPane gridpane = new GridPane();
     gridpane.getColumnConstraints().add(new ColumnConstraints(100)); // column 0 is 100 wide
     gridpane.getColumnConstraints().add(new ColumnConstraints(200)); // column 1 is 200 wide
 

By default the gridpane will resize rows/columns to their preferred sizes (either computed from content or fixed), even if the gridpane is resized larger than its preferred size. If an application needs a particular row or column to grow if there is extra space, it may set its grow priority on the RowConstraints or ColumnConstraints object. For example:

     GridPane gridpane = new GridPane();
     ColumnConstraints column1 = new ColumnConstraints(100,100,Double.MAX_VALUE);
     column1.setHgrow(Priority.ALWAYS);
     ColumnConstraints column2 = new ColumnConstraints(100);
     gridpane.getColumnConstraints().addAll(column1, column2); // first column gets any extra width
 

Note: Nodes spanning multiple rows/columns will be also size to the preferred sizes. The affected rows/columns are resized by the following priority: grow priorities, last row. This is with respect to row/column constraints.

Percentage Sizing

Alternatively, RowConstraints and ColumnConstraints allow the size to be specified as a percentage of gridpane's available space:

     GridPane gridpane = new GridPane();
     ColumnConstraints column1 = new ColumnConstraints();
     column1.setPercentWidth(50);
     ColumnConstraints column2 = new ColumnConstraints();
     column2.setPercentWidth(50);
     gridpane.getColumnConstraints().addAll(column1, column2); // each get 50% of width
 

If a percentage value is set on a row/column, then that value takes precedent and the row/column's min, pref, max, and grow constraints will be ignored.

Note that if the sum of the widthPercent (or heightPercent) values total greater than 100, the values will be treated as weights. e.g. if 3 columns are each given a widthPercent of 50, then each will be allocated 1/3 of the gridpane's available width (50/(50+50+50)).

Mixing Size Types

An application may freely mix the size-types of rows/columns (computed from content, fixed, or percentage). The percentage rows/columns will always be allocated space first based on their percentage of the gridpane's available space (size minus insets and gaps). The remaining space will be allocated to rows/columns given their minimum, preferred, and maximum sizes and grow priorities.

Resizable Range

A gridpane's parent will resize the gridpane within the gridpane's resizable range during layout. By default the gridpane computes this range based on its content and row/column constraints as outlined in the table below.

GridPane Resize Table

	width	height
minimum	left/right insets plus the sum of each column's min width.	top/bottom insets plus the sum of each row's min height.
preferred	left/right insets plus the sum of each column's pref width.	top/bottom insets plus the sum of each row's pref height.
maximum	Double.MAX_VALUE	Double.MAX_VALUE

A gridpane's unbounded maximum width and height are an indication to the parent that it may be resized beyond its preferred size to fill whatever space is assigned to it.

GridPane provides properties for setting the size range directly. These properties default to the sentinel value USE_COMPUTED_SIZE, however the application may set them to other values as needed:

     gridpane.setPrefSize(300, 300);
     // never size the gridpane larger than its preferred size:
     gridpane.setMaxSize(Region.USE_COMPUTED_SIZE, Region.USE_COMPUTED_SIZE);
 

Applications may restore the computed values by setting these properties back to USE_COMPUTED_SIZE.

GridPane does not clip its content by default, so it is possible that childrens' bounds may extend outside its own bounds if a child's min size prevents it from being fit within it space.

Optional Layout Constraints

An application may set additional constraints on children to customize how the child is sized and positioned within the layout area established by it's row/column indices/spans:

GridPane Constraint Table

Constraint	Type	Description
halignment	javafx.geometry.HPos	The horizontal alignment of the child within its layout area.
valignment	javafx.geometry.VPos	The vertical alignment of the child within its layout area.
hgrow	javafx.scene.layout.Priority	The horizontal grow priority of the child.
vgrow	javafx.scene.layout.Priority	The vertical grow priority of the child.
margin	javafx.geometry.Insets	Margin space around the outside of the child.

By default the alignment of a child within its layout area is defined by the alignment set for the row and column. If an individual alignment constraint is set on a child, that alignment will override the row/column alignment only for that child. Alignment of other children in the same row or column will not be affected.

Grow priorities, on the other hand, can only be applied to entire rows or columns. Therefore, if a grow priority constraint is set on a single child, it will be used to compute the default grow priority of the encompassing row/column. If a grow priority is set directly on a RowConstraint or ColumnConstraint object, it will override the value computed from content.

extends Pane

Since:  JavaFX 2.0