home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 May / PCW596.iso / wtest / clico / sunsoft / java / solaris.lzh / SOLARIS.TAZ / SOLARIS / hotjava / classsrc / awt / RowColLayout.java < prev    next >
Encoding:
Java Source  |  1995-05-15  |  5.6 KB  |  201 lines
  1. /*
  2.  * @(#)RowColLayout.java    1.18 95/02/17 Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19. package awt;
  20.  
  21. /**
  22.  * RowColLayout arranges components in rows and columns.
  23.  * @version 1.18 17 Feb 1995
  24.  * @author Arthur van Hoff, Sami Shaio
  25.  */
  26.  
  27. public class RowColLayout extends GapsLayout {
  28.     int rows;
  29.     int cols;
  30.     boolean isPacked;
  31.     public static RowColLayout oneColumn;
  32.     public static RowColLayout splitVert;
  33.     public static RowColLayout splitHorz;
  34.  
  35.     static {
  36.     oneColumn = new RowColLayout(0, 1);
  37.     splitVert = new RowColLayout(1, 2);
  38.     splitHorz = new RowColLayout(2, 1);
  39.     }
  40.  
  41.     /**
  42.      * Constructor, rows can be 0, meaning any
  43.      * number of rows.
  44.      */
  45.     public RowColLayout(int pRows, int pCols) {
  46.     rows = pRows;
  47.     cols = pCols;
  48.     setGaps(4,4,4,4);
  49.     isPacked = false;
  50.     }
  51.     
  52.     /**
  53.      * Constructor, rows can be 0, meaning any number of rows. If
  54.      * packed is true then columns will vary in width according to the
  55.      * widest member in each column.
  56.      * @param pRows the number of rows, can be 0 for an arbitrary number.
  57.      * @param pCols the number of columns.
  58.      * @param packed if true then each column will have the width of
  59.      * its widest member rather than the width of the widest member for
  60.      * all the columns.
  61.      */
  62.     public RowColLayout(int pRows, int pCols, boolean packed) {
  63.     this(pRows, pCols);
  64.     isPacked = packed;
  65.     }
  66.  
  67.     /**
  68.      * Preferred Dimension
  69.      */
  70.     public Dimension getPreferredSize(Container pTarget) {
  71.     Dimension dim = new Dimension(0, 0);
  72.     int maxrow = 0;
  73.     int row = 0;
  74.     int rowh = 0;
  75.     int n;
  76.     int nmembers = pTarget.nChildren();
  77.     Layoutable m;
  78.  
  79.     //System.out.println("RowColLayout(" + cols + ")");
  80.     for (n = 0 ; n < nmembers; n++) {
  81.         if ((n % cols) == 0) {
  82.         // starting a new row
  83.         if (row > maxrow) {
  84.             maxrow = row;
  85.         }
  86.         rowh += dim.height;
  87.         row = 0;
  88.         }
  89.         
  90.         m = pTarget.getChild(n);
  91.         Dimension d = m.getPreferredSize();
  92.         //System.out.println("Component " + n + ": " + d.width + ", " +
  93.         //d.height); 
  94.         row += d.width + ((Component)m).marginWidth;
  95.         dim.height = max(dim.height,
  96.                  d.height + ((Component)m).marginHeight);
  97.     }
  98.     
  99.     dim.width = maxrow;
  100.     dim.height += rowh;
  101.     if (rows == 0) {
  102.         int r = (nmembers + cols - 1) / cols;
  103.  
  104.         dim.width += (cols - 1) * (gaps[EAST] + gaps[WEST]);
  105.         dim.height += (r - 1) * (gaps[NORTH] + gaps[SOUTH]);
  106.     } else {
  107.         dim.width += (cols - 1) * (gaps[EAST] + gaps[WEST]);
  108.         dim.height += (rows - 1) * (gaps[NORTH] + gaps[SOUTH]);
  109.     }
  110.  
  111.     int insets[] = getInsets(pTarget);
  112.     dim.width += insets[EAST] + insets[WEST];
  113.     dim.height += insets[NORTH] + insets[SOUTH];
  114.     //System.out.println("RowColLayout.getPreferredSize= " + dim.width
  115.     //+ ", " + dim.height);
  116.     return dim;
  117.     }
  118.  
  119.     /**
  120.      * Layout the container
  121.      */
  122.     public void layout(Container pTarget) {
  123.     int insets[] = getInsets(pTarget);
  124.     int r, c, w, h, n, x, y;
  125.     int nmembers = pTarget.nChildren();
  126.     int colWidths[] = new int[cols];
  127.  
  128.     //System.out.println("RowColLayout.layout");
  129.     if (isPacked) {
  130.         // figure out width for each column
  131.         for (c=0; c < cols; c++) {
  132.         colWidths[c] = 0;
  133.         }
  134.         for (r = n = 0; n < nmembers ; r++) {
  135.         for (c = 0 ; (n < nmembers) && (c < cols) ; c++, n++) {
  136.             Layoutable m = pTarget.getChild(n);
  137.             Dimension d = m.getPreferredSize();
  138.  
  139.             colWidths[c] = max(colWidths[c], d.width);
  140.         }
  141.         }
  142.     }
  143.     if (rows == 0) {
  144.         if (!isPacked) {
  145.         w = pTarget.width;
  146.         w -= insets[WEST] + insets[EAST];
  147.         w -= (cols - 1) * (gaps[WEST] + gaps[EAST]);
  148.         w /= cols;
  149.         for (c=0; c < cols; c++) {
  150.             colWidths[c] = w;
  151.         }
  152.         } else {
  153.         // add any slack to the last column
  154.         w = 0;
  155.         for (c=0; c < (cols - 1); c++) {
  156.             w += colWidths[c];
  157.         }
  158.         colWidths[cols - 1] = pTarget.width - w - insets[WEST]
  159.             - insets[EAST] - gaps[WEST] - gaps[EAST];
  160.         }
  161.         for (r = n = 0, y = insets[NORTH] ; n < nmembers ; r++) {
  162.         h = 0;
  163.         x = insets[WEST];
  164.         for (c = 0 ; (n < nmembers) && (c < cols) ; c++, n++) {
  165.             Layoutable m = pTarget.getChild(n);
  166.             Dimension d = m.getPreferredSize();
  167.             Component comp = (Component)m;
  168.             int mw, mh;
  169.  
  170.             mw = comp.marginWidth;
  171.             mh = comp.marginHeight;
  172.             h = max(h, d.height + mh);
  173.             m.reshape(x, y, colWidths[c], d.height);
  174.             x += colWidths[c] + gaps[WEST] + gaps[EAST];
  175.         }
  176.         y += h + gaps[NORTH] + gaps[SOUTH];
  177.         }
  178.     } else {
  179.         w = pTarget.width;
  180.         w -= insets[WEST] + insets[EAST];
  181.         w -= (cols - 1) * (gaps[WEST] + gaps[EAST]);
  182.         w /= cols;
  183.         h = pTarget.height;
  184.         h -= insets[NORTH] + insets[SOUTH];
  185.         h -= (rows - 1) * (gaps[NORTH] + gaps[SOUTH]);
  186.         h /= rows;
  187.         for (r = n = 0, y = insets[NORTH] ; n < nmembers ; r++) {
  188.         x = insets[WEST];
  189.         for (c = 0 ; (n < nmembers) && (c < cols) ; c++, n++) {
  190.             Layoutable m = pTarget.getChild(n);
  191.             m.reshape(x, y, w, h);
  192.             x += w + gaps[WEST] + gaps[EAST];
  193.         }
  194.         y += h + gaps[NORTH] + gaps[SOUTH];
  195.         }
  196.     }
  197.     }
  198. }
  199.  
  200.  
  201.