/*
* Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package java.awt;
/**
* The <code>GridLayout</code> class is a layout manager that
* lays out a container's components in a rectangular grid.
* The container is divided into equal-sized rectangles,
* and one component is placed in each rectangle.
* For example, the following is an applet that lays out six buttons
* into three rows and two columns:
*
* <hr><blockquote>
* <pre>
* import java.awt.*;
* import java.applet.Applet;
* public class ButtonGrid extends Applet {
* public void init() {
* setLayout(new GridLayout(3,2));
* add(new Button("1"));
* add(new Button("2"));
* add(new Button("3"));
* add(new Button("4"));
* add(new Button("5"));
* add(new Button("6"));
* }
* }
* </pre></blockquote><hr>
* <p>
* If the container's <code>ComponentOrientation</code> property is horizontal
* and left-to-right, the above example produces the output shown in Figure 1.
* If the container's <code>ComponentOrientation</code> property is horizontal
* and right-to-left, the example produces the output shown in Figure 2.
*
* <table style="float:center" WIDTH=600 summary="layout">
* <tr ALIGN=CENTER>
* <td><img SRC="doc-files/GridLayout-1.gif"
* alt="Shows 6 buttons in rows of 2. Row 1 shows buttons 1 then 2.
* Row 2 shows buttons 3 then 4. Row 3 shows buttons 5 then 6.">
* </td>
*
* <td ALIGN=CENTER><img SRC="doc-files/GridLayout-2.gif"
* alt="Shows 6 buttons in rows of 2. Row 1 shows buttons 2 then 1.
* Row 2 shows buttons 4 then 3. Row 3 shows buttons 6 then 5.">
* </td>
* </tr>
*
* <tr ALIGN=CENTER>
* <td>Figure 1: Horizontal, Left-to-Right</td>
*
* <td>Figure 2: Horizontal, Right-to-Left</td>
* </tr>
* </table>
* <p>
* When both the number of rows and the number of columns have
* been set to non-zero values, either by a constructor or
* by the <tt>setRows</tt> and <tt>setColumns</tt> methods, the number of
* columns specified is ignored. Instead, the number of
* columns is determined from the specified number of rows
* and the total number of components in the layout. So, for
* example, if three rows and two columns have been specified
* and nine components are added to the layout, they will
* be displayed as three rows of three columns. Specifying
* the number of columns affects the layout only when the
* number of rows is set to zero.
*
* @author Arthur van Hoff
* @since JDK1.0
*/
public class
GridLayout implements
LayoutManager, java.io.
Serializable {
/*
* serialVersionUID
*/
private static final long
serialVersionUID = -7411804673224730901L;
/**
* This is the horizontal gap (in pixels) which specifies the space
* between columns. They can be changed at any time.
* This should be a non-negative integer.
*
* @serial
* @see #getHgap()
* @see #setHgap(int)
*/
int
hgap;
/**
* This is the vertical gap (in pixels) which specifies the space
* between rows. They can be changed at any time.
* This should be a non negative integer.
*
* @serial
* @see #getVgap()
* @see #setVgap(int)
*/
int
vgap;
/**
* This is the number of rows specified for the grid. The number
* of rows can be changed at any time.
* This should be a non negative integer, where '0' means
* 'any number' meaning that the number of Rows in that
* dimension depends on the other dimension.
*
* @serial
* @see #getRows()
* @see #setRows(int)
*/
int
rows;
/**
* This is the number of columns specified for the grid. The number
* of columns can be changed at any time.
* This should be a non negative integer, where '0' means
* 'any number' meaning that the number of Columns in that
* dimension depends on the other dimension.
*
* @serial
* @see #getColumns()
* @see #setColumns(int)
*/
int
cols;
/**
* Creates a grid layout with a default of one column per component,
* in a single row.
* @since JDK1.1
*/
public
GridLayout() {
this(1, 0, 0, 0);
}
/**
* Creates a grid layout with the specified number of rows and
* columns. All components in the layout are given equal size.
* <p>
* One, but not both, of <code>rows</code> and <code>cols</code> can
* be zero, which means that any number of objects can be placed in a
* row or in a column.
* @param rows the rows, with the value zero meaning
* any number of rows.
* @param cols the columns, with the value zero meaning
* any number of columns.
*/
public
GridLayout(int
rows, int
cols) {
this(
rows,
cols, 0, 0);
}
/**
* Creates a grid layout with the specified number of rows and
* columns. All components in the layout are given equal size.
* <p>
* In addition, the horizontal and vertical gaps are set to the
* specified values. Horizontal gaps are placed between each
* of the columns. Vertical gaps are placed between each of
* the rows.
* <p>
* One, but not both, of <code>rows</code> and <code>cols</code> can
* be zero, which means that any number of objects can be placed in a
* row or in a column.
* <p>
* All <code>GridLayout</code> constructors defer to this one.
* @param rows the rows, with the value zero meaning
* any number of rows
* @param cols the columns, with the value zero meaning
* any number of columns
* @param hgap the horizontal gap
* @param vgap the vertical gap
* @exception IllegalArgumentException if the value of both
* <code>rows</code> and <code>cols</code> is
* set to zero
*/
public
GridLayout(int
rows, int
cols, int
hgap, int
vgap) {
if ((
rows == 0) && (
cols == 0)) {
throw new
IllegalArgumentException("rows and cols cannot both be zero");
}
this.
rows =
rows;
this.
cols =
cols;
this.
hgap =
hgap;
this.
vgap =
vgap;
}
/**
* Gets the number of rows in this layout.
* @return the number of rows in this layout
* @since JDK1.1
*/
public int
getRows() {
return
rows;
}
/**
* Sets the number of rows in this layout to the specified value.
* @param rows the number of rows in this layout
* @exception IllegalArgumentException if the value of both
* <code>rows</code> and <code>cols</code> is set to zero
* @since JDK1.1
*/
public void
setRows(int
rows) {
if ((
rows == 0) && (this.
cols == 0)) {
throw new
IllegalArgumentException("rows and cols cannot both be zero");
}
this.
rows =
rows;
}
/**
* Gets the number of columns in this layout.
* @return the number of columns in this layout
* @since JDK1.1
*/
public int
getColumns() {
return
cols;
}
/**
* Sets the number of columns in this layout to the specified value.
* Setting the number of columns has no affect on the layout
* if the number of rows specified by a constructor or by
* the <tt>setRows</tt> method is non-zero. In that case, the number
* of columns displayed in the layout is determined by the total
* number of components and the number of rows specified.
* @param cols the number of columns in this layout
* @exception IllegalArgumentException if the value of both
* <code>rows</code> and <code>cols</code> is set to zero
* @since JDK1.1
*/
public void
setColumns(int
cols) {
if ((
cols == 0) && (this.
rows == 0)) {
throw new
IllegalArgumentException("rows and cols cannot both be zero");
}
this.
cols =
cols;
}
/**
* Gets the horizontal gap between components.
* @return the horizontal gap between components
* @since JDK1.1
*/
public int
getHgap() {
return
hgap;
}
/**
* Sets the horizontal gap between components to the specified value.
* @param hgap the horizontal gap between components
* @since JDK1.1
*/
public void
setHgap(int
hgap) {
this.
hgap =
hgap;
}
/**
* Gets the vertical gap between components.
* @return the vertical gap between components
* @since JDK1.1
*/
public int
getVgap() {
return
vgap;
}
/**
* Sets the vertical gap between components to the specified value.
* @param vgap the vertical gap between components
* @since JDK1.1
*/
public void
setVgap(int
vgap) {
this.
vgap =
vgap;
}
/**
* Adds the specified component with the specified name to the layout.
* @param name the name of the component
* @param comp the component to be added
*/
public void
addLayoutComponent(
String name,
Component comp) {
}
/**
* Removes the specified component from the layout.
* @param comp the component to be removed
*/
public void
removeLayoutComponent(
Component comp) {
}
/**
* Determines the preferred size of the container argument using
* this grid layout.
* <p>
* The preferred width of a grid layout is the largest preferred
* width of all of the components in the container times the number of
* columns, plus the horizontal padding times the number of columns
* minus one, plus the left and right insets of the target container.
* <p>
* The preferred height of a grid layout is the largest preferred
* height of all of the components in the container times the number of
* rows, plus the vertical padding times the number of rows minus one,
* plus the top and bottom insets of the target container.
*
* @param parent the container in which to do the layout
* @return the preferred dimensions to lay out the
* subcomponents of the specified container
* @see java.awt.GridLayout#minimumLayoutSize
* @see java.awt.Container#getPreferredSize()
*/
public
Dimension preferredLayoutSize(
Container parent) {
synchronized (
parent.
getTreeLock()) {
Insets insets =
parent.
getInsets();
int
ncomponents =
parent.
getComponentCount();
int
nrows =
rows;
int
ncols =
cols;
if (
nrows > 0) {
ncols = (
ncomponents +
nrows - 1) /
nrows;
} else {
nrows = (
ncomponents +
ncols - 1) /
ncols;
}
int
w = 0;
int
h = 0;
for (int
i = 0 ;
i <
ncomponents ;
i++) {
Component comp =
parent.
getComponent(
i);
Dimension d =
comp.
getPreferredSize();
if (
w <
d.
width) {
w =
d.
width;
}
if (
h <
d.
height) {
h =
d.
height;
}
}
return new
Dimension(
insets.
left +
insets.
right +
ncols*
w + (
ncols-1)*
hgap,
insets.
top +
insets.
bottom +
nrows*
h + (
nrows-1)*
vgap);
}
}
/**
* Determines the minimum size of the container argument using this
* grid layout.
* <p>
* The minimum width of a grid layout is the largest minimum width
* of all of the components in the container times the number of columns,
* plus the horizontal padding times the number of columns minus one,
* plus the left and right insets of the target container.
* <p>
* The minimum height of a grid layout is the largest minimum height
* of all of the components in the container times the number of rows,
* plus the vertical padding times the number of rows minus one, plus
* the top and bottom insets of the target container.
*
* @param parent the container in which to do the layout
* @return the minimum dimensions needed to lay out the
* subcomponents of the specified container
* @see java.awt.GridLayout#preferredLayoutSize
* @see java.awt.Container#doLayout
*/
public
Dimension minimumLayoutSize(
Container parent) {
synchronized (
parent.
getTreeLock()) {
Insets insets =
parent.
getInsets();
int
ncomponents =
parent.
getComponentCount();
int
nrows =
rows;
int
ncols =
cols;
if (
nrows > 0) {
ncols = (
ncomponents +
nrows - 1) /
nrows;
} else {
nrows = (
ncomponents +
ncols - 1) /
ncols;
}
int
w = 0;
int
h = 0;
for (int
i = 0 ;
i <
ncomponents ;
i++) {
Component comp =
parent.
getComponent(
i);
Dimension d =
comp.
getMinimumSize();
if (
w <
d.
width) {
w =
d.
width;
}
if (
h <
d.
height) {
h =
d.
height;
}
}
return new
Dimension(
insets.
left +
insets.
right +
ncols*
w + (
ncols-1)*
hgap,
insets.
top +
insets.
bottom +
nrows*
h + (
nrows-1)*
vgap);
}
}
/**
* Lays out the specified container using this layout.
* <p>
* This method reshapes the components in the specified target
* container in order to satisfy the constraints of the
* <code>GridLayout</code> object.
* <p>
* The grid layout manager determines the size of individual
* components by dividing the free space in the container into
* equal-sized portions according to the number of rows and columns
* in the layout. The container's free space equals the container's
* size minus any insets and any specified horizontal or vertical
* gap. All components in a grid layout are given the same size.
*
* @param parent the container in which to do the layout
* @see java.awt.Container
* @see java.awt.Container#doLayout
*/
public void
layoutContainer(
Container parent) {
synchronized (
parent.
getTreeLock()) {
Insets insets =
parent.
getInsets();
int
ncomponents =
parent.
getComponentCount();
int
nrows =
rows;
int
ncols =
cols;
boolean
ltr =
parent.
getComponentOrientation().
isLeftToRight();
if (
ncomponents == 0) {
return;
}
if (
nrows > 0) {
ncols = (
ncomponents +
nrows - 1) /
nrows;
} else {
nrows = (
ncomponents +
ncols - 1) /
ncols;
}
// 4370316. To position components in the center we should:
// 1. get an amount of extra space within Container
// 2. incorporate half of that value to the left/top position
// Note that we use trancating division for widthOnComponent
// The reminder goes to extraWidthAvailable
int
totalGapsWidth = (
ncols - 1) *
hgap;
int
widthWOInsets =
parent.
width - (
insets.
left +
insets.
right);
int
widthOnComponent = (
widthWOInsets -
totalGapsWidth) /
ncols;
int
extraWidthAvailable = (
widthWOInsets - (
widthOnComponent *
ncols +
totalGapsWidth)) / 2;
int
totalGapsHeight = (
nrows - 1) *
vgap;
int
heightWOInsets =
parent.
height - (
insets.
top +
insets.
bottom);
int
heightOnComponent = (
heightWOInsets -
totalGapsHeight) /
nrows;
int
extraHeightAvailable = (
heightWOInsets - (
heightOnComponent *
nrows +
totalGapsHeight)) / 2;
if (
ltr) {
for (int
c = 0,
x =
insets.
left +
extraWidthAvailable;
c <
ncols ;
c++,
x +=
widthOnComponent +
hgap) {
for (int
r = 0,
y =
insets.
top +
extraHeightAvailable;
r <
nrows ;
r++,
y +=
heightOnComponent +
vgap) {
int
i =
r *
ncols +
c;
if (
i <
ncomponents) {
parent.
getComponent(
i).
setBounds(
x,
y,
widthOnComponent,
heightOnComponent);
}
}
}
} else {
for (int
c = 0,
x = (
parent.
width -
insets.
right -
widthOnComponent) -
extraWidthAvailable;
c <
ncols ;
c++,
x -=
widthOnComponent +
hgap) {
for (int
r = 0,
y =
insets.
top +
extraHeightAvailable;
r <
nrows ;
r++,
y +=
heightOnComponent +
vgap) {
int
i =
r *
ncols +
c;
if (
i <
ncomponents) {
parent.
getComponent(
i).
setBounds(
x,
y,
widthOnComponent,
heightOnComponent);
}
}
}
}
}
}
/**
* Returns the string representation of this grid layout's values.
* @return a string representation of this grid layout
*/
public
String toString() {
return
getClass().
getName() + "[hgap=" +
hgap + ",vgap=" +
vgap +
",rows=" +
rows + ",cols=" +
cols + "]";
}
}