bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/layout/TrimCommonUIHandle.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 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.layout;

 import org.eclipse.jface.action.ContributionItem;
 import org.eclipse.jface.action.MenuManager;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.events.ControlEvent;
 import org.eclipse.swt.events.ControlListener;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.events.SelectionListener;
 import org.eclipse.swt.graphics.Cursor;
 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.Event;
 import org.eclipse.swt.widgets.Label;
 import org.eclipse.swt.widgets.Listener;
 import org.eclipse.swt.widgets.Menu;
 import org.eclipse.swt.widgets.MenuItem;
 import org.eclipse.ui.internal.IChangeListener;
 import org.eclipse.ui.internal.IntModel;
 import org.eclipse.ui.internal.RadioMenu;
 import org.eclipse.ui.internal.WindowTrimProxy;
 import org.eclipse.ui.internal.WorkbenchMessages;
 import org.eclipse.ui.internal.dnd.DragUtil;
 import org.eclipse.ui.presentations.PresentationUtil;

 /**
  * This control provides common UI functionality for trim elements. Its
  * lifecycle is managed by the <code>TrimLayout</code> which automatically
  * adds a UI handle to all added trim elements. It uses an instance of a
  * CoolBar to provide the platform-specific drag affordance.
  * <p>
  * It provides the following features:
  * <p>
  * Drag affordance and handling:
  * <ol>
  * <li>Drag affordance is provided in the <code>paintControl</code> method</li>
  * <li>Drag handling is provided to allow rearrangement within a trim side or
  * to other sides, depending on the values returned by <code>IWindowTrim.getValidSides</code></li>
  * </ol>
  * </p>
  * <p>
  * Context Menu:
  * <ol>
  * <li>A "Dock on" menu item is provided to allow changing the side, depending on the values returned by
  * <code>IWindowTrim.getValidSides</code></li>
  * <li>A "Close" menu item is provided to allow the User to close (hide) the trim element,
  * based on the value returned by <code>IWindowTrim.isCloseable</code>
  * </ol>
  * </p>
  * <p>
  * @since 3.2
  * </p>
  */
 public class TrimCommonUIHandle extends Composite {
 	/*
 	 * Fields
 	 */
 	private TrimLayout  layout;
     private IWindowTrim trim;
 	private Control     toDrag;
 	private int orientation;

 	// CoolBar handling
 	private CoolBar cb = null;
 	private CoolItem ci = null;
 	private static int horizontalHandleSize = -1;
 	private static int verticalHandleSize = -1;

     /*
      * Context Menu
      */
 	private MenuManager dockMenuManager;
 	private ContributionItem dockContributionItem = null;
     private Menu sidesMenu;
 	private MenuItem dockCascade;
     private RadioMenu radioButtons;
     private IntModel radioVal = new IntModel(0);
 //	private Menu showMenu;
 //	private MenuItem showCascade;

 	/*
 	 * Listeners...
 	 */

     /**
      * This listener starts a drag operation when
      * the Drag and Drop manager tells it to
      */
     private Listener dragListener = new Listener() {
         public void handleEvent(Event event) {
         	// Only allow 'left mouse' drags...
         	if (event.button != 3) {
 	            Point position = DragUtil.getEventLoc(event);
 	            startDraggingTrim(position);
         	}
         }
     };

     /**
      * This listener brings up the context menu
      */
     private Listener menuListener = new Listener() {
         public void handleEvent(Event event) {
             Point loc = new Point(event.x, event.y);
             if (event.type == SWT.MenuDetect) {
                 showDockTrimPopup(loc);
             }
         }
     };

     /**
      * Listen to size changes in the control so we can adjust the
      * Coolbar and CoolItem to match.
      */
     private ControlListener controlListener = new ControlListener() {
 		public void controlMoved(ControlEvent e) {
 		}

 		public void controlResized(ControlEvent e) {
 			if (e.widget instanceof TrimCommonUIHandle) {
 				TrimCommonUIHandle ctrl = (TrimCommonUIHandle) e.widget;
 		        Point size = ctrl.getSize();

 		        // Set the CoolBar and item to match the handle's size
 		        cb.setSize(size);
 		        ci.setSize(size);
 		        ci.setPreferredSize(size);
 		        cb.layout(true);
 			}
 		}
     };

     /**
      * Create a new trim UI handle for a particular IWindowTrim item
      *
      * @param layout the TrimLayout we're being used in
      * @param trim the IWindowTrim we're acting on behalf of
      * @param curSide  the SWT side that the trim is currently on
      */
     public TrimCommonUIHandle(TrimLayout layout, IWindowTrim trim, int curSide) {
     	super(trim.getControl().getParent(), SWT.NONE);

     	// Set the control up with all its various hooks, cursor...
     	setup(layout, trim, curSide);

         // Listen to size changes to keep the CoolBar synched
         addControlListener(controlListener);
     }

 	/**
 	 * Set up the trim with its cursor, drag listener, context menu and menu listener.
 	 * This method can also be used to 'recycle' a trim handle as long as the new handle
 	 * is for trim under the same parent as it was originally used for.
 	 */
 	public void setup(TrimLayout layout, IWindowTrim trim, int curSide) {
     	this.layout = layout;
     	this.trim = trim;
     	this.toDrag = trim.getControl();
     	this.radioVal.set(curSide);

     	// remember the orientation to use
     	orientation = (curSide == SWT.LEFT || curSide == SWT.RIGHT) ? SWT.VERTICAL  : SWT.HORIZONTAL;

         // Insert a CoolBar and extras in order to provide the drag affordance
         insertCoolBar(orientation);

 		// Create a window trim proxy for the handle
 		createWindowTrimProxy();

     	// Set the cursor affordance
     	setDragCursor();

         // Set up the dragging behaviour
         PresentationUtil.addDragListener(cb, dragListener);

     	// Create the docking context menu
     	dockMenuManager = new MenuManager();
     	dockContributionItem = getDockingContribution();
         dockMenuManager.add(dockContributionItem);

         cb.addListener(SWT.MenuDetect, menuListener);

         setVisible(true);
     }

     /**
      * Handle the event generated when a User selects a new side to
      * dock this trim on using the context menu
      */
     private void handleShowOnChange() {
     	layout.removeTrim(trim);
     	trim.dock(radioVal.get());
     	layout.addTrim(radioVal.get(), trim, null);

     	// perform an optimized layout to show the trim in its new location
     	LayoutUtil.resize(trim.getControl());
 	}

 	/**
 	 * Create and format the IWindowTrim for the handle, ensuring that the
 	 * handle will be 'wide' enough to display the drag affordance.
 	 */
 	private void createWindowTrimProxy() {
 		// Create a window trim proxy for the handle
 		WindowTrimProxy proxy = new WindowTrimProxy(this, "NONE", "NONE", //$NON-NLS-1$ //$NON-NLS-2$
 				SWT.TOP | SWT.BOTTOM | SWT.LEFT | SWT.RIGHT, false);

 		// Set up the handle's hints based on the computed size that
 		// the handle has to be (i.e. if it's HORIZONTAL then the
 		// 'width' is determined by the space required to show the
 		// CB's drag affordance).
 		if (orientation == SWT.HORIZONTAL) {
 			proxy.setWidthHint(getHandleSize());
 			proxy.setHeightHint(0);
 		}
 		else {
 			proxy.setWidthHint(0);
 			proxy.setHeightHint(getHandleSize());
 		}

 		setLayoutData(proxy);
 	}

 	/**
 	 * 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() {
 		// Do we already have a 'cached' value?
 		if (orientation == SWT.HORIZONTAL && horizontalHandleSize != -1) {
 			return horizontalHandleSize;
 		}

 		if (orientation == SWT.VERTICAL && verticalHandleSize != -1) {
 			return verticalHandleSize;
 		}

 		// Must be the first time, calculate the value
 		CoolBar bar = new CoolBar (trim.getControl().getParent(), orientation);

 		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 (orientation == SWT.HORIZONTAL) {
 			length = bl.x - cl.x;
 			horizontalHandleSize = length;
 		}
 		else {
 			length = bl.y - cl.y;
 			verticalHandleSize = length;
 		}

 		return length;
 	}

 	/**
 	 * Place a CoolBar / CoolItem / Control inside the current
 	 * UI handle. These elements will maintain thier size based on
 	 * the size of their 'parent' (this).
 	 *
 	 * @param parent
 	 * @param orientation
 	 */
 	public void insertCoolBar(int orientation) {
 		// Clean up the previous info in case we've changed orientation
 		if (cb != null) {
 			ci.dispose();
 	        PresentationUtil.removeDragListener(cb, dragListener);
 			cb.dispose();
 		}

 		// Create the necessary parts...
 		cb = new CoolBar(this, orientation | SWT.FLAT);
 		cb.setLocation(0,0);
 		ci = new CoolItem(cb, SWT.FLAT);

 		// Create a composite in order to get the handles to appear
 		Composite comp = new Composite(cb, SWT.NONE);
 		ci.setControl(comp);
 	}

 	/**
 	 * Set the cursor to the four-way arrow to indicate that the
 	 * trim can be dragged
 	 */
 	private void setDragCursor() {
     	Cursor dragCursor = toDrag.getDisplay().getSystemCursor(SWT.CURSOR_SIZEALL);
     	setCursor(dragCursor);
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.swt.widgets.Composite#computeSize(int, int, boolean)
 	 */
 	public Point computeSize(int wHint, int hHint, boolean changed) {
 		Point ctrlPrefSize = trim.getControl().computeSize(wHint, hHint);
 		if (orientation == SWT.HORIZONTAL) {
 			return new Point(getHandleSize(), ctrlPrefSize.y);
 		}

 		// Must be vertical....
 		return new Point(ctrlPrefSize.x, getHandleSize());
 	}

 	/**
 	 * Construct (if necessary) a context menu contribution item and return it. This
 	 * is explicitly <code>public</code> so that trim elements can retrieve the item
 	 * and add it into their own context menus if desired.
 	 *
 	 * @return The contribution item for the handle's context menu.
 	 */
 	public ContributionItem getDockingContribution() {
     	if (dockContributionItem == null) {
     		dockContributionItem = new ContributionItem() {
     			public void fill(Menu menu, int index) {
     				// populate from superclass
     				super.fill(menu, index);

     				// Add a 'Close' menu entry if the trim supports the operation
     				if (trim.isCloseable()) {
 	    				MenuItem closeItem = new MenuItem(menu, SWT.PUSH, index++);
 	    				closeItem.setText(WorkbenchMessages.TrimCommon_Close);

 	    				closeItem.addSelectionListener(new SelectionListener() {
 							public void widgetSelected(SelectionEvent e) {
 								handleCloseTrim();
 							}

 							public void widgetDefaultSelected(SelectionEvent e) {
 							}
 	    				});

 	    				new MenuItem(menu, SWT.SEPARATOR, index++);
     				}

     				// Test Hook: add a menu entry that brings up a dialog to allow
     				// testing with various GUI prefs.
 //    				MenuItem closeItem = new MenuItem(menu, SWT.PUSH, index++);
 //    				closeItem.setText("Change Preferences"); //$NON-NLS-1$
 //
 //    				closeItem.addSelectionListener(new SelectionListener() {
 //						public void widgetSelected(SelectionEvent e) {
 //							handleChangePreferences();
 //						}
 //
 //						public void widgetDefaultSelected(SelectionEvent e) {
 //						}
 //    				});
 //
 //    				new MenuItem(menu, SWT.SEPARATOR, index++);

     				// Create a cascading menu to allow the user to dock the trim
     				dockCascade = new MenuItem(menu, SWT.CASCADE, index++);
     				{
     					dockCascade.setText(WorkbenchMessages.TrimCommon_DockOn);

     					sidesMenu = new Menu(dockCascade);
     					radioButtons = new RadioMenu(sidesMenu, radioVal);

 						radioButtons.addMenuItem(WorkbenchMessages.TrimCommon_Top, new Integer(SWT.TOP));
 						radioButtons.addMenuItem(WorkbenchMessages.TrimCommon_Bottom, new Integer(SWT.BOTTOM));
 						radioButtons.addMenuItem(WorkbenchMessages.TrimCommon_Left, new Integer(SWT.LEFT));
 						radioButtons.addMenuItem(WorkbenchMessages.TrimCommon_Right, new Integer(SWT.RIGHT));

     					dockCascade.setMenu(sidesMenu);
     				}

     		    	// if the radioVal changes it means that the User wants to change the docking location
     		    	radioVal.addChangeListener(new IChangeListener() {
     					public void update(boolean changed) {
     						if (changed) {
 								handleShowOnChange();
 							}
     					}
     		    	});

     				// Provide Show / Hide trim capabilities
 //    				showCascade = new MenuItem(menu, SWT.CASCADE, index++);
 //    				{
 //    					showCascade.setText(WorkbenchMessages.TrimCommon_ShowTrim);
 //
 //    					showMenu = new Menu(dockCascade);
 //
 //    					// Construct a 'hide/show' cascade from -all- the existing trim...
 //    					List trimItems = layout.getAllTrim();
 //    					Iterator d = trimItems.iterator();
 //    					while (d.hasNext()) {
 //    						IWindowTrim trimItem = (IWindowTrim) d.next();
 //							MenuItem item = new MenuItem(showMenu, SWT.CHECK);
 //							item.setText(trimItem.getDisplayName());
 //							item.setSelection(trimItem.getControl().getVisible());
 //							item.setData(trimItem);
 //
 //							// TODO: Make this work...wire it off for now
 //							item.setEnabled(false);
 //
 //							item.addSelectionListener(new SelectionListener() {
 //
 //								public void widgetSelected(SelectionEvent e) {
 //									IWindowTrim trim = (IWindowTrim) e.widget.getData();
 //									layout.setTrimVisible(trim, !trim.getControl().getVisible());
 //								}
 //
 //								public void widgetDefaultSelected(SelectionEvent e) {
 //								}
 //
 //							});
 //						}
 //
 //    					showCascade.setMenu(showMenu);
 //    				}
     			}
     		};
     	}
     	return dockContributionItem;
     }

 	/**
 	 * Test Hook: Bring up a dialog that allows the user to
 	 * modify the trimdragging GUI preferences.
 	 */
 //	private void handleChangePreferences() {
 //		TrimDragPreferenceDialog dlg = new TrimDragPreferenceDialog(getShell());
 //		dlg.open();
 //	}

 	/**
 	 * Handle the event generated when the "Close" item is
 	 * selected on the context menu. This removes the associated
 	 * trim and calls back to the IWidnowTrim to inform it that
 	 * the User has closed the trim.
 	 */
 	private void handleCloseTrim() {
 		layout.removeTrim(trim);
 		trim.handleClose();
 	}

     /* (non-Javadoc)
      * @see org.eclipse.swt.widgets.Widget#dispose()
      */
     public void dispose() {
         if (radioButtons != null) {
             radioButtons.dispose();
         }

         // tidy up...
         removeControlListener(controlListener);
         removeListener(SWT.MenuDetect, menuListener);

         super.dispose();
     }

     /**
      * Begins dragging the trim
      *
      * @param position initial mouse position
      */
     protected void startDraggingTrim(Point position) {
     	Rectangle fakeBounds = new Rectangle(100000, 0,0,0);
         DragUtil.performDrag(trim, fakeBounds, position, true);
     }

     /**
      * Shows the popup menu for an item in the fast view bar.
      */
     private void showDockTrimPopup(Point pt) {
         Menu menu = dockMenuManager.createContextMenu(toDrag);
         menu.setLocation(pt.x, pt.y);
         menu.setVisible(true);
     }
 }
	/*******************************************************************************
	* Copyright (c) 2005, 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.layout;

	import org.eclipse.jface.action.ContributionItem;
	import org.eclipse.jface.action.MenuManager;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.events.ControlEvent;
	import org.eclipse.swt.events.ControlListener;
	import org.eclipse.swt.events.SelectionEvent;
	import org.eclipse.swt.events.SelectionListener;
	import org.eclipse.swt.graphics.Cursor;
	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.Event;
	import org.eclipse.swt.widgets.Label;
	import org.eclipse.swt.widgets.Listener;
	import org.eclipse.swt.widgets.Menu;
	import org.eclipse.swt.widgets.MenuItem;
	import org.eclipse.ui.internal.IChangeListener;
	import org.eclipse.ui.internal.IntModel;
	import org.eclipse.ui.internal.RadioMenu;
	import org.eclipse.ui.internal.WindowTrimProxy;
	import org.eclipse.ui.internal.WorkbenchMessages;
	import org.eclipse.ui.internal.dnd.DragUtil;
	import org.eclipse.ui.presentations.PresentationUtil;

	/**
	* This control provides common UI functionality for trim elements. Its
	* lifecycle is managed by the <code>TrimLayout</code> which automatically
	* adds a UI handle to all added trim elements. It uses an instance of a
	* CoolBar to provide the platform-specific drag affordance.
	* <p>
	* It provides the following features:
	* <p>
	* Drag affordance and handling:
	* <ol>
	* <li>Drag affordance is provided in the <code>paintControl</code> method</li>
	* <li>Drag handling is provided to allow rearrangement within a trim side or
	* to other sides, depending on the values returned by <code>IWindowTrim.getValidSides</code></li>
	* </ol>
	* </p>
	* <p>
	* Context Menu:
	* <ol>
	* <li>A "Dock on" menu item is provided to allow changing the side, depending on the values returned by
	* <code>IWindowTrim.getValidSides</code></li>
	* <li>A "Close" menu item is provided to allow the User to close (hide) the trim element,
	* based on the value returned by <code>IWindowTrim.isCloseable</code>
	* </ol>
	* </p>
	* <p>
	* @since 3.2
	* </p>
	*/
	public class TrimCommonUIHandle extends Composite {
	/*
	* Fields
	*/
	private TrimLayout layout;
	private IWindowTrim trim;
	private Control toDrag;
	private int orientation;

	// CoolBar handling
	private CoolBar cb = null;
	private CoolItem ci = null;
	private static int horizontalHandleSize = -1;
	private static int verticalHandleSize = -1;

	/*
	* Context Menu
	*/
	private MenuManager dockMenuManager;
	private ContributionItem dockContributionItem = null;
	private Menu sidesMenu;
	private MenuItem dockCascade;
	private RadioMenu radioButtons;
	private IntModel radioVal = new IntModel(0);
	// private Menu showMenu;
	// private MenuItem showCascade;

	/*
	* Listeners...
	*/

	/**
	* This listener starts a drag operation when
	* the Drag and Drop manager tells it to
	*/
	private Listener dragListener = new Listener() {
	public void handleEvent(Event event) {
	// Only allow 'left mouse' drags...
	if (event.button != 3) {
	Point position = DragUtil.getEventLoc(event);
	startDraggingTrim(position);
	}
	}
	};

	/**
	* This listener brings up the context menu
	*/
	private Listener menuListener = new Listener() {
	public void handleEvent(Event event) {
	Point loc = new Point(event.x, event.y);
	if (event.type == SWT.MenuDetect) {
	showDockTrimPopup(loc);
	}
	}
	};

	/**
	* Listen to size changes in the control so we can adjust the
	* Coolbar and CoolItem to match.
	*/
	private ControlListener controlListener = new ControlListener() {
	public void controlMoved(ControlEvent e) {
	}

	public void controlResized(ControlEvent e) {
	if (e.widget instanceof TrimCommonUIHandle) {
	TrimCommonUIHandle ctrl = (TrimCommonUIHandle) e.widget;
	Point size = ctrl.getSize();

	// Set the CoolBar and item to match the handle's size
	cb.setSize(size);
	ci.setSize(size);
	ci.setPreferredSize(size);
	cb.layout(true);
	}
	}
	};

	/**
	* Create a new trim UI handle for a particular IWindowTrim item
	*
	* @param layout the TrimLayout we're being used in
	* @param trim the IWindowTrim we're acting on behalf of
	* @param curSide the SWT side that the trim is currently on
	*/
	public TrimCommonUIHandle(TrimLayout layout, IWindowTrim trim, int curSide) {
	super(trim.getControl().getParent(), SWT.NONE);

	// Set the control up with all its various hooks, cursor...
	setup(layout, trim, curSide);

	// Listen to size changes to keep the CoolBar synched
	addControlListener(controlListener);
	}

	/**
	* Set up the trim with its cursor, drag listener, context menu and menu listener.
	* This method can also be used to 'recycle' a trim handle as long as the new handle
	* is for trim under the same parent as it was originally used for.
	*/
	public void setup(TrimLayout layout, IWindowTrim trim, int curSide) {
	this.layout = layout;
	this.trim = trim;
	this.toDrag = trim.getControl();
	this.radioVal.set(curSide);

	// remember the orientation to use
	orientation = (curSide == SWT.LEFT \|\| curSide == SWT.RIGHT) ? SWT.VERTICAL : SWT.HORIZONTAL;

	// Insert a CoolBar and extras in order to provide the drag affordance
	insertCoolBar(orientation);

	// Create a window trim proxy for the handle
	createWindowTrimProxy();

	// Set the cursor affordance
	setDragCursor();

	// Set up the dragging behaviour
	PresentationUtil.addDragListener(cb, dragListener);

	// Create the docking context menu
	dockMenuManager = new MenuManager();
	dockContributionItem = getDockingContribution();
	dockMenuManager.add(dockContributionItem);

	cb.addListener(SWT.MenuDetect, menuListener);

	setVisible(true);
	}

	/**
	* Handle the event generated when a User selects a new side to
	* dock this trim on using the context menu
	*/
	private void handleShowOnChange() {
	layout.removeTrim(trim);
	trim.dock(radioVal.get());
	layout.addTrim(radioVal.get(), trim, null);

	// perform an optimized layout to show the trim in its new location
	LayoutUtil.resize(trim.getControl());
	}

	/**
	* Create and format the IWindowTrim for the handle, ensuring that the
	* handle will be 'wide' enough to display the drag affordance.
	*/
	private void createWindowTrimProxy() {
	// Create a window trim proxy for the handle
	WindowTrimProxy proxy = new WindowTrimProxy(this, "NONE", "NONE", //$NON-NLS-1$ //$NON-NLS-2$
	SWT.TOP \| SWT.BOTTOM \| SWT.LEFT \| SWT.RIGHT, false);

	// Set up the handle's hints based on the computed size that
	// the handle has to be (i.e. if it's HORIZONTAL then the
	// 'width' is determined by the space required to show the
	// CB's drag affordance).
	if (orientation == SWT.HORIZONTAL) {
	proxy.setWidthHint(getHandleSize());
	proxy.setHeightHint(0);
	}
	else {
	proxy.setWidthHint(0);
	proxy.setHeightHint(getHandleSize());
	}

	setLayoutData(proxy);
	}

	/**
	* 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() {
	// Do we already have a 'cached' value?
	if (orientation == SWT.HORIZONTAL && horizontalHandleSize != -1) {
	return horizontalHandleSize;
	}

	if (orientation == SWT.VERTICAL && verticalHandleSize != -1) {
	return verticalHandleSize;
	}

	// Must be the first time, calculate the value
	CoolBar bar = new CoolBar (trim.getControl().getParent(), orientation);

	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 (orientation == SWT.HORIZONTAL) {
	length = bl.x - cl.x;
	horizontalHandleSize = length;
	}
	else {
	length = bl.y - cl.y;
	verticalHandleSize = length;
	}

	return length;
	}

	/**
	* Place a CoolBar / CoolItem / Control inside the current
	* UI handle. These elements will maintain thier size based on
	* the size of their 'parent' (this).
	*
	* @param parent
	* @param orientation
	*/
	public void insertCoolBar(int orientation) {
	// Clean up the previous info in case we've changed orientation
	if (cb != null) {
	ci.dispose();
	PresentationUtil.removeDragListener(cb, dragListener);
	cb.dispose();
	}

	// Create the necessary parts...
	cb = new CoolBar(this, orientation \| SWT.FLAT);
	cb.setLocation(0,0);
	ci = new CoolItem(cb, SWT.FLAT);

	// Create a composite in order to get the handles to appear
	Composite comp = new Composite(cb, SWT.NONE);
	ci.setControl(comp);
	}

	/**
	* Set the cursor to the four-way arrow to indicate that the
	* trim can be dragged
	*/
	private void setDragCursor() {
	Cursor dragCursor = toDrag.getDisplay().getSystemCursor(SWT.CURSOR_SIZEALL);
	setCursor(dragCursor);
	}

	/* (non-Javadoc)
	* @see org.eclipse.swt.widgets.Composite#computeSize(int, int, boolean)
	*/
	public Point computeSize(int wHint, int hHint, boolean changed) {
	Point ctrlPrefSize = trim.getControl().computeSize(wHint, hHint);
	if (orientation == SWT.HORIZONTAL) {
	return new Point(getHandleSize(), ctrlPrefSize.y);
	}

	// Must be vertical....
	return new Point(ctrlPrefSize.x, getHandleSize());
	}

	/**
	* Construct (if necessary) a context menu contribution item and return it. This
	* is explicitly <code>public</code> so that trim elements can retrieve the item
	* and add it into their own context menus if desired.
	*
	* @return The contribution item for the handle's context menu.
	*/
	public ContributionItem getDockingContribution() {
	if (dockContributionItem == null) {
	dockContributionItem = new ContributionItem() {
	public void fill(Menu menu, int index) {
	// populate from superclass
	super.fill(menu, index);

	// Add a 'Close' menu entry if the trim supports the operation
	if (trim.isCloseable()) {
	MenuItem closeItem = new MenuItem(menu, SWT.PUSH, index++);
	closeItem.setText(WorkbenchMessages.TrimCommon_Close);

	closeItem.addSelectionListener(new SelectionListener() {
	public void widgetSelected(SelectionEvent e) {
	handleCloseTrim();
	}

	public void widgetDefaultSelected(SelectionEvent e) {
	}
	});

	new MenuItem(menu, SWT.SEPARATOR, index++);
	}

	// Test Hook: add a menu entry that brings up a dialog to allow
	// testing with various GUI prefs.
	// MenuItem closeItem = new MenuItem(menu, SWT.PUSH, index++);
	// closeItem.setText("Change Preferences"); //$NON-NLS-1$
	//
	// closeItem.addSelectionListener(new SelectionListener() {
	// public void widgetSelected(SelectionEvent e) {
	// handleChangePreferences();
	// }
	//
	// public void widgetDefaultSelected(SelectionEvent e) {
	// }
	// });
	//
	// new MenuItem(menu, SWT.SEPARATOR, index++);

	// Create a cascading menu to allow the user to dock the trim
	dockCascade = new MenuItem(menu, SWT.CASCADE, index++);
	{
	dockCascade.setText(WorkbenchMessages.TrimCommon_DockOn);

	sidesMenu = new Menu(dockCascade);
	radioButtons = new RadioMenu(sidesMenu, radioVal);

	radioButtons.addMenuItem(WorkbenchMessages.TrimCommon_Top, new Integer(SWT.TOP));
	radioButtons.addMenuItem(WorkbenchMessages.TrimCommon_Bottom, new Integer(SWT.BOTTOM));
	radioButtons.addMenuItem(WorkbenchMessages.TrimCommon_Left, new Integer(SWT.LEFT));
	radioButtons.addMenuItem(WorkbenchMessages.TrimCommon_Right, new Integer(SWT.RIGHT));

	dockCascade.setMenu(sidesMenu);
	}

	// if the radioVal changes it means that the User wants to change the docking location
	radioVal.addChangeListener(new IChangeListener() {
	public void update(boolean changed) {
	if (changed) {
	handleShowOnChange();
	}
	}
	});

	// Provide Show / Hide trim capabilities
	// showCascade = new MenuItem(menu, SWT.CASCADE, index++);
	// {
	// showCascade.setText(WorkbenchMessages.TrimCommon_ShowTrim);
	//
	// showMenu = new Menu(dockCascade);
	//
	// // Construct a 'hide/show' cascade from -all- the existing trim...
	// List trimItems = layout.getAllTrim();
	// Iterator d = trimItems.iterator();
	// while (d.hasNext()) {
	// IWindowTrim trimItem = (IWindowTrim) d.next();
	// MenuItem item = new MenuItem(showMenu, SWT.CHECK);
	// item.setText(trimItem.getDisplayName());
	// item.setSelection(trimItem.getControl().getVisible());
	// item.setData(trimItem);
	//
	// // TODO: Make this work...wire it off for now
	// item.setEnabled(false);
	//
	// item.addSelectionListener(new SelectionListener() {
	//
	// public void widgetSelected(SelectionEvent e) {
	// IWindowTrim trim = (IWindowTrim) e.widget.getData();
	// layout.setTrimVisible(trim, !trim.getControl().getVisible());
	// }
	//
	// public void widgetDefaultSelected(SelectionEvent e) {
	// }
	//
	// });
	// }
	//
	// showCascade.setMenu(showMenu);
	// }
	}
	};
	}
	return dockContributionItem;
	}

	/**
	* Test Hook: Bring up a dialog that allows the user to
	* modify the trimdragging GUI preferences.
	*/
	// private void handleChangePreferences() {
	// TrimDragPreferenceDialog dlg = new TrimDragPreferenceDialog(getShell());
	// dlg.open();
	// }

	/**
	* Handle the event generated when the "Close" item is
	* selected on the context menu. This removes the associated
	* trim and calls back to the IWidnowTrim to inform it that
	* the User has closed the trim.
	*/
	private void handleCloseTrim() {
	layout.removeTrim(trim);
	trim.handleClose();
	}

	/* (non-Javadoc)
	* @see org.eclipse.swt.widgets.Widget#dispose()
	*/
	public void dispose() {
	if (radioButtons != null) {
	radioButtons.dispose();
	}

	// tidy up...
	removeControlListener(controlListener);
	removeListener(SWT.MenuDetect, menuListener);

	super.dispose();
	}

	/**
	* Begins dragging the trim
	*
	* @param position initial mouse position
	*/
	protected void startDraggingTrim(Point position) {
	Rectangle fakeBounds = new Rectangle(100000, 0,0,0);
	DragUtil.performDrag(trim, fakeBounds, position, true);
	}

	/**
	* Shows the popup menu for an item in the fast view bar.
	*/
	private void showDockTrimPopup(Point pt) {
	Menu menu = dockMenuManager.createContextMenu(toDrag);
	menu.setLocation(pt.x, pt.y);
	menu.setVisible(true);
	}
	}