implements LayoutManager2 : LayoutManager2 « java.awt « Java by API






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.Component;
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(&quot;1&quot;), new Rectangle(0, 0, 1, 1));
 *     // Add a 2x1 Rect at (2,0)
 *     add(new Button(&quot;2&quot;), new Rectangle(2, 0, 2, 1));
 *     // Add a 1x2 Rect at (1,1)
 *     add(new Button(&quot;3&quot;), new Rectangle(1, 1, 1, 2));
 *     // Add a 2x2 Rect at (3,2)
 *     add(new Button(&quot;4&quot;), new Rectangle(3, 2, 2, 2));
 *     // Add a 1x1 Rect at (0,4)
 *     add(new Button(&quot;5&quot;), new Rectangle(0, 4, 1, 1));
 *     // Add a 1x2 Rect at (2,3)
 *     add(new Button(&quot;6&quot;), 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.Component#getMinimumSize()
   * @see java.awt.Component#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);

  }

}

   
  








Related examples in the same category