/* * @(#)TableView.java	1.32 03/01/23 * * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package javax.swing.text.html;import java.awt.*;import java.util.BitSet;import java.util.Vector;import javax.swing.SizeRequirements;import javax.swing.event.DocumentEvent;import javax.swing.text.*;/** * HTML table view.   *  * @author  Timothy Prinzing * @version 1.32 01/23/03 * @see     View *//*public*/ class TableView extends BoxView implements ViewFactory {    /**     * Constructs a TableView for the given element.     *     * @param elem the element that this view is responsible for     */    public TableView(Element elem) {	super(elem, View.Y_AXIS);	rows = new Vector();	gridValid = false;	captionIndex = -1;        totalColumnRequirements = new SizeRequirements();    }    /**     * Creates a new table row.     *     * @param elem an element     * @return the row     */    protected RowView createTableRow(Element elem) {	// PENDING(prinz) need to add support for some of the other	// elements, but for now just ignore anything that is not	// a TR.	Object o = elem.getAttributes().getAttribute(StyleConstants.NameAttribute);	if (o == HTML.Tag.TR) {	    return new RowView(elem);	}	return null;    }    /**     * The number of columns in the table.     */    public int getColumnCount() {	return columnSpans.length;    }    /**     * Fetches the span (width) of the given column.       * This is used by the nested cells to query the      * sizes of grid locations outside of themselves.     */    public int getColumnSpan(int col) {	if (col < columnSpans.length) {	    return columnSpans[col];	}	return 0;    }    /**     * The number of rows in the table.     */    public int getRowCount() {	return rows.size();    }    /**     * Fetch the span of multiple rows.  This includes     * the border area.     */    public int getMultiRowSpan(int row0, int row1) {	RowView rv0 = getRow(row0);	RowView rv1 = getRow(row1);	if ((rv0 != null) && (rv1 != null)) {	    int index0 = rv0.viewIndex;	    int index1 = rv1.viewIndex;	    int span = getOffset(Y_AXIS, index1) - getOffset(Y_AXIS, index0) + 		getSpan(Y_AXIS, index1);	    return span;	}	return 0;    }    /**     * Fetches the span (height) of the given row.     */    public int getRowSpan(int row) {	RowView rv = getRow(row);	if (rv != null) {	    return getSpan(Y_AXIS, rv.viewIndex);	}	return 0;    }    RowView getRow(int row) {	if (row < rows.size()) {	    return (RowView) rows.elementAt(row);	}	return null;    }    protected View getViewAtPoint(int x, int y, Rectangle alloc) {	int n = getViewCount();	View v = null;	Rectangle allocation = new Rectangle();	for (int i = 0; i < n; i++) {	    allocation.setBounds(alloc);	    childAllocation(i, allocation);	    v = getView(i);	    if (v instanceof RowView) {		v = ((RowView)v).findViewAtPoint(x, y, allocation);		if (v != null) {		    alloc.setBounds(allocation);		    return v;		}	    }	}        return super.getViewAtPoint(x, y, alloc);    }    /**     * Determines the number of columns occupied by     * the table cell represented by given element.     */    protected int getColumnsOccupied(View v) {	AttributeSet a = v.getElement().getAttributes();        if (a.isDefined(HTML.Attribute.COLSPAN)) {            String s = (String) a.getAttribute(HTML.Attribute.COLSPAN);            if (s != null) {                try {                    return Integer.parseInt(s);                } catch (NumberFormatException nfe) {                    // fall through to one column                }            }        }	return 1;    }    /**     * Determines the number of rows occupied by     * the table cell represented by given element.     */    protected int getRowsOccupied(View v) {	AttributeSet a = v.getElement().getAttributes();        if (a.isDefined(HTML.Attribute.ROWSPAN)) {            String s = (String) a.getAttribute(HTML.Attribute.ROWSPAN);            if (s != null) {                try {                    return Integer.parseInt(s);                } catch (NumberFormatException nfe) {                    // fall through to one row                }            }        }	return 1;    }    protected void invalidateGrid() {	gridValid = false;    }    protected StyleSheet getStyleSheet() {	HTMLDocument doc = (HTMLDocument) getDocument();	return doc.getStyleSheet();    }    /**     * Update the insets, which contain the caption if there     * is a caption.     */    void updateInsets() {	short top = (short) painter.getInset(TOP, this);	short bottom = (short) painter.getInset(BOTTOM, this);	if (captionIndex != -1) {	    View caption = getView(captionIndex);	    short h = (short) caption.getPreferredSpan(Y_AXIS);	    AttributeSet a = caption.getAttributes();	    Object align = a.getAttribute(CSS.Attribute.CAPTION_SIDE);	    if ((align != null) && (align.equals("bottom"))) {		bottom += h;	    } else {		top += h;	    }	}	setInsets(top, (short) painter.getInset(LEFT, this), 		  bottom, (short) painter.getInset(RIGHT, this));    }    /**     * Update any cached values that come from attributes.     */    protected void setPropertiesFromAttributes() {	StyleSheet sheet = getStyleSheet();	attr = sheet.getViewAttributes(this);	painter = sheet.getBoxPainter(attr);	if (attr != null) {	    setInsets((short) painter.getInset(TOP, this), 		      (short) painter.getInset(LEFT, this), 			  (short) painter.getInset(BOTTOM, this), 		      (short) painter.getInset(RIGHT, this));/*	    CSS.LengthValue lv = (CSS.LengthValue) 		attr.getAttribute(CSS.Attribute.BORDER_SPACING);	    if (lv != null) {		cellSpacing = (int) lv.getValue();	    } else {		cellSpacing = 0;	    }	    */	}    }    /**     * Fill in the grid locations that are placeholders     * for multi-column, multi-row, and missing grid     * locations.     */    void updateGrid() {	if (! gridValid) {	    relativeCells = false;	    multiRowCells = false;	    // determine which views are table rows and clear out	    // grid points marked filled.	    captionIndex = -1;	    rows.removeAllElements();	    int n = getViewCount();	    for (int i = 0; i < n; i++) {		View v = getView(i);		if (v instanceof RowView) {		    rows.addElement(v);		    RowView rv = (RowView) v;		    rv.clearFilledColumns();		    rv.rowIndex = rows.size() - 1;		    rv.viewIndex = i;		} else {		    Object o = v.getElement().getAttributes().getAttribute(StyleConstants.NameAttribute);		    if (o instanceof HTML.Tag) {			HTML.Tag kind = (HTML.Tag) o;			if (kind == HTML.Tag.CAPTION) {			    captionIndex = i;			}		    }		}	    }	    int maxColumns = 0;	    int nrows = rows.size();	    for (int row = 0; row < nrows; row++) {		RowView rv = getRow(row);		int col = 0;		for (int cell = 0; cell < rv.getViewCount(); cell++, col++) {		    View cv = rv.getView(cell);		    if (! relativeCells) {			AttributeSet a = cv.getAttributes();			CSS.LengthValue lv = (CSS.LengthValue) 			    a.getAttribute(CSS.Attribute.WIDTH);			if ((lv != null) && (lv.isPercentage())) {			    relativeCells = true;			}		    }		    // advance to a free column		    for (; rv.isFilled(col); col++);		    int rowSpan = getRowsOccupied(cv);		    if (rowSpan > 1) {			multiRowCells = true;		    }		    int colSpan = getColumnsOccupied(cv);		    if ((colSpan > 1) || (rowSpan > 1)) {			// fill in the overflow entries for this cell			int rowLimit = row + rowSpan;			int colLimit = col + colSpan;			for (int i = row; i < rowLimit; i++) {			    for (int j = col; j < colLimit; j++) {				if (i != row || j != col) {				    addFill(i, j);				}			    }			}			if (colSpan > 1) {			    col += colSpan - 1;			}		    }		}		maxColumns = Math.max(maxColumns, col);	    }	    // setup the column layout/requirements	    columnSpans = new int[maxColumns];	    columnOffsets = new int[maxColumns];	    columnRequirements = new SizeRequirements[maxColumns];	    for (int i = 0; i < maxColumns; i++) {		columnRequirements[i] = new SizeRequirements();                columnRequirements[i].maximum = Integer.MAX_VALUE;	    }	    gridValid = true;	}    }    /**     * Mark a grid location as filled in for a cells overflow.     */    void addFill(int row, int col) {	RowView rv = getRow(row);	if (rv != null) {	    rv.fillColumn(col);	}    }    /**     * Layout the columns to fit within the given target span.     *     * @param targetSpan the given span for total of all the table     *  columns     * @param reqs the requirements desired for each column.  This     *  is the column maximum of the cells minimum, preferred, and     *  maximum requested span     * @param spans the return value of how much to allocated to     *  each column     * @param offsets the return value of the offset from the     *  origin for each column     * @return the offset from the origin and the span for each column      *  in the offsets and spans parameters     */    protected void layoutColumns(int targetSpan, int[] offsets, int[] spans, 				 SizeRequirements[] reqs) {	colIterator.setLayoutArrays(offsets, spans, targetSpan);	CSS.calculateTiledLayout(colIterator, targetSpan);    }    /**     * Calculate the requirements for each column.  The calculation     * is done as two passes over the table.  The table cells that     * occupy a single column are scanned first to determine the     * maximum of minimum, preferred, and maximum spans along the     * give axis.  Table cells that span multiple columns are excluded     * from the first pass.  A second pass is made to determine if     * the cells that span multiple columns are satisfied.  If the     * column requirements are not satisified, the needs of the      * multi-column cell is mixed into the existing column requirements.     * The calculation of the multi-column distribution is based upon     * the proportions of the existing column requirements and taking     * into consideration any constraining maximums.     */    void calculateColumnRequirements(int axis) {	// pass 1 - single column cells	boolean hasMultiColumn = false;	int nrows = getRowCount();	for (int i = 0; i < nrows; i++) {	    RowView row = getRow(i);	    int col = 0;	    int ncells = row.getViewCount();	    for (int cell = 0; cell < ncells; cell++, col++) {		View cv = row.getView(cell);		for (; row.isFilled(col); col++); // advance to a free column		int rowSpan = getRowsOccupied(cv);		int colSpan = getColumnsOccupied(cv);		if (colSpan == 1) {		    checkSingleColumnCell(axis, col, cv);		} else {		    hasMultiColumn = true;		    col += colSpan - 1;		}	    }	}	// pass 2 - multi-column cells	if (hasMultiColumn) {	    for (int i = 0; i < nrows; i++) {		RowView row = getRow(i);		int col = 0;		int ncells = row.getViewCount();		for (int cell = 0; cell < ncells; cell++, col++) {		    View cv = row.getView(cell);		    for (; row.isFilled(col); col++); // advance to a free column		    int colSpan = getColumnsOccupied(cv);		    if (colSpan > 1) {			checkMultiColumnCell(axis, col, colSpan, cv);			col += colSpan - 1;		    }		}	    }	}    }    /**     * check the requirements of a table cell that spans a single column.     */    void checkSingleColumnCell(int axis, int col, View v) {	SizeRequirements req = columnRequirements[col];	req.minimum = Math.max((int) v.getMinimumSpan(axis), req.minimum);	req.preferred = Math.max((int) v.getPreferredSpan(axis), req.preferred);    }    /**     * check the requirements of a table cell that spans multiple     * columns.     */    void checkMultiColumnCell(int axis, int col, int ncols, View v) {	// calculate the totals	long min = 0;	long pref = 0;	long max = 0;	for (int i = 0; i < ncols; i++) {	    SizeRequirements req = columnRequirements[col + i];	    min += req.minimum;	    pref += req.preferred;	    max += req.maximum;	}	// check if the minimum size needs adjustment.