tableview.java

JAVA 所有包

    public void replace(int offset, int length, View[] views) {
	super.replace(offset, length, views);
	invalidateGrid();
    }

    // --- ViewFactory methods ------------------------------------------

    /**
     * The table itself acts as a factory for the various 
     * views that actually represent pieces of the table.
     * All other factory activity is delegated to the factory
     * returned by the parent of the table.
     */
    public View create(Element elem) {
	Object o = elem.getAttributes().getAttribute(StyleConstants.NameAttribute);
	if (o instanceof HTML.Tag) {
	    HTML.Tag kind = (HTML.Tag) o;
	    if (kind == HTML.Tag.TR) {
		return createTableRow(elem);
	    } else if ((kind == HTML.Tag.TD) || (kind == HTML.Tag.TH)) {
		return new CellView(elem);
	    } else if (kind == HTML.Tag.CAPTION) {
		return new javax.swing.text.html.ParagraphView(elem);
	    }
	}
	// default is to delegate to the normal factory
	View p = getParent();
	if (p != null) {
	    ViewFactory f = p.getViewFactory();
	    if (f != null) {
		return f.create(elem);
	    }
	}
	return null;
    }
	
    // ---- variables ----------------------------------------------------

    private AttributeSet attr;
    private StyleSheet.BoxPainter painter;

    private int cellSpacing;
    private int borderWidth;

    /**
     * The index of the caption view if there is a caption.
     * This has a value of -1 if there is no caption.  The
     * caption lives in the inset area of the table, and is
     * updated with each time the grid is recalculated.
     */
    private int captionIndex;

    /**
     * Do any of the table cells contain a relative size
     * specification?  This is updated with each call to
     * updateGrid().  If this is true, the ColumnIterator
     * will do extra work to calculate relative cell 
     * specifications.
     */
    private boolean relativeCells;

    /**
     * Do any of the table cells span multiple rows?  If
     * true, the RowRequirementIterator will do additional
     * work to adjust the requirements of rows spanned by
     * a single table cell.  This is updated with each call to
     * updateGrid().
     */
    private boolean multiRowCells;

    int[] columnSpans;
    int[] columnOffsets;
    /**
     * SizeRequirements for all the columns.
     */
    SizeRequirements totalColumnRequirements;
    SizeRequirements[] columnRequirements;

    RowIterator rowIterator = new RowIterator();
    ColumnIterator colIterator = new ColumnIterator();

    Vector rows;

    // whether to display comments inside table or not.
    boolean skipComments = false;

    boolean gridValid;
    static final private BitSet EMPTY = new BitSet();

    class ColumnIterator implements CSS.LayoutIterator {

	/**
	 * Disable percentage adjustments which should only apply
	 * when calculating layout, not requirements.
	 */
	void disablePercentages() {
	    percentages = null;
	}

	/**
	 * Update percentage adjustments if they are needed.
	 */
	private void updatePercentagesAndAdjustmentWeights(int span) {
	    adjustmentWeights = new int[columnRequirements.length];
	    for (int i = 0; i < columnRequirements.length; i++) {
		adjustmentWeights[i] = 0;
	    }
	    if (relativeCells) {
		percentages = new int[columnRequirements.length];
	    } else {
		percentages = null;
	    }
	    int nrows = getRowCount();
	    for (int rowIndex = 0; rowIndex < nrows; rowIndex++) {
		RowView row = getRow(rowIndex);
		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);
		    AttributeSet a = cv.getAttributes();
		    CSS.LengthValue lv = (CSS.LengthValue) 
			a.getAttribute(CSS.Attribute.WIDTH);
		    if ( lv != null ) {
			int len = (int) (lv.getValue(span) / colSpan + 0.5f);
			for (int i = 0; i < colSpan; i++) {
			    if (lv.isPercentage()) {
				// add a percentage requirement
				percentages[col+i] = Math.max(percentages[col+i], len);
                                adjustmentWeights[col + i] = Math.max(adjustmentWeights[col + i], WorstAdjustmentWeight);
			    } else {
                                adjustmentWeights[col + i] = Math.max(adjustmentWeights[col + i], WorstAdjustmentWeight - 1);
			    }
			}
		    }
		    col += colSpan - 1;
		}
	    }
	} 

	/**
	 * Set the layout arrays to use for holding layout results
	 */
	public void setLayoutArrays(int offsets[], int spans[], int targetSpan) {
	    this.offsets = offsets;
	    this.spans = spans;
	    updatePercentagesAndAdjustmentWeights(targetSpan);
	}

	// --- RequirementIterator methods -------------------

	public int getCount() {
	    return columnRequirements.length;
	}

	public void setIndex(int i) {
	    col = i;
	}

	public void setOffset(int offs) {
	    offsets[col] = offs;
	}

	public int getOffset() {
	    return offsets[col];
	}

	public void setSpan(int span) {
	    spans[col] = span;
	}

	public int getSpan() {
	    return spans[col];
	}

	public float getMinimumSpan(float parentSpan) {
	    // do not care for percentages, since min span can't 
            // be less than columnRequirements[col].minimum,
	    // but can be less than percentage value.
	    return columnRequirements[col].minimum;
	}

	public float getPreferredSpan(float parentSpan) {
	    if ((percentages != null) && (percentages[col] != 0)) {
                return Math.max(percentages[col], columnRequirements[col].minimum);
	    }
	    return columnRequirements[col].preferred;
	}

	public float getMaximumSpan(float parentSpan) {
	    return columnRequirements[col].maximum;
	}

	public float getBorderWidth() {
	    return borderWidth;        
	}                              


	public float getLeadingCollapseSpan() {
	    return cellSpacing;
	}

	public float getTrailingCollapseSpan() {
	    return cellSpacing;
	}

	public int getAdjustmentWeight() {
	    return adjustmentWeights[col];
	}

	/**
	 * Current column index
	 */
	private int col;

	/**
	 * percentage values (may be null since there
	 * might not be any).
	 */
	private int[] percentages;

	private int[] adjustmentWeights;

	private int[] offsets;
	private int[] spans;
    }

    class RowIterator implements CSS.LayoutIterator {

	RowIterator() {
	}

	void updateAdjustments() {
	    int axis = Y_AXIS;
	    if (multiRowCells) {
		// adjust requirements of multi-row cells
		int n = getRowCount();
		adjustments = new int[n];
		for (int i = 0; i < n; i++) {
		    RowView rv = getRow(i);
		    if (rv.multiRowCells == true) {
			int ncells = rv.getViewCount();
			for (int j = 0; j < ncells; j++) {
			    View v = rv.getView(j);
			    int nrows = getRowsOccupied(v);
			    if (nrows > 1) {
				int spanNeeded = (int) v.getPreferredSpan(axis);
				adjustMultiRowSpan(spanNeeded, nrows, i);
			    }
			}
		    }
		}
	    } else {
		adjustments = null;
	    }
	}

	/**
	 * Fixup preferences to accomodate a multi-row table cell
	 * if not already covered by existing preferences.  This is
	 * a no-op if not all of the rows needed (to do this check/fixup)
	 * have arrived yet.
	 */
	void adjustMultiRowSpan(int spanNeeded, int nrows, int rowIndex) {
	    if ((rowIndex + nrows) > getCount()) {
		// rows are missing (could be a bad rowspan specification)
		// or not all the rows have arrived.  Do the best we can with
		// the current set of rows.
		nrows = getCount() - rowIndex;
		if (nrows < 1) {
		    return;
		}
	    }
	    int span = 0;
	    for (int i = 0; i < nrows; i++) {
		RowView rv = getRow(rowIndex + i);
		span += rv.getPreferredSpan(Y_AXIS);
	    }
	    if (spanNeeded > span) {
		int adjust = (spanNeeded - span);
		int rowAdjust = adjust / nrows;
		int firstAdjust = rowAdjust + (adjust - (rowAdjust * nrows));
		RowView rv = getRow(rowIndex);
                adjustments[rowIndex] = Math.max(adjustments[rowIndex],
                                                 firstAdjust);
		for (int i = 1; i < nrows; i++) {
                    adjustments[rowIndex + i] = Math.max(
                        adjustments[rowIndex + i], rowAdjust);
		}
	    }
	}

	void setLayoutArrays(int[] offsets, int[] spans) {
	    this.offsets = offsets;
	    this.spans = spans;
	}

	// --- RequirementIterator methods -------------------

	public void setOffset(int offs) {
	    RowView rv = getRow(row);
	    if (rv != null) {
		offsets[rv.viewIndex] = offs;
	    }
	}

	public int getOffset() {
	    RowView rv = getRow(row);
	    if (rv != null) {
		return offsets[rv.viewIndex];
	    }
	    return 0;
	}

	public void setSpan(int span) {
	    RowView rv = getRow(row);
	    if (rv != null) {
		spans[rv.viewIndex] = span;
	    }
	}

	public int getSpan() {
	    RowView rv = getRow(row);
	    if (rv != null) {
		return spans[rv.viewIndex];
	    }
	    return 0;
	}

	public int getCount() {
	    return rows.size();
	}

	public void setIndex(int i) {
	    row = i;
	}

	public float getMinimumSpan(float parentSpan) {
	    return getPreferredSpan(parentSpan);
	}

	public float getPreferredSpan(float parentSpan) {
	    RowView rv = getRow(row);
	    if (rv != null) {
		int adjust = (adjustments != null) ? adjustments[row] : 0;
		return rv.getPreferredSpan(TableView.this.getAxis()) + adjust;
	    }
	    return 0;
	}

	public float getMaximumSpan(float parentSpan) {
	    return getPreferredSpan(parentSpan);
	}

	public float getBorderWidth() {
	    return borderWidth;        
	}                              

	public float getLeadingCollapseSpan() {
	    return cellSpacing;
	}

	public float getTrailingCollapseSpan() {
	    return cellSpacing;
	}

	public int getAdjustmentWeight() {
	    return 0;
	}

	/**
	 * Current row index
	 */
	private int row;

	/**
	 * Adjustments to the row requirements to handle multi-row
	 * table cells.  
	 */
	private int[] adjustments;

	private int[] offsets;
	private int[] spans;
    }

    /**
     * View of a row in a row-centric table.
     */
    public class RowView extends BoxView {

	/**
	 * Constructs a TableView for the given element.
	 *
	 * @param elem the element that this view is responsible for
	 */
        public RowView(Element elem) {
	    super(elem, View.X_AXIS);
	    fillColumns = new BitSet();
	    RowView.this.setPropertiesFromAttributes();
	}

	void clearFilledColumns() {
	    fillColumns.and(EMPTY);
	}

	void fillColumn(int col) {
	    fillColumns.set(col);
	}

	boolean isFilled(int col) {
	    return fillColumns.get(col);
	}

	/**
	 * The number of columns present in this row.
	 */
	int getColumnCount() {
	    int nfill = 0;
	    int n = fillColumns.size();
	    for (int i = 0; i < n; i++) {
		if (fillColumns.get(i)) {
		    nfill ++;
		}
	    }
	    return getViewCount() + nfill;
	}

	/**
	 * Fetches the attributes to use when rendering.  This is
	 * implemented to multiplex the attributes specified in the
	 * model with a StyleSheet.
	 */
        public AttributeSet getAttributes() {
	    return attr;
	}

	View findViewAtPoint(int x, int y, Rectangle alloc) {
	    int n = getViewCount();
	    for (int i = 0; i < n; i++) {
		if (getChildAllocation(i, alloc).contains(x, y)) {
		    childAllocation(i, alloc);
		    return getView(i);
		}
	    }
	    return null;