bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/WorkbenchLayout.java

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

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CBanner;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.CoolBar;
import org.eclipse.swt.widgets.CoolItem;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Layout;
import org.eclipse.ui.internal.layout.TrimCommonUIHandle;

/**
 * This layout implements the handling necessary to support the positioning of
 * all of the 'trim' elements defined for the workbench.
 * <p>
 * NOTE: This class is a part of a 'work in progress' and should not be used
 * without consulting the Platform UI group. No guarantees are made as to the
 * stability of the API.
 * </p>
 * 
 * @since 3.2
 * 
 */
public class WorkbenchLayout extends Layout {
	private static int defaultMargin = 5;

	/**
	 * This is a convenience class that caches information for a single 'tiled'
	 * line of trim.
	 * 
	 * @since 3.2
	 * 
	 */
	private class TrimLine {
		/**
		 * Teh list of controls in this trim line
		 */
		List controls = new ArrayList();

		/**
		 * A cache of the previously computed sizes of each trim control
		 */
		List computedSizes = new ArrayList();

		/**
		 * In horizontal terms this is the 'height' of the tallest control.
		 */
		int minorMax = 0;

		/**
		 * The number of controls in the line that want to 'grab' extra space.
		 * Any unused space in a trim line is shared equally among these
		 * controls
		 */
		int resizableCount = 0;

		/**
		 * The amount of unused space in the line
		 */
		int extraSpace = 0;
	}

	/**
	 * This layout is used to capture the CBanner's calls to 'computeSize' for
	 * the left trim (which is used to determine the height of the CBanner) so
	 * that it will compute its own height to be the max of either the left or
	 * the right control.
	 * <p>
	 * NOTE: This class is expected to be removed once the CBanner mods are in.
	 * </p>
	 * 
	 * @since 3.2
	 * 
	 */
	private class LeftBannerLayout extends Layout {

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.swt.widgets.Layout#computeSize(org.eclipse.swt.widgets.Composite,
		 *      int, int, boolean)
		 */
		protected Point computeSize(Composite composite, int wHint, int hHint,
				boolean flushCache) {
			// 'topMax' is the maximum height of both the left and
			// the right side
			return new Point(wHint, WorkbenchLayout.this.topMax);
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.swt.widgets.Layout#layout(org.eclipse.swt.widgets.Composite,
		 *      boolean)
		 */
		protected void layout(Composite composite, boolean flushCache) {
		}

	}

	// Trim area 'ids'
	public static final String TRIMID_CMD_PRIMARY = "Command Primary"; //$NON-NLS-1$

	public static final String TRIMID_CMD_SECONDARY = "Command Secondary"; //$NON-NLS-1$

	public static final String TRIMID_VERTICAL1 = "vertical1"; //$NON-NLS-1$

	public static final String TRIMID_VERTICAL2 = "vertical2"; //$NON-NLS-1$

	public static final String TRIMID_STATUS = "Status"; //$NON-NLS-1$

	public static final String TRIMID_CENTER = "Center"; //$NON-NLS-1$

	// 'CBanner' info
	public CBanner banner;

	private int topMax;

	// 'Center' composite
	public Composite centerComposite;

	// inter-element spacing
	private int spacing = 0;

	// Trim Areas
	private TrimArea cmdPrimaryTrimArea;

	private TrimArea cmdSecondaryTrimArea;

	private TrimArea leftTrimArea;

	private TrimArea rightTrimArea;

	private TrimArea bottomTrimArea;

	// Drag handle info
	private int horizontalHandleSize = -1;

	private int verticalHandleSize = -1;

	private List dragHandles;

	// statics used in the layout
	private static Composite layoutComposite;

	private static Rectangle clientRect;

	/**
	 * Construct a new layout. This defines the trim areas that trim can be
	 * placed into.
	 */
	public WorkbenchLayout() {
		super();

		// Add the trim areas into the layout
		cmdPrimaryTrimArea = new TrimArea(TRIMID_CMD_PRIMARY, SWT.TOP,
				defaultMargin);
		cmdSecondaryTrimArea = new TrimArea(TRIMID_CMD_SECONDARY, SWT.TOP,
				defaultMargin);
		leftTrimArea = new TrimArea(TRIMID_VERTICAL1, SWT.LEFT, defaultMargin);
		rightTrimArea = new TrimArea(TRIMID_VERTICAL2, SWT.RIGHT, defaultMargin);
		bottomTrimArea = new TrimArea(TRIMID_STATUS, SWT.BOTTOM, defaultMargin);

		// init the list that has the drag handle cache
		dragHandles = new ArrayList();
	}

	/**
	 * Create the CBanner control used to control the horizontal span of the
	 * primary and secondary command areas.
	 * 
	 * @param workbenchComposite
	 *            The workbench acting as the parent of the CBanner
	 */
	public void createCBanner(Composite workbenchComposite) {
		banner = new CBanner(workbenchComposite, SWT.NONE);
		banner.setSimple(false);
		banner.setRightWidth(175);
		banner.setLocation(0, 0);

		// Create the left composite and override its 'computeSize'
		// to delegate to the 'primary' command trim area
		Composite bannerLeft = new Composite(banner, SWT.NONE) {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.widgets.Composite#computeSize(int, int,
			 *      boolean)
			 */
			public Point computeSize(int wHint, int hHint, boolean changed) {
				// If we're doing a 'real' workbench layout then delegate to the
				// appropriate trim area
				if (WorkbenchLayout.layoutComposite != null) {
					return WorkbenchLayout.this.computeSize(TRIMID_CMD_PRIMARY,
							wHint);
				}

				return super.computeSize(wHint, hHint, changed);
			}
		};
		bannerLeft.setLayout(new LeftBannerLayout());
		bannerLeft.setBackground(workbenchComposite.getDisplay()
				.getSystemColor(SWT.COLOR_DARK_BLUE));
		banner.setLeft(bannerLeft);

		// Create the right hand part of the CBanner
		Composite bannerRight = new Composite(banner, SWT.NONE) {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.widgets.Composite#computeSize(int, int,
			 *      boolean)
			 */
			public Point computeSize(int wHint, int hHint, boolean changed) {
				// If we're doing a 'real' workbench layout then delegate to the
				// appropriate trim area
				if (WorkbenchLayout.layoutComposite != null) {
					return WorkbenchLayout.this.computeSize(
							TRIMID_CMD_SECONDARY, wHint);
				}

				return super.computeSize(wHint, hHint, changed);
			}
		};
		bannerRight.setBackground(workbenchComposite.getDisplay()
				.getSystemColor(SWT.COLOR_DARK_BLUE));
		banner.setRight(bannerRight);

		// If the right banner control changes size it's because
		// the 'swoop' moved.
		bannerRight.addControlListener(new ControlListener() {
			public void controlMoved(ControlEvent e) {
			}

			public void controlResized(ControlEvent e) {
				Composite leftComp = (Composite) e.widget;
				leftComp.getShell().layout(true);
			}
		});

		// Place the CBanner on the 'bottom' of the z-order
		banner.moveBelow(null);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.swt.widgets.Layout#computeSize(org.eclipse.swt.widgets.Composite,
	 *      int, int, boolean)
	 * 
	 * Note that this is arbitrary since the we're a top level shell (so
	 * computeSize won't be called.
	 */
	protected Point computeSize(Composite composite, int wHint, int hHint,
			boolean flushCache) {
		Point size = new Point(wHint, hHint);
		if (size.x == SWT.DEFAULT) {
			size.x = 300;
		}
		if (size.y == SWT.DEFAULT) {
			size.y = 300;
		}
		return size;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.swt.widgets.Layout#layout(org.eclipse.swt.widgets.Composite,
	 *      boolean)
	 * 
	 * TODO: Supply a full description of the layout mechanicsS
	 */
	protected void layout(Composite composite, boolean flushCache) {
		layoutComposite = composite;
		clientRect = composite.getClientArea();

		// reset all the drag handles to be invisible
		resetDragHandles();

		// Compute the proper size for each trim area
		// Do Top Right, Top Left, Left, Right then Bottom so the math works out
		if (useCBanner()) {
			banner.moveBelow(null);

			// NOTE: calling 'computeSize' here will, in turn, call the
			// 'computeSize' for the left/right areas, each with the
			// 'correct' width hint...
			Point bannerSize = banner
					.computeSize(clientRect.width, SWT.DEFAULT);

			// set the amount of space used by the 'cmd' areas for use later
			topMax = bannerSize.y;

			banner.setSize(bannerSize);
		} else {
			Point c1Size = computeSize(TRIMID_CMD_PRIMARY, clientRect.width);
			Point c2Size = computeSize(TRIMID_CMD_SECONDARY, clientRect.width);

			// set the amount of space used by the 'cmd' areas for use later
			topMax = c1Size.y + c2Size.y;
		}

		// Now do the vertical areas; their 'major' is whatever is left
		// vertically once the top areas have been computed
		Point v1Size = computeSize(TRIMID_VERTICAL1, clientRect.height - topMax);
		Point v2Size = computeSize(TRIMID_VERTICAL2, clientRect.height - topMax);

		// Finally, the status area's 'major' is whatever is left over
		// horizontally once the vertical areas have been computed.
		computeSize(TRIMID_STATUS, clientRect.width - (v1Size.x + v2Size.x));

		// Now, layout the trim within each area
		// Command primary area
		if (useCBanner()) {
			Point leftLoc = banner.getLeft().getLocation();
			cmdPrimaryTrimArea.areaBounds.x = leftLoc.x;
			cmdPrimaryTrimArea.areaBounds.y = leftLoc.y;
		} else {
			cmdPrimaryTrimArea.areaBounds.x = 0;
			cmdPrimaryTrimArea.areaBounds.y = 0;
		}
		layoutTrim(cmdPrimaryTrimArea, cmdPrimaryTrimArea.areaBounds);

		// Command secondary area
		if (useCBanner()) {
			Point rightLoc = banner.getRight().getLocation();
			cmdSecondaryTrimArea.areaBounds.x = rightLoc.x;
			cmdSecondaryTrimArea.areaBounds.y = rightLoc.y;
		} else {
			cmdSecondaryTrimArea.areaBounds.x = 0;
			cmdSecondaryTrimArea.areaBounds.y = cmdPrimaryTrimArea.areaBounds.height;
		}
		layoutTrim(cmdSecondaryTrimArea, cmdSecondaryTrimArea.areaBounds);

		leftTrimArea.areaBounds.x = 0;
		leftTrimArea.areaBounds.y = topMax;
		layoutTrim(leftTrimArea, leftTrimArea.areaBounds);

		rightTrimArea.areaBounds.x = clientRect.width
				- rightTrimArea.areaBounds.width;
		rightTrimArea.areaBounds.y = topMax;
		layoutTrim(rightTrimArea, rightTrimArea.areaBounds);

		bottomTrimArea.areaBounds.x = leftTrimArea.areaBounds.width;
		bottomTrimArea.areaBounds.y = clientRect.height
				- bottomTrimArea.areaBounds.height;
		layoutTrim(bottomTrimArea, bottomTrimArea.areaBounds);

		// Set the center control's bounds to fill the space remaining
		// after the trim has been arranged
		layoutCenter();
	}

	/**
	 * Indicates whether or not the layout should use the CBanner or tile the
	 * primary and secondary trim areas one above the other.
	 * 
	 * @return <code>true</code> iff the layout should use the CBanner.
	 */
	private boolean useCBanner() {
		return (banner != null && banner.getVisible());
	}

	/**
	 * @param areaId
	 *            The identifier for the TrimArea to return
	 * @return The TrimArea that matches the given areaId
	 */
	private TrimArea getTrimArea(String areaId) {
		if (TRIMID_CMD_PRIMARY.equals(areaId)) {
			return cmdPrimaryTrimArea;
		}
		if (TRIMID_CMD_SECONDARY.equals(areaId)) {
			return cmdSecondaryTrimArea;
		}
		if (TRIMID_VERTICAL1.equals(areaId)) {
			return leftTrimArea;
		}
		if (TRIMID_VERTICAL2.equals(areaId)) {
			return rightTrimArea;
		}
		if (TRIMID_STATUS.equals(areaId)) {
			return bottomTrimArea;
		}

		return null;
	}

	/**
	 * @param areaId
	 *            The TrimArea that we want to get the controls for
	 * @return The list of controls whose TrimLayoutData's areaId matches the
	 *         given areaId parameter
	 */
	private List getTrimContents(String areaId) {
		List trimContents = new ArrayList();
		Control[] children = layoutComposite.getChildren();
		for (int i = 0; i < children.length; i++) {
			// Skip any disposed or invisible widgets
			if (children[i].isDisposed() || !children[i].getVisible()) {
				continue;
			}

			// Only accept children that want to be layed out in a particular
			// trim area
			if (children[i].getLayoutData() instanceof TrimLayoutData) {
				TrimLayoutData tlData = (TrimLayoutData) children[i]
						.getLayoutData();
				if (tlData.areaId.equals(areaId)) {
					trimContents.add(children[i]);
				}
			}
		}

		return trimContents;
	}

	/**
	 * Lays out the center composite once the outer trim areas have all been
	 * done.
	 */
	private void layoutCenter() {
		if (centerComposite != null) {
			// The center is the 'inner' bounding box of the other trim areas
			Rectangle areaBounds = new Rectangle(
					leftTrimArea.areaBounds.x + leftTrimArea.areaBounds.width,
					topMax,
					clientRect.width
							- (leftTrimArea.areaBounds.width + rightTrimArea.areaBounds.width),
					clientRect.height
							- (topMax + bottomTrimArea.areaBounds.height));

			centerComposite.setBounds(areaBounds);
		}
	}

	/**
	 * Computes the size of a trim area given the length of its major dimension.
	 * Depending on whether the trim area is horizontal or vertical one of the
	 * two value will always match the supplied 'majorHint' ('x' if it's
	 * horizontal).
	 * <p>
	 * Effectively, this computes the length of the minor dimension by tiling
	 * the trim area's controls into multiple lines based on the length of the
	 * major dimension.
	 * </p>
	 * 
	 * @param areaId
	 *            The area id to compute the size for
	 * @param majorHint
	 *            The length of the major dimension
	 * 
	 * @return The computed size
	 */
	private Point computeSize(String areaId, int majorHint) {
		TrimArea trimArea = getTrimArea(areaId);
		boolean horizontal = trimArea.orientation == SWT.TOP
				|| trimArea.orientation == SWT.BOTTOM;

		// Gather up all the controls for this area and tile them out
		trimArea.trimContents = getTrimContents(trimArea.areaId);

		// Split the controls list into a list of TrimLines that each fit into
		// the trim area
		trimArea.trimLines = computeWrappedTrim(trimArea, majorHint);

		// Now, calculate the max between the default and the contents
		int minorMax = 0;
		for (Iterator iter = trimArea.trimLines.iterator(); iter.hasNext();) {
			TrimLine curLine = (TrimLine) iter.next();
			minorMax += curLine.minorMax;
		}
		minorMax = Math.max(minorMax, trimArea.defaultMinor);

		// Store the size in the area'a cache...
		Point computedSize = new Point(0, 0);
		if (horizontal) {
			computedSize.x = trimArea.areaBounds.width = majorHint;
			computedSize.y = trimArea.areaBounds.height = minorMax;
		} else {
			computedSize.x = trimArea.areaBounds.width = minorMax;
			computedSize.y = trimArea.areaBounds.height = majorHint;
		}

		// ...and return it
		return computedSize;
	}

	/**
	 * This is where the information required to lay the controls belonging to a
	 * particular trim area out.
	 * <p>
	 * Tile the controls in the trim area into one or more lines. Each line is
	 * guaranteed to take up less than or equal to the 'majorHint' in the major
	 * dimension. The result is a complete cache of the information needed to
	 * lay the controls in the trim area out.
	 * </p>
	 * 
	 * @param trimArea The trim area to create the cache info for
	 * @param majorHint The length of the major dimension
	 * 
	 * @return A List of <code>TrimLine</code> elements
	 */
	private List computeWrappedTrim(TrimArea trimArea, int majorHint) {
		boolean horizontal = trimArea.orientation == SWT.TOP
				|| trimArea.orientation == SWT.BOTTOM;
		// Return a list of 'lines' to tile the control into...
		List lines = new ArrayList();
		TrimLine curLine = new TrimLine();
		lines.add(curLine);
		curLine.minorMax = trimArea.defaultMinor;

		// Init the tilePos to force a 'new' line
		int tilePos = 0;
		for (Iterator iter = trimArea.trimContents.iterator(); iter.hasNext();) {
			Control control = (Control) iter.next();
			TrimLayoutData td = (TrimLayoutData) control.getLayoutData();

			Point prefSize;
			if (horizontal) {
				//prefSize = control.computeSize(majorHint, SWT.DEFAULT);
				prefSize = control.computeSize(SWT.DEFAULT, SWT.DEFAULT);
			} else {
				prefSize = control.computeSize(SWT.DEFAULT, majorHint);
			}

			// Will this control fit onto the current line?
			int curTileSize = horizontal ? prefSize.x : prefSize.y;

			// every control except the first one needs to include the 'spacing'
			// in the calc
			if (curLine.controls.size() > 0) {
				curTileSize += spacing;
			}

			// If the control can be re-positioned then we have to add a drag
			// handle to it
			// we have to include the space that it'll occupy in the calcs
			if (td.listener != null) {
				curTileSize += horizontal ? horizontalHandleSize
						: verticalHandleSize;
			}

			// Place the control into the 'current' line if it'll fit (or if
			// it's the
			// -first- control (this handles the case where a control is too
			// large to
			// fit into the current TrimArea's 'major' size.
			if ((tilePos + curTileSize) <= majorHint
					|| curLine.controls.size() == 0) {
				curLine.controls.add(control);

				// Cache the maximum amount of 'minor' space needed
				int minorSize = horizontal ? prefSize.y : prefSize.x;
				if (minorSize > curLine.minorMax) {
					curLine.minorMax = minorSize;
				}

				tilePos += curTileSize;
			} else {
				// Remember how much space was left on the current line
				curLine.extraSpace = majorHint - tilePos;

				// We need a new line...
				curLine = new TrimLine();
				lines.add(curLine);

				curLine.controls.add(control);

				// Cache the maximum amount of 'minor' space needed
				int minorSize = horizontal ? prefSize.y : prefSize.x;
				if (minorSize > curLine.minorMax) {
					curLine.minorMax = minorSize;
				}

				tilePos = curTileSize;
			}

			// Count how many 'resizable' controls there are
			if ((td.flags & TrimLayoutData.GROWABLE) != 0) {
				curLine.resizableCount++;
			}
		}

		// Remember how much space was left on the current line
		curLine.extraSpace = majorHint - tilePos;

		return lines;
	}

	private void layoutTrim(TrimArea trimArea, Rectangle areaBounds) {
		boolean horizontal = trimArea.orientation == SWT.TOP
				|| trimArea.orientation == SWT.BOTTOM;

		// How much space do we have to 'tile' into?
		int areaMajor = horizontal ? areaBounds.width : areaBounds.height;

		// Get the tiled 'List of Lists' for the trim
		List tileAreas = trimArea.trimLines;

		// Tile each 'line' into the trim
		int tilePosMinor = horizontal ? areaBounds.y : areaBounds.x;
		for (Iterator areaIter = tileAreas.iterator(); areaIter.hasNext();) {
			TrimLine curLine = (TrimLine) areaIter.next();

			// Compute how much space to give to 'resizable' controls. Note that
			// we can end up computing -negative- 'extraSpace' values if the
			// control's
			// preferred 'major' size is actually > the 'major' size for the
			// trim area
			int resizePadding = 0;
			if (curLine.resizableCount > 0 && curLine.extraSpace > 0) {
				resizePadding = curLine.extraSpace / curLine.resizableCount;
			}

			// Tile each line
			int tilePosMajor = horizontal ? areaBounds.x : areaBounds.y;
			for (Iterator iter = curLine.controls.iterator(); iter.hasNext();) {
				Control control = (Control) iter.next();
				TrimLayoutData td = (TrimLayoutData) control.getLayoutData();
				Point prefSize = control.computeSize(SWT.DEFAULT, SWT.DEFAULT);

				int major = horizontal ? prefSize.x : prefSize.y;
				int minor = horizontal ? prefSize.y : prefSize.x;

				// Ensure that controls that are too wide for the area get
				// 'clipped'
				if (major > areaMajor) {
					major = areaMajor;
				}

				// If desired, extend the 'minor' size of the control to fill
				// the area
				if ((td.flags & TrimLayoutData.GRAB_EXCESS_MINOR) != 0) {
					minor = curLine.minorMax;
				}

				// If desired, extend the 'major' size of the control to fill
				// the area
				if ((td.flags & TrimLayoutData.GROWABLE) != 0) {
					major += resizePadding;
				}

				// If we have to show a drag handle then do it here
				if (td.listener != null && createHandles()) {
					TrimCommonUIHandle handle = getDragHandle(trimArea.orientation);
					// handle.setControl(control);

					if (horizontal) {
						handle.setBounds(tilePosMajor, tilePosMinor,
								getHandleSize(true), curLine.minorMax);
					} else {
						handle.setBounds(tilePosMinor, tilePosMajor,
								curLine.minorMax, getHandleSize(false));
					}

					tilePosMajor += horizontal ? getHandleSize(true)
							: getHandleSize(false);
				}

				// Now, lay out the actual control
				switch (trimArea.orientation) {
				case SWT.TOP:
					control.setBounds(tilePosMajor, tilePosMinor, major, minor);
					break;
				case SWT.LEFT:
					control.setBounds(tilePosMinor, tilePosMajor, minor, major);
					break;
				case SWT.RIGHT:
					// Here we want to tile the control to the RIGHT edge
					int rightEdge = tilePosMinor + curLine.minorMax;
					control.setBounds(rightEdge - minor, tilePosMajor, minor,
							major);
					break;
				case SWT.BOTTOM:
					// Here we want to tile the control to the RIGHT edge
					int bottomEdge = tilePosMinor + curLine.minorMax;
					control.setBounds(tilePosMajor, bottomEdge - minor, major,
							minor);
					break;
				}

				// Ensure that the control is above the trim control
				tilePosMajor += major + spacing;
			}
			tilePosMinor += curLine.minorMax;
			tilePosMajor = horizontal ? areaBounds.x : areaBounds.y;
		}
	}

	/**
	 * HACK>>>Remove if found in the wild...
	 * @return
	 */
	private boolean createHandles() {
		return false;
	}

	private void resetDragHandles() {
		for (Iterator iter = dragHandles.iterator(); iter.hasNext();) {
			// TrimCommonUIHandle handle = (TrimCommonUIHandle) iter.next();
			// handle.setControl(null);
		}
	}

	private TrimCommonUIHandle getDragHandle(int orientation) {
		// boolean horizontal = orientation == SWT.TOP
		// || orientation == SWT.BOTTOM;

		for (Iterator iter = dragHandles.iterator(); iter.hasNext();) {
			TrimCommonUIHandle handle = (TrimCommonUIHandle) iter.next();
			// if (handle.toDrag == null && handle.horizontal == horizontal)
			return handle;
		}

		// If we get here then we haven't found a new drag handle so create one
		System.out.println("new Handle"); //$NON-NLS-1$
		// TrimCommonUIHandle newHandle = new
		// TrimCommonUIHandle(layoutComposite,
		// horizontal);
		// dragHandles.add(newHandle);
		// return newHandle;
		return null;
	}

	/**
	 * Return the SWT side that the trim area is on
	 * 
	 * @param areaId The id of the area to get the orientation of
	 * 
	 * @return The SWT  side corresponding that the given area
	 */
	public static int getOrientation(String areaId) {
		if (TRIMID_CMD_PRIMARY.equals(areaId)) {
			return SWT.TOP;
		}
		if (TRIMID_CMD_SECONDARY.equals(areaId)) {
			return SWT.TOP;
		}
		if (TRIMID_VERTICAL1.equals(areaId)) {
			return SWT.LEFT;
		}
		if (TRIMID_VERTICAL2.equals(areaId)) {
			return SWT.RIGHT;
		}
		if (TRIMID_STATUS.equals(areaId)) {
			return SWT.BOTTOM;
		}

		return SWT.NONE;
	}

	/**
	 * Calculate a size for the handle that will be large enough to show the
	 * CoolBar's drag affordance.
	 * 
	 * @return The size that the handle has to be, based on the orientation
	 */
	private int getHandleSize(boolean horizontal) {
		// Do we already have a 'cached' value?
		if (horizontal && horizontalHandleSize != -1) {
			return horizontalHandleSize;
		}

		if (!horizontal && verticalHandleSize != -1) {
			return verticalHandleSize;
		}

		// Must be the first time, calculate the value
		CoolBar bar = new CoolBar(layoutComposite, horizontal ? SWT.HORIZONTAL
				: SWT.VERTICAL);

		CoolItem item = new CoolItem(bar, SWT.NONE);

		Label ctrl = new Label(bar, SWT.PUSH);
		ctrl.setText("Button 1"); //$NON-NLS-1$
		Point size = ctrl.computeSize(SWT.DEFAULT, SWT.DEFAULT);

		Point ps = item.computeSize(size.x, size.y);
		item.setPreferredSize(ps);
		item.setControl(ctrl);

		bar.pack();

		// OK, now the difference between the location of the CB and the
		// location of the
		Point bl = ctrl.getLocation();
		Point cl = bar.getLocation();

		// Toss them now...
		ctrl.dispose();
		item.dispose();
		bar.dispose();

		// The 'size' is the difference between the start of teh CoolBar and
		// start of its first control
		int length;
		if (horizontal) {
			length = bl.x - cl.x;
			horizontalHandleSize = length;
		} else {
			length = bl.y - cl.y;
			verticalHandleSize = length;
		}

		return length;
	}

}