1: /* GridLayout.java -- Grid-based layout engine 2: Copyright (C) 1999, 2000, 2002, 2004 Free Software Foundation 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package java.awt; 40: 41: import java.io.Serializable; 42: 43: /** This class implements a grid-based layout scheme. Components are 44: * all given the same size and are laid out from left to right and top 45: * to bottom. A GridLayout is configured with a number of rows and a 46: * number of columns. If both are specified, then the number of 47: * columns is ignored and is derived from the number of rows and the 48: * total number of components. If either is zero then that dimension 49: * is computed based on the actual size of the container. An 50: * exception is thrown if an attempt is made to set both the number of 51: * rows and the number of columns to 0. This class also supports 52: * horizontal and vertical gaps; these are used as spacing between 53: * cells. 54: * 55: * @author Tom Tromey (tromey@redhat.com) 56: * @author Aaron M. Renn (arenn@urbanophile.com) 57: */ 58: public class GridLayout implements LayoutManager, Serializable 59: { 60: static final long serialVersionUID = -7411804673224730901L; 61: 62: /** Add a new component to the layout. This particular implementation 63: * does nothing. 64: * @param name The name of the component to add. 65: * @param comp The component to add. 66: */ 67: public void addLayoutComponent (String name, Component comp) 68: { 69: // Nothing. 70: } 71: 72: /** Return the number of columns in this layout. */ 73: public int getColumns () 74: { 75: return cols; 76: } 77: 78: /** Return the horizontal gap. */ 79: public int getHgap () 80: { 81: return hgap; 82: } 83: 84: /** Return the number of rows in this layout. */ 85: public int getRows () 86: { 87: return rows; 88: } 89: 90: /** Return the vertical gap. */ 91: public int getVgap () 92: { 93: return vgap; 94: } 95: 96: /** Create a new <code>GridLayout</code> with one row and any number 97: * of columns. Both gaps are set to 0. 98: */ 99: public GridLayout () 100: { 101: this (1, 0, 0, 0); 102: } 103: 104: /** Create a new <code>GridLayout</code> with the specified number 105: * of rows and columns. Both gaps are set to 0. Note that the row 106: * and column settings cannot both be zero. If both the row and 107: * column values are non-zero, the rows value takes precedence. 108: * @param rows Number of rows 109: * @param cols Number of columns 110: * @exception IllegalArgumentException If rows and columns are both 111: * 0, or if either are negative 112: */ 113: public GridLayout (int rows, int cols) 114: { 115: this (rows, cols, 0, 0); 116: } 117: 118: /** Create a new GridLayout with the specified number of rows and 119: * columns and the specified gaps. 120: * Note that the row and column settings cannot both be 121: * zero. If both the row and column values are non-zero, the rows value 122: * takes precedence. 123: * @param rows Number of rows 124: * @param cols Number of columns 125: * @param hgap The horizontal gap 126: * @param vgap The vertical gap 127: * @exception IllegalArgumentException If rows and columns are both 128: * 0, if either are negative, or if either gap is negative 129: */ 130: public GridLayout (int rows, int cols, int hgap, int vgap) 131: { 132: if (rows < 0) 133: throw new IllegalArgumentException ("number of rows cannot be negative"); 134: if (cols < 0) 135: throw new IllegalArgumentException ("number of columns cannot be negative"); 136: if (rows == 0 && cols == 0) 137: throw new IllegalArgumentException ("both rows and columns cannot be 0"); 138: if (hgap < 0) 139: throw new IllegalArgumentException ("horizontal gap must be nonnegative"); 140: if (vgap < 0) 141: throw new IllegalArgumentException ("vertical gap must be nonnegative"); 142: this.rows = rows; 143: this.cols = cols; 144: this.hgap = hgap; 145: this.vgap = vgap; 146: } 147: 148: /** Lay out the container's components based on current settings. 149: * The free space in the container is divided evenly into the specified 150: * number of rows and columns in this object. 151: * @param parent The container to lay out 152: */ 153: public void layoutContainer (Container parent) 154: { 155: synchronized (parent.getTreeLock ()) 156: { 157: int num = parent.ncomponents; 158: 159: // There's no point, and handling this would mean adding special 160: // cases. 161: if (num == 0) 162: return; 163: 164: // This is more efficient than calling getComponents(). 165: Component[] comps = parent.component; 166: 167: int real_rows = rows; 168: int real_cols = cols; 169: if (real_rows == 0) 170: real_rows = (num + real_cols - 1) / real_cols; 171: else 172: real_cols = (num + real_rows - 1) / real_rows; 173: 174: // We might have less than a single row. In this case we expand 175: // to fill. 176: if (num < real_cols) 177: real_cols = num; 178: 179: Dimension d = parent.getSize (); 180: Insets ins = parent.getInsets (); 181: 182: // Compute width and height of each cell in the grid. 183: int tw = d.width - ins.left - ins.right; 184: tw = (tw - (real_cols - 1) * hgap) / real_cols; 185: int th = d.height - ins.top - ins.bottom; 186: th = (th - (real_rows - 1) * vgap) / real_rows; 187: 188: // If the cells are too small, still try to do something. 189: if (tw < 0) 190: tw = 1; 191: if (th < 0) 192: th = 1; 193: 194: int x = ins.left; 195: int y = ins.top; 196: int i = 0; 197: int recount = 0; 198: 199: while (i < num) 200: { 201: comps[i].setBounds (x, y, tw, th); 202: 203: ++i; 204: ++recount; 205: if (recount == real_cols) 206: { 207: recount = 0; 208: y += vgap + th; 209: x = ins.left; 210: } 211: else 212: x += hgap + tw; 213: } 214: } 215: } 216: 217: /** Get the minimum layout size of the container. 218: * @param cont The parent container 219: */ 220: public Dimension minimumLayoutSize (Container cont) 221: { 222: return getSize (cont, true); 223: } 224: 225: /** Get the preferred layout size of the container. 226: * @param cont The parent container 227: */ 228: public Dimension preferredLayoutSize (Container cont) 229: { 230: return getSize (cont, false); 231: } 232: 233: /** Remove the indicated component from this layout manager. 234: * This particular implementation does nothing. 235: * @param comp The component to remove 236: */ 237: public void removeLayoutComponent (Component comp) 238: { 239: // Nothing. 240: } 241: 242: /** Set the number of columns. 243: * @param newCols 244: * @exception IllegalArgumentException If the number of columns is 245: * negative, or if the number of columns is zero and the number 246: * of rows is already 0. 247: */ 248: public void setColumns (int newCols) 249: { 250: if (newCols < 0) 251: throw new IllegalArgumentException ("number of columns cannot be negative"); 252: if (newCols == 0 && rows == 0) 253: throw new IllegalArgumentException ("number of rows is already 0"); 254: this.cols = newCols; 255: } 256: 257: /** Set the horizontal gap. An Exception is not thrown if hgap < 0. 258: * @param hgap The horizontal gap 259: */ 260: public void setHgap (int hgap) 261: { 262: this.hgap = hgap; 263: } 264: 265: /** Set the number of rows 266: * @param newRows 267: * @exception IllegalArgumentException If the number of rows is 268: * negative, or if the number of rows is zero and the number 269: * of columns is already 0. 270: */ 271: public void setRows (int newRows) 272: { 273: if (newRows < 0) 274: throw new IllegalArgumentException ("number of rows cannot be negative"); 275: if (newRows == 0 && cols == 0) 276: throw new IllegalArgumentException ("number of columns is already 0"); 277: this.rows = newRows; 278: } 279: 280: /** Set the vertical gap. An Exception is not thrown if vgap < 0. 281: * @param vgap The vertical gap 282: */ 283: public void setVgap (int vgap) 284: { 285: this.vgap = vgap; 286: } 287: 288: /** Return String description of this object. */ 289: public String toString () 290: { 291: return (getClass ().getName () + "[" 292: + "hgap=" + hgap + ",vgap=" + vgap 293: + ",rows=" + rows + ",cols=" + cols 294: + "]"); 295: } 296: 297: // This method is used to compute the various sizes. 298: private Dimension getSize (Container parent, boolean is_min) 299: { 300: synchronized (parent.getTreeLock ()) 301: { 302: int w = 0, h = 0, num = parent.ncomponents; 303: // This is more efficient than calling getComponents(). 304: Component[] comps = parent.component; 305: 306: for (int i = 0; i < num; ++i) 307: { 308: Dimension d; 309: 310: if (is_min) 311: d = comps[i].getMinimumSize (); 312: else 313: d = comps[i].getPreferredSize (); 314: 315: w = Math.max (d.width, w); 316: h = Math.max (d.height, h); 317: } 318: 319: int real_rows = rows; 320: int real_cols = cols; 321: if (real_rows == 0) 322: real_rows = (num + real_cols - 1) / real_cols; 323: else 324: real_cols = (num + real_rows - 1) / real_rows; 325: 326: Insets ins = parent.getInsets (); 327: // We subtract out an extra gap here because the gaps are only 328: // between cells. 329: w = ins.left + ins.right + real_cols * (w + hgap) - hgap; 330: h = ins.top + ins.bottom + real_rows * (h + vgap) - vgap; 331: return new Dimension (w, h); 332: } 333: } 334: 335: /** 336: * @serial The number of columns in the grid. 337: */ 338: private int cols; 339: 340: /** 341: * @serial The number of rows in the grid. 342: */ 343: private int rows; 344: 345: /** 346: * @serial The horizontal gap between columns 347: */ 348: private int hgap; 349: 350: /** 351: * @serial The vertical gap between rows 352: */ 353: private int vgap; 354: }