gridsnaplayout.java

深入java虚拟机（第二版）光盘所有源码

/*
* Copyright (c) 1996-1999 Bill Venners. All Rights Reserved.
*
* This Java source file is part of the Interactive Illustrations Web
* Site, which is delivered in the applets directory of the CD-ROM
* that accompanies the book "Inside the Java 2 Virtual Machine" by Bill
* Venners, published by McGraw-Hill, 1999, ISBN: 0-07-135093-4. This
* source file is provided for evaluation purposes only, but you can
* redistribute it under certain conditions, described in the full
* copyright notice below.
*
* Full Copyright Notice:
*
* All the web pages and Java applets delivered in the applets
* directory of the CD-ROM, consisting of ".html," ".gif," ".class,"
* and ".java" files, are copyrighted (c) 1996-1999 by Bill
* Venners, and all rights are reserved.  This material may be copied
* and placed on any commercial or non-commercial web server on any
* network (including the internet) provided that the following
* guidelines are followed:
*
* a. All the web pages and Java Applets (".html," ".gif," ".class,"
* and ".java" files), including the source code, that are delivered
* in the applets directory of the CD-ROM that
* accompanies the book must be published together on the same web
* site.
*
* b. All the web pages and Java Applets (".html," ".gif," ".class,"
* and ".java" files) must be published "as is" and may not be altered
* in any way.
*
* c. All use and access to this web site must be free, and no fees
* can be charged to view these materials, unless express written
* permission is obtained from Bill Venners.
*
* d. The web pages and Java Applets may not be distributed on any
* media, other than a web server on a network, and may not accompany
* any book or publication.
*
* BILL VENNERS MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
* SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING
* BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR PARTICULAR PURPOSE, OR NON-INFRINGEMENT.  BILL VENNERS
* SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY A LICENSEE AS A
* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES.
*/
package COM.artima.jvmsim;
import java.awt.*;

/**
* GridSnapLayout lays out components in a grid that can have columns of
* varying width. This is not a very general purpose layout manager. It
* solves the specific problem of getting all the information I want to display about
* the stack and method areas in a nice grid. Because some columns of info need
* more room than others, and space is limited on a web page, I needed to be
* able to specify varying widths of columns in a grid.
*
* @author  Bill Venners
*/
class GridSnapLayout implements LayoutManager {

    // rows and cols are the number of rows and columns of the grid upon
    // which the components are placed. Components are always one row
    // in height, but may be more than one column in width. The number
    // of columns width of each component is stored in hComponentCellWidths.
    // The array length of hComponentCellWidths indicates the number of
    // components that will appear on each row.
    private int rows;
    private int cols;
    private int[] hComponentCellWidths;

    public GridSnapLayout(int rows, int cols, int[] hComponentCellWidths) {

    	this.rows = rows;
    	this.cols = cols;
    	this.hComponentCellWidths = hComponentCellWidths;
    }

    public void addLayoutComponent(String name, Component comp) {
    }

    public void removeLayoutComponent(Component comp) {
    }

    // Calculate preferred size as if each component were taking an equal
    // share of the width of a row.
    public Dimension preferredLayoutSize(Container parent) {

    	int rowCount = rows;
    	int colCount = cols;
    	Insets parentInsets = parent.insets();
    	int componentCount = parent.countComponents();

    	if (rowCount > 0) {
    	    colCount = (componentCount + rowCount - 1) / rowCount;
    	} else {
    	    rowCount = (componentCount + colCount - 1) / colCount;
    	}

        // Find the maximum preferred width and the maximum preferred height
        // of any component.
    	int w = 0;
    	int h = 0;
    	for (int i = 0; i < componentCount; i++) {

    	    Component comp = parent.getComponent(i);
    	    Dimension d = comp.preferredSize();
    	    if (w < d.width) {
    		    w = d.width;
    	    }
    	    if (h < d.height) {
    		    h = d.height;
    	    }
    	}

    	// Return the maximum preferred component width and height times the number
    	// of columns and rows, respectively, plus any insets in the parent.
    	return new Dimension(parentInsets.left + parentInsets.right + colCount*w,
    	    parentInsets.top + parentInsets.bottom + rowCount*h);
    }

    // Calculate minimum size as if each component were taking an equal
    // share of the width of a row.
    public Dimension minimumLayoutSize(Container parent) {

    	Insets parentInsets = parent.insets();
    	int componentCount = parent.countComponents();
    	int rowCount = rows;
    	int colCount = cols;

    	if (rowCount > 0) {
    	    colCount = (componentCount + rowCount - 1) / rowCount;
    	} else {
    	    rowCount = (componentCount + colCount - 1) / colCount;
    	}

        // Find the maximum "minimum width" and the maximum "minimum height"
        // of any component.
    	int w = 0;
    	int h = 0;
    	for (int i = 0; i < componentCount; i++) {

    	    Component comp = parent.getComponent(i);
    	    Dimension d = comp.minimumSize();
    	    if (w < d.width) {
    		    w = d.width;
    	    }
    	    if (h < d.height) {
    		    h = d.height;
    	    }
    	}

    	// Return the maximum "minimum component width and height" times the number
    	// of columns and rows, respectively, plus any insets in the parent.
    	return new Dimension(parentInsets.left + parentInsets.right + colCount*w,
    	    parentInsets.top + parentInsets.bottom + rowCount*h);
    }

    // Layout the container such that the widths of columns correspond
    // to the number of columns in that components hComponentCellWidth
    // array element. For example, if the
    public void layoutContainer(Container parent) {

    	int rowCount = rows;
    	int colCount = hComponentCellWidths.length;
    	Insets parentInsets = parent.insets();
    	int componentCount = parent.countComponents();

    	if (componentCount == 0) {
    	    return;
    	}

        // Calculate the width and height of each grid cell. The height will
        // be the height of each component, but the width may not. The width
        // of a component will be some multiple of a grid cell width. The
        // number of grid cells for each component is defined by the
        // hComponentCellWidths array. w is width of each grid cell. h is
        // height of each grid cell.
    	Dimension parentDim = parent.size();
    	int w = parentDim.width - (parentInsets.left + parentInsets.right);
    	int h = parentDim.height - (parentInsets.top + parentInsets.bottom);
    	w /= cols;
    	h /= rowCount;

        // For each row and column of components (not grid cells) position
        // the component.
    	for (int c = 0, x = parentInsets.left ; c < colCount ; c++) {
    	    for (int r = 0, y = parentInsets.top ; r < rowCount ; r++) {

        		int i = r * colCount + c;
        		if (i < componentCount) {
        		    parent.getComponent(i).reshape(x, y, w * hComponentCellWidths[c], h);
        		}
        		y += h;
    	    }
    	    x += (w * hComponentCellWidths[c]);
    	}
    }
}