Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package javax.swing.text;

	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.HTML;

	/**
	* <p>
	* Implements View interface for a table, that is composed of an
	* element structure where the child elements of the element
	* this view is responsible for represent rows and the child
	* elements of the row elements are cells. The cell elements can
	* have an arbitrary element structure under them, which will
	* be built with the ViewFactory returned by the getViewFactory
	* method.
	* <pre>
	*
	*   TABLE
	*   ROW
	*   CELL
	*   CELL
	*   ROW
	*   CELL
	*   CELL
	*
	* </pre>
	* <p>
	* This is implemented as a hierarchy of boxes, the table itself
	* is a vertical box, the rows are horizontal boxes, and the cells
	* are vertical boxes. The cells are allowed to span multiple
	* columns and rows. By default, the table can be thought of as
	* being formed over a grid (i.e. somewhat like one would find in
	* gridbag layout), where table cells can request to span more
	* than one grid cell. The default horizontal span of table cells
	* will be based upon this grid, but can be changed by reimplementing
	* the requested span of the cell (i.e. table cells can have independant
	* spans if desired).
	*
	* @author Timothy Prinzing
	* @see View
	*/
	public abstract class TableView extends BoxView {

	/**
	* 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<TableRow>();
	gridValid = false;
	}

	/**
	* Creates a new table row.
	*
	* @param elem an element
	* @return the row
	*/
	protected TableRow createTableRow(Element elem) {
	return new TableRow(elem);
	}

	/**
	* @deprecated Table cells can now be any arbitrary
	* View implementation and should be produced by the
	* ViewFactory rather than the table.
	*
	* @param elem an element
	* @return the cell
	*/
	@Deprecated
	protected TableCell createTableCell(Element elem) {
	return new TableCell(elem);
	}

	/**
	* The number of columns in the table.
	*/
	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.
	*/
	int getColumnSpan(int col) {
	return columnSpans[col];
	}

	/**
	* The number of rows in the table.
	*/
	int getRowCount() {
	return rows.size();
	}

	/**
	* Fetches the span (height) of the given row.
	*/
	int getRowSpan(int row) {
	View rv = getRow(row);
	if (rv != null) {
	return (int) rv.getPreferredSpan(Y_AXIS);
	}
	return 0;
	}

	TableRow getRow(int row) {
	if (row < rows.size()) {
	return rows.elementAt(row);
	}
	return null;
	}

	/**
	* Determines the number of columns occupied by
	* the table cell represented by given element.
	*/
	/protected/ int getColumnsOccupied(View v) {
	// PENDING(prinz) this code should be in the html
	// paragraph, but we can't add api to enable it.
	AttributeSet a = v.getElement().getAttributes();
	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) {
	// PENDING(prinz) this code should be in the html
	// paragraph, but we can't add api to enable it.
	AttributeSet a = v.getElement().getAttributes();
	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 void forwardUpdate(DocumentEvent.ElementChange ec,
	DocumentEvent e, Shape a, ViewFactory f) {
	super.forwardUpdate(ec, e, a, f);
	// A change in any of the table cells usually effects the whole table,
	// so redraw it all!
	if (a != null) {
	Component c = getContainer();
	if (c != null) {
	Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a :
	a.getBounds();
	c.repaint(alloc.x, alloc.y, alloc.width, alloc.height);
	}
	}
	}

	/**
	* Change the child views. This is implemented to
	* provide the superclass behavior and invalidate the
	* grid so that rows and columns will be recalculated.
	*/
	public void replace(int offset, int length, View[] views) {
	super.replace(offset, length, views);
	invalidateGrid();
	}

	/**
	* Fill in the grid locations that are placeholders
	* for multi-column, multi-row, and missing grid
	* locations.
	*/
	void updateGrid() {
	if (! gridValid) {
	// determine which views are table rows and clear out
	// grid points marked filled.
	rows.removeAllElements();
	int n = getViewCount();
	for (int i = 0; i < n; i++) {
	View v = getView(i);
	if (v instanceof TableRow) {
	rows.addElement((TableRow) v);
	TableRow rv = (TableRow) v;
	rv.clearFilledColumns();
	rv.setRow(i);
	}
	}

	int maxColumns = 0;
	int nrows = rows.size();
	for (int row = 0; row < nrows; row++) {
	TableRow rv = getRow(row);
	int col = 0;
	for (int cell = 0; cell < rv.getViewCount(); cell++, col++) {
	View cv = rv.getView(cell);
	// advance to a free column
	for (; rv.isFilled(col); col++);
	int rowSpan = getRowsOccupied(cv);
	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();
	}
	gridValid = true;
	}
	}

	/**
	* Mark a grid location as filled in for a cells overflow.
	*/
	void addFill(int row, int col) {
	TableRow rv = getRow(row);
	if (rv != null) {
	rv.fillColumn(col);
	}
	}

	/**
	* Lays out the columns to fit within the given target span.
	* Returns the results through {@code offsets} and {@code spans}.
	*
	* @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
	*/
	protected void layoutColumns(int targetSpan, int[] offsets, int[] spans,
	SizeRequirements[] reqs) {
	// allocate using the convenience method on SizeRequirements
	SizeRequirements.calculateTiledPositions(targetSpan, null, reqs,
	offsets, spans);
	}

	/**
	* Perform layout for the minor axis of the box (i.e. the
	* axis orthogonal to the axis that it represents). The results
	* of the layout should be placed in the given arrays which represent
	* the allocations to the children along the minor axis. This
	* is called by the superclass whenever the layout needs to be
	* updated along the minor axis.
	* <p>
	* This is implemented to call the
	* {@link #layoutColumns layoutColumns} method, and then
	* forward to the superclass to actually carry out the layout
	* of the tables rows.
	*
	* @param targetSpan the total span given to the view, which
	* would be used to layout the children.
	* @param axis the axis being layed out.
	* @param offsets the offsets from the origin of the view for
	* each of the child views. This is a return value and is
	* filled in by the implementation of this method.
	* @param spans the span of each child view. This is a return
	* value and is filled in by the implementation of this method.
	*/
	protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, int[] spans) {
	// make grid is properly represented
	updateGrid();

	// all of the row layouts are invalid, so mark them that way
	int n = getRowCount();
	for (int i = 0; i < n; i++) {
	TableRow row = getRow(i);
	row.layoutChanged(axis);
	}

	// calculate column spans
	layoutColumns(targetSpan, columnOffsets, columnSpans, columnRequirements);

	// continue normal layout
	super.layoutMinorAxis(targetSpan, axis, offsets, spans);
	}

	/**
	* Calculate the requirements for the minor axis. This is called by
	* the superclass whenever the requirements need to be updated (i.e.
	* a preferenceChanged was messaged through this view).
	* <p>
	* This is implemented to calculate the requirements as the sum of the
	* requirements of the columns.
	*/
	protected SizeRequirements calculateMinorAxisRequirements(int axis, SizeRequirements r) {
	updateGrid();

	// calculate column requirements for each column
	calculateColumnRequirements(axis);


	// the requirements are the sum of the columns.
	if (r == null) {
	r = new SizeRequirements();
	}
	long min = 0;
	long pref = 0;
	long max = 0;
	for (SizeRequirements req : columnRequirements) {
	min += req.minimum;
	pref += req.preferred;
	max += req.maximum;
	}
	r.minimum = (int) min;
	r.preferred = (int) pref;
	r.maximum = (int) max;
	r.alignment = 0;
	return r;
	}

	/*
	boolean shouldTrace() {
	AttributeSet a = getElement().getAttributes();
	Object o = a.getAttribute(HTML.Attribute.ID);
	if ((o != null) && o.equals("debug")) {
	return true;
	}
	return false;
	}
	*/

	/**
	* 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++) {
	TableRow 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++) {
	TableRow 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;
	}
	}
	}
	}

	/*
	if (shouldTrace()) {
	System.err.println("calc:");
	for (int i = 0; i < columnRequirements.length; i++) {
	System.err.println(" " + i + ": " + columnRequirements[i]);
	}
	}
	*/
	}

	/**
	* 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);
	req.maximum = Math.max((int) v.getMaximumSpan(axis), req.maximum);
	}

	/**
	* 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.
	int cmin = (int) v.getMinimumSpan(axis);
	if (cmin > min) {
	/*
	* the columns that this cell spans need adjustment to fit
	* this table cell.... calculate the adjustments. The
	* maximum for each cell is the maximum of the existing
	* maximum or the amount needed by the cell.
	*/
	SizeRequirements[] reqs = new SizeRequirements[ncols];
	for (int i = 0; i < ncols; i++) {
	SizeRequirements r = reqs[i] = columnRequirements[col + i];
	r.maximum = Math.max(r.maximum, (int) v.getMaximumSpan(axis));
	}
	int[] spans = new int[ncols];
	int[] offsets = new int[ncols];
	SizeRequirements.calculateTiledPositions(cmin, null, reqs,
	offsets, spans);
	// apply the adjustments
	for (int i = 0; i < ncols; i++) {
	SizeRequirements req = reqs[i];
	req.minimum = Math.max(spans[i], req.minimum);
	req.preferred = Math.max(req.minimum, req.preferred);
	req.maximum = Math.max(req.preferred, req.maximum);
	}
	}

	// check if the preferred size needs adjustment.
	int cpref = (int) v.getPreferredSpan(axis);
	if (cpref > pref) {
	/*
	* the columns that this cell spans need adjustment to fit
	* this table cell.... calculate the adjustments. The
	* maximum for each cell is the maximum of the existing
	* maximum or the amount needed by the cell.
	*/
	SizeRequirements[] reqs = new SizeRequirements[ncols];
	for (int i = 0; i < ncols; i++) {
	SizeRequirements r = reqs[i] = columnRequirements[col + i];
	}
	int[] spans = new int[ncols];
	int[] offsets = new int[ncols];
	SizeRequirements.calculateTiledPositions(cpref, null, reqs,
	offsets, spans);
	// apply the adjustments
	for (int i = 0; i < ncols; i++) {
	SizeRequirements req = reqs[i];
	req.preferred = Math.max(spans[i], req.preferred);
	req.maximum = Math.max(req.preferred, req.maximum);
	}
	}

	}

	/**
	* Fetches the child view that represents the given position in
	* the model. This is implemented to walk through the children
	* looking for a range that contains the given position. In this
	* view the children do not necessarily have a one to one mapping
	* with the child elements.
	*
	* @param pos the search position >= 0
	* @param a the allocation to the table on entry, and the
	* allocation of the view containing the position on exit
	* @return the view representing the given position, or
	* <code>null</code> if there isn't one
	*/
	protected View getViewAtPosition(int pos, Rectangle a) {
	int n = getViewCount();
	for (int i = 0; i < n; i++) {
	View v = getView(i);
	int p0 = v.getStartOffset();
	int p1 = v.getEndOffset();
	if ((pos >= p0) && (pos < p1)) {
	// it's in this view.
	if (a != null) {
	childAllocation(i, a);
	}
	return v;
	}
	}
	if (pos == getEndOffset()) {
	View v = getView(n - 1);
	if (a != null) {
	this.childAllocation(n - 1, a);
	}
	return v;
	}
	return null;
	}

	// ---- variables ----------------------------------------------------

	int[] columnSpans;
	int[] columnOffsets;
	SizeRequirements[] columnRequirements;
	Vector<TableRow> rows;
	boolean gridValid;
	static final private BitSet EMPTY = new BitSet();

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

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

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

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

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

	/** get location in the overall set of rows */
	int getRow() {
	return row;
	}

	/**
	* set location in the overall set of rows, this is
	* set by the TableView.updateGrid() method.
	*/
	void setRow(int row) {
	this.row = row;
	}

	/**
	* 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;
	}

	/**
	* Change the child views. This is implemented to
	* provide the superclass behavior and invalidate the
	* grid so that rows and columns will be recalculated.
	*/
	public void replace(int offset, int length, View[] views) {
	super.replace(offset, length, views);
	invalidateGrid();
	}

	/**
	* Perform layout for the major axis of the box (i.e. the
	* axis that it represents). The results of the layout should
	* be placed in the given arrays which represent the allocations
	* to the children along the major axis.
	* <p>
	* This is re-implemented to give each child the span of the column
	* width for the table, and to give cells that span multiple columns
	* the multi-column span.
	*
	* @param targetSpan the total span given to the view, which
	* would be used to layout the children.
	* @param axis the axis being layed out.
	* @param offsets the offsets from the origin of the view for
	* each of the child views. This is a return value and is
	* filled in by the implementation of this method.
	* @param spans the span of each child view. This is a return
	* value and is filled in by the implementation of this method.
	*/
	protected void layoutMajorAxis(int targetSpan, int axis, int[] offsets, int[] spans) {
	int col = 0;
	int ncells = getViewCount();
	for (int cell = 0; cell < ncells; cell++, col++) {
	View cv = getView(cell);
	for (; isFilled(col); col++); // advance to a free column
	int colSpan = getColumnsOccupied(cv);
	spans[cell] = columnSpans[col];
	offsets[cell] = columnOffsets[col];
	if (colSpan > 1) {
	int n = columnSpans.length;
	for (int j = 1; j < colSpan; j++) {
	// Because the table may be only partially formed, some
	// of the columns may not yet exist. Therefore we check
	// the bounds.
	if ((col+j) < n) {
	spans[cell] += columnSpans[col+j];
	}
	}
	col += colSpan - 1;
	}
	}
	}

	/**
	* Perform layout for the minor axis of the box (i.e. the
	* axis orthogonal to the axis that it represents). The results
	* of the layout should be placed in the given arrays which represent
	* the allocations to the children along the minor axis. This
	* is called by the superclass whenever the layout needs to be
	* updated along the minor axis.
	* <p>
	* This is implemented to delegate to the superclass, then adjust
	* the span for any cell that spans multiple rows.
	*
	* @param targetSpan the total span given to the view, which
	* would be used to layout the children.
	* @param axis the axis being layed out.
	* @param offsets the offsets from the origin of the view for
	* each of the child views. This is a return value and is
	* filled in by the implementation of this method.
	* @param spans the span of each child view. This is a return
	* value and is filled in by the implementation of this method.
	*/
	protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, int[] spans) {
	super.layoutMinorAxis(targetSpan, axis, offsets, spans);
	int col = 0;
	int ncells = getViewCount();
	for (int cell = 0; cell < ncells; cell++, col++) {
	View cv = getView(cell);
	for (; isFilled(col); col++); // advance to a free column
	int colSpan = getColumnsOccupied(cv);
	int rowSpan = getRowsOccupied(cv);
	if (rowSpan > 1) {
	for (int j = 1; j < rowSpan; j++) {
	// test bounds of each row because it may not exist
	// either because of error or because the table isn't
	// fully loaded yet.
	int row = getRow() + j;
	if (row < TableView.this.getViewCount()) {
	int span = TableView.this.getSpan(Y_AXIS, getRow()+j);
	spans[cell] += span;
	}
	}
	}
	if (colSpan > 1) {
	col += colSpan - 1;
	}
	}
	}

	/**
	* Determines the resizability of the view along the
	* given axis. A value of 0 or less is not resizable.
	*
	* @param axis may be either View.X_AXIS or View.Y_AXIS
	* @return the resize weight
	* @exception IllegalArgumentException for an invalid axis
	*/
	public int getResizeWeight(int axis) {
	return 1;
	}

	/**
	* Fetches the child view that represents the given position in
	* the model. This is implemented to walk through the children
	* looking for a range that contains the given position. In this
	* view the children do not necessarily have a one to one mapping
	* with the child elements.
	*
	* @param pos the search position >= 0
	* @param a the allocation to the table on entry, and the
	* allocation of the view containing the position on exit
	* @return the view representing the given position, or
	* <code>null</code> if there isn't one
	*/
	protected View getViewAtPosition(int pos, Rectangle a) {
	int n = getViewCount();
	for (int i = 0; i < n; i++) {
	View v = getView(i);
	int p0 = v.getStartOffset();
	int p1 = v.getEndOffset();
	if ((pos >= p0) && (pos < p1)) {
	// it's in this view.
	if (a != null) {
	childAllocation(i, a);
	}
	return v;
	}
	}
	if (pos == getEndOffset()) {
	View v = getView(n - 1);
	if (a != null) {
	this.childAllocation(n - 1, a);
	}
	return v;
	}
	return null;
	}

	/** columns filled by multi-column or multi-row cells */
	BitSet fillColumns;
	/** the row within the overall grid */
	int row;
	}

	/**
	* @deprecated A table cell can now be any View implementation.
	*/
	@Deprecated
	public class TableCell extends BoxView implements GridCell {

	/**
	* Constructs a TableCell for the given element.
	*
	* @param elem the element that this view is responsible for
	* @since 1.4
	*/
	public TableCell(Element elem) {
	super(elem, View.Y_AXIS);
	}

	// --- GridCell methods -------------------------------------

	/**
	* Gets the number of columns this cell spans (e.g. the
	* grid width).
	*
	* @return the number of columns
	*/
	public int getColumnCount() {
	return 1;
	}

	/**
	* Gets the number of rows this cell spans (that is, the
	* grid height).
	*
	* @return the number of rows
	*/
	public int getRowCount() {
	return 1;
	}


	/**
	* Sets the grid location.
	*
	* @param row the row >= 0
	* @param col the column >= 0
	*/
	public void setGridLocation(int row, int col) {
	this.row = row;
	this.col = col;
	}

	/**
	* Gets the row of the grid location
	*/
	public int getGridRow() {
	return row;
	}

	/**
	* Gets the column of the grid location
	*/
	public int getGridColumn() {
	return col;
	}

	int row;
	int col;
	}

	/**
	* <em>
	* THIS IS NO LONGER USED, AND WILL BE REMOVED IN THE
	* NEXT RELEASE. THE JCK SIGNATURE TEST THINKS THIS INTERFACE
	* SHOULD EXIST
	* </em>
	*/
	interface GridCell {

	/**
	* Sets the grid location.
	*
	* @param row the row >= 0
	* @param col the column >= 0
	*/
	public void setGridLocation(int row, int col);

	/**
	* Gets the row of the grid location
	*/
	public int getGridRow();

	/**
	* Gets the column of the grid location
	*/
	public int getGridColumn();

	/**
	* Gets the number of columns this cell spans (e.g. the
	* grid width).
	*
	* @return the number of columns
	*/
	public int getColumnCount();

	/**
	* Gets the number of rows this cell spans (that is, the
	* grid height).
	*
	* @return the number of rows
	*/
	public int getRowCount();

	}

	}

Back to index...