Java by API/java.awt/LayoutManager2
implements LayoutManager2
/*
*
* Copyright (c) 1998 Sun Microsystems, Inc. All Rights Reserved.
*
* Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
* modify and redistribute this software in source and binary code form,
* provided that i) this copyright notice and license appear on all copies of
* the software; and ii) Licensee does not utilize the software in a manner
* which is disparaging to Sun.
*
* This software is provided "AS IS," without a warranty of any kind. ALL
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
* IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
* LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
* OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
* LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
* INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
* CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
* OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*
* This software is not designed or intended for use in on-line control of
* aircraft, air traffic, aircraft navigation or aircraft communications; or in
* the design, construction, operation or maintenance of any nuclear
* facility. Licensee represents and warrants that it will not use or
* redistribute the Software for such purposes.
*/
import java.awt.Button;
import java.awt.ruponent;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.awt.LayoutManager2;
import java.awt.Rectangle;
import java.util.Hashtable;
import javax.swing.JFrame;
/**
* The <code>GraphPaperLayout</code> class is a layout manager that lays out a
* container"s components in a rectangular grid, similar to GridLayout. Unlike
* GridLayout, however, components can take up multiple rows and/or columns. The
* layout manager acts as a sheet of graph paper. When a component is added to
* the layout manager, the location and relative size of the component are
* simply supplied by the constraints as a Rectangle.
* <P>
* <code><pre>
* import java.awt.*;
* import java.applet.Applet;
*
* public class ButtonGrid extends Applet {
* public void init() {
* setLayout(new GraphPaperLayout(new Dimension(5, 5)));
* // Add a 1x1 Rect at (0,0)
* add(new Button("1"), new Rectangle(0, 0, 1, 1));
* // Add a 2x1 Rect at (2,0)
* add(new Button("2"), new Rectangle(2, 0, 2, 1));
* // Add a 1x2 Rect at (1,1)
* add(new Button("3"), new Rectangle(1, 1, 1, 2));
* // Add a 2x2 Rect at (3,2)
* add(new Button("4"), new Rectangle(3, 2, 2, 2));
* // Add a 1x1 Rect at (0,4)
* add(new Button("5"), new Rectangle(0, 4, 1, 1));
* // Add a 1x2 Rect at (2,3)
* add(new Button("6"), new Rectangle(2, 3, 1, 2));
* }
* }
* </pre></code>
*
* @author Michael Martak
*/
class GraphPaperLayout implements LayoutManager2 {
int hgap; // horizontal gap
int vgap; // vertical gap
Dimension gridSize; // grid size in logical units (n x m)
Hashtable<Component, Rectangle> compTable; // constraints (Rectangles)
/**
* Creates a graph paper layout with a default of a 1 x 1 graph, with no
* vertical or horizontal padding.
*/
public GraphPaperLayout() {
this(new Dimension(1, 1));
}
/**
* Creates a graph paper layout with the given grid size, with no vertical or
* horizontal padding.
*/
public GraphPaperLayout(Dimension gridSize) {
this(gridSize, 0, 0);
}
/**
* Creates a graph paper layout with the given grid size and padding.
*
* @param gridSize
* size of the graph paper in logical units (n x m)
* @param hgap
* horizontal padding
* @param vgap
* vertical padding
*/
public GraphPaperLayout(Dimension gridSize, int hgap, int vgap) {
if ((gridSize.width <= 0) || (gridSize.height <= 0)) {
throw new IllegalArgumentException("dimensions must be greater than zero");
}
this.gridSize = new Dimension(gridSize);
this.hgap = hgap;
this.vgap = vgap;
compTable = new Hashtable<Component, Rectangle>();
}
/**
* @return the size of the graph paper in logical units (n x m)
*/
public Dimension getGridSize() {
return new Dimension(gridSize);
}
/**
* Set the size of the graph paper in logical units (n x m)
*/
public void setGridSize(Dimension d) {
setGridSize(d.width, d.height);
}
/**
* Set the size of the graph paper in logical units (n x m)
*/
public void setGridSize(int width, int height) {
gridSize = new Dimension(width, height);
}
public void setConstraints(Component comp, Rectangle constraints) {
compTable.put(comp, new Rectangle(constraints));
}
/**
* Adds the specified component with the specified name to the layout. This
* does nothing in GraphPaperLayout, since constraints are required.
*/
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) {
compTable.remove(comp);
}
/**
* Calculates the preferred size dimensions for the specified panel given the
* components in the specified parent container.
*
* @param parent
* the component to be laid out
*
* @see #minimumLayoutSize
*/
public Dimension preferredLayoutSize(Container parent) {
return getLayoutSize(parent, true);
}
/**
* Calculates the minimum size dimensions for the specified panel given the
* components in the specified parent container.
*
* @param parent
* the component to be laid out
* @see #preferredLayoutSize
*/
public Dimension minimumLayoutSize(Container parent) {
return getLayoutSize(parent, false);
}
/**
* Algorithm for calculating layout size (minimum or preferred).
* <P>
* The width of a graph paper layout is the largest cell width (calculated in
* <code>getLargestCellSize()</code> times the number of columns, plus the
* horizontal padding times the number of columns plus one, plus the left and
* right insets of the target container.
* <P>
* The height of a graph paper layout is the largest cell height (calculated
* in <code>getLargestCellSize()</code> times the number of rows, plus the
* vertical padding times the number of rows plus one, plus the top and bottom
* insets of the target container.
*
* @param parent
* the container in which to do the layout.
* @param isPreferred
* true for calculating preferred size, false for calculating minimum
* size.
* @return the dimensions to lay out the subcomponents of the specified
* container.
* @see java.awt.GraphPaperLayout#getLargestCellSize
*/
protected Dimension getLayoutSize(Container parent, boolean isPreferred) {
Dimension largestSize = getLargestCellSize(parent, isPreferred);
Insets insets = parent.getInsets();
largestSize.width = (largestSize.width * gridSize.width) + (hgap * (gridSize.width + 1))
+ insets.left + insets.right;
largestSize.height = (largestSize.height * gridSize.height) + (vgap * (gridSize.height + 1))
+ insets.top + insets.bottom;
return largestSize;
}
/**
* Algorithm for calculating the largest minimum or preferred cell size.
* <P>
* Largest cell size is calculated by getting the applicable size of each
* component and keeping the maximum value, dividing the component"s width by
* the number of columns it is specified to occupy and dividing the
* component"s height by the number of rows it is specified to occupy.
*
* @param parent
* the container in which to do the layout.
* @param isPreferred
* true for calculating preferred size, false for calculating minimum
* size.
* @return the largest cell size required.
*/
protected Dimension getLargestCellSize(Container parent, boolean isPreferred) {
int ncomponents = parent.getComponentCount();
Dimension maxCellSize = new Dimension(0, 0);
for (int i = 0; i < ncomponents; i++) {
Component c = parent.getComponent(i);
Rectangle rect = compTable.get(c);
if (c != null && rect != null) {
Dimension componentSize;
if (isPreferred) {
componentSize = c.getPreferredSize();
} else {
componentSize = c.getMinimumSize();
}
// Note: rect dimensions are already asserted to be > 0 when the
// component is added with constraints
maxCellSize.width = Math.max(maxCellSize.width, componentSize.width / rect.width);
maxCellSize.height = Math.max(maxCellSize.height, componentSize.height / rect.height);
}
}
return maxCellSize;
}
/**
* Lays out the container in the specified container.
*
* @param parent
* the component which needs to be laid out
*/
public void layoutContainer(Container parent) {
synchronized (parent.getTreeLock()) {
Insets insets = parent.getInsets();
int ncomponents = parent.getComponentCount();
if (ncomponents == 0) {
return;
}
// Total parent dimensions
Dimension size = parent.getSize();
int totalW = size.width - (insets.left + insets.right);
int totalH = size.height - (insets.top + insets.bottom);
// Cell dimensions, including padding
int totalCellW = totalW / gridSize.width;
int totalCellH = totalH / gridSize.height;
// Cell dimensions, without padding
int cellW = (totalW - ((gridSize.width + 1) * hgap)) / gridSize.width;
int cellH = (totalH - ((gridSize.height + 1) * vgap)) / gridSize.height;
for (int i = 0; i < ncomponents; i++) {
Component c = parent.getComponent(i);
Rectangle rect = compTable.get(c);
if (rect != null) {
int x = insets.left + (totalCellW * rect.x) + hgap;
int y = insets.top + (totalCellH * rect.y) + vgap;
int w = (cellW * rect.width) - hgap;
int h = (cellH * rect.height) - vgap;
c.setBounds(x, y, w, h);
}
}
}
}
// LayoutManager2 /////////////////////////////////////////////////////////
/**
* Adds the specified component to the layout, using the specified constraint
* object.
*
* @param comp
* the component to be added
* @param constraints
* where/how the component is added to the layout.
*/
public void addLayoutComponent(Component comp, Object constraints) {
if (constraints instanceof Rectangle) {
Rectangle rect = (Rectangle) constraints;
if (rect.width <= 0 || rect.height <= 0) {
throw new IllegalArgumentException(
"cannot add to layout: rectangle must have positive width and height");
}
if (rect.x < 0 || rect.y < 0) {
throw new IllegalArgumentException("cannot add to layout: rectangle x and y must be >= 0");
}
setConstraints(comp, rect);
} else if (constraints != null) {
throw new IllegalArgumentException("cannot add to layout: constraint must be a Rectangle");
}
}
/**
* Returns the maximum size of this component.
*
* @see java.awt.ruponent#getMinimumSize()
* @see java.awt.ruponent#getPreferredSize()
* @see LayoutManager
*/
public Dimension maximumLayoutSize(Container target) {
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
}
/**
* Returns the alignment along the x axis. This specifies how the component
* would like to be aligned relative to other components. The value should be
* a number between 0 and 1 where 0 represents alignment along the origin, 1
* is aligned the furthest away from the origin, 0.5 is centered, etc.
*/
public float getLayoutAlignmentX(Container target) {
return 0.5f;
}
/**
* Returns the alignment along the y axis. This specifies how the component
* would like to be aligned relative to other components. The value should be
* a number between 0 and 1 where 0 represents alignment along the origin, 1
* is aligned the furthest away from the origin, 0.5 is centered, etc.
*/
public float getLayoutAlignmentY(Container target) {
return 0.5f;
}
/**
* Invalidates the layout, indicating that if the layout manager has cached
* information it should be discarded.
*/
public void invalidateLayout(Container target) {
// Do nothing
}
}
public class DemoGraphPaperLayout {
public static void main(String[] a) {
JFrame frame = new JFrame();
frame.setLayout(new GraphPaperLayout(new Dimension(5, 5)));
// Add a 1x1 Rect at (0,0)
frame.add(new Button("1"), new Rectangle(0, 0, 1, 1));
// Add a 2x1 Rect at (2,0)
frame.add(new Button("2"), new Rectangle(2, 0, 2, 1));
// Add a 1x2 Rect at (1,1)
frame.add(new Button("3"), new Rectangle(1, 1, 1, 2));
// Add a 2x2 Rect at (3,2)
frame.add(new Button("4"), new Rectangle(3, 2, 2, 2));
// Add a 1x1 Rect at (0,4)
frame.add(new Button("5"), new Rectangle(0, 4, 1, 1));
// Add a 1x2 Rect at (2,3)
frame.add(new Button("6"), new Rectangle(2, 3, 1, 2));
frame.pack();
frame.setVisible(true);
}
}
