javafx.scene.layout.GridPane Maven / Gradle / Ivy
/*
* Copyright (c) 2011, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javafx.scene.layout;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.ObjectProperty;
import javafx.collections.ListChangeListener.Change;
import javafx.collections.ObservableList;
import javafx.geometry.HPos;
import javafx.geometry.Insets;
import javafx.geometry.Orientation;
import javafx.geometry.Pos;
import javafx.geometry.VPos;
import javafx.scene.Group;
import javafx.scene.Node;
import javafx.scene.paint.Color;
import javafx.scene.shape.Line;
import com.sun.javafx.collections.TrackableObservableList;
import javafx.css.StyleableBooleanProperty;
import javafx.css.StyleableDoubleProperty;
import javafx.css.StyleableObjectProperty;
import javafx.css.CssMetaData;
import javafx.css.converter.BooleanConverter;
import javafx.css.converter.EnumConverter;
import javafx.css.converter.SizeConverter;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.TreeSet;
import javafx.beans.Observable;
import javafx.css.Styleable;
import javafx.css.StyleableProperty;
import javafx.geometry.BoundingBox;
import javafx.geometry.Bounds;
import javafx.util.Callback;
/**
* 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 laid 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
* {@link javafx.scene.layout.Region 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 children's
* 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.
*
*
* @since JavaFX 2.0
*/
public class GridPane extends Pane {
/**
* Sentinel value which may be set on a child's row/column span constraint to
* indicate that it should span the remaining rows/columns.
*/
public static final int REMAINING = Integer.MAX_VALUE;
/* ******************************************************************
* BEGIN static methods
********************************************************************/
private static final String MARGIN_CONSTRAINT = "gridpane-margin";
private static final String HALIGNMENT_CONSTRAINT = "gridpane-halignment";
private static final String VALIGNMENT_CONSTRAINT = "gridpane-valignment";
private static final String HGROW_CONSTRAINT = "gridpane-hgrow";
private static final String VGROW_CONSTRAINT = "gridpane-vgrow";
private static final String ROW_INDEX_CONSTRAINT = "gridpane-row";
private static final String COLUMN_INDEX_CONSTRAINT = "gridpane-column";
private static final String ROW_SPAN_CONSTRAINT = "gridpane-row-span";
private static final String COLUMN_SPAN_CONSTRAINT = "gridpane-column-span";
private static final String FILL_WIDTH_CONSTRAINT = "gridpane-fill-width";
private static final String FILL_HEIGHT_CONSTRAINT = "gridpane-fill-height";
/**
* Sets the row index for the child when contained by a gridpane
* so that it will be positioned starting in that row of the gridpane.
* If a gridpane child has no row index set, it will be positioned in the
* first row.
* Setting the value to null will remove the constraint.
* @param child the child node of a gridpane
* @param value the row index of the child
*/
public static void setRowIndex(Node child, Integer value) {
if (value != null && value < 0) {
throw new IllegalArgumentException("rowIndex must be greater or equal to 0, but was "+value);
}
setConstraint(child, ROW_INDEX_CONSTRAINT, value);
}
/**
* Returns the child's row index constraint if set.
* @param child the child node of a gridpane
* @return the row index for the child or null if no row index was set
*/
public static Integer getRowIndex(Node child) {
return (Integer)getConstraint(child, ROW_INDEX_CONSTRAINT);
}
/**
* Sets the column index for the child when contained by a gridpane
* so that it will be positioned starting in that column of the gridpane.
* If a gridpane child has no column index set, it will be positioned in
* the first column.
* Setting the value to null will remove the constraint.
* @param child the child node of a gridpane
* @param value the column index of the child
*/
public static void setColumnIndex(Node child, Integer value) {
if (value != null && value < 0) {
throw new IllegalArgumentException("columnIndex must be greater or equal to 0, but was "+value);
}
setConstraint(child, COLUMN_INDEX_CONSTRAINT, value);
}
/**
* Returns the child's column index constraint if set.
* @param child the child node of a gridpane
* @return the column index for the child or null if no column index was set
*/
public static Integer getColumnIndex(Node child) {
return (Integer)getConstraint(child, COLUMN_INDEX_CONSTRAINT);
}
/**
* Sets the row span for the child when contained by a gridpane
* so that it will span that number of rows vertically. This may be
* set to REMAINING, which will cause the span to extend across all the remaining
* rows.
*
* If a gridpane child has no row span set, it will default to spanning one row.
* Setting the value to null will remove the constraint.
* @param child the child node of a gridpane
* @param value the row span of the child
*/
public static void setRowSpan(Node child, Integer value) {
if (value != null && value < 1) {
throw new IllegalArgumentException("rowSpan must be greater or equal to 1, but was "+value);
}
setConstraint(child, ROW_SPAN_CONSTRAINT, value);
}
/**
* Returns the child's row-span constraint if set.
* @param child the child node of a gridpane
* @return the row span for the child or null if no row span was set
*/
public static Integer getRowSpan(Node child) {
return (Integer)getConstraint(child, ROW_SPAN_CONSTRAINT);
}
/**
* Sets the column span for the child when contained by a gridpane
* so that it will span that number of columns horizontally. This may be
* set to REMAINING, which will cause the span to extend across all the remaining
* columns.
*
* If a gridpane child has no column span set, it will default to spanning one column.
* Setting the value to null will remove the constraint.
* @param child the child node of a gridpane
* @param value the column span of the child
*/
public static void setColumnSpan(Node child, Integer value) {
if (value != null && value < 1) {
throw new IllegalArgumentException("columnSpan must be greater or equal to 1, but was "+value);
}
setConstraint(child, COLUMN_SPAN_CONSTRAINT, value);
}
/**
* Returns the child's column-span constraint if set.
* @param child the child node of a gridpane
* @return the column span for the child or null if no column span was set
*/
public static Integer getColumnSpan(Node child) {
return (Integer)getConstraint(child, COLUMN_SPAN_CONSTRAINT);
}
/**
* Sets the margin for the child when contained by a gridpane.
* If set, the gridpane will lay it out with the margin space around it.
* Setting the value to null will remove the constraint.
* @param child the child node of a gridpane
* @param value the margin of space around the child
*/
public static void setMargin(Node child, Insets value) {
setConstraint(child, MARGIN_CONSTRAINT, value);
}
/**
* Returns the child's margin constraint if set.
* @param child the child node of a gridpane
* @return the margin for the child or null if no margin was set
*/
public static Insets getMargin(Node child) {
return (Insets)getConstraint(child, MARGIN_CONSTRAINT);
}
private double getBaselineComplementForChild(Node child) {
if (isNodePositionedByBaseline(child)) {
return rowMinBaselineComplement[getNodeRowIndex(child)];
}
return -1;
}
private static final Callback marginAccessor = n -> getMargin(n);
/**
* Sets the horizontal alignment for the child when contained by a gridpane.
* If set, will override the gridpane's default horizontal alignment.
* Setting the value to null will remove the constraint.
* @param child the child node of a gridpane
* @param value the hozizontal alignment for the child
*/
public static void setHalignment(Node child, HPos value) {
setConstraint(child, HALIGNMENT_CONSTRAINT, value);
}
/**
* Returns the child's halignment constraint if set.
* @param child the child node of a gridpane
* @return the horizontal alignment for the child or null if no alignment was set
*/
public static HPos getHalignment(Node child) {
return (HPos)getConstraint(child, HALIGNMENT_CONSTRAINT);
}
/**
* Sets the vertical alignment for the child when contained by a gridpane.
* If set, will override the gridpane's default vertical alignment.
* Setting the value to null will remove the constraint.
* @param child the child node of a gridpane
* @param value the vertical alignment for the child
*/
public static void setValignment(Node child, VPos value) {
setConstraint(child, VALIGNMENT_CONSTRAINT, value);
}
/**
* Returns the child's valignment constraint if set.
* @param child the child node of a gridpane
* @return the vertical alignment for the child or null if no alignment was set
*/
public static VPos getValignment(Node child) {
return (VPos)getConstraint(child, VALIGNMENT_CONSTRAINT);
}
/**
* Sets the horizontal grow priority for the child when contained by a gridpane.
* If set, the gridpane will use the priority to allocate the child additional
* horizontal space if the gridpane is resized larger than it's preferred width.
* Setting the value to null will remove the constraint.
* @param child the child of a gridpane
* @param value the horizontal grow priority for the child
*/
public static void setHgrow(Node child, Priority value) {
setConstraint(child, HGROW_CONSTRAINT, value);
}
/**
* Returns the child's hgrow constraint if set.
* @param child the child node of a gridpane
* @return the horizontal grow priority for the child or null if no priority was set
*/
public static Priority getHgrow(Node child) {
return (Priority)getConstraint(child, HGROW_CONSTRAINT);
}
/**
* Sets the vertical grow priority for the child when contained by a gridpane.
* If set, the gridpane will use the priority to allocate the child additional
* vertical space if the gridpane is resized larger than it's preferred height.
* Setting the value to null will remove the constraint.
* @param child the child of a gridpane
* @param value the vertical grow priority for the child
*/
public static void setVgrow(Node child, Priority value) {
setConstraint(child, VGROW_CONSTRAINT, value);
}
/**
* Returns the child's vgrow constraint if set.
* @param child the child node of a gridpane
* @return the vertical grow priority for the child or null if no priority was set
*/
public static Priority getVgrow(Node child) {
return (Priority)getConstraint(child, VGROW_CONSTRAINT);
}
/**
* Sets the horizontal fill policy for the child when contained by a gridpane.
* If set, the gridpane will use the policy to determine whether node
* should be expanded to fill the column or resized to its preferred width.
* Setting the value to null will remove the constraint.
* If not value is specified for the node nor for the column, the default value is true.
* @param child the child node of a gridpane
* @param value the horizontal fill policy or null for unset
* @since JavaFX 8.0
*/
public static void setFillWidth(Node child, Boolean value) {
setConstraint(child, FILL_WIDTH_CONSTRAINT, value);
}
/**
* Returns the child's horizontal fill policy if set
* @param child the child node of a gridpane
* @return the horizontal fill policy for the child or null if no policy was set
* @since JavaFX 8.0
*/
public static Boolean isFillWidth(Node child) {
return (Boolean) getConstraint(child, FILL_WIDTH_CONSTRAINT);
}
/**
* Sets the vertical fill policy for the child when contained by a gridpane.
* If set, the gridpane will use the policy to determine whether node
* should be expanded to fill the row or resized to its preferred height.
* Setting the value to null will remove the constraint.
* If not value is specified for the node nor for the row, the default value is true.
* @param child the child node of a gridpane
* @param value the vertical fill policy or null for unset
* @since JavaFX 8.0
*/
public static void setFillHeight(Node child, Boolean value) {
setConstraint(child, FILL_HEIGHT_CONSTRAINT, value);
}
/**
* Returns the child's vertical fill policy if set
* @param child the child node of a gridpane
* @return the vertical fill policy for the child or null if no policy was set
* @since JavaFX 8.0
*/
public static Boolean isFillHeight(Node child) {
return (Boolean) getConstraint(child, FILL_HEIGHT_CONSTRAINT);
}
/**
* Sets the column,row indeces for the child when contained in a gridpane.
* @param child the child node of a gridpane
* @param columnIndex the column index position for the child
* @param rowIndex the row index position for the child
*/
public static void setConstraints(Node child, int columnIndex, int rowIndex) {
setRowIndex(child, rowIndex);
setColumnIndex(child, columnIndex);
}
/**
* Sets the column, row, column-span, and row-span value for the child when
* contained in a gridpane.
* @param child the child node of a gridpane
* @param columnIndex the column index position for the child
* @param rowIndex the row index position for the child
* @param columnspan the number of columns the child should span
* @param rowspan the number of rows the child should span
*/
public static void setConstraints(Node child, int columnIndex, int rowIndex, int columnspan, int rowspan) {
setRowIndex(child, rowIndex);
setColumnIndex(child, columnIndex);
setRowSpan(child, rowspan);
setColumnSpan(child, columnspan);
}
/**
* Sets the grid position, spans, and alignment for the child when contained in a gridpane.
* @param child the child node of a gridpane
* @param columnIndex the column index position for the child
* @param rowIndex the row index position for the child
* @param columnspan the number of columns the child should span
* @param rowspan the number of rows the child should span
* @param halignment the horizontal alignment of the child
* @param valignment the vertical alignment of the child
*/
public static void setConstraints(Node child, int columnIndex, int rowIndex, int columnspan, int rowspan,
HPos halignment, VPos valignment) {
setRowIndex(child, rowIndex);
setColumnIndex(child, columnIndex);
setRowSpan(child, rowspan);
setColumnSpan(child, columnspan);
setHalignment(child, halignment);
setValignment(child, valignment);
}
/**
* Sets the grid position, spans, and alignment for the child when contained in a gridpane.
* @param child the child node of a gridpane
* @param columnIndex the column index position for the child
* @param rowIndex the row index position for the child
* @param columnspan the number of columns the child should span
* @param rowspan the number of rows the child should span
* @param halignment the horizontal alignment of the child
* @param valignment the vertical alignment of the child
* @param hgrow the horizontal grow priority of the child
* @param vgrow the vertical grow priority of the child
*/
public static void setConstraints(Node child, int columnIndex, int rowIndex, int columnspan, int rowspan,
HPos halignment, VPos valignment, Priority hgrow, Priority vgrow) {
setRowIndex(child, rowIndex);
setColumnIndex(child, columnIndex);
setRowSpan(child, rowspan);
setColumnSpan(child, columnspan);
setHalignment(child, halignment);
setValignment(child, valignment);
setHgrow(child, hgrow);
setVgrow(child, vgrow);
}
/**
* Sets the grid position, spans, alignment, grow priorities, and margin for
* the child when contained in a gridpane.
* @param child the child node of a gridpane
* @param columnIndex the column index position for the child
* @param rowIndex the row index position for the child
* @param columnspan the number of columns the child should span
* @param rowspan the number of rows the child should span
* @param halignment the horizontal alignment of the child
* @param valignment the vertical alignment of the child
* @param hgrow the horizontal grow priority of the child
* @param vgrow the vertical grow priority of the child
* @param margin the margin of space around the child
*/
public static void setConstraints(Node child, int columnIndex, int rowIndex, int columnspan, int rowspan,
HPos halignment, VPos valignment, Priority hgrow, Priority vgrow, Insets margin) {
setRowIndex(child, rowIndex);
setColumnIndex(child, columnIndex);
setRowSpan(child, rowspan);
setColumnSpan(child, columnspan);
setHalignment(child, halignment);
setValignment(child, valignment);
setHgrow(child, hgrow);
setVgrow(child, vgrow);
setMargin(child, margin);
}
/**
* Removes all gridpane constraints from the child node.
* @param child the child node
*/
public static void clearConstraints(Node child) {
setRowIndex(child, null);
setColumnIndex(child, null);
setRowSpan(child, null);
setColumnSpan(child, null);
setHalignment(child, null);
setValignment(child, null);
setHgrow(child, null);
setVgrow(child, null);
setMargin(child, null);
}
private static final Color GRID_LINE_COLOR = Color.rgb(30, 30, 30);
private static final double GRID_LINE_DASH = 3;
static void createRow(int rowIndex, int columnIndex, Node... nodes) {
for (int i = 0; i < nodes.length; i++) {
setConstraints(nodes[i], columnIndex + i, rowIndex);
}
}
static void createColumn(int columnIndex, int rowIndex, Node... nodes) {
for (int i = 0; i < nodes.length; i++) {
setConstraints(nodes[i], columnIndex, rowIndex + i);
}
}
static int getNodeRowIndex(Node node) {
Integer rowIndex = getRowIndex(node);
return rowIndex != null? rowIndex : 0;
}
private static int getNodeRowSpan(Node node) {
Integer rowspan = getRowSpan(node);
return rowspan != null? rowspan : 1;
}
static int getNodeRowEnd(Node node) {
int rowSpan = getNodeRowSpan(node);
return rowSpan != REMAINING? getNodeRowIndex(node) + rowSpan - 1 : REMAINING;
}
static int getNodeColumnIndex(Node node) {
Integer columnIndex = getColumnIndex(node);
return columnIndex != null? columnIndex : 0;
}
private static int getNodeColumnSpan(Node node) {
Integer colspan = getColumnSpan(node);
return colspan != null? colspan : 1;
}
static int getNodeColumnEnd(Node node) {
int columnSpan = getNodeColumnSpan(node);
return columnSpan != REMAINING? getNodeColumnIndex(node) + columnSpan - 1 : REMAINING;
}
private static Priority getNodeHgrow(Node node) {
Priority hgrow = getHgrow(node);
return hgrow != null? hgrow : Priority.NEVER;
}
private static Priority getNodeVgrow(Node node) {
Priority vgrow = getVgrow(node);
return vgrow != null? vgrow : Priority.NEVER;
}
private static Priority[] createPriorityArray(int length, Priority value) {
Priority[] array = new Priority[length];
Arrays.fill(array, value);
return array;
}
/* ******************************************************************
* END static methods
********************************************************************/
/**
* Creates a GridPane layout with hgap/vgap = 0 and TOP_LEFT alignment.
*/
public GridPane() {
super();
getChildren().addListener((Observable o) -> requestLayout());
}
/**
* The width of the horizontal gaps between columns.
* @return the width of the horizontal gaps between columns
*/
public final DoubleProperty hgapProperty() {
if (hgap == null) {
hgap = new StyleableDoubleProperty(0) {
@Override
public void invalidated() {
requestLayout();
}
@Override
public CssMetaData getCssMetaData() {
return StyleableProperties.HGAP;
}
@Override
public Object getBean() {
return GridPane.this;
}
@Override
public String getName() {
return "hgap";
}
};
}
return hgap;
}
private DoubleProperty hgap;
public final void setHgap(double value) { hgapProperty().set(value); }
public final double getHgap() { return hgap == null ? 0 : hgap.get(); }
/**
* The height of the vertical gaps between rows.
* @return the height of the vertical gaps between rows
*/
public final DoubleProperty vgapProperty() {
if (vgap == null) {
vgap = new StyleableDoubleProperty(0) {
@Override
public void invalidated() {
requestLayout();
}
@Override
public CssMetaData getCssMetaData() {
return StyleableProperties.VGAP;
}
@Override
public Object getBean() {
return GridPane.this;
}
@Override
public String getName() {
return "vgap";
}
};
}
return vgap;
}
private DoubleProperty vgap;
public final void setVgap(double value) { vgapProperty().set(value); }
public final double getVgap() { return vgap == null ? 0 : vgap.get(); }
/**
* The alignment of the grid within the gridpane's width and height.
* @return the alignment of the grid within the gridpane's width and height
*/
public final ObjectProperty alignmentProperty() {
if (alignment == null) {
alignment = new StyleableObjectProperty(Pos.TOP_LEFT) {
@Override
public void invalidated() {
requestLayout();
}
@Override
public CssMetaData getCssMetaData() {
return StyleableProperties.ALIGNMENT;
}
@Override
public Object getBean() {
return GridPane.this;
}
@Override
public String getName() {
return "alignment";
}
};
}
return alignment;
}
private ObjectProperty alignment;
public final void setAlignment(Pos value) {
alignmentProperty().set(value);
}
public final Pos getAlignment() {
return alignment == null ? Pos.TOP_LEFT : alignment.get();
}
private Pos getAlignmentInternal() {
Pos localPos = getAlignment();
return localPos == null ? Pos.TOP_LEFT : localPos;
}
/**
* For debug purposes only: controls whether lines are displayed to show the gridpane's rows and columns.
* Default is false
.
* @return true if lines are displayed to show the gridpane's rows and columns
*/
public final BooleanProperty gridLinesVisibleProperty() {
if (gridLinesVisible == null) {
gridLinesVisible = new StyleableBooleanProperty() {
@Override
protected void invalidated() {
if (get()) {
gridLines = new Group();
gridLines.setManaged(false);
getChildren().add(gridLines);
} else {
getChildren().remove(gridLines);
gridLines = null;
}
requestLayout();
}
@Override
public CssMetaData getCssMetaData() {
return StyleableProperties.GRID_LINES_VISIBLE;
}
@Override
public Object getBean() {
return GridPane.this;
}
@Override
public String getName() {
return "gridLinesVisible";
}
};
}
return gridLinesVisible;
}
private BooleanProperty gridLinesVisible;
public final void setGridLinesVisible(boolean value) { gridLinesVisibleProperty().set(value); }
public final boolean isGridLinesVisible() { return gridLinesVisible == null ? false : gridLinesVisible.get(); }
/**
* RowConstraints instances can be added to explicitly control individual row
* sizing and layout behavior.
* If not set, row sizing and layout behavior will be computed based on content.
*
*/
private final ObservableList rowConstraints = new TrackableObservableList() {
@Override
protected void onChanged(Change c) {
while (c.next()) {
for (RowConstraints constraints : c.getRemoved()) {
if (constraints != null && !rowConstraints.contains(constraints)) {
constraints.remove(GridPane.this);
}
}
for (RowConstraints constraints : c.getAddedSubList()) {
if (constraints != null) {
constraints.add(GridPane.this);
}
}
}
requestLayout();
}
};
/**
* Returns list of row constraints. Row constraints can be added to
* explicitly control individual row sizing and layout behavior.
* If not set, row sizing and layout behavior is computed based on content.
*
* Index in the ObservableList denotes the row number, so the row constraint for the first row
* is at the position of 0.
* @return the list of row constraints
*/
public final ObservableList getRowConstraints() { return rowConstraints; }
/**
* ColumnConstraints instances can be added to explicitly control individual column
* sizing and layout behavior.
* If not set, column sizing and layout behavior will be computed based on content.
*/
private final ObservableList columnConstraints = new TrackableObservableList() {
@Override
protected void onChanged(Change c) {
while(c.next()) {
for (ColumnConstraints constraints : c.getRemoved()) {
if (constraints != null && !columnConstraints.contains(constraints)) {
constraints.remove(GridPane.this);
}
}
for (ColumnConstraints constraints : c.getAddedSubList()) {
if (constraints != null) {
constraints.add(GridPane.this);
}
}
}
requestLayout();
}
};
/**
* Returns list of column constraints. Column constraints can be added to
* explicitly control individual column sizing and layout behavior.
* If not set, column sizing and layout behavior is computed based on content.
*
* Index in the ObservableList denotes the column number, so the column constraint for the first column
* is at the position of 0.
* @return the list of column constraints
*/
public final ObservableList getColumnConstraints() { return columnConstraints; }
/**
* Adds a child to the gridpane at the specified [column, row] position.
* This convenience method will set the gridpane column and row constraints
* on the child.
* @param child the node being added to the gridpane
* @param columnIndex the column index position for the child within the gridpane, counting from 0
* @param rowIndex the row index position for the child within the gridpane, counting from 0
*/
public void add(Node child, int columnIndex, int rowIndex) {
setConstraints(child, columnIndex, rowIndex);
getChildren().add(child);
}
/**
* Adds a child to the gridpane at the specified [column, row] position and spans.
* This convenience method will set the gridpane column, row, and span constraints
* on the child.
* @param child the node being added to the gridpane
* @param columnIndex the column index position for the child within the gridpane, counting from 0
* @param rowIndex the row index position for the child within the gridpane, counting from 0
* @param colspan the number of columns the child's layout area should span
* @param rowspan the number of rows the child's layout area should span
*/
public void add(Node child, int columnIndex, int rowIndex, int colspan, int rowspan) {
setConstraints(child, columnIndex, rowIndex, colspan, rowspan);
getChildren().add(child);
}
/**
* Convenience method for placing the specified nodes sequentially in a given
* row of the gridpane. If the row already contains nodes the specified nodes
* will be appended to the row. For example, the first node will be positioned at [column,row],
* the second at [column+1,row], etc. This method will set the appropriate gridpane
* row/column constraints on the nodes as well as add the nodes to the gridpane's
* children sequence.
*
* @param rowIndex the row index position for the children within the gridpane
* @param children the nodes to be added as a row in the gridpane
*/
public void addRow(int rowIndex, Node... children) {
int columnIndex = 0;
final List managed = getManagedChildren();
for (int i = 0, size = managed.size(); i < size; i++) {
Node child = managed.get(i);
final int nodeRowIndex = getNodeRowIndex(child);
final int nodeRowEnd = getNodeRowEnd(child);
if (rowIndex >= nodeRowIndex &&
(rowIndex <= nodeRowEnd || nodeRowEnd == REMAINING)) {
int index = getNodeColumnIndex(child);
int end = getNodeColumnEnd(child);
columnIndex = Math.max(columnIndex, (end != REMAINING? end : index) + 1);
}
}
createRow(rowIndex, columnIndex, children);
getChildren().addAll(children);
}
/**
* Convenience method for placing the specified nodes sequentially in a given
* column of the gridpane. If the column already contains nodes the specified nodes
* will be appended to the column. For example, the first node will be positioned at [column, row],
* the second at [column, row+1], etc. This method will set the appropriate gridpane
* row/column constraints on the nodes as well as add the nodes to the gridpane's
* children sequence.
*
* @param columnIndex the column index position for the children within the gridpane
* @param children the nodes to be added as a column in the gridpane
*/
public void addColumn(int columnIndex, Node... children) {
int rowIndex = 0;
final List managed = getManagedChildren();
for (int i = 0, size = managed.size(); i < size; i++) {
Node child = managed.get(i);
final int nodeColumnIndex = getNodeColumnIndex(child);
final int nodeColumnEnd = getNodeColumnEnd(child);
if (columnIndex >= nodeColumnIndex
&& (columnIndex <= nodeColumnEnd || nodeColumnEnd == REMAINING)) {
int index = getNodeRowIndex(child);
int end = getNodeRowEnd(child);
rowIndex = Math.max(rowIndex, (end != REMAINING? end : index) + 1);
}
}
createColumn(columnIndex, rowIndex, children);
getChildren().addAll(children);
}
private Group gridLines;
private Orientation bias;
private double[] rowPercentHeight;
private double rowPercentTotal = 0;
private CompositeSize rowMinHeight;
private CompositeSize rowPrefHeight;
private CompositeSize rowMaxHeight;
private List[] rowBaseline;
private double[] rowMinBaselineComplement;
private double[] rowPrefBaselineComplement;
private double[] rowMaxBaselineComplement;
private Priority[] rowGrow;
private double[] columnPercentWidth;
private double columnPercentTotal = 0;
private CompositeSize columnMinWidth;
private CompositeSize columnPrefWidth;
private CompositeSize columnMaxWidth;
private Priority[] columnGrow;
private boolean metricsDirty = true;
// This is set to true while in layoutChildren and set false on the conclusion.
// It is used to decide whether to update metricsDirty in requestLayout().
private boolean performingLayout = false;
private int numRows;
private int numColumns;
private int getNumberOfRows() {
computeGridMetrics();
return numRows;
}
private int getNumberOfColumns() {
computeGridMetrics();
return numColumns;
}
private boolean isNodePositionedByBaseline(Node n){
return (getRowValignment(getNodeRowIndex(n)) == VPos.BASELINE && getValignment(n) == null)
|| getValignment(n) == VPos.BASELINE;
}
private void computeGridMetrics() {
if (metricsDirty) {
numRows = rowConstraints.size();
numColumns = columnConstraints.size();
final List managed = getManagedChildren();
for (int i = 0, size = managed.size(); i < size; i++) {
Node child = managed.get(i);
int rowIndex = getNodeRowIndex(child);
int columnIndex = getNodeColumnIndex(child);
int rowEnd = getNodeRowEnd(child);
int columnEnd = getNodeColumnEnd(child);
numRows = Math.max(numRows, (rowEnd != REMAINING ? rowEnd : rowIndex) + 1);
numColumns = Math.max(numColumns, (columnEnd != REMAINING ? columnEnd : columnIndex) + 1);
}
rowPercentHeight = createDoubleArray(numRows, -1);
rowPercentTotal = 0;
columnPercentWidth = createDoubleArray(numColumns, -1);
columnPercentTotal = 0;
columnGrow = createPriorityArray(numColumns, Priority.NEVER);
rowGrow = createPriorityArray(numRows, Priority.NEVER);
rowMinBaselineComplement = createDoubleArray(numRows, -1);
rowPrefBaselineComplement = createDoubleArray(numRows, -1);
rowMaxBaselineComplement = createDoubleArray(numRows, -1);
rowBaseline = new List[numRows];
for (int i = 0, sz = numRows; i < sz; ++i) {
if (i < rowConstraints.size()) {
final RowConstraints rc = rowConstraints.get(i);
double percentHeight = rc.getPercentHeight();
Priority vGrow = rc.getVgrow();
if (percentHeight >= 0) {
rowPercentHeight[i] = percentHeight;
}
if (vGrow != null) {
rowGrow[i] = vGrow;
}
}
List baselineNodes = new ArrayList<>(numColumns);
for (int j = 0, size = managed.size(); j < size; j++) {
Node n = managed.get(j);
if (getNodeRowIndex(n) == i && isNodePositionedByBaseline(n)) {
baselineNodes.add(n);
}
}
rowMinBaselineComplement[i] = getMinBaselineComplement(baselineNodes);
rowPrefBaselineComplement[i] = getPrefBaselineComplement(baselineNodes);
rowMaxBaselineComplement[i] = getMaxBaselineComplement(baselineNodes);
rowBaseline[i] = baselineNodes;
}
for (int i = 0, sz = Math.min(numColumns, columnConstraints.size()); i < sz; ++i) {
final ColumnConstraints cc = columnConstraints.get(i);
double percentWidth = cc.getPercentWidth();
Priority hGrow = cc.getHgrow();
if (percentWidth >= 0)
columnPercentWidth[i] = percentWidth;
if (hGrow != null)
columnGrow[i] = hGrow;
}
for (int i = 0, size = managed.size(); i < size; i++) {
Node child = managed.get(i);
if (getNodeColumnSpan(child) == 1) {
Priority hg = getNodeHgrow(child);
int idx = getNodeColumnIndex(child);
columnGrow[idx] = Priority.max(columnGrow[idx], hg);
}
if (getNodeRowSpan(child) == 1) {
Priority vg = getNodeVgrow(child);
int idx = getNodeRowIndex(child);
rowGrow[idx] = Priority.max(rowGrow[idx], vg);
}
}
for (int i = 0; i < rowPercentHeight.length; i++) {
if (rowPercentHeight[i] > 0) {
rowPercentTotal += rowPercentHeight[i];
}
}
if (rowPercentTotal > 100) {
double weight = 100 / rowPercentTotal;
for (int i = 0; i < rowPercentHeight.length; i++) {
if (rowPercentHeight[i] > 0) {
rowPercentHeight[i] *= weight;
}
}
rowPercentTotal = 100;
}
for (int i = 0; i < columnPercentWidth.length; i++) {
if (columnPercentWidth[i] > 0) {
columnPercentTotal += columnPercentWidth[i];
}
}
if (columnPercentTotal > 100) {
double weight = 100 / columnPercentTotal;
for (int i = 0; i < columnPercentWidth.length; i++) {
if (columnPercentWidth[i] > 0) {
columnPercentWidth[i] *= weight;
}
}
columnPercentTotal = 100;
}
bias = null;
for (int i = 0; i < managed.size(); ++i) {
final Orientation b = managed.get(i).getContentBias();
if (b != null) {
bias = b;
if (b == Orientation.HORIZONTAL) {
break;
}
}
}
metricsDirty = false;
}
}
@Override protected double computeMinWidth(double height) {
computeGridMetrics();
performingLayout = true;
try {
final double[] heights = height == -1 ? null : computeHeightsToFit(height).asArray();
return snapSpaceX(getInsets().getLeft()) +
computeMinWidths(heights).computeTotalWithMultiSize() +
snapSpaceX(getInsets().getRight());
} finally {
performingLayout = false;
}
}
@Override protected double computeMinHeight(double width) {
computeGridMetrics();
performingLayout = true;
try {
final double[] widths = width == -1 ? null : computeWidthsToFit(width).asArray();
return snapSpaceY(getInsets().getTop()) +
computeMinHeights(widths).computeTotalWithMultiSize() +
snapSpaceY(getInsets().getBottom());
} finally {
performingLayout = false;
}
}
@Override protected double computePrefWidth(double height) {
computeGridMetrics();
performingLayout = true;
try {
final double[] heights = height == -1 ? null : computeHeightsToFit(height).asArray();
return snapSpaceX(getInsets().getLeft()) +
computePrefWidths(heights).computeTotalWithMultiSize() +
snapSpaceX(getInsets().getRight());
} finally {
performingLayout = false;
}
}
@Override protected double computePrefHeight(double width) {
computeGridMetrics();
performingLayout = true;
try {
final double[] widths = width == -1 ? null : computeWidthsToFit(width).asArray();
return snapSpaceY(getInsets().getTop()) +
computePrefHeights(widths).computeTotalWithMultiSize() +
snapSpaceY(getInsets().getBottom());
} finally {
performingLayout = false;
}
}
private VPos getRowValignment(int rowIndex) {
if (rowIndex < getRowConstraints().size()) {
RowConstraints constraints = getRowConstraints().get(rowIndex);
if (constraints.getValignment() != null) {
return constraints.getValignment();
}
}
return VPos.CENTER;
}
private HPos getColumnHalignment(int columnIndex) {
if (columnIndex < getColumnConstraints().size()) {
ColumnConstraints constraints = getColumnConstraints().get(columnIndex);
if (constraints.getHalignment() != null) {
return constraints.getHalignment();
}
}
return HPos.LEFT;
}
private double getColumnMinWidth(int columnIndex) {
if (columnIndex < getColumnConstraints().size()) {
ColumnConstraints constraints = getColumnConstraints().get(columnIndex);
return constraints.getMinWidth();
}
return USE_COMPUTED_SIZE;
}
private double getRowMinHeight(int rowIndex) {
if (rowIndex < getRowConstraints().size()) {
RowConstraints constraints = getRowConstraints().get(rowIndex);
return constraints.getMinHeight();
}
return USE_COMPUTED_SIZE;
}
private double getColumnMaxWidth(int columnIndex) {
if (columnIndex < getColumnConstraints().size()) {
ColumnConstraints constraints = getColumnConstraints().get(columnIndex);
return constraints.getMaxWidth();
}
return USE_COMPUTED_SIZE;
}
private double getColumnPrefWidth(int columnIndex) {
if (columnIndex < getColumnConstraints().size()) {
ColumnConstraints constraints = getColumnConstraints().get(columnIndex);
return constraints.getPrefWidth();
}
return USE_COMPUTED_SIZE;
}
private double getRowPrefHeight(int rowIndex) {
if (rowIndex < getRowConstraints().size()) {
RowConstraints constraints = getRowConstraints().get(rowIndex);
return constraints.getPrefHeight();
}
return USE_COMPUTED_SIZE;
}
private double getRowMaxHeight(int rowIndex) {
if (rowIndex < getRowConstraints().size()) {
RowConstraints constraints = getRowConstraints().get(rowIndex);
return constraints.getMaxHeight();
}
return USE_COMPUTED_SIZE;
}
private boolean shouldRowFillHeight(int rowIndex) {
if (rowIndex < getRowConstraints().size()) {
return getRowConstraints().get(rowIndex).isFillHeight();
}
return true;
}
private boolean shouldColumnFillWidth(int columnIndex) {
if (columnIndex < getColumnConstraints().size()) {
return getColumnConstraints().get(columnIndex).isFillWidth();
}
return true;
}
private double getTotalWidthOfNodeColumns(Node child, double[] widths) {
if (getNodeColumnSpan(child) == 1) {
return widths[getNodeColumnIndex(child)];
} else {
double total = 0;
for (int i = getNodeColumnIndex(child), last = getNodeColumnEndConvertRemaining(child); i <= last; ++i) {
total += widths[i];
}
return total;
}
}
private CompositeSize computeMaxHeights() {
if (rowMaxHeight == null) {
rowMaxHeight = createCompositeRows(Double.MAX_VALUE); // Do not restrict the row (to allow grow). The
// Nodes will be restricted to their computed size
// in Region.layoutInArea call
final ObservableList rowConstr = getRowConstraints();
CompositeSize prefHeights = null;
for (int i = 0; i < rowConstr.size(); ++i) {
final RowConstraints curConstraint = rowConstr.get(i);
final double constrMaxH = curConstraint.getMaxHeight();
if (constrMaxH == USE_PREF_SIZE) {
if (prefHeights == null) {
prefHeights = computePrefHeights(null);
}
rowMaxHeight.setPresetSize(i, prefHeights.getSize(i));
} else if (constrMaxH != USE_COMPUTED_SIZE) {
final double maxRowHeight = snapSizeY(constrMaxH);
final double constrMinH = curConstraint.getMinHeight();
if (constrMinH >= 0 ) {
final double min = snapSizeY(curConstraint.getMinHeight());
rowMaxHeight.setPresetSize(i, boundedSize(min, maxRowHeight, maxRowHeight));
} else {
rowMaxHeight.setPresetSize(i, maxRowHeight);
}
}
}
}
return rowMaxHeight;
}
private CompositeSize computePrefHeights(double[] widths) {
CompositeSize result;
if (widths == null) {
if (rowPrefHeight != null) {
return rowPrefHeight;
}
rowPrefHeight = createCompositeRows(0);
result = rowPrefHeight;
} else {
result = createCompositeRows(0);
}
final ObservableList rowConstr = getRowConstraints();
for (int i = 0; i < rowConstr.size(); ++i) {
final RowConstraints curConstraint = rowConstr.get(i);
final double constrMinH = curConstraint.getMinHeight();
final double constrPrefH = curConstraint.getPrefHeight();
if (constrPrefH != USE_COMPUTED_SIZE) {
final double prefRowHeight = snapSizeY(constrPrefH);
final double constrMaxH = curConstraint.getMaxHeight();
if (constrMinH >= 0 || constrMaxH >= 0) {
final double min = (constrMinH < 0 ? 0 : snapSizeY(constrMinH));
final double max = (constrMaxH < 0 ? Double.POSITIVE_INFINITY : snapSizeY(constrMaxH));
result.setPresetSize(i, boundedSize(min, prefRowHeight, max));
} else {
result.setPresetSize(i, prefRowHeight);
}
} else if (constrMinH > 0){
result.setSize(i, snapSizeY(constrMinH));
}
}
List managed = getManagedChildren();
for (int i = 0, size = managed.size(); i < size; i++) {
Node child = managed.get(i);
int start = getNodeRowIndex(child);
int end = getNodeRowEndConvertRemaining(child);
double childPrefAreaHeight = computeChildPrefAreaHeight(child, isNodePositionedByBaseline(child) ? rowPrefBaselineComplement[start] : -1, getMargin(child),
widths == null ? -1 : getTotalWidthOfNodeColumns(child, widths));
if (start == end && !result.isPreset(start)) {
double min = getRowMinHeight(start);
double max = getRowMaxHeight(start);
result.setMaxSize(start, boundedSize(min < 0 ? 0 : min, childPrefAreaHeight, max < 0 ? Double.MAX_VALUE : max));
} else if (start != end){
result.setMaxMultiSize(start, end + 1, childPrefAreaHeight);
}
}
return result;
}
private CompositeSize computeMinHeights(double[] widths) {
CompositeSize result;
if (widths == null) {
if (rowMinHeight != null) {
return rowMinHeight;
}
rowMinHeight = createCompositeRows(0);
result = rowMinHeight;
} else {
result = createCompositeRows(0);
}
final ObservableList rowConstr = getRowConstraints();
CompositeSize prefHeights = null;
for (int i = 0; i < rowConstr.size(); ++i) {
final double constrMinH = rowConstr.get(i).getMinHeight();
if (constrMinH == USE_PREF_SIZE) {
if (prefHeights == null) {
prefHeights = computePrefHeights(widths);
}
result.setPresetSize(i, prefHeights.getSize(i));
} else if (constrMinH != USE_COMPUTED_SIZE) {
result.setPresetSize(i, snapSizeY(constrMinH));
}
}
List managed = getManagedChildren();
for (int i = 0, size = managed.size(); i < size; i++) {
Node child = managed.get(i);
int start = getNodeRowIndex(child);
int end = getNodeRowEndConvertRemaining(child);
double childMinAreaHeight = computeChildMinAreaHeight(child, isNodePositionedByBaseline(child) ? rowMinBaselineComplement[start] : -1, getMargin(child),
widths == null ? -1 : getTotalWidthOfNodeColumns(child, widths));
if (start == end && !result.isPreset(start)) {
result.setMaxSize(start, childMinAreaHeight);
} else if (start != end){
result.setMaxMultiSize(start, end + 1, childMinAreaHeight);
}
}
return result;
}
private double getTotalHeightOfNodeRows(Node child, double[] heights) {
if (getNodeRowSpan(child) == 1) {
return heights[getNodeRowIndex(child)];
} else {
double total = 0;
for (int i = getNodeRowIndex(child), last = getNodeRowEndConvertRemaining(child); i <= last; ++i) {
total += heights[i];
}
return total;
}
}
private CompositeSize computeMaxWidths() {
if (columnMaxWidth == null) {
columnMaxWidth = createCompositeColumns(Double.MAX_VALUE);// Do not restrict the column (to allow grow). The
// Nodes will be restricted to their computed size
// in Region.layoutInArea call
final ObservableList columnConstr = getColumnConstraints();
CompositeSize prefWidths = null;
for (int i = 0; i < columnConstr.size(); ++i) {
final ColumnConstraints curConstraint = columnConstr.get(i);
final double constrMaxW = curConstraint.getMaxWidth();
if (constrMaxW == USE_PREF_SIZE) {
if (prefWidths == null) {
prefWidths = computePrefWidths(null);
}
columnMaxWidth.setPresetSize(i, prefWidths.getSize(i));
} else if (constrMaxW != USE_COMPUTED_SIZE) {
double maxColumnWidth = snapSizeX(constrMaxW);
final double constrMinW = curConstraint.getMinWidth();
if (constrMinW >= 0) {
final double min = snapSizeX(constrMinW);
columnMaxWidth.setPresetSize(i, boundedSize(min, maxColumnWidth, maxColumnWidth));
} else {
columnMaxWidth.setPresetSize(i, maxColumnWidth);
}
}
}
}
return columnMaxWidth;
}
private CompositeSize computePrefWidths(double[] heights) {
CompositeSize result;
if (heights == null) {
if (columnPrefWidth != null) {
return columnPrefWidth;
}
columnPrefWidth = createCompositeColumns(0);
result = columnPrefWidth;
} else {
result = createCompositeColumns(0);
}
final ObservableList columnConstr = getColumnConstraints();
for (int i = 0; i < columnConstr.size(); ++i) {
final ColumnConstraints curConstraint = columnConstr.get(i);
final double constrPrefW = curConstraint.getPrefWidth();
final double constrMinW = curConstraint.getMinWidth();
if (constrPrefW != USE_COMPUTED_SIZE) {
final double prefColumnWidth = snapSizeX(constrPrefW);
final double constrMaxW = curConstraint.getMaxWidth();
if (constrMinW >= 0 || constrMaxW >= 0) {
double min = (constrMinW < 0 ? 0 : snapSizeX(constrMinW));
final double max = (constrMaxW < 0 ? Double.POSITIVE_INFINITY : snapSizeX(constrMaxW));
result.setPresetSize(i, boundedSize(min < 0 ? 0 : min,
prefColumnWidth,
max < 0 ? Double.POSITIVE_INFINITY : max));
} else {
result.setPresetSize(i, prefColumnWidth);
}
} else if (constrMinW > 0){
result.setSize(i, snapSizeX(constrMinW));
}
}
List managed = getManagedChildren();
for (int i = 0, size = managed.size(); i < size; i++) {
Node child = managed.get(i);
int start = getNodeColumnIndex(child);
int end = getNodeColumnEndConvertRemaining(child);
if (start == end && !result.isPreset(start)) {
double min = getColumnMinWidth(start);
double max = getColumnMaxWidth(start);
result.setMaxSize(start, boundedSize(min < 0 ? 0 : min, computeChildPrefAreaWidth(child,
getBaselineComplementForChild(child), getMargin(child),
heights == null ? -1 : getTotalHeightOfNodeRows(child, heights), false),
max < 0 ? Double.MAX_VALUE : max));
} else if (start != end) {
result.setMaxMultiSize(start, end + 1, computeChildPrefAreaWidth(child, getBaselineComplementForChild(child),
getMargin(child),
heights == null ? -1 : getTotalHeightOfNodeRows(child, heights), false));
}
}
return result;
}
private CompositeSize computeMinWidths(double[] heights) {
CompositeSize result;
if (heights == null) {
if (columnMinWidth != null) {
return columnMinWidth;
}
columnMinWidth = createCompositeColumns(0);
result = columnMinWidth;
} else {
result = createCompositeColumns(0);
}
final ObservableList columnConstr = getColumnConstraints();
CompositeSize prefWidths = null;
for (int i = 0; i < columnConstr.size(); ++i) {
final double constrMinW = columnConstr.get(i).getMinWidth();
if (constrMinW == USE_PREF_SIZE) {
if (prefWidths == null) {
prefWidths = computePrefWidths(heights);
}
result.setPresetSize(i, prefWidths.getSize(i));
} else if (constrMinW != USE_COMPUTED_SIZE) {
result.setPresetSize(i, snapSizeX(constrMinW));
}
}
List managed = getManagedChildren();
for (int i = 0, size = managed.size(); i < size; i++) {
Node child = managed.get(i);
int start = getNodeColumnIndex(child);
int end = getNodeColumnEndConvertRemaining(child);
if (start == end && !result.isPreset(start)) {
result.setMaxSize(start, computeChildMinAreaWidth(child, getBaselineComplementForChild(child),
getMargin(child),
heights == null ? -1 : getTotalHeightOfNodeRows(child, heights),false));
} else if (start != end){
result.setMaxMultiSize(start, end + 1, computeChildMinAreaWidth(child, getBaselineComplementForChild(child),
getMargin(child),
heights == null ? -1 : getTotalHeightOfNodeRows(child, heights), false));
}
}
return result;
}
private CompositeSize computeHeightsToFit(double height) {
assert(height != -1);
final CompositeSize heights;
if (rowPercentTotal == 100) {
// all rows defined by percentage, no need to compute pref heights
heights = createCompositeRows(0);
} else {
heights = (CompositeSize) computePrefHeights(null).clone();
}
adjustRowHeights(heights, height);
return heights;
}
private CompositeSize computeWidthsToFit(double width) {
assert(width != -1);
final CompositeSize widths;
if (columnPercentTotal == 100) {
// all columns defined by percentage, no need to compute pref widths
widths = createCompositeColumns(0);
} else {
widths = (CompositeSize) computePrefWidths(null).clone();
}
adjustColumnWidths(widths, width);
return widths;
}
/**
*
* @return null unless one of its children has a content bias.
*/
@Override public Orientation getContentBias() {
computeGridMetrics();
return bias;
}
@Override public void requestLayout() {
// RT-18878: Do not update metrics dirty if we are performing layout.
// If metricsDirty is set true during a layout pass the next call to computeGridMetrics()
// will clear all the cell bounds resulting in out of date info until the
// next layout pass.
if (performingLayout) {
return;
} else if (metricsDirty) {
super.requestLayout();
return;
}
metricsDirty = true;
bias = null;
rowGrow = null;
rowMinHeight = rowPrefHeight = rowMaxHeight = null;
columnGrow = null;
columnMinWidth = columnPrefWidth = columnMaxWidth = null;
rowMinBaselineComplement = rowPrefBaselineComplement = rowMaxBaselineComplement = null;
super.requestLayout();
}
@Override protected void layoutChildren() {
performingLayout = true;
try {
final double snaphgap = snapSpaceX(getHgap());
final double snapvgap = snapSpaceY(getVgap());
final double top = snapSpaceY(getInsets().getTop());
final double bottom = snapSpaceY(getInsets().getBottom());
final double left = snapSpaceX(getInsets().getLeft());
final double right = snapSpaceX(getInsets().getRight());
final double width = getWidth();
final double height = getHeight();
final double contentHeight = height - top - bottom;
final double contentWidth = width - left - right;
double columnTotal;
double rowTotal;
computeGridMetrics();
Orientation contentBias = getContentBias();
CompositeSize heights;
final CompositeSize widths;
if (contentBias == null) {
heights = (CompositeSize) computePrefHeights(null).clone();
widths = (CompositeSize) computePrefWidths(null).clone();
rowTotal = adjustRowHeights(heights, height);
columnTotal = adjustColumnWidths(widths, width);
} else if (contentBias == Orientation.HORIZONTAL) {
widths = (CompositeSize) computePrefWidths(null).clone();
columnTotal = adjustColumnWidths(widths, width);
heights = computePrefHeights(widths.asArray());
rowTotal = adjustRowHeights(heights, height);
} else {
heights = (CompositeSize) computePrefHeights(null).clone();
rowTotal = adjustRowHeights(heights, height);
widths = computePrefWidths(heights.asArray());
columnTotal = adjustColumnWidths(widths, width);
}
final double x = left + computeXOffset(contentWidth, columnTotal, getAlignmentInternal().getHpos());
final double y = top + computeYOffset(contentHeight, rowTotal, getAlignmentInternal().getVpos());
final List managed = getManagedChildren();
double[] baselineOffsets = createDoubleArray(numRows, -1);
for (int i = 0, size = managed.size(); i < size; i++) {
final Node child = managed.get(i);
final int rowIndex = getNodeRowIndex(child);
int columnIndex = getNodeColumnIndex(child);
int colspan = getNodeColumnSpan(child);
if (colspan == REMAINING) {
colspan = widths.getLength() - columnIndex;
}
int rowspan = getNodeRowSpan(child);
if (rowspan == REMAINING) {
rowspan = heights.getLength() - rowIndex;
}
double areaX = x;
for (int j = 0; j < columnIndex; j++) {
areaX += widths.getSize(j) + snaphgap;
}
double areaY = y;
for (int j = 0; j < rowIndex; j++) {
areaY += heights.getSize(j) + snapvgap;
}
double areaW = widths.getSize(columnIndex);
for (int j = 2; j <= colspan; j++) {
areaW += widths.getSize(columnIndex + j - 1) + snaphgap;
}
double areaH = heights.getSize(rowIndex);
for (int j = 2; j <= rowspan; j++) {
areaH += heights.getSize(rowIndex + j - 1) + snapvgap;
}
HPos halign = getHalignment(child);
VPos valign = getValignment(child);
Boolean fillWidth = isFillWidth(child);
Boolean fillHeight = isFillHeight(child);
if (halign == null) {
halign = getColumnHalignment(columnIndex);
}
if (valign == null) {
valign = getRowValignment(rowIndex);
}
if (fillWidth == null) {
fillWidth = shouldColumnFillWidth(columnIndex);
}
if (fillHeight == null) {
fillHeight = shouldRowFillHeight(rowIndex);
}
double baselineOffset = 0;
if (valign == VPos.BASELINE) {
if (baselineOffsets[rowIndex] == -1) {
baselineOffsets[rowIndex] = getAreaBaselineOffset(rowBaseline[rowIndex],
marginAccessor,
t -> {
Node n = rowBaseline[rowIndex].get(t);
int c = getNodeColumnIndex(n);
int cs = getNodeColumnSpan(n);
if (cs == REMAINING) {
cs = widths.getLength() - c;
}
double w = widths.getSize(c);
for (int j = 2; j <= cs; j++) {
w += widths.getSize(c + j - 1) + snaphgap;
}
return w;
},
areaH,
t -> {
Boolean b = isFillHeight(child);
if (b != null) {
return b;
}
return shouldRowFillHeight(getNodeRowIndex(child));
}, rowMinBaselineComplement[rowIndex]
);
}
baselineOffset = baselineOffsets[rowIndex];
}
Insets margin = getMargin(child);
layoutInArea(child, areaX, areaY, areaW, areaH,
baselineOffset,
margin,
fillWidth, fillHeight,
halign, valign);
}
layoutGridLines(widths, heights, x, y, rowTotal, columnTotal);
currentHeights = heights;
currentWidths = widths;
} finally {
performingLayout = false;
}
}
private double adjustRowHeights(final CompositeSize heights, double height) {
assert(height != -1);
final double snapvgap = snapSpaceY(getVgap());
final double top = snapSpaceY(getInsets().getTop());
final double bottom = snapSpaceY(getInsets().getBottom());
final double vgaps = snapvgap * (getNumberOfRows() - 1);
final double contentHeight = height - top - bottom;
// if there are percentage rows, give them their percentages first
if (rowPercentTotal > 0) {
double remainder = 0;
for (int i = 0; i < rowPercentHeight.length; i++) {
if (rowPercentHeight[i] >= 0) {
double size = (contentHeight - vgaps) * (rowPercentHeight[i]/100);
double floor = Math.floor(size);
remainder += size - floor;
// snap size to integer boundary based on the computed remainder as we loop through the rows.
size = floor;
if (remainder >= 0.5) {
size++;
remainder = (-1.0) + remainder;
}
heights.setSize(i, size);
}
}
}
double rowTotal = heights.computeTotal();
if (rowPercentTotal < 100) {
double heightAvailable = height - top - bottom - rowTotal;
// now that both fixed and percentage rows have been computed, divy up any surplus or deficit
if (heightAvailable != 0) {
// maybe grow or shrink row heights
double remaining = growToMultiSpanPreferredHeights(heights, heightAvailable);
remaining = growOrShrinkRowHeights(heights, Priority.ALWAYS, remaining);
remaining = growOrShrinkRowHeights(heights, Priority.SOMETIMES, remaining);
rowTotal += (heightAvailable - remaining);
}
}
return rowTotal;
}
private double growToMultiSpanPreferredHeights(CompositeSize heights, double extraHeight) {
if (extraHeight <= 0) {
return extraHeight;
}
Set rowsAlways = new TreeSet<>();
Set rowsSometimes = new TreeSet<>();
Set lastRows = new TreeSet<>();
for (Entry ms : heights.multiSizes()) {
final Interval interval = ms.getKey();
for (int i = interval.begin; i < interval.end; ++i) {
if (rowPercentHeight[i] < 0) {
switch (rowGrow[i]) {
case ALWAYS:
rowsAlways.add(i);
break;
case SOMETIMES:
rowsSometimes.add(i);
break;
}
}
}
if (rowPercentHeight[interval.end - 1] < 0) {
lastRows.add(interval.end - 1);
}
}
double remaining = extraHeight;
while (rowsAlways.size() > 0 && remaining > rowsAlways.size()) {
double rowPortion = Math.floor(remaining / rowsAlways.size());
for (Iterator it = rowsAlways.iterator(); it.hasNext();) {
int i = it.next();
double maxOfRow = getRowMaxHeight(i);
double prefOfRow = getRowPrefHeight(i);
double actualPortion = rowPortion;
for (Entry ms : heights.multiSizes()) {
final Interval interval = ms.getKey();
if (interval.contains(i)) {
int intervalRows = 0;
for (int j = interval.begin; j < interval.end; ++j) {
if (rowsAlways.contains(j)) {
intervalRows++;
}
}
double curLength = heights.computeTotal(interval.begin, interval.end);
actualPortion = Math.min(Math.floor(Math.max(0, (ms.getValue() - curLength) / intervalRows)),
actualPortion);
}
}
final double current = heights.getSize(i);
double bounded = maxOfRow >= 0 ? boundedSize(0, current + actualPortion, maxOfRow) :
maxOfRow == USE_PREF_SIZE && prefOfRow > 0 ? boundedSize(0, current + actualPortion, prefOfRow) :
current + actualPortion;
final double portionUsed = bounded - current;
remaining -= portionUsed;
if (portionUsed != actualPortion || portionUsed == 0) {
it.remove();
}
heights.setSize(i, bounded);
}
}
while (rowsSometimes.size() > 0 && remaining > rowsSometimes.size()) {
double colPortion = Math.floor(remaining / rowsSometimes.size());
for (Iterator it = rowsSometimes.iterator(); it.hasNext();) {
int i = it.next();
double maxOfRow = getRowMaxHeight(i);
double prefOfRow = getRowPrefHeight(i);
double actualPortion = colPortion;
for (Entry ms : heights.multiSizes()) {
final Interval interval = ms.getKey();
if (interval.contains(i)) {
int intervalRows = 0;
for (int j = interval.begin; j < interval.end; ++j) {
if (rowsSometimes.contains(j)) {
intervalRows++;
}
}
double curLength = heights.computeTotal(interval.begin, interval.end);
actualPortion = Math.min(Math.floor(Math.max(0, (ms.getValue() - curLength) / intervalRows)),
actualPortion);
}
}
final double current = heights.getSize(i);
double bounded = maxOfRow >= 0 ? boundedSize(0, current + actualPortion, maxOfRow) :
maxOfRow == USE_PREF_SIZE && prefOfRow > 0 ? boundedSize(0, current + actualPortion, prefOfRow) :
current + actualPortion;
final double portionUsed = bounded - current;
remaining -= portionUsed;
if (portionUsed != actualPortion || portionUsed == 0) {
it.remove();
}
heights.setSize(i, bounded);
}
}
while (lastRows.size() > 0 && remaining > lastRows.size()) {
double colPortion = Math.floor(remaining / lastRows.size());
for (Iterator it = lastRows.iterator(); it.hasNext();) {
int i = it.next();
double maxOfRow = getRowMaxHeight(i);
double prefOfRow = getRowPrefHeight(i);
double actualPortion = colPortion;
for (Entry ms : heights.multiSizes()) {
final Interval interval = ms.getKey();
if (interval.end - 1 == i) {
double curLength = heights.computeTotal(interval.begin, interval.end);
actualPortion = Math.min(Math.max(0, ms.getValue() - curLength),
actualPortion);
}
}
final double current = heights.getSize(i);
double bounded = maxOfRow >= 0 ? boundedSize(0, current + actualPortion, maxOfRow) :
maxOfRow == USE_PREF_SIZE && prefOfRow > 0 ? boundedSize(0, current + actualPortion, prefOfRow) :
current + actualPortion;
final double portionUsed = bounded - current;
remaining -= portionUsed;
if (portionUsed != actualPortion || portionUsed == 0) {
it.remove();
}
heights.setSize(i, bounded);
}
}
return remaining;
}
private double growOrShrinkRowHeights(CompositeSize heights, Priority priority, double extraHeight) {
final boolean shrinking = extraHeight < 0;
List adjusting = new ArrayList<>();
for (int i = 0; i < rowGrow.length; i++) {
if (rowPercentHeight[i] < 0 && (shrinking || rowGrow[i] == priority)) {
adjusting.add(i);
}
}
double available = extraHeight; // will be negative in shrinking case
boolean handleRemainder = false;
double portion = 0;
// RT-25684: We have to be careful that when subtracting change
// that we don't jump right past 0 - this leads to an infinite
// loop
final boolean wasPositive = available >= 0.0;
boolean isPositive = wasPositive;
CompositeSize limitSize = shrinking? computeMinHeights(null) :
computeMaxHeights();
while (available != 0 && wasPositive == isPositive && adjusting.size() > 0) {
if (!handleRemainder) {
portion = available > 0 ? Math.floor(available / adjusting.size()) :
Math.ceil(available / adjusting.size()); // negative in shrinking case
}
if (portion != 0) {
for (Iterator i = adjusting.iterator(); i.hasNext();) {
final int index = i.next();
double limit = snapSpaceY(limitSize.getProportionalMinOrMaxSize(index, shrinking))
- heights.getSize(index); // negative in shrinking case
if (shrinking && limit > 0
|| !shrinking && limit < 0) { // Limit completely if current size
// (originally based on preferred) already passed the computed limit
limit = 0;
}
final double change = Math.abs(limit) <= Math.abs(portion)? limit : portion;
heights.addSize(index, change);
available -= change;
isPositive = available >= 0.0;
if (Math.abs(change) < Math.abs(portion)) {
i.remove();
}
if (available == 0) {
break;
}
}
} else {
// Handle the remainder
portion = (int)(available) % adjusting.size();
if (portion == 0) {
break;
} else {
// We have a remainder evenly distribute it.
portion = shrinking ? -1 : 1;
handleRemainder = true;
}
}
}
return available; // might be negative in shrinking case
}
private double adjustColumnWidths(final CompositeSize widths, double width) {
assert(width != -1);
final double snaphgap = snapSpaceX(getHgap());
final double left = snapSpaceX(getInsets().getLeft());
final double right = snapSpaceX(getInsets().getRight());
final double hgaps = snaphgap * (getNumberOfColumns() - 1);
final double contentWidth = width - left - right;
// if there are percentage rows, give them their percentages first
if (columnPercentTotal > 0) {
double remainder = 0;
for (int i = 0; i < columnPercentWidth.length; i++) {
if (columnPercentWidth[i] >= 0) {
double size = (contentWidth - hgaps) * (columnPercentWidth[i]/100);
double floor = Math.floor(size);
remainder += size - floor;
// snap size to integer boundary based on the computed remainder as we loop through the columns.
size = floor;
if (remainder >= 0.5) {
size++;
remainder = (-1.0) + remainder;
}
widths.setSize(i, size);
}
}
}
double columnTotal = widths.computeTotal();
if (columnPercentTotal < 100) {
double widthAvailable = width - left - right - columnTotal;
// now that both fixed and percentage rows have been computed, divy up any surplus or deficit
if (widthAvailable != 0) {
// maybe grow or shrink row heights
double remaining = growToMultiSpanPreferredWidths(widths, widthAvailable);
remaining = growOrShrinkColumnWidths(widths, Priority.ALWAYS, remaining);
remaining = growOrShrinkColumnWidths(widths, Priority.SOMETIMES, remaining);
columnTotal += (widthAvailable - remaining);
}
}
return columnTotal;
}
private double growToMultiSpanPreferredWidths(CompositeSize widths, double extraWidth) {
if (extraWidth <= 0) {
return extraWidth;
}
Set columnsAlways = new TreeSet<>();
Set columnsSometimes = new TreeSet<>();
Set lastColumns = new TreeSet<>();
for (Entry ms : widths.multiSizes()) {
final Interval interval = ms.getKey();
for (int i = interval.begin; i < interval.end; ++i) {
if (columnPercentWidth[i] < 0) {
switch (columnGrow[i]) {
case ALWAYS:
columnsAlways.add(i);
break;
case SOMETIMES:
columnsSometimes.add(i);
break;
}
}
}
if (columnPercentWidth[interval.end - 1] < 0) {
lastColumns.add(interval.end - 1);
}
}
double remaining = extraWidth;
while (columnsAlways.size() > 0 && remaining > columnsAlways.size()) {
double colPortion = Math.floor(remaining / columnsAlways.size());
for (Iterator it = columnsAlways.iterator(); it.hasNext();) {
int i = it.next();
double maxOfColumn = getColumnMaxWidth(i);
double prefOfColumn = getColumnPrefWidth(i);
double actualPortion = colPortion;
for (Entry ms : widths.multiSizes()) {
final Interval interval = ms.getKey();
if (interval.contains(i)) {
int intervalColumns = 0;
for (int j = interval.begin; j < interval.end; ++j) {
if (columnsAlways.contains(j)) {
intervalColumns++;
}
}
double curLength = widths.computeTotal(interval.begin, interval.end);
actualPortion = Math.min(Math.floor(Math.max(0, (ms.getValue() - curLength) / intervalColumns)),
actualPortion);
}
}
final double current = widths.getSize(i);
double bounded = maxOfColumn >= 0 ? boundedSize(0, current + actualPortion, maxOfColumn) :
maxOfColumn == USE_PREF_SIZE && prefOfColumn > 0 ? boundedSize(0, current + actualPortion, prefOfColumn) :
current + actualPortion;
final double portionUsed = bounded - current;
remaining -= portionUsed;
if (portionUsed != actualPortion || portionUsed == 0) {
it.remove();
}
widths.setSize(i, bounded);
}
}
while (columnsSometimes.size() > 0 && remaining > columnsSometimes.size()) {
double colPortion = Math.floor(remaining / columnsSometimes.size());
for (Iterator it = columnsSometimes.iterator(); it.hasNext();) {
int i = it.next();
double maxOfColumn = getColumnMaxWidth(i);
double prefOfColumn = getColumnPrefWidth(i);
double actualPortion = colPortion;
for (Entry ms : widths.multiSizes()) {
final Interval interval = ms.getKey();
if (interval.contains(i)) {
int intervalColumns = 0;
for (int j = interval.begin; j < interval.end; ++j) {
if (columnsSometimes.contains(j)) {
intervalColumns++;
}
}
double curLength = widths.computeTotal(interval.begin, interval.end);
actualPortion = Math.min(Math.floor(Math.max(0, (ms.getValue() - curLength) / intervalColumns)),
actualPortion);
}
}
final double current = widths.getSize(i);
double bounded = maxOfColumn >= 0 ? boundedSize(0, current + actualPortion, maxOfColumn) :
maxOfColumn == USE_PREF_SIZE && prefOfColumn > 0 ? boundedSize(0, current + actualPortion, prefOfColumn) :
current + actualPortion;
final double portionUsed = bounded - current;
remaining -= portionUsed;
if (portionUsed != actualPortion || portionUsed == 0) {
it.remove();
}
widths.setSize(i, bounded);
}
}
while (lastColumns.size() > 0 && remaining > lastColumns.size()) {
double colPortion = Math.floor(remaining / lastColumns.size());
for (Iterator it = lastColumns.iterator(); it.hasNext();) {
int i = it.next();
double maxOfColumn = getColumnMaxWidth(i);
double prefOfColumn = getColumnPrefWidth(i);
double actualPortion = colPortion;
for (Entry ms : widths.multiSizes()) {
final Interval interval = ms.getKey();
if (interval.end - 1 == i) {
double curLength = widths.computeTotal(interval.begin, interval.end);
actualPortion = Math.min(Math.max(0, ms.getValue() - curLength),
actualPortion);
}
}
final double current = widths.getSize(i);
double bounded = maxOfColumn >= 0 ? boundedSize(0, current + actualPortion, maxOfColumn) :
maxOfColumn == USE_PREF_SIZE && prefOfColumn > 0 ? boundedSize(0, current + actualPortion, prefOfColumn) :
current + actualPortion;
final double portionUsed = bounded - current;
remaining -= portionUsed;
if (portionUsed != actualPortion || portionUsed == 0) {
it.remove();
}
widths.setSize(i, bounded);
}
}
return remaining;
}
private double growOrShrinkColumnWidths(CompositeSize widths, Priority priority, double extraWidth) {
if (extraWidth == 0) {
return 0;
}
final boolean shrinking = extraWidth < 0;
List adjusting = new ArrayList<>();
for (int i = 0; i < columnGrow.length; i++) {
if (columnPercentWidth[i] < 0 && (shrinking || columnGrow[i] == priority)) {
adjusting.add(i);
}
}
double available = extraWidth; // will be negative in shrinking case
boolean handleRemainder = false;
double portion = 0;
// RT-25684: We have to be careful that when subtracting change
// that we don't jump right past 0 - this leads to an infinite
// loop
final boolean wasPositive = available >= 0.0;
boolean isPositive = wasPositive;
CompositeSize limitSize = shrinking? computeMinWidths(null) :
computeMaxWidths();
while (available != 0 && wasPositive == isPositive && adjusting.size() > 0) {
if (!handleRemainder) {
portion = available > 0 ? Math.floor(available / adjusting.size()) :
Math.ceil(available / adjusting.size()); // negative in shrinking case
}
if (portion != 0) {
for (Iterator i = adjusting.iterator(); i.hasNext();) {
final int index = i.next();
double limit = snapSpaceX(limitSize.getProportionalMinOrMaxSize(index, shrinking))
- widths.getSize(index); // negative in shrinking case
if (shrinking && limit > 0
|| !shrinking && limit < 0) { // Limit completely if current size
// (originally based on preferred) already passed the computed limit
limit = 0;
}
final double change = Math.abs(limit) <= Math.abs(portion)? limit : portion;
widths.addSize(index, change);
available -= change;
isPositive = available >= 0.0;
if (Math.abs(change) < Math.abs(portion)) {
i.remove();
}
if (available == 0) {
break;
}
}
} else {
// Handle the remainder
portion = (int)(available) % adjusting.size();
if (portion == 0) {
break;
} else {
// We have a remainder evenly distribute it.
portion = shrinking ? -1 : 1;
handleRemainder = true;
}
}
}
return available; // might be negative in shrinking case
}
private void layoutGridLines(CompositeSize columnWidths, CompositeSize rowHeights, double x, double y, double columnHeight, double rowWidth) {
if (!isGridLinesVisible()) {
return;
}
if (!gridLines.getChildren().isEmpty()) {
gridLines.getChildren().clear();
}
double hGap = snapSpaceX(getHgap());
double vGap = snapSpaceY(getVgap());
// create vertical lines
double linex = x;
double liney = y;
for (int i = 0; i <= columnWidths.getLength(); i++) {
gridLines.getChildren().add(createGridLine(linex, liney, linex, liney + columnHeight));
if (i > 0 && i < columnWidths.getLength() && hGap != 0) {
linex += hGap;
gridLines.getChildren().add(createGridLine(linex, liney, linex, liney + columnHeight));
}
if (i < columnWidths.getLength()) {
linex += columnWidths.getSize(i);
}
}
// create horizontal lines
linex = x;
for (int i = 0; i <= rowHeights.getLength(); i++) {
gridLines.getChildren().add(createGridLine(linex, liney, linex + rowWidth, liney));
if (i > 0 && i < rowHeights.getLength() && vGap != 0) {
liney += vGap;
gridLines.getChildren().add(createGridLine(linex, liney, linex + rowWidth, liney));
}
if (i < rowHeights.getLength()) {
liney += rowHeights.getSize(i);
}
}
}
private Line createGridLine(double startX, double startY, double endX, double endY) {
Line line = new Line();
line.setStartX(startX);
line.setStartY(startY);
line.setEndX(endX);
line.setEndY(endY);
line.setStroke(GRID_LINE_COLOR);
line.setStrokeDashOffset(GRID_LINE_DASH);
return line;
}
/**
* Returns a string representation of this {@code GridPane} object.
* @return a string representation of this {@code GridPane} object.
*/
@Override public String toString() {
return "Grid hgap="+getHgap()+", vgap="+getVgap()+", alignment="+getAlignment();
}
private CompositeSize createCompositeRows(double initSize) {
return new CompositeSize(getNumberOfRows(), rowPercentHeight, rowPercentTotal,
snapSpaceY(getVgap()), initSize);
}
private CompositeSize createCompositeColumns(double initSize) {
return new CompositeSize(getNumberOfColumns(), columnPercentWidth, columnPercentTotal,
snapSpaceX(getHgap()), initSize);
}
private int getNodeRowEndConvertRemaining(Node child) {
int rowSpan = getNodeRowSpan(child);
return rowSpan != REMAINING? getNodeRowIndex(child) + rowSpan - 1 : getNumberOfRows() - 1;
}
private int getNodeColumnEndConvertRemaining(Node child) {
int columnSpan = getNodeColumnSpan(child);
return columnSpan != REMAINING? getNodeColumnIndex(child) + columnSpan - 1 : getNumberOfColumns() - 1;
}
// This methods are inteded to be used by GridPaneDesignInfo
private CompositeSize currentHeights;
private CompositeSize currentWidths;
double[][] getGrid() {
if (currentHeights == null || currentWidths == null) {
return null;
}
return new double[][] {currentWidths.asArray(), currentHeights.asArray()};
}
/* *************************************************************************
* *
* Stylesheet Handling *
* *
**************************************************************************/
/*
* Super-lazy instantiation pattern from Bill Pugh.
*/
private static class StyleableProperties {
private static final CssMetaData GRID_LINES_VISIBLE =
new CssMetaData("-fx-grid-lines-visible",
BooleanConverter.getInstance(), Boolean.FALSE) {
@Override
public boolean isSettable(GridPane node) {
return node.gridLinesVisible == null ||
!node.gridLinesVisible.isBound();
}
@Override
public StyleableProperty getStyleableProperty(GridPane node) {
return (StyleableProperty)node.gridLinesVisibleProperty();
}
};
private static final CssMetaData HGAP =
new CssMetaData("-fx-hgap",
SizeConverter.getInstance(), 0.0){
@Override
public boolean isSettable(GridPane node) {
return node.hgap == null || !node.hgap.isBound();
}
@Override
public StyleableProperty getStyleableProperty(GridPane node) {
return (StyleableProperty)node.hgapProperty();
}
};
private static final CssMetaData ALIGNMENT =
new CssMetaData("-fx-alignment",
new EnumConverter(Pos.class), Pos.TOP_LEFT) {
@Override
public boolean isSettable(GridPane node) {
return node.alignment == null || !node.alignment.isBound();
}
@Override
public StyleableProperty getStyleableProperty(GridPane node) {
return (StyleableProperty)node.alignmentProperty();
}
};
private static final CssMetaData VGAP =
new CssMetaData("-fx-vgap",
SizeConverter.getInstance(), 0.0){
@Override
public boolean isSettable(GridPane node) {
return node.vgap == null || !node.vgap.isBound();
}
@Override
public StyleableProperty getStyleableProperty(GridPane node) {
return (StyleableProperty)node.vgapProperty();
}
};
private static final List> STYLEABLES;
static {
final List> styleables =
new ArrayList>(Region.getClassCssMetaData());
styleables.add(GRID_LINES_VISIBLE);
styleables.add(HGAP);
styleables.add(ALIGNMENT);
styleables.add(VGAP);
STYLEABLES = Collections.unmodifiableList(styleables);
}
}
/**
* @return The CssMetaData associated with this class, which may include the
* CssMetaData of its superclasses.
* @since JavaFX 8.0
*/
public static List> getClassCssMetaData() {
return StyleableProperties.STYLEABLES;
}
/**
* {@inheritDoc}
*
* @since JavaFX 8.0
*/
@Override
public List> getCssMetaData() {
return getClassCssMetaData();
}
private static final class Interval implements Comparable {
public final int begin;
public final int end;
public Interval(int begin, int end) {
this.begin = begin;
this.end = end;
}
@Override
public int compareTo(Interval o) {
return begin != o.begin ? begin - o.begin : end - o.end;
}
private boolean contains(int position) {
return begin <= position && position < end;
}
private int size() {
return end - begin;
}
}
private static final class CompositeSize implements Cloneable {
// These variables will be modified during the computations
double singleSizes[];
private SortedMap multiSizes;
private BitSet preset;
// Preset metrics for this dimension
private final double fixedPercent[];
private final double totalFixedPercent;
private final double gap;
public CompositeSize(int capacity, double fixedPercent[], double totalFixedPercent, double gap, double initSize) {
singleSizes = new double[capacity];
Arrays.fill(singleSizes, initSize);
this.fixedPercent = fixedPercent;
this.totalFixedPercent = totalFixedPercent;
this.gap = gap;
}
private void setSize(int position, double size) {
singleSizes[position] = size;
}
private void setPresetSize(int position, double size) {
setSize(position, size);
if (preset == null) {
preset = new BitSet(singleSizes.length);
}
preset.set(position);
}
private boolean isPreset(int position) {
if (preset == null) {
return false;
}
return preset.get(position);
}
private void addSize(int position, double change) {
singleSizes[position] = singleSizes[position] + change;
}
private double getSize(int position) {
return singleSizes[position];
}
private void setMaxSize(int position, double size) {
singleSizes[position] = Math.max(singleSizes[position], size);
}
private void setMultiSize(int startPosition, int endPosition, double size) {
if (multiSizes == null) {
multiSizes = new TreeMap<>();
}
Interval i = new Interval(startPosition, endPosition);
multiSizes.put(i, size);
}
private Iterable> multiSizes() {
if (multiSizes == null) {
return Collections.EMPTY_LIST;
}
return multiSizes.entrySet();
}
private void setMaxMultiSize(int startPosition, int endPosition, double size) {
if (multiSizes == null) {
multiSizes = new TreeMap<>();
}
Interval i = new Interval(startPosition, endPosition);
Double sz = multiSizes.get(i);
if (sz == null) {
multiSizes.put(i, size);
} else {
multiSizes.put(i, Math.max(size, sz));
}
}
private double getProportionalMinOrMaxSize(int position, boolean min) {
double result = singleSizes[position];
if (!isPreset(position) && multiSizes != null) {
for (Interval i : multiSizes.keySet()) {
if (i.contains(position)) {
double segment = multiSizes.get(i) / i.size();
double propSize = segment;
for (int j = i.begin; j < i.end; ++j) {
if (j != position) {
if (min ? singleSizes[j] > segment : singleSizes[j] < segment) {
propSize += segment - singleSizes[j];
}
}
}
result = min ? Math.max(result, propSize) : Math.min(result, propSize);
}
}
}
return result;
}
private double computeTotal(final int from, final int to) {
double total = gap * (to - from - 1);
for (int i = from; i < to; ++i) {
total += singleSizes[i];
}
return total;
}
private double computeTotal() {
return computeTotal(0, singleSizes.length);
}
private boolean allPreset(int begin, int end) {
if (preset == null) {
return false;
}
for (int i = begin; i < end; ++i) {
if (!preset.get(i)) {
return false;
}
}
return true;
}
private double computeTotalWithMultiSize() {
double total = computeTotal();
if (multiSizes != null) {
for (Entry e: multiSizes.entrySet()) {
final Interval i = e.getKey();
if (!allPreset(i.begin, i.end)) {
double subTotal = computeTotal(i.begin, i.end);
if (e.getValue() > subTotal) {
total += e.getValue() - subTotal;
}
}
}
}
if (totalFixedPercent > 0) {
double totalNotFixed = 0;
// First, remove the sizes that are fixed to be 0
for (int i = 0; i < fixedPercent.length; ++i) {
if (fixedPercent[i] == 0) {
total -= singleSizes[i];
}
}
for (int i = 0; i < fixedPercent.length; ++i) {
if (fixedPercent[i] > 0) {
// Grow the total so that every size at it's value corresponds at least to it's fixedPercent of the total
// i.e. total * fixedPercent[i] >= singleSizes[i]
total = Math.max(total, singleSizes[i] * (100 / fixedPercent[i]));
} else if (fixedPercent[i] < 0){
totalNotFixed += singleSizes[i];
}
}
if (totalFixedPercent < 100) {
total = Math.max(total, totalNotFixed * 100 / (100 - totalFixedPercent));
}
}
return total;
}
private int getLength() {
return singleSizes.length;
}
@Override
protected Object clone() {
try {
CompositeSize clone = (CompositeSize) super.clone();
clone.singleSizes = clone.singleSizes.clone();
if (multiSizes != null)
clone.multiSizes = new TreeMap<>(clone.multiSizes);
return clone;
} catch (CloneNotSupportedException ex) {
throw new RuntimeException(ex);
}
}
private double[] asArray() {
return singleSizes;
}
}
/**
* Returns the number of rows in this GridPane.
*
* @return the row count
* @since 9
*/
public final int getRowCount() {
int nRows = this.getRowConstraints().size();
for (int i = 0; i < this.getChildren().size(); i++) {
Node child = this.getChildren().get(i);
if (child.isManaged()) {
int rowIndex = GridPane.getNodeRowIndex(child);
int rowEnd = GridPane.getNodeRowEnd(child);
nRows = Math.max(nRows, (rowEnd != GridPane.REMAINING? rowEnd : rowIndex) + 1);
}
}
return nRows;
}
/**
* Returns the number of columns in this GridPane.
*
* @return the column count
* @since 9
*/
public final int getColumnCount() {
int nColumns = this.getColumnConstraints().size();
for (int i = 0; i < this.getChildren().size(); i++) {
Node child = this.getChildren().get(i);
if (child.isManaged()) {
int columnIndex = GridPane.getNodeColumnIndex(child);
int columnEnd = GridPane.getNodeColumnEnd(child);
nColumns = Math.max(nColumns, (columnEnd != GridPane.REMAINING? columnEnd : columnIndex) + 1);
}
}
return nColumns;
}
/**
* Returns the bounds of the cell at the specified column and row position.
*
* @param columnIndex the column index position for the cell within this
* GridPane, counting from 0
* @param rowIndex the row index position for the cell within this GridPane,
* counting from 0
* @return the bounds of the cell at columnIndex and rowIndex.
* @since 9
*/
public final Bounds getCellBounds(int columnIndex, int rowIndex) {
final double snaphgap = this.snapSpaceX(this.getHgap());
final double snapvgap = this.snapSpaceY(this.getVgap());
final double top = this.snapSpaceY(this.getInsets().getTop());
final double right = this.snapSpaceX(this.getInsets().getRight());
final double bottom = this.snapSpaceY(this.getInsets().getBottom());
final double left = this.snapSpaceX(this.getInsets().getLeft());
final double gridPaneHeight = this.snapSizeY(this.getHeight()) - (top + bottom);
final double gridPaneWidth = this.snapSizeX(this.getWidth()) - (left + right);
// Compute grid. Result contains two double arrays, first for columns, second for rows
double[] columnWidths;
double[] rowHeights;
double[][] grid = this.getGrid();
if (grid == null) {
rowHeights = new double[] {0};
rowIndex = 0;
columnWidths = new double[] {0};
columnIndex = 0;
} else {
columnWidths = grid[0];
rowHeights = grid[1];
}
// Compute the total row height
double rowTotal = 0;
for (int i = 0; i < rowHeights.length; i++) {
rowTotal += rowHeights[i];
}
rowTotal += ((rowHeights.length - 1) * snapvgap);
// Adjust for alignment
double minY = top + Region.computeYOffset(gridPaneHeight, rowTotal, this.getAlignment().getVpos());
double height = rowHeights[rowIndex];
for (int j = 0; j < rowIndex; j++) {
minY += rowHeights[j] + snapvgap;
}
// Compute the total column width
double columnTotal = 0;
for (int i = 0; i < columnWidths.length; i++) {
columnTotal += columnWidths[i];
}
columnTotal += ((columnWidths.length - 1) * snaphgap);
// Adjust for alignment
double minX = left + Region.computeXOffset(gridPaneWidth, columnTotal, this.getAlignment().getHpos());
double width = columnWidths[columnIndex];
for (int j = 0; j < columnIndex; j++) {
minX += columnWidths[j] + snaphgap;
}
return new BoundingBox(minX, minY, width, height);
}
}