update/org.eclipse.update.ui.forms/src/org/eclipse/update/ui/forms/internal/HTMLTableLayout.java - platform/eclipse.platform - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.update.ui.forms.internal;
 import java.util.Vector;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.graphics.*;
 import org.eclipse.swt.widgets.*;

 /**
  * This implementation of the layout algorithm attempts to position controls in
  * the composite using a two-pass autolayout HTML table altorithm recommeded by
  * HTML 4.01 W3C specification. The main differences with GridLayout is that it
  * has two passes and that width and height are not calculated in the same
  * pass.
  * <p>
  * The advantage of the algorithm over GridLayout is that it is capable of
  * flowing text controls capable of line wrap. These controls do not have
  * natural 'preferred size'. Instead, they are capable of providing the
  * required height if the width is set. Consequently, this algorithm first
  * calculates the widths that will be assigned to columns, and then passes
  * those widths to the controls to calculate the height. When a composite with
  * this layout is a child of the scrolling composite, they should interact in
  * such a way that reduction in the scrolling composite width results in the
  * reflow and increase of the overall height.
  * <p>
  * If none of the columns contain expandable and wrappable controls, the
  * end-result will be similar to the one provided by GridLayout. The difference
  * will show up for layouts that contain controls whose minimum and maximum
  * widths are not the same.
  */

 public class HTMLTableLayout extends Layout implements ILayoutExtension {
 	public int numColumns = 1;
 	public int leftMargin = 5;
 	public int rightMargin = 5;
 	public int topMargin = 5;
 	public int bottomMargin = 5;
 	public int horizontalSpacing = 5;
 	public int verticalSpacing = 5;
 	public boolean makeColumnsEqualWidth = false;

 	private boolean initialLayout = true;
 	private Vector grid = null;
 	private int[] minColumnWidths, maxColumnWidths;
 	private int widestColumnWidth;
 	private int[] growingColumns;

 	public int getMinimumWidth(Composite parent, boolean changed) {
 		changed = true;
 		initializeIfNeeded(parent, changed);
 		if (initialLayout) {
 			changed = true;
 			initialLayout = false;
 		}
 		if (grid == null || changed) {
 			changed = true;
 			grid = new Vector();
 			createGrid(parent);
 		}
 		if (minColumnWidths == null)
 			minColumnWidths = new int[numColumns];
 		for (int i = 0; i < numColumns; i++) {
 			minColumnWidths[i] = 0;
 		}
 		return internalGetMinimumWidth(parent, changed);
 	}

 	public int getMaximumWidth(Composite parent, boolean changed) {
 		changed = true;
 		initializeIfNeeded(parent, changed);
 		if (initialLayout) {
 			changed = true;
 			initialLayout = false;
 		}
 		if (grid == null || changed) {
 			changed = true;
 			grid = new Vector();
 			createGrid(parent);
 		}
 		if (maxColumnWidths == null)
 			maxColumnWidths = new int[numColumns];
 		for (int i = 0; i < numColumns; i++) {
 			maxColumnWidths[i] = 0;
 		}
 		return internalGetMaximumWidth(parent, changed);
 	}

 	/**
 	 * @see Layout#layout(Composite, boolean)
 	 */
 	protected void layout(Composite parent, boolean changed) {
 		Rectangle clientArea = parent.getClientArea();
 		Control[] children = parent.getChildren();
 		if (children.length == 0)
 			return;
 		int parentWidth = clientArea.width;
 		changed = true;
 		initializeIfNeeded(parent, changed);
 		if (initialLayout) {
 			changed = true;
 			initialLayout = false;
 		}
 		if (grid == null || changed) {
 			changed = true;
 			grid = new Vector();
 			createGrid(parent);
 		}
 		resetColumnWidths();
 		int minWidth = internalGetMinimumWidth(parent, changed);
 		int maxWidth = internalGetMaximumWidth(parent, changed);

 		int tableWidth = parentWidth;

 		int[] columnWidths;

 		if (parentWidth < minWidth) {
 			tableWidth = minWidth;
 			if (makeColumnsEqualWidth) {
 				columnWidths = new int[numColumns];
 				for (int i = 0; i < numColumns; i++) {
 					columnWidths[i] = widestColumnWidth;
 				}
 			} else
 				columnWidths = minColumnWidths;
 		} else if (parentWidth > maxWidth) {
 			if (growingColumns.length == 0) {
 				tableWidth = maxWidth;
 				columnWidths = maxColumnWidths;
 			} else {
 				columnWidths = new int[numColumns];
 				int colSpace = tableWidth - leftMargin - rightMargin;
 				colSpace -= (numColumns - 1) * horizontalSpacing;
 				int extra = parentWidth - maxWidth;
 				int colExtra = extra / growingColumns.length;
 				for (int i = 0; i < numColumns; i++) {
 					columnWidths[i] = maxColumnWidths[i];

 					if (isGrowingColumn(i)) {
 						columnWidths[i] += colExtra;
 					}
 				}
 			}
 		} else {
 			columnWidths = new int[numColumns];
 			if (makeColumnsEqualWidth) {
 				int colSpace = tableWidth - leftMargin - rightMargin;
 				colSpace -= (numColumns - 1) * horizontalSpacing;
 				int col = colSpace / numColumns;
 				for (int i = 0; i < numColumns; i++) {
 					columnWidths[i] = col;
 				}
 			} else {
 				int[] extraSpace =
 					calculateExtraSpace(tableWidth, maxWidth, minWidth);
 				for (int i = 0; i < numColumns; i++) {
 					int minCWidth = minColumnWidths[i];
 					columnWidths[i] = minCWidth + extraSpace[i];
 				}
 			}
 		}
 		int x = 0;
 		int y = topMargin;
 		// assign widths
 		for (int i = 0; i < grid.size(); i++) {
 			TableData[] row = (TableData[]) grid.elementAt(i);
 			// assign widths, calculate heights
 			int rowHeight = 0;
 			x = leftMargin;
 			for (int j = 0; j < numColumns; j++) {
 				TableData td = row[j];
 				if (td.isItemData == false) {
 					continue;
 				}
 				Control child = children[td.childIndex];
 				int span = td.colspan;
 				int cwidth = 0;
 				for (int k = j; k < j + span; k++) {
 					cwidth += columnWidths[k];
 					if (k < j + span - 1)
 						cwidth += horizontalSpacing;
 				}
 				Point size = computeSize(child, cwidth, changed);
 				td.compWidth = cwidth;
 				if (td.heightHint != SWT.DEFAULT) {
 					size = new Point(size.x, td.heightHint);
 				}
 				td.compSize = size;
 				rowHeight = Math.max(rowHeight, size.y);
 			}
 			for (int j = 0; j < numColumns; j++) {
 				TableData td = row[j];
 				if (td.isItemData == false) {
 					continue;
 				}
 				Control child = children[td.childIndex];
 				placeControl(child, td, x, y, rowHeight);
 				x += td.compWidth;
 				if (j < numColumns - 1)
 					x += horizontalSpacing;
 			}
 			y += rowHeight + verticalSpacing;
 		}
 	}

 	boolean isGrowingColumn(int col) {
 		if (growingColumns == null)
 			return false;
 		for (int i = 0; i < growingColumns.length; i++) {
 			if (col == growingColumns[i])
 				return true;
 		}
 		return false;
 	}

 	int[] calculateExtraSpace(int tableWidth, int maxWidth, int minWidth) {
 		int fixedPart =
 			leftMargin + rightMargin + (numColumns - 1) * horizontalSpacing;
 		int D = maxWidth - minWidth;

 		int W = tableWidth - fixedPart - minWidth;

 		int extraSpace[] = new int[numColumns];

 		int rem = 0;
 		for (int i = 0; i < numColumns; i++) {
 			int cmin = minColumnWidths[i];
 			int cmax = maxColumnWidths[i];
 			int d = cmax - cmin;
 			int extra = D != 0 ? (d * W) / D : 0;
 			if (i < numColumns - 1) {
 				extraSpace[i] = extra;
 				rem += extra;
 			} else {
 				extraSpace[i] = W - rem;
 			}
 		}
 		return extraSpace;
 	}

 	Point computeSize(Control child, int width, boolean changed) {
 		int widthArg = width;
 		if (!isWrap(child))
 			widthArg = SWT.DEFAULT;
 		Point size = child.computeSize(widthArg, SWT.DEFAULT, changed);
 		return size;
 	}

 	void placeControl(
 		Control control,
 		TableData td,
 		int x,
 		int y,
 		int rowHeight) {
 		int xloc = x + td.indent;
 		int yloc = y;
 		int width = td.compSize.x;
 		int height = td.compSize.y;
 		int colWidth = td.compWidth;

 		// align horizontally
 		if (td.align == TableData.CENTER) {
 			xloc = x + colWidth / 2 - width / 2;
 		} else if (td.align == TableData.RIGHT) {
 			xloc = x + colWidth - width;
 		} else if (td.align == TableData.FILL) {
 			width = colWidth;
 		}
 		// align vertically
 		if (td.valign == TableData.MIDDLE) {
 			yloc = y + rowHeight / 2 - height / 2;
 		} else if (td.valign == TableData.BOTTOM) {
 			yloc = y + rowHeight - height;
 		} else if (td.valign == TableData.FILL) {
 			height = rowHeight;
 		}
 		control.setBounds(xloc, yloc, width, height);
 	}

 	void createGrid(Composite composite) {
 		int row, column, rowFill, columnFill;
 		Control[] children;
 		TableData spacerSpec;
 		Vector growingCols = new Vector();

 		//
 		children = composite.getChildren();
 		if (children.length == 0)
 			return;

 		//
 		grid.addElement(createEmptyRow());
 		row = 0;
 		column = 0;

 		// Loop through the children and place their associated layout specs in
 		// the
 		// grid. Placement occurs left to right, top to bottom (i.e., by row).
 		for (int i = 0; i < children.length; i++) {
 			// Find the first available spot in the grid.
 			Control child = children[i];
 			TableData spec = (TableData) child.getLayoutData();
 			while (((TableData[]) grid.elementAt(row))[column] != null) {
 				column = column + 1;
 				if (column >= numColumns) {
 					row = row + 1;
 					column = 0;
 					if (row >= grid.size()) {
 						grid.addElement(createEmptyRow());
 					}
 				}
 			}
 			// See if the place will support the widget's horizontal span. If
 			// not, go to the
 			// next row.
 			if (column + spec.colspan - 1 >= numColumns) {
 				grid.addElement(createEmptyRow());
 				row = row + 1;
 				column = 0;
 			}

 			// The vertical span for the item will be at least 1. If it is > 1,
 			// add other rows to the grid.
 			for (int j = 2; j <= spec.rowspan; j++) {
 				if (row + j > grid.size()) {
 					grid.addElement(createEmptyRow());
 				}
 			}

 			// Store the layout spec. Also cache the childIndex. NOTE: That we
 			// assume the children of a
 			// composite are maintained in the order in which they are created
 			// and added to the composite.
 			 ((TableData[]) grid.elementAt(row))[column] = spec;
 			spec.childIndex = i;

 			if (spec.grabHorizontal) {
 				updateGrowingColumns(growingCols, spec, column);
 			}

 			// Put spacers in the grid to account for the item's vertical and
 			// horizontal
 			// span.
 			rowFill = spec.rowspan - 1;
 			columnFill = spec.colspan - 1;
 			for (int r = 1; r <= rowFill; r++) {
 				for (int c = 0; c < spec.colspan; c++) {
 					spacerSpec = new TableData();
 					spacerSpec.isItemData = false;
 					((TableData[]) grid.elementAt(row + r))[column + c] =
 						spacerSpec;
 				}
 			}
 			for (int c = 1; c <= columnFill; c++) {
 				for (int r = 0; r < spec.rowspan; r++) {
 					spacerSpec = new TableData();
 					spacerSpec.isItemData = false;
 					((TableData[]) grid.elementAt(row + r))[column + c] =
 						spacerSpec;
 				}
 			}
 			column = column + spec.colspan - 1;
 		}

 		// Fill out empty grid cells with spacers.
 		for (int k = column + 1; k < numColumns; k++) {
 			spacerSpec = new TableData();
 			spacerSpec.isItemData = false;
 			((TableData[]) grid.elementAt(row))[k] = spacerSpec;
 		}
 		for (int k = row + 1; k < grid.size(); k++) {
 			spacerSpec = new TableData();
 			spacerSpec.isItemData = false;
 			((TableData[]) grid.elementAt(k))[column] = spacerSpec;
 		}
 		growingColumns = new int[growingCols.size()];
 		for (int i = 0; i < growingCols.size(); i++) {
 			growingColumns[i] = ((Integer) growingCols.get(i)).intValue();
 		}
 	}

 	private void updateGrowingColumns(
 		Vector growingColumns,
 		TableData spec,
 		int column) {
 		int affectedColumn = column + spec.colspan - 1;
 		for (int i = 0; i < growingColumns.size(); i++) {
 			Integer col = (Integer) growingColumns.get(i);
 			if (col.intValue() == affectedColumn)
 				return;
 		}
 		growingColumns.add(new Integer(affectedColumn));
 	}

 	private TableData[] createEmptyRow() {
 		TableData[] row = new TableData[numColumns];
 		for (int i = 0; i < numColumns; i++)
 			row[i] = null;
 		return row;
 	}

 	/**
 	 * @see Layout#computeSize(Composite, int, int, boolean)
 	 */
 	protected Point computeSize(
 		Composite parent,
 		int wHint,
 		int hHint,
 		boolean changed) {
 		Control[] children = parent.getChildren();
 		if (children.length == 0) {
 			return new Point(0, 0);
 		}
 		int parentWidth = wHint;
 		changed = true;
 		initializeIfNeeded(parent, changed);
 		if (initialLayout) {
 			changed = true;
 			initialLayout = false;
 		}
 		if (grid == null || changed) {
 			changed = true;
 			grid = new Vector();
 			createGrid(parent);
 		}
 		resetColumnWidths();
 		int minWidth = internalGetMinimumWidth(parent, changed);
 		int maxWidth = internalGetMaximumWidth(parent, changed);

 		int tableWidth = parentWidth;

 		int[] columnWidths;

 		if (parentWidth < minWidth) {
 			tableWidth = minWidth;
 			if (makeColumnsEqualWidth) {
 				columnWidths = new int[numColumns];
 				for (int i = 0; i < numColumns; i++) {
 					columnWidths[i] = widestColumnWidth;
 				}
 			} else
 				columnWidths = minColumnWidths;
 		} else if (parentWidth > maxWidth) {
 			if (makeColumnsEqualWidth) {
 				columnWidths = new int[numColumns];
 				int colSpace = parentWidth - leftMargin - rightMargin;
 				colSpace -= (numColumns - 1) * horizontalSpacing;
 				int col = colSpace / numColumns;
 				for (int i = 0; i < numColumns; i++) {
 					columnWidths[i] = col;
 				}
 			} else {
 				tableWidth = maxWidth;
 				columnWidths = maxColumnWidths;
 			}
 		} else {
 			columnWidths = new int[numColumns];
 			if (makeColumnsEqualWidth) {
 				int colSpace = tableWidth - leftMargin - rightMargin;
 				colSpace -= (numColumns - 1) * horizontalSpacing;
 				int col = colSpace / numColumns;
 				for (int i = 0; i < numColumns; i++) {
 					columnWidths[i] = col;
 				}
 			} else {
 				int[] extraSpace =
 					calculateExtraSpace(tableWidth, maxWidth, minWidth);
 				for (int i = 0; i < numColumns; i++) {
 					int minCWidth = minColumnWidths[i];
 					columnWidths[i] = minCWidth + extraSpace[i];
 				}
 			}
 		}
 		int totalHeight = 0;
 		int y = topMargin;
 		// compute widths
 		for (int i = 0; i < grid.size(); i++) {
 			TableData[] row = (TableData[]) grid.elementAt(i);
 			// assign widths, calculate heights
 			int rowHeight = 0;
 			for (int j = 0; j < numColumns; j++) {
 				TableData td = row[j];
 				if (td.isItemData == false) {
 					continue;
 				}
 				Control child = children[td.childIndex];
 				int span = td.colspan;
 				int cwidth = 0;
 				for (int k = j; k < j + span; k++) {
 					if (k > j)
 						cwidth += horizontalSpacing;
 					cwidth += columnWidths[k];
 				}
 				int cy = td.heightHint;
 				if (cy == SWT.DEFAULT) {
 					Point size = computeSize(child, cwidth, changed);
 					cy = size.y;
 				}
 				rowHeight = Math.max(rowHeight, cy);
 			}
 			y += rowHeight + verticalSpacing;
 		}
 		totalHeight = y + bottomMargin;
 		return new Point(tableWidth, totalHeight);
 	}

 	int internalGetMinimumWidth(Composite parent, boolean changed) {
 		if (changed)
 			calculateMinimumColumnWidths(parent, true);
 		int minimumWidth = 0;

 		widestColumnWidth = 0;

 		if (makeColumnsEqualWidth) {
 			for (int i = 0; i < numColumns; i++) {
 				widestColumnWidth =
 					Math.max(widestColumnWidth, minColumnWidths[i]);
 			}
 		}
 		for (int i = 0; i < numColumns; i++) {
 			if (i > 0)
 				minimumWidth += horizontalSpacing;
 			if (makeColumnsEqualWidth)
 				minimumWidth += widestColumnWidth;
 			else
 				minimumWidth += minColumnWidths[i];
 		}
 		// add margins
 		minimumWidth += leftMargin + rightMargin;
 		return minimumWidth;
 	}

 	int internalGetMaximumWidth(Composite parent, boolean changed) {
 		if (changed)
 			calculateMaximumColumnWidths(parent, true);
 		int maximumWidth = 0;
 		for (int i = 0; i < numColumns; i++) {
 			if (i > 0)
 				maximumWidth += horizontalSpacing;
 			maximumWidth += maxColumnWidths[i];
 		}
 		// add margins
 		maximumWidth += leftMargin + rightMargin;
 		return maximumWidth;
 	}

 	void resetColumnWidths() {
 		if (minColumnWidths == null)
 			minColumnWidths = new int[numColumns];
 		if (maxColumnWidths == null)
 			maxColumnWidths = new int[numColumns];
 		for (int i = 0; i < numColumns; i++) {
 			minColumnWidths[i] = 0;
 		}
 		for (int i = 0; i < numColumns; i++) {
 			maxColumnWidths[i] = 0;
 		}
 	}

 	void calculateMinimumColumnWidths(Composite parent, boolean changed) {
 		Control[] children = parent.getChildren();

 		for (int i = 0; i < grid.size(); i++) {
 			TableData[] row = (TableData[]) grid.elementAt(i);
 			for (int j = 0; j < numColumns; j++) {
 				TableData td = row[j];
 				if (td.isItemData == false)
 					continue;
 				Control child = children[td.childIndex];
 				int minWidth = -1;
 				if (child instanceof Composite) {
 					Composite cc = (Composite) child;
 					Layout l = cc.getLayout();
 					if (l instanceof ILayoutExtension) {
 						minWidth =
 							((ILayoutExtension) l).getMinimumWidth(cc, changed);
 					}
 				}
 				if (minWidth == -1) {
 					if (isWrap(child)) {
 						// Should be the width of the
 						// longest word, we'll pick
 						// some small number instead
 						minWidth = 30;
 					} else {
 						Point size =
 							child.computeSize(
 								SWT.DEFAULT,
 								SWT.DEFAULT,
 								changed);
 						minWidth = size.x;
 					}
 				}
 				minWidth += td.indent;
 				minColumnWidths[j] = Math.max(minColumnWidths[j], minWidth);
 			}
 		}
 	}

 	boolean isWrap(Control control) {
 		if (control instanceof Composite
 			&& ((Composite) control).getLayout() instanceof ILayoutExtension)
 			return true;
 		return (control.getStyle() & SWT.WRAP) != 0;
 	}

 	void calculateMaximumColumnWidths(Composite parent, boolean changed) {
 		Control[] children = parent.getChildren();

 		for (int i = 0; i < numColumns; i++) {
 			maxColumnWidths[i] = 0;
 		}
 		for (int i = 0; i < grid.size(); i++) {
 			TableData[] row = (TableData[]) grid.elementAt(i);
 			for (int j = 0; j < numColumns; j++) {
 				TableData td = row[j];
 				if (td.isItemData == false)
 					continue;
 				Control child = children[td.childIndex];
 				int maxWidth = -1;
 				if (child instanceof Composite) {
 					Composite cc = (Composite) child;
 					Layout l = cc.getLayout();
 					if (l instanceof ILayoutExtension) {
 						maxWidth =
 							((ILayoutExtension) l).getMaximumWidth(cc, changed);
 					}
 				}
 				if (maxWidth == -1) {
 					Point size =
 						child.computeSize(SWT.DEFAULT, SWT.DEFAULT, changed);
 					maxWidth = size.x;
 				}
 				maxWidth += td.indent;
 				if (td.colspan == 1)
 					maxColumnWidths[j] = Math.max(maxColumnWidths[j], maxWidth);
 				else {
 					// grow the last column
 					int last = j + td.colspan - 1;
 					int rem = 0;
 					for (int k = j; k < j + td.colspan - 1; k++) {
 						rem += maxColumnWidths[k];
 					}
 					int reduced = maxWidth - rem;
 					maxColumnWidths[last] =
 						Math.max(maxColumnWidths[last], reduced);
 				}
 			}
 		}
 	}

 	private void initializeIfNeeded(Composite parent, boolean changed) {
 		if (changed)
 			initialLayout = true;
 		if (initialLayout) {
 			initializeLayoutData(parent);
 			initialLayout = false;
 		}
 	}

 	void initializeLayoutData(Composite composite) {
 		Control[] children = composite.getChildren();
 		for (int i = 0; i < children.length; i++) {
 			Control child = children[i];
 			if (child.getLayoutData() == null) {
 				child.setLayoutData(new TableData());
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2003 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Common Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/cpl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.update.ui.forms.internal;
	import java.util.Vector;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.graphics.*;
	import org.eclipse.swt.widgets.*;

	/**
	* This implementation of the layout algorithm attempts to position controls in
	* the composite using a two-pass autolayout HTML table altorithm recommeded by
	* HTML 4.01 W3C specification. The main differences with GridLayout is that it
	* has two passes and that width and height are not calculated in the same
	* pass.
	* <p>
	* The advantage of the algorithm over GridLayout is that it is capable of
	* flowing text controls capable of line wrap. These controls do not have
	* natural 'preferred size'. Instead, they are capable of providing the
	* required height if the width is set. Consequently, this algorithm first
	* calculates the widths that will be assigned to columns, and then passes
	* those widths to the controls to calculate the height. When a composite with
	* this layout is a child of the scrolling composite, they should interact in
	* such a way that reduction in the scrolling composite width results in the
	* reflow and increase of the overall height.
	* <p>
	* If none of the columns contain expandable and wrappable controls, the
	* end-result will be similar to the one provided by GridLayout. The difference
	* will show up for layouts that contain controls whose minimum and maximum
	* widths are not the same.
	*/

	public class HTMLTableLayout extends Layout implements ILayoutExtension {
	public int numColumns = 1;
	public int leftMargin = 5;
	public int rightMargin = 5;
	public int topMargin = 5;
	public int bottomMargin = 5;
	public int horizontalSpacing = 5;
	public int verticalSpacing = 5;
	public boolean makeColumnsEqualWidth = false;

	private boolean initialLayout = true;
	private Vector grid = null;
	private int[] minColumnWidths, maxColumnWidths;
	private int widestColumnWidth;
	private int[] growingColumns;

	public int getMinimumWidth(Composite parent, boolean changed) {
	changed = true;
	initializeIfNeeded(parent, changed);
	if (initialLayout) {
	changed = true;
	initialLayout = false;
	}
	if (grid == null \|\| changed) {
	changed = true;
	grid = new Vector();
	createGrid(parent);
	}
	if (minColumnWidths == null)
	minColumnWidths = new int[numColumns];
	for (int i = 0; i < numColumns; i++) {
	minColumnWidths[i] = 0;
	}
	return internalGetMinimumWidth(parent, changed);
	}

	public int getMaximumWidth(Composite parent, boolean changed) {
	changed = true;
	initializeIfNeeded(parent, changed);
	if (initialLayout) {
	changed = true;
	initialLayout = false;
	}
	if (grid == null \|\| changed) {
	changed = true;
	grid = new Vector();
	createGrid(parent);
	}
	if (maxColumnWidths == null)
	maxColumnWidths = new int[numColumns];
	for (int i = 0; i < numColumns; i++) {
	maxColumnWidths[i] = 0;
	}
	return internalGetMaximumWidth(parent, changed);
	}

	/**
	* @see Layout#layout(Composite, boolean)
	*/
	protected void layout(Composite parent, boolean changed) {
	Rectangle clientArea = parent.getClientArea();
	Control[] children = parent.getChildren();
	if (children.length == 0)
	return;
	int parentWidth = clientArea.width;
	changed = true;
	initializeIfNeeded(parent, changed);
	if (initialLayout) {
	changed = true;
	initialLayout = false;
	}
	if (grid == null \|\| changed) {
	changed = true;
	grid = new Vector();
	createGrid(parent);
	}
	resetColumnWidths();
	int minWidth = internalGetMinimumWidth(parent, changed);
	int maxWidth = internalGetMaximumWidth(parent, changed);

	int tableWidth = parentWidth;

	int[] columnWidths;

	if (parentWidth < minWidth) {
	tableWidth = minWidth;
	if (makeColumnsEqualWidth) {
	columnWidths = new int[numColumns];
	for (int i = 0; i < numColumns; i++) {
	columnWidths[i] = widestColumnWidth;
	}
	} else
	columnWidths = minColumnWidths;
	} else if (parentWidth > maxWidth) {
	if (growingColumns.length == 0) {
	tableWidth = maxWidth;
	columnWidths = maxColumnWidths;
	} else {
	columnWidths = new int[numColumns];
	int colSpace = tableWidth - leftMargin - rightMargin;
	colSpace -= (numColumns - 1) * horizontalSpacing;
	int extra = parentWidth - maxWidth;
	int colExtra = extra / growingColumns.length;
	for (int i = 0; i < numColumns; i++) {
	columnWidths[i] = maxColumnWidths[i];

	if (isGrowingColumn(i)) {
	columnWidths[i] += colExtra;
	}
	}
	}
	} else {
	columnWidths = new int[numColumns];
	if (makeColumnsEqualWidth) {
	int colSpace = tableWidth - leftMargin - rightMargin;
	colSpace -= (numColumns - 1) * horizontalSpacing;
	int col = colSpace / numColumns;
	for (int i = 0; i < numColumns; i++) {
	columnWidths[i] = col;
	}
	} else {
	int[] extraSpace =
	calculateExtraSpace(tableWidth, maxWidth, minWidth);
	for (int i = 0; i < numColumns; i++) {
	int minCWidth = minColumnWidths[i];
	columnWidths[i] = minCWidth + extraSpace[i];
	}
	}
	}
	int x = 0;
	int y = topMargin;
	// assign widths
	for (int i = 0; i < grid.size(); i++) {
	TableData[] row = (TableData[]) grid.elementAt(i);
	// assign widths, calculate heights
	int rowHeight = 0;
	x = leftMargin;
	for (int j = 0; j < numColumns; j++) {
	TableData td = row[j];
	if (td.isItemData == false) {
	continue;
	}
	Control child = children[td.childIndex];
	int span = td.colspan;
	int cwidth = 0;
	for (int k = j; k < j + span; k++) {
	cwidth += columnWidths[k];
	if (k < j + span - 1)
	cwidth += horizontalSpacing;
	}
	Point size = computeSize(child, cwidth, changed);
	td.compWidth = cwidth;
	if (td.heightHint != SWT.DEFAULT) {
	size = new Point(size.x, td.heightHint);
	}
	td.compSize = size;
	rowHeight = Math.max(rowHeight, size.y);
	}
	for (int j = 0; j < numColumns; j++) {
	TableData td = row[j];
	if (td.isItemData == false) {
	continue;
	}
	Control child = children[td.childIndex];
	placeControl(child, td, x, y, rowHeight);
	x += td.compWidth;
	if (j < numColumns - 1)
	x += horizontalSpacing;
	}
	y += rowHeight + verticalSpacing;
	}
	}

	boolean isGrowingColumn(int col) {
	if (growingColumns == null)
	return false;
	for (int i = 0; i < growingColumns.length; i++) {
	if (col == growingColumns[i])
	return true;
	}
	return false;
	}

	int[] calculateExtraSpace(int tableWidth, int maxWidth, int minWidth) {
	int fixedPart =
	leftMargin + rightMargin + (numColumns - 1) * horizontalSpacing;
	int D = maxWidth - minWidth;

	int W = tableWidth - fixedPart - minWidth;

	int extraSpace[] = new int[numColumns];

	int rem = 0;
	for (int i = 0; i < numColumns; i++) {
	int cmin = minColumnWidths[i];
	int cmax = maxColumnWidths[i];
	int d = cmax - cmin;
	int extra = D != 0 ? (d * W) / D : 0;
	if (i < numColumns - 1) {
	extraSpace[i] = extra;
	rem += extra;
	} else {
	extraSpace[i] = W - rem;
	}
	}
	return extraSpace;
	}

	Point computeSize(Control child, int width, boolean changed) {
	int widthArg = width;
	if (!isWrap(child))
	widthArg = SWT.DEFAULT;
	Point size = child.computeSize(widthArg, SWT.DEFAULT, changed);
	return size;
	}

	void placeControl(
	Control control,
	TableData td,
	int x,
	int y,
	int rowHeight) {
	int xloc = x + td.indent;
	int yloc = y;
	int width = td.compSize.x;
	int height = td.compSize.y;
	int colWidth = td.compWidth;

	// align horizontally
	if (td.align == TableData.CENTER) {
	xloc = x + colWidth / 2 - width / 2;
	} else if (td.align == TableData.RIGHT) {
	xloc = x + colWidth - width;
	} else if (td.align == TableData.FILL) {
	width = colWidth;
	}
	// align vertically
	if (td.valign == TableData.MIDDLE) {
	yloc = y + rowHeight / 2 - height / 2;
	} else if (td.valign == TableData.BOTTOM) {
	yloc = y + rowHeight - height;
	} else if (td.valign == TableData.FILL) {
	height = rowHeight;
	}
	control.setBounds(xloc, yloc, width, height);
	}

	void createGrid(Composite composite) {
	int row, column, rowFill, columnFill;
	Control[] children;
	TableData spacerSpec;
	Vector growingCols = new Vector();

	//
	children = composite.getChildren();
	if (children.length == 0)
	return;

	//
	grid.addElement(createEmptyRow());
	row = 0;
	column = 0;

	// Loop through the children and place their associated layout specs in
	// the
	// grid. Placement occurs left to right, top to bottom (i.e., by row).
	for (int i = 0; i < children.length; i++) {
	// Find the first available spot in the grid.
	Control child = children[i];
	TableData spec = (TableData) child.getLayoutData();
	while (((TableData[]) grid.elementAt(row))[column] != null) {
	column = column + 1;
	if (column >= numColumns) {
	row = row + 1;
	column = 0;
	if (row >= grid.size()) {
	grid.addElement(createEmptyRow());
	}
	}
	}
	// See if the place will support the widget's horizontal span. If
	// not, go to the
	// next row.
	if (column + spec.colspan - 1 >= numColumns) {
	grid.addElement(createEmptyRow());
	row = row + 1;
	column = 0;
	}

	// The vertical span for the item will be at least 1. If it is > 1,
	// add other rows to the grid.
	for (int j = 2; j <= spec.rowspan; j++) {
	if (row + j > grid.size()) {
	grid.addElement(createEmptyRow());
	}
	}

	// Store the layout spec. Also cache the childIndex. NOTE: That we
	// assume the children of a
	// composite are maintained in the order in which they are created
	// and added to the composite.
	((TableData[]) grid.elementAt(row))[column] = spec;
	spec.childIndex = i;

	if (spec.grabHorizontal) {
	updateGrowingColumns(growingCols, spec, column);
	}

	// Put spacers in the grid to account for the item's vertical and
	// horizontal
	// span.
	rowFill = spec.rowspan - 1;
	columnFill = spec.colspan - 1;
	for (int r = 1; r <= rowFill; r++) {
	for (int c = 0; c < spec.colspan; c++) {
	spacerSpec = new TableData();
	spacerSpec.isItemData = false;
	((TableData[]) grid.elementAt(row + r))[column + c] =
	spacerSpec;
	}
	}
	for (int c = 1; c <= columnFill; c++) {
	for (int r = 0; r < spec.rowspan; r++) {
	spacerSpec = new TableData();
	spacerSpec.isItemData = false;
	((TableData[]) grid.elementAt(row + r))[column + c] =
	spacerSpec;
	}
	}
	column = column + spec.colspan - 1;
	}

	// Fill out empty grid cells with spacers.
	for (int k = column + 1; k < numColumns; k++) {
	spacerSpec = new TableData();
	spacerSpec.isItemData = false;
	((TableData[]) grid.elementAt(row))[k] = spacerSpec;
	}
	for (int k = row + 1; k < grid.size(); k++) {
	spacerSpec = new TableData();
	spacerSpec.isItemData = false;
	((TableData[]) grid.elementAt(k))[column] = spacerSpec;
	}
	growingColumns = new int[growingCols.size()];
	for (int i = 0; i < growingCols.size(); i++) {
	growingColumns[i] = ((Integer) growingCols.get(i)).intValue();
	}
	}

	private void updateGrowingColumns(
	Vector growingColumns,
	TableData spec,
	int column) {
	int affectedColumn = column + spec.colspan - 1;
	for (int i = 0; i < growingColumns.size(); i++) {
	Integer col = (Integer) growingColumns.get(i);
	if (col.intValue() == affectedColumn)
	return;
	}
	growingColumns.add(new Integer(affectedColumn));
	}

	private TableData[] createEmptyRow() {
	TableData[] row = new TableData[numColumns];
	for (int i = 0; i < numColumns; i++)
	row[i] = null;
	return row;
	}

	/**
	* @see Layout#computeSize(Composite, int, int, boolean)
	*/
	protected Point computeSize(
	Composite parent,
	int wHint,
	int hHint,
	boolean changed) {
	Control[] children = parent.getChildren();
	if (children.length == 0) {
	return new Point(0, 0);
	}
	int parentWidth = wHint;
	changed = true;
	initializeIfNeeded(parent, changed);
	if (initialLayout) {
	changed = true;
	initialLayout = false;
	}
	if (grid == null \|\| changed) {
	changed = true;
	grid = new Vector();
	createGrid(parent);
	}
	resetColumnWidths();
	int minWidth = internalGetMinimumWidth(parent, changed);
	int maxWidth = internalGetMaximumWidth(parent, changed);

	int tableWidth = parentWidth;

	int[] columnWidths;

	if (parentWidth < minWidth) {
	tableWidth = minWidth;
	if (makeColumnsEqualWidth) {
	columnWidths = new int[numColumns];
	for (int i = 0; i < numColumns; i++) {
	columnWidths[i] = widestColumnWidth;
	}
	} else
	columnWidths = minColumnWidths;
	} else if (parentWidth > maxWidth) {
	if (makeColumnsEqualWidth) {
	columnWidths = new int[numColumns];
	int colSpace = parentWidth - leftMargin - rightMargin;
	colSpace -= (numColumns - 1) * horizontalSpacing;
	int col = colSpace / numColumns;
	for (int i = 0; i < numColumns; i++) {
	columnWidths[i] = col;
	}
	} else {
	tableWidth = maxWidth;
	columnWidths = maxColumnWidths;
	}
	} else {
	columnWidths = new int[numColumns];
	if (makeColumnsEqualWidth) {
	int colSpace = tableWidth - leftMargin - rightMargin;
	colSpace -= (numColumns - 1) * horizontalSpacing;
	int col = colSpace / numColumns;
	for (int i = 0; i < numColumns; i++) {
	columnWidths[i] = col;
	}
	} else {
	int[] extraSpace =
	calculateExtraSpace(tableWidth, maxWidth, minWidth);
	for (int i = 0; i < numColumns; i++) {
	int minCWidth = minColumnWidths[i];
	columnWidths[i] = minCWidth + extraSpace[i];
	}
	}
	}
	int totalHeight = 0;
	int y = topMargin;
	// compute widths
	for (int i = 0; i < grid.size(); i++) {
	TableData[] row = (TableData[]) grid.elementAt(i);
	// assign widths, calculate heights
	int rowHeight = 0;
	for (int j = 0; j < numColumns; j++) {
	TableData td = row[j];
	if (td.isItemData == false) {
	continue;
	}
	Control child = children[td.childIndex];
	int span = td.colspan;
	int cwidth = 0;
	for (int k = j; k < j + span; k++) {
	if (k > j)
	cwidth += horizontalSpacing;
	cwidth += columnWidths[k];
	}
	int cy = td.heightHint;
	if (cy == SWT.DEFAULT) {
	Point size = computeSize(child, cwidth, changed);
	cy = size.y;
	}
	rowHeight = Math.max(rowHeight, cy);
	}
	y += rowHeight + verticalSpacing;
	}
	totalHeight = y + bottomMargin;
	return new Point(tableWidth, totalHeight);
	}

	int internalGetMinimumWidth(Composite parent, boolean changed) {
	if (changed)
	calculateMinimumColumnWidths(parent, true);
	int minimumWidth = 0;

	widestColumnWidth = 0;

	if (makeColumnsEqualWidth) {
	for (int i = 0; i < numColumns; i++) {
	widestColumnWidth =
	Math.max(widestColumnWidth, minColumnWidths[i]);
	}
	}
	for (int i = 0; i < numColumns; i++) {
	if (i > 0)
	minimumWidth += horizontalSpacing;
	if (makeColumnsEqualWidth)
	minimumWidth += widestColumnWidth;
	else
	minimumWidth += minColumnWidths[i];
	}
	// add margins
	minimumWidth += leftMargin + rightMargin;
	return minimumWidth;
	}

	int internalGetMaximumWidth(Composite parent, boolean changed) {
	if (changed)
	calculateMaximumColumnWidths(parent, true);
	int maximumWidth = 0;
	for (int i = 0; i < numColumns; i++) {
	if (i > 0)
	maximumWidth += horizontalSpacing;
	maximumWidth += maxColumnWidths[i];
	}
	// add margins
	maximumWidth += leftMargin + rightMargin;
	return maximumWidth;
	}

	void resetColumnWidths() {
	if (minColumnWidths == null)
	minColumnWidths = new int[numColumns];
	if (maxColumnWidths == null)
	maxColumnWidths = new int[numColumns];
	for (int i = 0; i < numColumns; i++) {
	minColumnWidths[i] = 0;
	}
	for (int i = 0; i < numColumns; i++) {
	maxColumnWidths[i] = 0;
	}
	}

	void calculateMinimumColumnWidths(Composite parent, boolean changed) {
	Control[] children = parent.getChildren();

	for (int i = 0; i < grid.size(); i++) {
	TableData[] row = (TableData[]) grid.elementAt(i);
	for (int j = 0; j < numColumns; j++) {
	TableData td = row[j];
	if (td.isItemData == false)
	continue;
	Control child = children[td.childIndex];
	int minWidth = -1;
	if (child instanceof Composite) {
	Composite cc = (Composite) child;
	Layout l = cc.getLayout();
	if (l instanceof ILayoutExtension) {
	minWidth =
	((ILayoutExtension) l).getMinimumWidth(cc, changed);
	}
	}
	if (minWidth == -1) {
	if (isWrap(child)) {
	// Should be the width of the
	// longest word, we'll pick
	// some small number instead
	minWidth = 30;
	} else {
	Point size =
	child.computeSize(
	SWT.DEFAULT,
	SWT.DEFAULT,
	changed);
	minWidth = size.x;
	}
	}
	minWidth += td.indent;
	minColumnWidths[j] = Math.max(minColumnWidths[j], minWidth);
	}
	}
	}

	boolean isWrap(Control control) {
	if (control instanceof Composite
	&& ((Composite) control).getLayout() instanceof ILayoutExtension)
	return true;
	return (control.getStyle() & SWT.WRAP) != 0;
	}

	void calculateMaximumColumnWidths(Composite parent, boolean changed) {
	Control[] children = parent.getChildren();

	for (int i = 0; i < numColumns; i++) {
	maxColumnWidths[i] = 0;
	}
	for (int i = 0; i < grid.size(); i++) {
	TableData[] row = (TableData[]) grid.elementAt(i);
	for (int j = 0; j < numColumns; j++) {
	TableData td = row[j];
	if (td.isItemData == false)
	continue;
	Control child = children[td.childIndex];
	int maxWidth = -1;
	if (child instanceof Composite) {
	Composite cc = (Composite) child;
	Layout l = cc.getLayout();
	if (l instanceof ILayoutExtension) {
	maxWidth =
	((ILayoutExtension) l).getMaximumWidth(cc, changed);
	}
	}
	if (maxWidth == -1) {
	Point size =
	child.computeSize(SWT.DEFAULT, SWT.DEFAULT, changed);
	maxWidth = size.x;
	}
	maxWidth += td.indent;
	if (td.colspan == 1)
	maxColumnWidths[j] = Math.max(maxColumnWidths[j], maxWidth);
	else {
	// grow the last column
	int last = j + td.colspan - 1;
	int rem = 0;
	for (int k = j; k < j + td.colspan - 1; k++) {
	rem += maxColumnWidths[k];
	}
	int reduced = maxWidth - rem;
	maxColumnWidths[last] =
	Math.max(maxColumnWidths[last], reduced);
	}
	}
	}
	}

	private void initializeIfNeeded(Composite parent, boolean changed) {
	if (changed)
	initialLayout = true;
	if (initialLayout) {
	initializeLayoutData(parent);
	initialLayout = false;
	}
	}

	void initializeLayoutData(Composite composite) {
	Control[] children = composite.getChildren();
	for (int i = 0; i < children.length; i++) {
	Control child = children[i];
	if (child.getLayoutData() == null) {
	child.setLayoutData(new TableData());
	}
	}
	}
	}