/*
 * 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 + "]";
 }
}