Attachment #45523 for bug #133279

View | Details | Raw Unified | Return to bug 133279 | Differences between
Collapse All | Expand All




package org.eclipse.gmf.internal.codegen.draw2d;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.draw2d.AbstractLayout;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.LayoutManager;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.swt.SWT;


/**
 * Lays out children into a Grid arrangement in which overall aligment and
 * spacing can be configured, as well as specfic layout requirements for the
 * each individual member of the GridLayout. This layout is a Draw2D port of the
 * swt GridLayout.
 * 
 * <code>GridLayout</code> has a number of configuration fields, and the
 * Figures it lays out can have an associated layout data object, called
 * <code>GridLayoutData</code> (similar to the swt GridLayoutData object). The power of
 * <code>GridLayout</code> lies in the ability to configure
 * <code>GridLayoutData</code> for each Figure in the layout.
 * <p>
 * The following code creates a container Figure managed by a
 * <code>GridLayout</code> with 2 columns, containing 3 RectangleFigure
 * shapes, the last of which has been given further layout instructions.
 * Note that it is the <code>GridLayout</code> method <code>setConstraint</code>
 * that binds the child <code>Figure</code> to its layout <code>GridLayoutData</code> object.
 * 
 * <pre>
 *     Figure container = new Figure();
 *     GridLayout gridLayout = new GridLayout();
 *     gridLayout.numColumns = 2;
 *     container.setLayout(gridLayout);
 * 
 *     Shape rect;
 *     rect = new RectangleFigure();
 *     container.add(rect);
 * 
 *     rect = new RectangleFigure();
 *     container.add(rect);
 * 
 *     rect = new RectangleFigure();
 *     GridLayoutData GridLayoutData = new GridLayoutData();
 *     GridLayoutData.widthHint = 150;
 *     layout.setConstraint(rect, GridLayoutData);
 * 
 *     container.add(rect);
 * </pre>
 * 
 * <p>
 * The <code>numColumns</code> field is the most important field in a
 * <code>GridLayout</code>. Widgets are laid out in columns from left to
 * right, and a new row is created when <code>numColumns</code>+ 1 figures
 * are added to the <code>Figure<code> parent container.
 * 
 * @see GridLayoutData
 * 
 * @author Asim Ullah
 * created: Sep 10, 2004
 */
public class GridLayout extends AbstractLayout {

	/**
	 * numColumns specifies the number of cell columns in the layout.
	 * 
	 * The default value is 1.
	 */
	public int numColumns = 1;

	/**
	 * makeColumnsEqualWidth specifies whether all columns in the layout will be
	 * forced to have the same width.
	 * 
	 * The default value is false.
	 */
	public boolean makeColumnsEqualWidth = false;

	/**
	 * marginWidth specifies the number of pixels of horizontal margin that will
	 * be placed along the left and right edges of the layout.
	 * 
	 * The default value is 5.
	 */
	public int marginWidth = 5;

	/**
	 * marginHeight specifies the number of pixels of vertical margin that will
	 * be placed along the top and bottom edges of the layout.
	 * 
	 * The default value is 5.
	 */
	public int marginHeight = 5;

	/**
	 * horizontalSpacing specifies the number of pixels between the right edge
	 * of one cell and the left edge of its neighbouring cell to the right.
	 * 
	 * The default value is 5.
	 */
	public int horizontalSpacing = 5;

	/**
	 * verticalSpacing specifies the number of pixels between the bottom edge of
	 * one cell and the top edge of its neighbouring cell underneath.
	 * 
	 * The default value is 5.
	 */
	public int verticalSpacing = 5;

	/** The layout contraints */
	protected Map constraints = new HashMap();

	/**
	 *  Default Constructor
	 */
	public GridLayout() {
		super();
	}

	/**
	 * Constructs a new instance of this class given the number of columns, and
	 * whether or not the columns should be forced to have the same width.
	 * 
	 * @param numColumns
	 *            the number of columns in the grid
	 * @param makeColumnsEqualWidth
	 *            whether or not the columns will have equal width
	 *  
	 */
	public GridLayout(int numColumns, boolean makeColumnsEqualWidth) {
		this.numColumns = numColumns;
		this.makeColumnsEqualWidth = makeColumnsEqualWidth;
	}

	/**
	 * @param child
	 * @param wHint
	 * @param hHint
	 * @return
	 */
	protected Dimension getChildSize(IFigure child, int wHint, int hHint) {
		return child.getPreferredSize(wHint, hHint);
	}

	GridLayoutData getData(IFigure[][] grid, int row, int column, int rowCount,
			int columnCount, boolean first) {
		IFigure figure = grid[row][column];
		if (figure != null) {
			GridLayoutData data = (GridLayoutData) getConstraint(figure);
			int hSpan = Math.max(1, Math.min(data.horizontalSpan, columnCount));
			int vSpan = Math.max(1, data.verticalSpan);
			int i = first ? row + vSpan - 1 : row - vSpan + 1;
			int j = first ? column + hSpan - 1 : column - hSpan + 1;
			if (0 <= i && i < rowCount) {
				if (0 <= j && j < columnCount) {
					if (figure == grid[i][j])
						return data;
				}
			}
		}
		return null;
	}
    
    void initChildren(IFigure container)
    {
        List children = container.getChildren();
        for (int i = 0; i < children.size(); i++) {
            IFigure child = (IFigure) children.get(i);
            if (child.getLayoutManager()==null)
            	child.setLayoutManager(this);
        }
    }

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.draw2d.AbstractLayout#calculatePreferredSize(org.eclipse.draw2d.IFigure,
	 *      int, int)
	 */
	protected Dimension calculatePreferredSize(IFigure container, int wHint,
			int hHint) {
		Dimension size = layout(container, false, 0, 0, wHint, hHint, /* flushCache */
				true);
    		if (wHint != SWT.DEFAULT)
			size.width = wHint;
		if (hHint != SWT.DEFAULT)
			size.height = hHint;

		return size;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.draw2d.LayoutManager#layout(org.eclipse.draw2d.IFigure)
	 */
	public void layout(IFigure container) {
        //initChildren( container);
		Rectangle rect = container.getClientArea();
		layout(container, true, rect.x, rect.y, rect.width, rect.height, /* flushCache */
				true);

	}

	Dimension layout(IFigure container, boolean move, int x, int y, int width,
			int height, boolean flushCache) {
		if (numColumns < 1)
			return new Dimension(marginWidth * 2, marginHeight * 2);
		List children = container.getChildren();
		for (int i = 0; i < children.size(); i++) {
			IFigure child = (IFigure) children.get(i);

			GridLayoutData data = (GridLayoutData) getConstraint(child);
			if (data == null)
				setConstraint(child, data = new GridLayoutData());
			if (flushCache)
				data.flushCache();
			data.computeSize(child, flushCache);
		}

		/* Build the grid */
		int row = 0, column = 0, rowCount = 0, columnCount = numColumns;
		IFigure[][] grid = new IFigure[4][columnCount];
		for (int i = 0; i < children.size(); i++) {
			IFigure child = (IFigure) children.get(i);
			GridLayoutData data = (GridLayoutData) getConstraint(child);
			int hSpan = Math.max(1, Math.min(data.horizontalSpan, columnCount));
			int vSpan = Math.max(1, data.verticalSpan);
			while (true) {
				int lastRow = row + vSpan;
				if (lastRow >= grid.length) {
					IFigure[][] newGrid = new IFigure[lastRow + 4][columnCount];
					System.arraycopy(grid, 0, newGrid, 0, grid.length);
					grid = newGrid;
				}
				if (grid[row] == null) {
					grid[row] = new IFigure[columnCount];
				}
				while (column < columnCount && grid[row][column] != null) {
					column++;
				}
				int endCount = column + hSpan;
				if (endCount <= columnCount) {
					int index = column;
					while (index < endCount && grid[row][index] == null) {
						index++;
					}
					if (index == endCount)
						break;
					column = index;
				}
				if (column + hSpan >= columnCount) {
					column = 0;
					row++;
				}
			}
			for (int j = 0; j < vSpan; j++) {
				if (grid[row + j] == null) {
					grid[row + j] = new IFigure[columnCount];
				}
				for (int k = 0; k < hSpan; k++) {
					grid[row + j][column + k] = child;
				}
			}
			rowCount = Math.max(rowCount, row + vSpan);
			column += hSpan;
		}

		/* Column widths */
		int availableWidth = width - horizontalSpacing * (columnCount - 1)
				- marginWidth * 2;
		int expandCount = 0;
		int[] widths = new int[columnCount];
		int[] minWidths = new int[columnCount];
		boolean[] expandColumn = new boolean[columnCount];
		for (int j = 0; j < columnCount; j++) {
			for (int i = 0; i < rowCount; i++) {
				GridLayoutData data = getData(grid, i, j, rowCount, columnCount, true);
				if (data != null) {
					int hSpan = Math.max(1, Math.min(data.horizontalSpan,
							columnCount));
					if (hSpan == 1) {
						int w = data.cacheWidth + data.horizontalIndent;
						widths[j] = Math.max(widths[j], w);
						if (data.grabExcessHorizontalSpace) {
							if (!expandColumn[j])
								expandCount++;
							expandColumn[j] = true;
						}
						if (data.widthHint != SWT.DEFAULT
								|| !data.grabExcessHorizontalSpace) {
							minWidths[j] = Math.max(minWidths[j], w);
						}
					}
				}
			}
			for (int i = 0; i < rowCount; i++) {
				GridLayoutData data = getData(grid, i, j, rowCount, columnCount,
						false);
				if (data != null) {
					int hSpan = Math.max(1, Math.min(data.horizontalSpan,
							columnCount));
					if (hSpan > 1) {
						int spanWidth = 0, spanMinWidth = 0, spanExpandCount = 0;
						for (int k = 0; k < hSpan; k++) {
							spanWidth += widths[j - k];
							spanMinWidth += minWidths[j - k];
							if (expandColumn[j - k])
								spanExpandCount++;
						}
						if (data.grabExcessHorizontalSpace
								&& spanExpandCount == 0) {
							expandCount++;
							expandColumn[j] = true;
						}
						int w = data.cacheWidth + data.horizontalIndent
								- spanWidth - (hSpan - 1) * horizontalSpacing;
						if (w > 0) {
							if (spanExpandCount == 0) {
								widths[j] += w;
							} else {
								int delta = w / spanExpandCount;
								int remainder = w % spanExpandCount, last = -1;
								for (int k = 0; k < hSpan; k++) {
									if (expandColumn[j - k]) {
										widths[last = j - k] += delta;
									}
								}
								if (last > -1)
									widths[last] += remainder;
							}
						}
						if (data.widthHint != SWT.DEFAULT
								|| !data.grabExcessHorizontalSpace) {
							w = data.cacheWidth + data.horizontalIndent
									- spanMinWidth - (hSpan - 1)
									* horizontalSpacing;
							if (w > 0) {
								if (spanExpandCount == 0) {
									minWidths[j] += w;
								} else {
									int delta = w / spanExpandCount;
									int remainder = w % spanExpandCount, last = -1;
									for (int k = 0; k < hSpan; k++) {
										if (expandColumn[j - k]) {
											minWidths[last = j - k] += delta;
										}
									}
									if (last > -1)
										minWidths[last] += remainder;
								}
							}
						}
					}
				}
			}
		}
		if (makeColumnsEqualWidth) {
			int minColumnWidth = 0;
			int columnWidth = 0;
			for (int i = 0; i < columnCount; i++) {
				minColumnWidth = Math.max(minColumnWidth, minWidths[i]);
				columnWidth = Math.max(columnWidth, widths[i]);
			}
			columnWidth = width == SWT.DEFAULT || expandCount == 0
					? columnWidth
					: Math.max(minColumnWidth, availableWidth / columnCount);
			for (int i = 0; i < columnCount; i++) {
				expandColumn[i] = expandCount > 0;
				widths[i] = columnWidth;
			}
		} else {
			if (width != SWT.DEFAULT && expandCount > 0) {
				int totalWidth = 0;
				for (int i = 0; i < columnCount; i++) {
					totalWidth += widths[i];
				}
				int count = expandCount;
				int delta = (availableWidth - totalWidth) / count;
				int remainder = (availableWidth - totalWidth) % count;
				int last = -1;
				while (totalWidth != availableWidth) {
					for (int j = 0; j < columnCount; j++) {
						if (expandColumn[j]) {
							if (widths[j] + delta > minWidths[j]) {
								widths[last = j] = widths[j] + delta;
							} else {
								widths[j] = minWidths[j];
								expandColumn[j] = false;
								count--;
							}
						}
					}
					if (last > -1)
						widths[last] += remainder;

					for (int j = 0; j < columnCount; j++) {
						for (int i = 0; i < rowCount; i++) {
							GridLayoutData data = getData(grid, i, j, rowCount,
									columnCount, false);
							if (data != null) {
								int hSpan = Math.max(1, Math.min(
										data.horizontalSpan, columnCount));
								if (hSpan > 1) {
									if (data.widthHint != SWT.DEFAULT
											|| !data.grabExcessHorizontalSpace) {
										int spanWidth = 0, spanExpandCount = 0;
										for (int k = 0; k < hSpan; k++) {
											spanWidth += widths[j - k];
											if (expandColumn[j - k])
												spanExpandCount++;
										}
										int w = data.cacheWidth
												+ data.horizontalIndent
												- spanWidth - (hSpan - 1)
												* horizontalSpacing;
										if (w > 0) {
											if (spanExpandCount == 0) {
												widths[j] += w;
											} else {
												int delta2 = w
														/ spanExpandCount;
												int remainder2 = w
														% spanExpandCount, last2 = -1;
												for (int k = 0; k < hSpan; k++) {
													if (expandColumn[j - k]) {
														widths[last2 = j - k] += delta2;
													}
												}
												if (last2 > -1)
													widths[last2] += remainder2;
											}
										}
									}
								}
							}
						}
					}
					if (count == 0)
						break;
					totalWidth = 0;
					for (int i = 0; i < columnCount; i++) {
						totalWidth += widths[i];
					}
					delta = (availableWidth - totalWidth) / count;
					remainder = (availableWidth - totalWidth) % count;
					last = -1;
				}
			}
		}

		/* Wrapping */
		GridLayoutData[] flush = null;
		int flushLength = 0;
		if (width != SWT.DEFAULT) {
			for (int j = 0; j < columnCount; j++) {
				for (int i = 0; i < rowCount; i++) {
					GridLayoutData data = getData(grid, i, j, rowCount, columnCount,
							false);
					if (data != null) {
						if (data.heightHint == SWT.DEFAULT) {
							IFigure child = grid[i][j];
							//TEMPORARY CODE
							int hSpan = Math.max(1, Math.min(
									data.horizontalSpan, columnCount));
							int currentWidth = 0;
							for (int k = 0; k < hSpan; k++) {
								currentWidth += widths[j - k];
							}
							currentWidth += (hSpan - 1) * horizontalSpacing
									- data.horizontalIndent;
							if ((currentWidth != data.cacheWidth && data.horizontalAlignment == SWT.FILL)
									|| (data.cacheWidth > currentWidth)) {
								int trim = 0;
								/*
								  // *Note*: Left this in place from SWT
								  // GridLayout. Not sure if Draw2D Borders or
								  // Scrollbars 'trim' will need to be takeninto account.
								  
								  if (child instanceof Group) { 
                                      Group g =(Group)child; trim = g.getSize ().x -
                                      g.getClientArea ().width; 
                                  } else if (child instanceof Scrollable) { 
                                      Rectangle rect =
                                          ((Scrollable) child).computeTrim (0, 0, 0,0);
                                           trim = rect.width; } 
                                  else {
    								  trim = child.getBorderWidth () * 2; 
                                  }
								 */
								int oldWidthHint = data.widthHint;
								data.widthHint = Math.max(0, currentWidth
										- trim);
								data.cacheWidth = data.cacheHeight = SWT.DEFAULT;
								data.computeSize(child, false);
								data.widthHint = oldWidthHint;
								if (flush == null)
									flush = new GridLayoutData[children.size()];
								flush[flushLength++] = data;
							}
						}
					}
				}
			}
		}

		/* Row heights */
		int availableHeight = height - verticalSpacing * (rowCount - 1)
				- marginHeight * 2;
		expandCount = 0;
		int[] heights = new int[rowCount];
		int[] minHeights = new int[rowCount];
		boolean[] expandRow = new boolean[rowCount];
		for (int i = 0; i < rowCount; i++) {
			for (int j = 0; j < columnCount; j++) {
				GridLayoutData data = getData(grid, i, j, rowCount, columnCount, true);
				if (data != null) {
					int vSpan = Math.max(1, Math.min(data.verticalSpan,
							rowCount));
					if (vSpan == 1) {
						int h = data.cacheHeight; // + data.verticalIndent;
						heights[i] = Math.max(heights[i], h);
						if (data.grabExcessVerticalSpace) {
							if (!expandRow[i])
								expandCount++;
							expandRow[i] = true;
						}
						if (data.heightHint != SWT.DEFAULT
								|| !data.grabExcessVerticalSpace) {
							minHeights[i] = Math.max(minHeights[i], h);
						}
					}
				}
			}
			for (int j = 0; j < columnCount; j++) {
				GridLayoutData data = getData(grid, i, j, rowCount, columnCount,
						false);
				if (data != null) {
					int vSpan = Math.max(1, Math.min(data.verticalSpan,
							rowCount));
					if (vSpan > 1) {
						int spanHeight = 0, spanMinHeight = 0, spanExpandCount = 0;
						for (int k = 0; k < vSpan; k++) {
							spanHeight += heights[i - k];
							spanMinHeight += minHeights[i - k];
							if (expandRow[i - k])
								spanExpandCount++;
						}
						if (data.grabExcessVerticalSpace
								&& spanExpandCount == 0) {
							expandCount++;
							expandRow[i] = true;
						}
						int h = data.cacheHeight - spanHeight - (vSpan - 1)
								* verticalSpacing; // + data.verticalalIndent
						if (h > 0) {
							if (spanExpandCount == 0) {
								heights[i] += h;
							} else {
								int delta = h / spanExpandCount;
								int remainder = h % spanExpandCount, last = -1;
								for (int k = 0; k < vSpan; k++) {
									if (expandRow[i - k]) {
										heights[last = i - k] += delta;
									}
								}
								if (last > -1)
									heights[last] += remainder;
							}
						}
						if (data.heightHint != SWT.DEFAULT
								|| !data.grabExcessVerticalSpace) {
							h = data.cacheHeight - spanMinHeight - (vSpan - 1)
									* verticalSpacing; // + data.verticalIndent
							if (h > 0) {
								if (spanExpandCount == 0) {
									minHeights[i] += h;
								} else {
									int delta = h / spanExpandCount;
									int remainder = h % spanExpandCount, last = -1;
									for (int k = 0; k < vSpan; k++) {
										if (expandRow[i - k]) {
											minHeights[last = i - k] += delta;
										}
									}
									if (last > -1)
										minHeights[last] += remainder;
								}
							}
						}
					}
				}
			}
		}
		if (height != SWT.DEFAULT && expandCount > 0) {
			int totalHeight = 0;
			for (int i = 0; i < rowCount; i++) {
				totalHeight += heights[i];
			}
			int count = expandCount;
			int delta = (availableHeight - totalHeight) / count;
			int remainder = (availableHeight - totalHeight) % count;
			int last = -1;
			while (totalHeight != availableHeight) {
				for (int i = 0; i < rowCount; i++) {
					if (expandRow[i]) {
						if (heights[i] + delta > minHeights[i]) {
							heights[last = i] = heights[i] + delta;
						} else {
							heights[i] = minHeights[i];
							expandRow[i] = false;
							count--;
						}
					}
				}
				if (last > -1)
					heights[last] += remainder;

				for (int i = 0; i < rowCount; i++) {
					for (int j = 0; j < columnCount; j++) {
						GridLayoutData data = getData(grid, i, j, rowCount,
								columnCount, false);
						if (data != null) {
							int vSpan = Math.max(1, Math.min(data.verticalSpan,
									rowCount));
							if (vSpan > 1) {
								if (data.heightHint != SWT.DEFAULT
										|| !data.grabExcessVerticalSpace) {
									int spanHeight = 0, spanExpandCount = 0;
									for (int k = 0; k < vSpan; k++) {
										spanHeight += heights[i - k];
										if (expandRow[i - k])
											spanExpandCount++;
									}
									int h = data.cacheHeight - spanHeight
											- (vSpan - 1) * verticalSpacing; // +
																			 // data.verticalIndent
									if (h > 0) {
										if (spanExpandCount == 0) {
											heights[i] += h;
										} else {
											int delta2 = h / spanExpandCount;
											int remainder2 = h
													% spanExpandCount, last2 = -1;
											for (int k = 0; k < vSpan; k++) {
												if (expandRow[i - k]) {
													heights[last2 = i - k] += delta2;
												}
											}
											if (last2 > -1)
												heights[last2] += remainder2;
										}
									}
								}
							}
						}
					}
				}
				if (count == 0)
					break;
				totalHeight = 0;
				for (int i = 0; i < rowCount; i++) {
					totalHeight += heights[i];
				}
				delta = (availableHeight - totalHeight) / count;
				remainder = (availableHeight - totalHeight) % count;
				last = -1;
			}
		}

		/* Position the IFigures */
		if (move) {
			int gridY = y + marginHeight;
			for (int i = 0; i < rowCount; i++) {
				int gridX = x + marginWidth;
				for (int j = 0; j < columnCount; j++) {
					GridLayoutData data = getData(grid, i, j, rowCount, columnCount,
							true);
					if (data != null) {
						int hSpan = Math.max(1, Math.min(data.horizontalSpan,
								columnCount));
						int vSpan = Math.max(1, data.verticalSpan);
						int cellWidth = 0, cellHeight = 0;
						for (int k = 0; k < hSpan; k++) {
							cellWidth += widths[j + k];
						}
						for (int k = 0; k < vSpan; k++) {
							cellHeight += heights[i + k];
						}
						cellWidth += horizontalSpacing * (hSpan - 1);
						int childX = gridX + data.horizontalIndent;
						int childWidth = Math.min(data.cacheWidth, cellWidth);
						switch (data.horizontalAlignment) {
							case SWT.CENTER :
							case GridLayoutData.CENTER :
								childX = gridX
										+ Math.max(0,
												(cellWidth - childWidth) / 2);
								break;
							case SWT.RIGHT :
							case SWT.END :
							case GridLayoutData.END :
								childX = gridX
										+ Math.max(0, cellWidth - childWidth);
								break;
							case SWT.FILL :
								childWidth = cellWidth - data.horizontalIndent;
								break;
						}
						cellHeight += verticalSpacing * (vSpan - 1);
						int childY = gridY; // + data.verticalIndent;
						int childHeight = Math
								.min(data.cacheHeight, cellHeight);
						switch (data.verticalAlignment) {
							case SWT.CENTER :
							case GridLayoutData.CENTER :
								childY = gridY
										+ Math.max(0,
												(cellHeight - childHeight) / 2);
								break;
							case SWT.BOTTOM :
							case SWT.END :
							case GridLayoutData.END :
								childY = gridY
										+ Math.max(0, cellHeight - childHeight);
								break;
							case SWT.FILL :
								childHeight = cellHeight; // -
														  // data.verticalIndent;
								break;
						}
						IFigure child = grid[i][j];
						if (child != null) {
							// following param could be replaced by
							// Rectangle.SINGLETON
							child.setBounds(new Rectangle(childX, childY,
									childWidth, childHeight));
						}
					}
					gridX += widths[j] + horizontalSpacing;
				}
				gridY += heights[i] + verticalSpacing;
			}
		}

		// clean up cache
		for (int i = 0; i < flushLength; i++) {
			flush[i].cacheWidth = flush[i].cacheHeight = -1;
		}

		int totalDefaultWidth = 0;
		int totalDefaultHeight = 0;
		for (int i = 0; i < columnCount; i++) {
			totalDefaultWidth += widths[i];
		}
		for (int i = 0; i < rowCount; i++) {
			totalDefaultHeight += heights[i];
		}
		totalDefaultWidth += horizontalSpacing * (columnCount - 1)
				+ marginWidth * 2;
		totalDefaultHeight += verticalSpacing * (rowCount - 1) + marginHeight
				* 2;
		return new Dimension(totalDefaultWidth, totalDefaultHeight);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.draw2d.LayoutManager#getConstraint(org.eclipse.draw2d.IFigure)
	 */
	public Object getConstraint(IFigure child) {
		return constraints.get(child);
	}

	/**
	 * Sets the layout constraint of the given figure. The constraints can only
	 * be of type {@link GridLayoutData}.
	 * 
	 * @see LayoutManager#setConstraint(IFigure, Object)
	 */
	public void setConstraint(IFigure figure, Object newConstraint) {
		super.setConstraint(figure, newConstraint);
		if (newConstraint != null)
        {
			constraints.put(figure, newConstraint);
            
        }
	}

}




package org.eclipse.gmf.internal.codegen.draw2d;

import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.swt.SWT;


/**
 * <code>GridLayoutData</code> is the layout data object associated with
 * <code>GridLayout</code>. To set a <code>GridLayoutData</code> object into a
 * <code>Figure</code>, you use the <code>setConstraint()</code> method of
 * <code>GridLayout</code> to map the <code>Figure</code> to its layout
 * <code>GridLayoutData</code>.
 * <p>
 * There are two ways to create a <code>GridLayoutData</code> object with certain
 * fields set. The first is to set the fields directly, like this:
 * 
 * <pre>
 * GridLayoutData gridData = new GridLayoutData();
 * gridData.horizontalAlignment = GridLayoutData.FILL;
 * gridData.grabExcessHorizontalSpace = true;
 * 
 * // associate the figure to the GridLayoutData object
 * myGridlayout.setConstraint(myFigure, gridData);
 * </pre>
 * 
 * The second is to take advantage of convenience style bits defined by
 * <code>GridLayoutData</code>:
 * 
 * <pre>
 * GridLayoutData gridData = new GridLayoutData(GridLayoutData.HORIZONTAL_ALIGN_FILL | GridLayoutData.GRAB_HORIZONTAL);
 * </pre>
 * 
 * </p>
 * <p>
 * NOTE: Do not reuse <code>GridLayoutData</code> objects. Every child in the parent
 * <code>Figure</code> that is managed by the <code>GridLayout</code> must
 * have a unique <code>GridLayoutData</code> object. If the layout data for a Grid
 * member in a <code>GridLayout</code> is null at layout time, a unique
 * <code>GridLayoutData</code> object is created for it.
 * </p>
 * 
 * [GMF]: NOTE: The set of the ALIGNMENT constants is changed in this class
 * comparing to original version to match the set of constants in the generated
 * code. E.g, <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code>.
 * Thus, this implementation is NOT intended to use SWT.* constants for
 * alignment.
 * 
 * @see GridLayout
 */
public final class GridLayoutData {
    /**
	 * verticalAlignment specifies how figures will be positioned vertically
	 * within a cell.
	 * 
	 * The default value is CENTER.
	 * 
	 * Possible values are:
	 * 
	 * <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code> (or
	 * <code>SWT.TOP - 1</code>): Position the figure at the top of the cell
	 * 
	 * <code>GridLayoutData.CENTER = SWT.CENTER - 1</code>: Position the
	 * figure in the vertical center of the cell
	 * 
	 * <code>GridLayoutData.END = SWT.END - 1</code> (or
	 * <code>SWT.BOTTOM - 1</code>): Position the figure at the bottom of the
	 * cell
	 * 
	 * <code>GridLayoutData.FILL = SWT.FILL - 1</code>: Resize the figure to
	 * fill the cell vertically
	 */
    public int verticalAlignment = CENTER;
    
    /**
	 * horizontalAlignment specifies how figures will be positioned horizontally
	 * within a cell.
	 * 
	 * The default value is BEGINNING.
	 * 
	 * Possible values are:
	 * 
	 * <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code> (or
	 * <code>SWT.TOP - 1</code>): Position the figure at the left of the cell
	 * 
	 * <code>GridLayoutData.CENTER = SWT.CENTER - 1</code>: Position the
	 * figure in the horizontal center of the cell
	 * 
	 * <code>GridLayoutData.END = SWT.END - 1</code> (or
	 * <code>SWT.BOTTOM - 1</code>): Position the figure at the right of the
	 * cell
	 * 
	 * <code>GridLayoutData.FILL = SWT.FILL - 1</code>: : Resize the figure
	 * to fill the cell horizontally
	 */
    public int horizontalAlignment = BEGINNING;
    
    /**
     * widthHint specifies a minimum width for the column. A value of 
     * SWT.DEFAULT indicates that no minimum width is specified.
     *
     * The default value is SWT.DEFAULT.
     */
    public int widthHint = SWT.DEFAULT;
    
    /**
     * heightHint specifies a minimum height for the row. A value of
     * SWT.DEFAULT indicates that no minimum height is specified.
     *
     * The default value is SWT.DEFAULT.
     */
    public int heightHint = SWT.DEFAULT;
    
    /**
     * horizontalIndent specifies the number of pixels of indentation
     * that will be placed along the left side of the cell.
     *
     * The default value is 0.
     */
    public int horizontalIndent = 0;
    
    /**
     * horizontalSpan specifies the number of column cells that the figure
     * will take up.
     *
     * The default value is 1.
     */
    public int horizontalSpan = 1;
    
    /**
     * verticalSpan specifies the number of row cells that the figure
     * will take up.
     *
     * The default value is 1.
     */
    public int verticalSpan = 1;
    
    /**
     * grabExcessHorizontalSpace specifies whether the cell will be made
     * wide enough to fit the remaining horizontal space.
     *
     * The default value is false.
     */ 
    public boolean grabExcessHorizontalSpace = false;
    
    /**
     * grabExcessVerticalSpace specifies whether the cell will be made
     * tall enough to fit the remaining vertical space.
     *
     * The default value is false.
     */ 
    public boolean grabExcessVerticalSpace = false;

    /**
     * Value for horizontalAlignment or verticalAlignment.
     * Position the figure at the top or left of the cell.
     */
    public static final int BEGINNING = 0; //SWT.BEGINNING - 1;
    
    /**
     * Value for horizontalAlignment or verticalAlignment.
     * Position the figure in the vertical or horizontal center of the cell
     */
    public static final int CENTER = 1;
    
    /**
     * Value for horizontalAlignment or verticalAlignment.
     * Position the figure at the bottom or right of the cell
     */
    public static final int END = 2;
    
    /**
     * Value for horizontalAlignment or verticalAlignment.
     * Resize the figure to fill the cell horizontally or vertically.
     */
    public static final int FILL = 3; //SWT.FILL - 1;

    /**
     * Style bit for <code>new GridLayoutData(int)</code>.
     * Position the figure at the top of the cell.
     * Not recommended. Use 
     * <code>new GridLayoutData(int, GridLayoutData.BEGINNING, boolean, boolean)</code>
     * instead.
     */
    public static final int VERTICAL_ALIGN_BEGINNING =  1 << 1;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure in the vertical center of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(int, GridLayoutData.CENTER, boolean, boolean)</code>
     * instead.
     */
    public static final int VERTICAL_ALIGN_CENTER = 1 << 2;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure at the bottom of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(int, GridLayoutData.END, boolean, boolean)</code>
     * instead.
     */
    public static final int VERTICAL_ALIGN_END = 1 << 3;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell vertically.
     * Not recommended. Use
     * <code>new GridLayoutData(int, GridLayoutData.FILL, boolean, boolean)</code>
     * instead
     */
    public static final int VERTICAL_ALIGN_FILL = 1 << 4;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure at the left of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.BEGINNING, int, boolean, boolean)</code>
     * instead.
     */
    public static final int HORIZONTAL_ALIGN_BEGINNING =  1 << 5;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure in the horizontal center of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.CENTER, int, boolean, boolean)</code>
     * instead.
     */
    public static final int HORIZONTAL_ALIGN_CENTER = 1 << 6;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure at the right of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.END, int, boolean, boolean)</code>
     * instead.
     */
    public static final int HORIZONTAL_ALIGN_END = 1 << 7;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell horizontally.
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.FILL, int, boolean, boolean)</code>
     * instead.
     */
    public static final int HORIZONTAL_ALIGN_FILL = 1 << 8;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fit the remaining horizontal space.
     * Not recommended. Use
     * <code>new GridLayoutData(int, int, true, boolean)</code>
     * instead.
     */
    public static final int GRAB_HORIZONTAL = 1 << 9;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fit the remaining vertical space.
     * Not recommended. Use
     * <code>new GridLayoutData(int, int, boolean, true)</code>
     * instead.
     */
    public static final int GRAB_VERTICAL = 1 << 10;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell vertically and to fit the remaining
     * vertical space.
     * FILL_VERTICAL = VERTICAL_ALIGN_FILL | GRAB_VERTICAL
     * Not recommended. Use
     * <code>new GridLayoutData(int, GridLayoutData.FILL, boolean, true)</code>
     * instead.
     */ 
    public static final int FILL_VERTICAL = VERTICAL_ALIGN_FILL | GRAB_VERTICAL;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell horizontally and to fit the remaining
     * horizontal space.
     * FILL_HORIZONTAL = HORIZONTAL_ALIGN_FILL | GRAB_HORIZONTAL
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.FILL, int, true, boolean)</code>
     * instead.
     */ 
    public static final int FILL_HORIZONTAL = HORIZONTAL_ALIGN_FILL | GRAB_HORIZONTAL;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell horizontally and vertically and 
     * to fit the remaining horizontal and vertical space.
     * FILL_BOTH = FILL_VERTICAL | FILL_HORIZONTAL
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.FILL, GridLayoutData.FILL, true, true)</code>
     * instead.
     */ 
    public static final int FILL_BOTH = FILL_VERTICAL | FILL_HORIZONTAL;

    int cacheWidth = -1, cacheHeight = -1;
    int [][] cache = new int[2][4];
    int cacheIndex = -1;

/**
 * Constructs a new instance of GridLayoutData using
 * default values.
 */
public GridLayoutData () {
    super ();
}

/**
 * Constructs a new instance based on the GridLayoutData style.
 * This constructor is not recommended.
 * 
 * @param style the GridLayoutData style
 */
public GridLayoutData (int style) {
    super ();
    if ((style & VERTICAL_ALIGN_BEGINNING) != 0) verticalAlignment = BEGINNING;
    if ((style & VERTICAL_ALIGN_CENTER) != 0) verticalAlignment = CENTER;
    if ((style & VERTICAL_ALIGN_FILL) != 0) verticalAlignment = FILL;
    if ((style & VERTICAL_ALIGN_END) != 0) verticalAlignment = END;
    if ((style & HORIZONTAL_ALIGN_BEGINNING) != 0) horizontalAlignment = BEGINNING;
    if ((style & HORIZONTAL_ALIGN_CENTER) != 0) horizontalAlignment = CENTER;
    if ((style & HORIZONTAL_ALIGN_FILL) != 0) horizontalAlignment = FILL;
    if ((style & HORIZONTAL_ALIGN_END) != 0) horizontalAlignment = END;
    grabExcessHorizontalSpace = (style & GRAB_HORIZONTAL) != 0;
    grabExcessVerticalSpace = (style & GRAB_VERTICAL) != 0;
}

/**
 * Constructs a new instance of GridLayoutData according to the parameters.
 * 
 * @param horizontalAlignment how figure will be positioned horizontally within a cell
 * @param verticalAlignment how figure will be positioned vertically within a cell
 * @param grabExcessHorizontalSpace whether cell will be made wide enough to fit the remaining horizontal space
 * @param grabExcessVerticalSpace whether cell will be made high enough to fit the remaining vertical space
 * 
 */
public GridLayoutData (int horizontalAlignment, int verticalAlignment, boolean grabExcessHorizontalSpace, boolean grabExcessVerticalSpace) {
    this (horizontalAlignment, verticalAlignment, grabExcessHorizontalSpace, grabExcessVerticalSpace, 1, 1);
}

/**
 * Constructs a new instance of GridLayoutData according to the parameters.
 *  
 * @param horizontalAlignment how figure will be positioned horizontally within a cell
 * @param verticalAlignment how figure will be positioned vertically within a cell
 * @param grabExcessHorizontalSpace whether cell will be made wide enough to fit the remaining horizontal space
 * @param grabExcessVerticalSpace whether cell will be made high enough to fit the remaining vertical space
 * @param horizontalSpan the number of column cells that the figure will take up
 * @param verticalSpan the number of row cells that the figure will take up
 * 
 */
public GridLayoutData (int horizontalAlignment, int verticalAlignment, boolean grabExcessHorizontalSpace, boolean grabExcessVerticalSpace, int horizontalSpan, int verticalSpan) {
    super ();
    this.horizontalAlignment = horizontalAlignment;
    this.verticalAlignment = verticalAlignment;
    this.grabExcessHorizontalSpace = grabExcessHorizontalSpace;
    this.grabExcessVerticalSpace = grabExcessVerticalSpace;
    this.horizontalSpan = horizontalSpan;
    this.verticalSpan = verticalSpan;
}

/**
 * Constructs a new instance of GridLayoutData according to the parameters.
 * A value of SWT.DEFAULT indicates that no minimum width or
 * no minumum height is specified.
 * 
 * @param width a minimum width for the column
 * @param height a minimum height for the row
 * 
 */
public GridLayoutData (int width, int height) {
    super ();
    this.widthHint = width;
    this.heightHint = height;
}

Dimension computeSize (IFigure figure, boolean flushCache) {
    if (cacheWidth != -1 && cacheHeight != -1) {
        return new Dimension (cacheWidth, cacheHeight);
    }
    for (int i = 0; i < cacheIndex + 1; i++) {
        if (cache [i][0] == widthHint && cache [i][1] == heightHint) {
            cacheWidth = cache [i][2];
            cacheHeight = cache [i][3];
            return new Dimension (cacheWidth, cacheHeight);
        }
    }

    Dimension size = figure.getPreferredSize(widthHint,heightHint);
    if (widthHint!=-1) size.width = widthHint;
    if (heightHint!=-1) size.height = heightHint;    

    if (cacheIndex < cache.length - 1) cacheIndex++;
    cache [cacheIndex][0] = widthHint;
    cache [cacheIndex][1] = heightHint;
    cacheWidth = cache [cacheIndex][2] = size.width;
    cacheHeight = cache [cacheIndex][3] = size.height;
    return size;
}


void flushCache () {
    cacheWidth = cacheHeight = -1;
    cacheIndex = -1;
}

String getName () {
    String string = getClass ().getName ();
    int index = string.lastIndexOf ('.');
    if (index == -1) return string;
    return string.substring (index + 1, string.length ());
}

public String toString () {

    String hAlign = "";
    switch (horizontalAlignment) {
        case FILL: hAlign = "GridLayoutData.FILL"; break;
        case BEGINNING: hAlign = "GridLayoutData.BEGINNING"; break;
        case END: hAlign = "GridLayoutData.LEFT"; break;
        case CENTER: hAlign = "GridLayoutData.CENTER"; break;
        default: hAlign = "Undefined "+horizontalAlignment; break;
    }
    String vAlign = "";
    switch (verticalAlignment) {
        case FILL: vAlign = "GridLayoutData.FILL"; break;
        case BEGINNING: vAlign = "GridLayoutData.BEGINNING"; break;
        case END: vAlign = "GridLayoutData.END"; break;
        case CENTER: vAlign = "GridLayoutData.CENTER"; break;
        default: vAlign = "Undefined "+verticalAlignment; break;
    }
    String string = getName()+" {";
    string += "horizontalAlignment="+hAlign+" ";
    if (horizontalIndent != 0) string += "horizontalIndent="+horizontalIndent+" ";
    if (horizontalSpan != 1) string += "horizontalSpan="+horizontalSpan+" ";
    if (grabExcessHorizontalSpace) string += "grabExcessHorizontalSpace="+grabExcessHorizontalSpace+" ";
    if (widthHint != SWT.DEFAULT) string += "widthHint="+widthHint+" ";
    string += "verticalAlignment="+vAlign+" ";
    if (verticalSpan != 1) string += "verticalSpan="+verticalSpan+" ";
    if (grabExcessVerticalSpace) string += "grabExcessVerticalSpace="+grabExcessVerticalSpace+" ";
    if (heightHint != SWT.DEFAULT) string += "heightHint="+heightHint+" ";
    string = string.trim();
    string += "}";
    return string;

}

}

Return to bug 133279

Added Link Here

(-)src/org/eclipse/gmf/internal/codegen/draw2d/GridLayoutData.java (+453 lines)
1	package org.eclipse.gmf.internal.codegen.draw2d;
2
3	import org.eclipse.draw2d.IFigure;
4	import org.eclipse.draw2d.geometry.Dimension;
5	import org.eclipse.swt.SWT;
6
7
8	/**
9	* <code>GridLayoutData</code> is the layout data object associated with
10	* <code>GridLayout</code>. To set a <code>GridLayoutData</code> object into a
11	* <code>Figure</code>, you use the <code>setConstraint()</code> method of
12	* <code>GridLayout</code> to map the <code>Figure</code> to its layout
13	* <code>GridLayoutData</code>.
14	* <p>
15	* There are two ways to create a <code>GridLayoutData</code> object with certain
16	* fields set. The first is to set the fields directly, like this:
17	*
18	* <pre>
19	* GridLayoutData gridData = new GridLayoutData();
20	* gridData.horizontalAlignment = GridLayoutData.FILL;
21	* gridData.grabExcessHorizontalSpace = true;
22	*
23	* // associate the figure to the GridLayoutData object
24	* myGridlayout.setConstraint(myFigure, gridData);
25	* </pre>
26	*
27	* The second is to take advantage of convenience style bits defined by
28	* <code>GridLayoutData</code>:
29	*
30	* <pre>
31	* GridLayoutData gridData = new GridLayoutData(GridLayoutData.HORIZONTAL_ALIGN_FILL \| GridLayoutData.GRAB_HORIZONTAL);
32	* </pre>
33	*
34	* </p>
35	* <p>
36	* NOTE: Do not reuse <code>GridLayoutData</code> objects. Every child in the parent
37	* <code>Figure</code> that is managed by the <code>GridLayout</code> must
38	* have a unique <code>GridLayoutData</code> object. If the layout data for a Grid
39	* member in a <code>GridLayout</code> is null at layout time, a unique
40	* <code>GridLayoutData</code> object is created for it.
41	* </p>
42	*
43	* [GMF]: NOTE: The set of the ALIGNMENT constants is changed in this class
44	* comparing to original version to match the set of constants in the generated
45	* code. E.g, <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code>.
46	* Thus, this implementation is NOT intended to use SWT.* constants for
47	* alignment.
48	*
49	* @see GridLayout
50	*/
51	public final class GridLayoutData {
52	/**
53	* verticalAlignment specifies how figures will be positioned vertically
54	* within a cell.
55	*
56	* The default value is CENTER.
57	*
58	* Possible values are:
59	*
60	* <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code> (or
61	* <code>SWT.TOP - 1</code>): Position the figure at the top of the cell
62	*
63	* <code>GridLayoutData.CENTER = SWT.CENTER - 1</code>: Position the
64	* figure in the vertical center of the cell
65	*
66	* <code>GridLayoutData.END = SWT.END - 1</code> (or
67	* <code>SWT.BOTTOM - 1</code>): Position the figure at the bottom of the
68	* cell
69	*
70	* <code>GridLayoutData.FILL = SWT.FILL - 1</code>: Resize the figure to
71	* fill the cell vertically
72	*/
73	public int verticalAlignment = CENTER;
74
75	/**
76	* horizontalAlignment specifies how figures will be positioned horizontally
77	* within a cell.
78	*
79	* The default value is BEGINNING.
80	*
81	* Possible values are:
82	*
83	* <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code> (or
84	* <code>SWT.TOP - 1</code>): Position the figure at the left of the cell
85	*
86	* <code>GridLayoutData.CENTER = SWT.CENTER - 1</code>: Position the
87	* figure in the horizontal center of the cell
88	*
89	* <code>GridLayoutData.END = SWT.END - 1</code> (or
90	* <code>SWT.BOTTOM - 1</code>): Position the figure at the right of the
91	* cell
92	*
93	* <code>GridLayoutData.FILL = SWT.FILL - 1</code>: : Resize the figure
94	* to fill the cell horizontally
95	*/
96	public int horizontalAlignment = BEGINNING;
97
98	/**
99	* widthHint specifies a minimum width for the column. A value of
100	* SWT.DEFAULT indicates that no minimum width is specified.
101	*
102	* The default value is SWT.DEFAULT.
103	*/
104	public int widthHint = SWT.DEFAULT;
105
106	/**
107	* heightHint specifies a minimum height for the row. A value of
108	* SWT.DEFAULT indicates that no minimum height is specified.
109	*
110	* The default value is SWT.DEFAULT.
111	*/
112	public int heightHint = SWT.DEFAULT;
113
114	/**
115	* horizontalIndent specifies the number of pixels of indentation
116	* that will be placed along the left side of the cell.
117	*
118	* The default value is 0.
119	*/
120	public int horizontalIndent = 0;
121
122	/**
123	* horizontalSpan specifies the number of column cells that the figure
124	* will take up.
125	*
126	* The default value is 1.
127	*/
128	public int horizontalSpan = 1;
129
130	/**
131	* verticalSpan specifies the number of row cells that the figure
132	* will take up.
133	*
134	* The default value is 1.
135	*/
136	public int verticalSpan = 1;
137
138	/**
139	* grabExcessHorizontalSpace specifies whether the cell will be made
140	* wide enough to fit the remaining horizontal space.
141	*
142	* The default value is false.
143	*/
144	public boolean grabExcessHorizontalSpace = false;
145
146	/**
147	* grabExcessVerticalSpace specifies whether the cell will be made
148	* tall enough to fit the remaining vertical space.
149	*
150	* The default value is false.
151	*/
152	public boolean grabExcessVerticalSpace = false;
153
154	/**
155	* Value for horizontalAlignment or verticalAlignment.
156	* Position the figure at the top or left of the cell.
157	*/
158	public static final int BEGINNING = 0; //SWT.BEGINNING - 1;
159
160	/**
161	* Value for horizontalAlignment or verticalAlignment.
162	* Position the figure in the vertical or horizontal center of the cell
163	*/
164	public static final int CENTER = 1;
165
166	/**
167	* Value for horizontalAlignment or verticalAlignment.
168	* Position the figure at the bottom or right of the cell
169	*/
170	public static final int END = 2;
171
172	/**
173	* Value for horizontalAlignment or verticalAlignment.
174	* Resize the figure to fill the cell horizontally or vertically.
175	*/
176	public static final int FILL = 3; //SWT.FILL - 1;
177
178	/**
179	* Style bit for <code>new GridLayoutData(int)</code>.
180	* Position the figure at the top of the cell.
181	* Not recommended. Use
182	* <code>new GridLayoutData(int, GridLayoutData.BEGINNING, boolean, boolean)</code>
183	* instead.
184	*/
185	public static final int VERTICAL_ALIGN_BEGINNING = 1 << 1;
186
187	/**
188	* Style bit for <code>new GridLayoutData(int)</code> to position the
189	* figure in the vertical center of the cell.
190	* Not recommended. Use
191	* <code>new GridLayoutData(int, GridLayoutData.CENTER, boolean, boolean)</code>
192	* instead.
193	*/
194	public static final int VERTICAL_ALIGN_CENTER = 1 << 2;
195
196	/**
197	* Style bit for <code>new GridLayoutData(int)</code> to position the
198	* figure at the bottom of the cell.
199	* Not recommended. Use
200	* <code>new GridLayoutData(int, GridLayoutData.END, boolean, boolean)</code>
201	* instead.
202	*/
203	public static final int VERTICAL_ALIGN_END = 1 << 3;
204
205	/**
206	* Style bit for <code>new GridLayoutData(int)</code> to resize the
207	* figure to fill the cell vertically.
208	* Not recommended. Use
209	* <code>new GridLayoutData(int, GridLayoutData.FILL, boolean, boolean)</code>
210	* instead
211	*/
212	public static final int VERTICAL_ALIGN_FILL = 1 << 4;
213
214	/**
215	* Style bit for <code>new GridLayoutData(int)</code> to position the
216	* figure at the left of the cell.
217	* Not recommended. Use
218	* <code>new GridLayoutData(GridLayoutData.BEGINNING, int, boolean, boolean)</code>
219	* instead.
220	*/
221	public static final int HORIZONTAL_ALIGN_BEGINNING = 1 << 5;
222
223	/**
224	* Style bit for <code>new GridLayoutData(int)</code> to position the
225	* figure in the horizontal center of the cell.
226	* Not recommended. Use
227	* <code>new GridLayoutData(GridLayoutData.CENTER, int, boolean, boolean)</code>
228	* instead.
229	*/
230	public static final int HORIZONTAL_ALIGN_CENTER = 1 << 6;
231
232	/**
233	* Style bit for <code>new GridLayoutData(int)</code> to position the
234	* figure at the right of the cell.
235	* Not recommended. Use
236	* <code>new GridLayoutData(GridLayoutData.END, int, boolean, boolean)</code>
237	* instead.
238	*/
239	public static final int HORIZONTAL_ALIGN_END = 1 << 7;
240
241	/**
242	* Style bit for <code>new GridLayoutData(int)</code> to resize the
243	* figure to fill the cell horizontally.
244	* Not recommended. Use
245	* <code>new GridLayoutData(GridLayoutData.FILL, int, boolean, boolean)</code>
246	* instead.
247	*/
248	public static final int HORIZONTAL_ALIGN_FILL = 1 << 8;
249
250	/**
251	* Style bit for <code>new GridLayoutData(int)</code> to resize the
252	* figure to fit the remaining horizontal space.
253	* Not recommended. Use
254	* <code>new GridLayoutData(int, int, true, boolean)</code>
255	* instead.
256	*/
257	public static final int GRAB_HORIZONTAL = 1 << 9;
258
259	/**
260	* Style bit for <code>new GridLayoutData(int)</code> to resize the
261	* figure to fit the remaining vertical space.
262	* Not recommended. Use
263	* <code>new GridLayoutData(int, int, boolean, true)</code>
264	* instead.
265	*/
266	public static final int GRAB_VERTICAL = 1 << 10;
267
268	/**
269	* Style bit for <code>new GridLayoutData(int)</code> to resize the
270	* figure to fill the cell vertically and to fit the remaining
271	* vertical space.
272	* FILL_VERTICAL = VERTICAL_ALIGN_FILL \| GRAB_VERTICAL
273	* Not recommended. Use
274	* <code>new GridLayoutData(int, GridLayoutData.FILL, boolean, true)</code>
275	* instead.
276	*/
277	public static final int FILL_VERTICAL = VERTICAL_ALIGN_FILL \| GRAB_VERTICAL;
278
279	/**
280	* Style bit for <code>new GridLayoutData(int)</code> to resize the
281	* figure to fill the cell horizontally and to fit the remaining
282	* horizontal space.
283	* FILL_HORIZONTAL = HORIZONTAL_ALIGN_FILL \| GRAB_HORIZONTAL
284	* Not recommended. Use
285	* <code>new GridLayoutData(GridLayoutData.FILL, int, true, boolean)</code>
286	* instead.
287	*/
288	public static final int FILL_HORIZONTAL = HORIZONTAL_ALIGN_FILL \| GRAB_HORIZONTAL;
289
290	/**
291	* Style bit for <code>new GridLayoutData(int)</code> to resize the
292	* figure to fill the cell horizontally and vertically and
293	* to fit the remaining horizontal and vertical space.
294	* FILL_BOTH = FILL_VERTICAL \| FILL_HORIZONTAL
295	* Not recommended. Use
296	* <code>new GridLayoutData(GridLayoutData.FILL, GridLayoutData.FILL, true, true)</code>
297	* instead.
298	*/
299	public static final int FILL_BOTH = FILL_VERTICAL \| FILL_HORIZONTAL;
300
301	int cacheWidth = -1, cacheHeight = -1;
302	int [][] cache = new int[2][4];
303	int cacheIndex = -1;
304
305	/**
306	* Constructs a new instance of GridLayoutData using
307	* default values.
308	*/
309	public GridLayoutData () {
310	super ();
311	}
312
313	/**
314	* Constructs a new instance based on the GridLayoutData style.
315	* This constructor is not recommended.
316	*
317	* @param style the GridLayoutData style
318	*/
319	public GridLayoutData (int style) {
320	super ();
321	if ((style & VERTICAL_ALIGN_BEGINNING) != 0) verticalAlignment = BEGINNING;
322	if ((style & VERTICAL_ALIGN_CENTER) != 0) verticalAlignment = CENTER;
323	if ((style & VERTICAL_ALIGN_FILL) != 0) verticalAlignment = FILL;
324	if ((style & VERTICAL_ALIGN_END) != 0) verticalAlignment = END;
325	if ((style & HORIZONTAL_ALIGN_BEGINNING) != 0) horizontalAlignment = BEGINNING;
326	if ((style & HORIZONTAL_ALIGN_CENTER) != 0) horizontalAlignment = CENTER;
327	if ((style & HORIZONTAL_ALIGN_FILL) != 0) horizontalAlignment = FILL;
328	if ((style & HORIZONTAL_ALIGN_END) != 0) horizontalAlignment = END;
329	grabExcessHorizontalSpace = (style & GRAB_HORIZONTAL) != 0;
330	grabExcessVerticalSpace = (style & GRAB_VERTICAL) != 0;
331	}
332
333	/**
334	* Constructs a new instance of GridLayoutData according to the parameters.
335	*
336	* @param horizontalAlignment how figure will be positioned horizontally within a cell
337	* @param verticalAlignment how figure will be positioned vertically within a cell
338	* @param grabExcessHorizontalSpace whether cell will be made wide enough to fit the remaining horizontal space
339	* @param grabExcessVerticalSpace whether cell will be made high enough to fit the remaining vertical space
340	*
341	*/
342	public GridLayoutData (int horizontalAlignment, int verticalAlignment, boolean grabExcessHorizontalSpace, boolean grabExcessVerticalSpace) {
343	this (horizontalAlignment, verticalAlignment, grabExcessHorizontalSpace, grabExcessVerticalSpace, 1, 1);
344	}
345
346	/**
347	* Constructs a new instance of GridLayoutData according to the parameters.
348	*
349	* @param horizontalAlignment how figure will be positioned horizontally within a cell
350	* @param verticalAlignment how figure will be positioned vertically within a cell
351	* @param grabExcessHorizontalSpace whether cell will be made wide enough to fit the remaining horizontal space
352	* @param grabExcessVerticalSpace whether cell will be made high enough to fit the remaining vertical space
353	* @param horizontalSpan the number of column cells that the figure will take up
354	* @param verticalSpan the number of row cells that the figure will take up
355	*
356	*/
357	public GridLayoutData (int horizontalAlignment, int verticalAlignment, boolean grabExcessHorizontalSpace, boolean grabExcessVerticalSpace, int horizontalSpan, int verticalSpan) {
358	super ();
359	this.horizontalAlignment = horizontalAlignment;
360	this.verticalAlignment = verticalAlignment;
361	this.grabExcessHorizontalSpace = grabExcessHorizontalSpace;
362	this.grabExcessVerticalSpace = grabExcessVerticalSpace;
363	this.horizontalSpan = horizontalSpan;
364	this.verticalSpan = verticalSpan;
365	}
366
367	/**
368	* Constructs a new instance of GridLayoutData according to the parameters.
369	* A value of SWT.DEFAULT indicates that no minimum width or
370	* no minumum height is specified.
371	*
372	* @param width a minimum width for the column
373	* @param height a minimum height for the row
374	*
375	*/
376	public GridLayoutData (int width, int height) {
377	super ();
378	this.widthHint = width;
379	this.heightHint = height;
380	}
381
382	Dimension computeSize (IFigure figure, boolean flushCache) {
383	if (cacheWidth != -1 && cacheHeight != -1) {
384	return new Dimension (cacheWidth, cacheHeight);
385	}
386	for (int i = 0; i < cacheIndex + 1; i++) {
387	if (cache [i][0] == widthHint && cache [i][1] == heightHint) {
388	cacheWidth = cache [i][2];
389	cacheHeight = cache [i][3];
390	return new Dimension (cacheWidth, cacheHeight);
391	}
392	}
393
394	Dimension size = figure.getPreferredSize(widthHint,heightHint);
395	if (widthHint!=-1) size.width = widthHint;
396	if (heightHint!=-1) size.height = heightHint;
397
398	if (cacheIndex < cache.length - 1) cacheIndex++;
399	cache [cacheIndex][0] = widthHint;
400	cache [cacheIndex][1] = heightHint;
401	cacheWidth = cache [cacheIndex][2] = size.width;
402	cacheHeight = cache [cacheIndex][3] = size.height;
403	return size;
404	}
405
406
407	void flushCache () {
408	cacheWidth = cacheHeight = -1;
409	cacheIndex = -1;
410	}
411
412	String getName () {
413	String string = getClass ().getName ();
414	int index = string.lastIndexOf ('.');
415	if (index == -1) return string;
416	return string.substring (index + 1, string.length ());
417	}
418
419	public String toString () {
420
421	String hAlign = "";
422	switch (horizontalAlignment) {
423	case FILL: hAlign = "GridLayoutData.FILL"; break;
424	case BEGINNING: hAlign = "GridLayoutData.BEGINNING"; break;
425	case END: hAlign = "GridLayoutData.LEFT"; break;
426	case CENTER: hAlign = "GridLayoutData.CENTER"; break;
427	default: hAlign = "Undefined "+horizontalAlignment; break;
428	}
429	String vAlign = "";
430	switch (verticalAlignment) {
431	case FILL: vAlign = "GridLayoutData.FILL"; break;
432	case BEGINNING: vAlign = "GridLayoutData.BEGINNING"; break;
433	case END: vAlign = "GridLayoutData.END"; break;
434	case CENTER: vAlign = "GridLayoutData.CENTER"; break;
435	default: vAlign = "Undefined "+verticalAlignment; break;
436	}
437	String string = getName()+" {";
438	string += "horizontalAlignment="+hAlign+" ";
439	if (horizontalIndent != 0) string += "horizontalIndent="+horizontalIndent+" ";
440	if (horizontalSpan != 1) string += "horizontalSpan="+horizontalSpan+" ";
441	if (grabExcessHorizontalSpace) string += "grabExcessHorizontalSpace="+grabExcessHorizontalSpace+" ";
442	if (widthHint != SWT.DEFAULT) string += "widthHint="+widthHint+" ";
443	string += "verticalAlignment="+vAlign+" ";
444	if (verticalSpan != 1) string += "verticalSpan="+verticalSpan+" ";
445	if (grabExcessVerticalSpace) string += "grabExcessVerticalSpace="+grabExcessVerticalSpace+" ";
446	if (heightHint != SWT.DEFAULT) string += "heightHint="+heightHint+" ";
447	string = string.trim();
448	string += "}";
449	return string;
450
451	}
452
453	}