plugins/org.eclipse.bpel.ui.noEmbeddedEditors/src/org/eclipse/bpel/ui/util/RowColumnLayout.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2012 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.bpel.ui.util;

 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.ListIterator;
 import java.util.Map;

 import org.eclipse.draw2d.AbstractLayout;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.draw2d.geometry.Dimension;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.gef.EditPart;
 import org.eclipse.gef.GraphicalEditPart;

 /**
  * class that implements a row/column layout used for BPEL Flows
  */
 public class RowColumnLayout extends AbstractLayout {

 	protected Map<IFigure, Object> constraints = new HashMap<IFigure, Object>();
 	private static final int MIN_WIDTH_HEIGHT = 30;

 	private int totalHeight, totalWidth;
 	private Rectangle region;
 	private int[] rowHeights;
 	private int[] colWidths;
 	boolean spanned = false;
 	private int gridWidth, gridHeight;
 	private int[] widthOffsets;
 	private int[] heightOffsets;
 	private int rows = 0, cols = 0;
 	private boolean debugThis = false;

 	public int getNumberOfColumns() {
 		return cols;
 	}

 	public int getNumberOfRows() {
 		return rows;
 	}

 	public boolean isSpanned() {
 		return spanned;
 	}

 	public void setSpanned(boolean spanned) {
 		//TODO:  setSpanned(true) not supported yet
 		this.spanned = spanned;
 	}

 	private Rectangle getChildRegion(IFigure f, int availableX, int availableY) {
 		if (spanned) {
 			Dimension sz = f.getPreferredSize();
 			int w = (int) Math.round((float) (sz.width) / this.gridWidth + 0.5);
 			int h = (int) Math.round((float) (sz.height) / this.gridHeight + 0.5);
 			return new Rectangle(availableX, availableY, w, h);
 		}
 		return new Rectangle(availableX, availableY, 1, 1);
 	}

 	public void characterizeGrid(IFigure f) {
 		initVars();
 		region = new Rectangle(0, 0, -1, -1);
 		int unresolved = 0;
 		ListIterator<IFigure> children = f.getChildren().listIterator();
 		while (children.hasNext()) {
 			IFigure child = children.next();
 			Rectangle r = (Rectangle) constraints.get(child);
 			if (r == null || r.width < 0 || r.height < 0) {
 				unresolved++;
 				if (debugThis) {
 					if (r != null) System.out.println("unresolved figure " + r + " " + child); //$NON-NLS-1$ //$NON-NLS-2$
 					else System.out.println("unresolved figure " + child); //$NON-NLS-1$
 				}
 				continue;
 			}

 			if (debugThis) System.out.println("resolved figure " + r + " " + child); //$NON-NLS-1$ //$NON-NLS-2$

 			if (region.height < 0)
 				region.setBounds(r);
 			else
 				region.union(r);
 		}

 		if (region.height >= 0) {
 			rows = region.getBottomRight().y;
 			cols = region.getBottomRight().x;
 		}

 		// we have to resolve the unresolved items by calculating a new row-column for it
 		if (unresolved > 0) {
 			children = f.getChildren().listIterator();
 			while (children.hasNext()) {
 				IFigure child = children.next();
 				Rectangle r = (Rectangle) constraints.get(child);
 				if (r == null || r.width < 0 || r.height < 0) {
 					if (debugThis) System.out.println("trying to resolve figure at " + child); //$NON-NLS-1$
 					r = getChildRegion(child, cols, 0);
 					constraints.put(child, r);
 					if (debugThis) System.out.println("new rect " + r); //$NON-NLS-1$
 					if (region.height < 0)
 						region.setBounds(r);
 					else
 						region.union(r);
 					cols = region.getBottomRight().x;
 				}
 			}
 		}

 		// update again
 		if (region.x >= 0) {
 			rows = region.getBottomRight().y;
 			cols = region.getBottomRight().x;
 		}
 		else {
 			return;
 		}

 		if (rows < 0)
 			return;

 		if (debugThis)	{
 			System.out.println("bounds  " + region);	 //$NON-NLS-1$
 			System.out.println("rows " + rows); //$NON-NLS-1$
 			System.out.println("cols " + cols); //$NON-NLS-1$
 		}

 		// allocate an array of row, col sizes;
 		rowHeights = new int[rows];
 		colWidths = new int[cols];

 		for (int i = 0; i < cols; i++) {
 			colWidths[i] = MIN_WIDTH_HEIGHT;
 		}
 		for (int i = 0; i < rows; i++) {
 			rowHeights[i] = MIN_WIDTH_HEIGHT;
 		}

 		if (!isSpanned()) {
 			children = f.getChildren().listIterator();
 			while (children.hasNext()) {
 				IFigure child = children.next();
 				Rectangle rowcol = (Rectangle) constraints.get(child);

 				if (debugThis)	{
 					System.out.println("child " + child + " " + rowcol);	 //$NON-NLS-1$ //$NON-NLS-2$
 				}

 				Dimension sz = getChildSize(child, -1, -1);
 				if (rowcol.x >= cols || rowcol.y >= rows)
 					throw new IllegalArgumentException();
 				if (rowcol.x < 0 || rowcol.y < 0)
 					throw new IllegalArgumentException();
 				rowHeights[rowcol.y] = Math.max(rowHeights[rowcol.y], sz.height+10);
 				colWidths[rowcol.x] = Math.max(colWidths[rowcol.x], sz.width+10);
 			}
 		}

 		for (int i = 0; i < rows; i++)
 			totalHeight += rowHeights[i];
 		for (int i = 0; i < cols; i++)
 			totalWidth += colWidths[i];

 		// calculate the offsets of each cell in the coordinate space
 		widthOffsets = new int[cols];
 		heightOffsets = new int[rows];
 		for (int i = 1; i < cols; i++)
 			widthOffsets[i] = colWidths[i - 1] + widthOffsets[i - 1];
 		for (int i = 1; i < rows; i++)
 			heightOffsets[i] = rowHeights[i - 1] + heightOffsets[i - 1];
 	}

 	/**
 	 * Provides the given child's preferred size
 	 * @param child	The Figure whose preferred size needs to be calculated
 	 * @param wHint	The width hint to be used when calculating the child's preferred size
 	 * @param hHint	The height hint to be used when calculating the child's preferred size
 	 * @return the child's preferred size
 	 */
 	protected Dimension getChildSize(IFigure child, int wHint, int hHint) {
 		return child.getPreferredSize(wHint, hHint);
 	}

 	@Override
 	public Object getConstraint(IFigure figure) {
 		return constraints.get(figure);
 	}

 	public Point getOrigin(IFigure parent) {
 		return parent.getClientArea().getLocation();
 	}

 	private void initVars() {
 		totalHeight = 0;
 		totalWidth = 0;
 		rowHeights = null;
 		colWidths = null;
 		gridWidth = 40;
 		gridHeight = 40;
 		widthOffsets = null;
 		heightOffsets = null;
 		rows = 0;
 		cols = 0;
 	}

 	@Override
 	public void remove(IFigure figure) {
 		super.remove(figure);
 		constraints.remove(figure);
 	}

 	/**
 	 * Sets the given bounds for the child figure input.
 	 *
 	 * @param parent  Parent Figure which holds the child.
 	 * @param child   Child Figure whose bounds are to be set.
 	 * @param bounds  The size of the child to be set.
 	 * @since 2.0
 	 */
 	protected void setBoundsOfChild(IFigure parent, IFigure child, Rectangle bounds) {
 		parent.getClientArea(Rectangle.SINGLETON);
 		bounds.translate(Rectangle.SINGLETON.x, Rectangle.SINGLETON.y);
 		child.setBounds(bounds);
 	}

 	/**
 	 * Sets the layout constraint of the given figure.
 	 *
 	 * @param figure  Figure for which the constarint is being set.
 	 * @param newConstraint  Constraint for the input figure.
 	 * @see  #getConstraint(IFigure)
 	 * @since 2.0
 	 */
 	@Override
 	public void setConstraint(IFigure figure, Object newConstraint) {
 		super.setConstraint(figure, newConstraint);
 		if (newConstraint != null)
 			constraints.put(figure, newConstraint);
 		if (debugThis) {
 			if (newConstraint != null)
 				System.out.println("setConstraint("+ figure + " " + newConstraint + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 		}
 	}

 	@Override
 	protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
 		// Subtract out the insets from the hints
 		characterizeGrid(container);

 		Dimension prefSize = new Dimension();
 		prefSize.height += totalHeight;
 		prefSize.width += totalWidth;
 		prefSize.width += container.getInsets().getWidth();
 		prefSize.height += container.getInsets().getHeight();
 		prefSize.union(getBorderPreferredSize(container));
 		return prefSize;
 	}

 	/**
 	 * @see org.eclipse.draw2d.LayoutManager#layout(IFigure)
 	 */
 	public void layout(IFigure parent) {
 		characterizeGrid(parent);
 		if (rows == 0 || cols == 0)
 			return;
 		int row, col;
 		Point offset = getOrigin(parent);
 		Point centeringOffset = new Point();
 		IFigure f;

 		Iterator<IFigure> children;
 		children = parent.getChildren().iterator();
 		while (children.hasNext()) {
 			f = children.next();
 			Rectangle bounds = (Rectangle) getConstraint(f);
 			if (bounds == null)
 				continue;
 			if (debugThis) System.out.println("bounds " + " " + f + " " + bounds); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

 			Rectangle newChildArea = new Rectangle();
 			row = bounds.y;
 			col = bounds.x;

 			newChildArea.x = widthOffsets[col];
 			newChildArea.y = heightOffsets[row];
 			if (isSpanned()) {
 				newChildArea.height = gridHeight * bounds.height;
 				newChildArea.width = gridWidth * bounds.width;
 			} else {
 				newChildArea.height = rowHeights[row];
 				newChildArea.width = colWidths[col];
 			}
 			centeringOffset.x = (newChildArea.width - f.getPreferredSize().width) / 2;
 			centeringOffset.y = (newChildArea.height - f.getPreferredSize().height) / 2;
 			newChildArea = newChildArea.getTranslated(offset);
 			newChildArea = newChildArea.getTranslated(centeringOffset);
 			newChildArea.width = f.getPreferredSize().width;
 			newChildArea.height = f.getPreferredSize().height;
 			f.setBounds(newChildArea);
 		}
 	}

 	/**
 	 * @param pt - location to test
 	 * @param gridInfo - returns the grid information from that point
 	 * @param pixelRegionInfo - returns the pixel region of that grid
 	 * @return true if the point pass the hittest.
 	 */
 	public boolean getGridInfoFromLocation(Point pt, Rectangle gridInfo, Rectangle pixRegion) {
 		Rectangle hitTest = new Rectangle();
 		for (int i = 0; i < cols; i++)
 			for (int k = 0; k < rows; k++) {
 				hitTest.x = widthOffsets[i];
 				hitTest.y = heightOffsets[k];
 				hitTest.width = colWidths[i];
 				hitTest.height = rowHeights[k];
 				if (hitTest.contains(pt)) {
 					gridInfo.x = i;
 					gridInfo.y = k;
 					gridInfo.setSize(1, 1);
 					pixRegion.setBounds(hitTest);
 					return true;
 				}
 			}
 		return false;
 	}

 	public boolean isDroppableAt(EditPart parentPart, EditPart test, Rectangle gridInfo) {
 		IFigure f = ((GraphicalEditPart)parentPart).getContentPane();
 		ListIterator<IFigure> children = f.getChildren().listIterator();
 		while (children.hasNext()) {
 			IFigure child = children.next();
 			Rectangle r = (Rectangle) constraints.get(child);
 			if (r.getLocation().equals(gridInfo.getLocation())) {
 				return false;
 			}
 		}
 		return true;
 	}

 	public Rectangle [] getDividers() {
 		if (rows <= 1 && cols <= 1)
 			return null;
 		Rectangle [] rects = new Rectangle[(rows-1)+(cols-1)];
 		int n = 0;
 		for (int i = 0; i < (cols-1); i++) {
 			rects[n++] = new Rectangle(new Point(widthOffsets[i+1], 0), new Dimension(0, totalHeight));
 		}
 		for (int i = 0; i < (rows-1); i++) {
 			rects[n++] = new Rectangle(new Point(0, heightOffsets[i+1]), new Dimension(totalWidth, 0));
 		}
 		return rects;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2012 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.bpel.ui.util;

	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.ListIterator;
	import java.util.Map;

	import org.eclipse.draw2d.AbstractLayout;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.draw2d.geometry.Dimension;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.Rectangle;
	import org.eclipse.gef.EditPart;
	import org.eclipse.gef.GraphicalEditPart;

	/**
	* class that implements a row/column layout used for BPEL Flows
	*/
	public class RowColumnLayout extends AbstractLayout {

	protected Map<IFigure, Object> constraints = new HashMap<IFigure, Object>();
	private static final int MIN_WIDTH_HEIGHT = 30;

	private int totalHeight, totalWidth;
	private Rectangle region;
	private int[] rowHeights;
	private int[] colWidths;
	boolean spanned = false;
	private int gridWidth, gridHeight;
	private int[] widthOffsets;
	private int[] heightOffsets;
	private int rows = 0, cols = 0;
	private boolean debugThis = false;

	public int getNumberOfColumns() {
	return cols;
	}

	public int getNumberOfRows() {
	return rows;
	}

	public boolean isSpanned() {
	return spanned;
	}

	public void setSpanned(boolean spanned) {
	//TODO: setSpanned(true) not supported yet
	this.spanned = spanned;
	}

	private Rectangle getChildRegion(IFigure f, int availableX, int availableY) {
	if (spanned) {
	Dimension sz = f.getPreferredSize();
	int w = (int) Math.round((float) (sz.width) / this.gridWidth + 0.5);
	int h = (int) Math.round((float) (sz.height) / this.gridHeight + 0.5);
	return new Rectangle(availableX, availableY, w, h);
	}
	return new Rectangle(availableX, availableY, 1, 1);
	}

	public void characterizeGrid(IFigure f) {
	initVars();
	region = new Rectangle(0, 0, -1, -1);
	int unresolved = 0;
	ListIterator<IFigure> children = f.getChildren().listIterator();
	while (children.hasNext()) {
	IFigure child = children.next();
	Rectangle r = (Rectangle) constraints.get(child);
	if (r == null \|\| r.width < 0 \|\| r.height < 0) {
	unresolved++;
	if (debugThis) {
	if (r != null) System.out.println("unresolved figure " + r + " " + child); //$NON-NLS-1$ //$NON-NLS-2$
	else System.out.println("unresolved figure " + child); //$NON-NLS-1$
	}
	continue;
	}

	if (debugThis) System.out.println("resolved figure " + r + " " + child); //$NON-NLS-1$ //$NON-NLS-2$

	if (region.height < 0)
	region.setBounds(r);
	else
	region.union(r);
	}

	if (region.height >= 0) {
	rows = region.getBottomRight().y;
	cols = region.getBottomRight().x;
	}

	// we have to resolve the unresolved items by calculating a new row-column for it
	if (unresolved > 0) {
	children = f.getChildren().listIterator();
	while (children.hasNext()) {
	IFigure child = children.next();
	Rectangle r = (Rectangle) constraints.get(child);
	if (r == null \|\| r.width < 0 \|\| r.height < 0) {
	if (debugThis) System.out.println("trying to resolve figure at " + child); //$NON-NLS-1$
	r = getChildRegion(child, cols, 0);
	constraints.put(child, r);
	if (debugThis) System.out.println("new rect " + r); //$NON-NLS-1$
	if (region.height < 0)
	region.setBounds(r);
	else
	region.union(r);
	cols = region.getBottomRight().x;
	}
	}
	}

	// update again
	if (region.x >= 0) {
	rows = region.getBottomRight().y;
	cols = region.getBottomRight().x;
	}
	else {
	return;
	}

	if (rows < 0)
	return;

	if (debugThis) {
	System.out.println("bounds " + region); //$NON-NLS-1$
	System.out.println("rows " + rows); //$NON-NLS-1$
	System.out.println("cols " + cols); //$NON-NLS-1$
	}

	// allocate an array of row, col sizes;
	rowHeights = new int[rows];
	colWidths = new int[cols];

	for (int i = 0; i < cols; i++) {
	colWidths[i] = MIN_WIDTH_HEIGHT;
	}
	for (int i = 0; i < rows; i++) {
	rowHeights[i] = MIN_WIDTH_HEIGHT;
	}

	if (!isSpanned()) {
	children = f.getChildren().listIterator();
	while (children.hasNext()) {
	IFigure child = children.next();
	Rectangle rowcol = (Rectangle) constraints.get(child);

	if (debugThis) {
	System.out.println("child " + child + " " + rowcol); //$NON-NLS-1$ //$NON-NLS-2$
	}

	Dimension sz = getChildSize(child, -1, -1);
	if (rowcol.x >= cols \|\| rowcol.y >= rows)
	throw new IllegalArgumentException();
	if (rowcol.x < 0 \|\| rowcol.y < 0)
	throw new IllegalArgumentException();
	rowHeights[rowcol.y] = Math.max(rowHeights[rowcol.y], sz.height+10);
	colWidths[rowcol.x] = Math.max(colWidths[rowcol.x], sz.width+10);
	}
	}

	for (int i = 0; i < rows; i++)
	totalHeight += rowHeights[i];
	for (int i = 0; i < cols; i++)
	totalWidth += colWidths[i];

	// calculate the offsets of each cell in the coordinate space
	widthOffsets = new int[cols];
	heightOffsets = new int[rows];
	for (int i = 1; i < cols; i++)
	widthOffsets[i] = colWidths[i - 1] + widthOffsets[i - 1];
	for (int i = 1; i < rows; i++)
	heightOffsets[i] = rowHeights[i - 1] + heightOffsets[i - 1];
	}

	/**
	* Provides the given child's preferred size
	* @param child The Figure whose preferred size needs to be calculated
	* @param wHint The width hint to be used when calculating the child's preferred size
	* @param hHint The height hint to be used when calculating the child's preferred size
	* @return the child's preferred size
	*/
	protected Dimension getChildSize(IFigure child, int wHint, int hHint) {
	return child.getPreferredSize(wHint, hHint);
	}

	@Override
	public Object getConstraint(IFigure figure) {
	return constraints.get(figure);
	}

	public Point getOrigin(IFigure parent) {
	return parent.getClientArea().getLocation();
	}

	private void initVars() {
	totalHeight = 0;
	totalWidth = 0;
	rowHeights = null;
	colWidths = null;
	gridWidth = 40;
	gridHeight = 40;
	widthOffsets = null;
	heightOffsets = null;
	rows = 0;
	cols = 0;
	}

	@Override
	public void remove(IFigure figure) {
	super.remove(figure);
	constraints.remove(figure);
	}

	/**
	* Sets the given bounds for the child figure input.
	*
	* @param parent Parent Figure which holds the child.
	* @param child Child Figure whose bounds are to be set.
	* @param bounds The size of the child to be set.
	* @since 2.0
	*/
	protected void setBoundsOfChild(IFigure parent, IFigure child, Rectangle bounds) {
	parent.getClientArea(Rectangle.SINGLETON);
	bounds.translate(Rectangle.SINGLETON.x, Rectangle.SINGLETON.y);
	child.setBounds(bounds);
	}

	/**
	* Sets the layout constraint of the given figure.
	*
	* @param figure Figure for which the constarint is being set.
	* @param newConstraint Constraint for the input figure.
	* @see #getConstraint(IFigure)
	* @since 2.0
	*/
	@Override
	public void setConstraint(IFigure figure, Object newConstraint) {
	super.setConstraint(figure, newConstraint);
	if (newConstraint != null)
	constraints.put(figure, newConstraint);
	if (debugThis) {
	if (newConstraint != null)
	System.out.println("setConstraint("+ figure + " " + newConstraint + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}
	}

	@Override
	protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
	// Subtract out the insets from the hints
	characterizeGrid(container);

	Dimension prefSize = new Dimension();
	prefSize.height += totalHeight;
	prefSize.width += totalWidth;
	prefSize.width += container.getInsets().getWidth();
	prefSize.height += container.getInsets().getHeight();
	prefSize.union(getBorderPreferredSize(container));
	return prefSize;
	}

	/**
	* @see org.eclipse.draw2d.LayoutManager#layout(IFigure)
	*/
	public void layout(IFigure parent) {
	characterizeGrid(parent);
	if (rows == 0 \|\| cols == 0)
	return;
	int row, col;
	Point offset = getOrigin(parent);
	Point centeringOffset = new Point();
	IFigure f;

	Iterator<IFigure> children;
	children = parent.getChildren().iterator();
	while (children.hasNext()) {
	f = children.next();
	Rectangle bounds = (Rectangle) getConstraint(f);
	if (bounds == null)
	continue;
	if (debugThis) System.out.println("bounds " + " " + f + " " + bounds); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	Rectangle newChildArea = new Rectangle();
	row = bounds.y;
	col = bounds.x;

	newChildArea.x = widthOffsets[col];
	newChildArea.y = heightOffsets[row];
	if (isSpanned()) {
	newChildArea.height = gridHeight * bounds.height;
	newChildArea.width = gridWidth * bounds.width;
	} else {
	newChildArea.height = rowHeights[row];
	newChildArea.width = colWidths[col];
	}
	centeringOffset.x = (newChildArea.width - f.getPreferredSize().width) / 2;
	centeringOffset.y = (newChildArea.height - f.getPreferredSize().height) / 2;
	newChildArea = newChildArea.getTranslated(offset);
	newChildArea = newChildArea.getTranslated(centeringOffset);
	newChildArea.width = f.getPreferredSize().width;
	newChildArea.height = f.getPreferredSize().height;
	f.setBounds(newChildArea);
	}
	}

	/**
	* @param pt - location to test
	* @param gridInfo - returns the grid information from that point
	* @param pixelRegionInfo - returns the pixel region of that grid
	* @return true if the point pass the hittest.
	*/
	public boolean getGridInfoFromLocation(Point pt, Rectangle gridInfo, Rectangle pixRegion) {
	Rectangle hitTest = new Rectangle();
	for (int i = 0; i < cols; i++)
	for (int k = 0; k < rows; k++) {
	hitTest.x = widthOffsets[i];
	hitTest.y = heightOffsets[k];
	hitTest.width = colWidths[i];
	hitTest.height = rowHeights[k];
	if (hitTest.contains(pt)) {
	gridInfo.x = i;
	gridInfo.y = k;
	gridInfo.setSize(1, 1);
	pixRegion.setBounds(hitTest);
	return true;
	}
	}
	return false;
	}

	public boolean isDroppableAt(EditPart parentPart, EditPart test, Rectangle gridInfo) {
	IFigure f = ((GraphicalEditPart)parentPart).getContentPane();
	ListIterator<IFigure> children = f.getChildren().listIterator();
	while (children.hasNext()) {
	IFigure child = children.next();
	Rectangle r = (Rectangle) constraints.get(child);
	if (r.getLocation().equals(gridInfo.getLocation())) {
	return false;
	}
	}
	return true;
	}

	public Rectangle [] getDividers() {
	if (rows <= 1 && cols <= 1)
	return null;
	Rectangle [] rects = new Rectangle[(rows-1)+(cols-1)];
	int n = 0;
	for (int i = 0; i < (cols-1); i++) {
	rects[n++] = new Rectangle(new Point(widthOffsets[i+1], 0), new Dimension(0, totalHeight));
	}
	for (int i = 0; i < (rows-1); i++) {
	rects[n++] = new Rectangle(new Point(0, heightOffsets[i+1]), new Dimension(totalWidth, 0));
	}
	return rects;
	}
	}