import org.eclipse.jface.action.IToolBarContributionItem;

import org.eclipse.jface.action.IToolBarContributionItem;

/*******************************************************************************

 * 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.presentations;

import org.eclipse.jface.action.ICoolBarManager;

import org.eclipse.jface.action.IToolBarContributionItem;

import org.eclipse.jface.action.IToolBarManager;

import org.eclipse.jface.action.IToolBarManager2;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

/**

 * The intention of this class is to allow for replacing the implementation of

 * the cool bar and tool bars in the workbench.

 * <p>

 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as

 * part of a work in progress. There is a guarantee neither that this API will

 * work nor that it will remain the same. Please do not use this API without

 * consulting with the Platform/UI team.

 * </p>

 * 

 * @since 3.2

 */

public interface IActionBarPresentationFactory {

	/**

	 * Creates the cool bar manager for the window's tool bar area.

	 * 

	 * @return the cool bar manager

	 */

	public ICoolBarManager createCoolBarManager();

	/**

	 * Creates the control for the window's cool bar. Subclasses may override.

	 * 

	 * @param coolBarManager

	 *            the window's cool bar manager

	 * @param parent

	 *            the parent composite

	 * @return the window's cool bar control

	 */

	public Control createCoolBarControl(ICoolBarManager coolBarManager,

			Composite parent);

	/**

	 * Creates a tool bar manager for window's tool bar area.

	 * 

	 * @return the tool bar manager

	 */

	public IToolBarManager2 createToolBarManager();

	/**

	 * Creates the control for the window's tool bar. Subclasses may override.

	 * 

	 * @param toolBarManager

	 *            the window's toolbar manager

	 * @param parent

	 *            the parent composite

	 * @return the window's tool bar control

	 */

	public Control createToolBarControl(IToolBarManager2 toolBarManager,

			Composite parent);

	/**

	 * Creates a tool bar manager for a view's tool bar.

	 * 

	 * @return the tool bar manager

	 */

	public IToolBarManager2 createViewToolBarManager();

	/**

	 * Creates the control for a view tool bar. Subclasses may override.

	 * 

	 * @param toolBarManager

	 *            the view's tool bar manager

	 * @param parent

	 *            the parent composite

	 * @return the view's tool bar control

	 */

	public Control createViewToolBarControl(IToolBarManager2 toolBarManager,

			Composite parent);

	/**

	 * Creates a toolbar contribution item for a window toolbar manager to be

	 * added to the window's cool bar.

	 * 

	 * @param toolBarManager

	 *            the tool bar manager

	 * @param id

	 *            the id of the contribution

	 * @return the toolbar contribution item

	 */

	public IToolBarContributionItem createToolBarContributionItem(

			IToolBarManager toolBarManager, String id);

}

/*******************************************************************************

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

import org.eclipse.jface.action.CoolBarManager;

import org.eclipse.jface.action.ICoolBarManager;

import org.eclipse.jface.action.IToolBarContributionItem;

import org.eclipse.jface.action.IToolBarManager;

import org.eclipse.jface.action.IToolBarManager2;

import org.eclipse.jface.action.ToolBarContributionItem;

import org.eclipse.jface.action.ToolBarManager;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

/**

 * The intention of this class is to allow for replacing the implementation of

 * the cool bar and tool bars in the workbench.

 * <p>

 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as

 * part of a work in progress. There is a guarantee neither that this API will

 * work nor that it will remain the same. Please do not use this API without

 * consulting with the Platform/UI team.

 * </p>

 * 

 * @since 3.2

 */

public class DefaultActionBarPresentationFactory implements IActionBarPresentationFactory {

	/* (non-Javadoc)

	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createCoolBarManager()

	 */

	public ICoolBarManager createCoolBarManager() {

		return new CoolBarManager(SWT.FLAT);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createCoolBarControl(org.eclipse.jface.action.ICoolBarManager, org.eclipse.swt.widgets.Composite)

	 */

	public Control createCoolBarControl(ICoolBarManager coolBarManager,

			Composite parent) {

		return coolBarManager.createControl2(parent);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createToolBarManager()

	 */

	public IToolBarManager2 createToolBarManager() {

		return new ToolBarManager(SWT.FLAT | SWT.RIGHT);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createToolBarControl(org.eclipse.jface.action.IToolBarManager2, org.eclipse.swt.widgets.Composite)

	 */

	public Control createToolBarControl(IToolBarManager2 toolBarManager,

			Composite parent) {

		return toolBarManager.createControl2(parent);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createViewToolBarManager()

	 */

	public IToolBarManager2 createViewToolBarManager() {

		return new ToolBarManager(SWT.FLAT | SWT.RIGHT);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createViewToolBarControl(org.eclipse.jface.action.IToolBarManager2, org.eclipse.swt.widgets.Composite)

	 */

	public Control createViewToolBarControl(IToolBarManager2 toolBarManager,

			Composite parent) {

		return toolBarManager.createControl2(parent);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createToolBarContributionItem(org.eclipse.jface.action.IToolBarManager, java.lang.String)

	 */

	public IToolBarContributionItem createToolBarContributionItem(

			IToolBarManager toolBarManager, String id) {

		return new ToolBarContributionItem(toolBarManager, id);

	}

}

      <factory

            class="org.eclipse.ui.examples.presentation.customtoolbar.CustomToolBarPresentationFactory"

            id="org.eclipse.ui.examples.presentation.customtoolbar"

            name="Custom Toolbar"/>

package org.eclipse.ui.examples.presentation.customtoolbar.widgets;

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.Display;

public class HannoverGlobalCoolBarSkin implements Skin {

	// border colors

	Color borderTopColor = new Color(null, 255, 255, 255);

	Color borderBottomColor = new Color(null, 144, 161, 181);

	Color borderLeftRightColor = new Color(null, 255, 255, 255);

	Color draggerLineColor = new Color(null, 168, 191, 197);

	Color draggerLineColor2 = new Color(null, 255, 255, 255);

	// background colors

	Color shadowColor = new Color(null, 109, 131, 180);

	Color backgroundTopColor = new Color(null, 247, 247, 247);

	Color backgroundBottomColor = new Color(null, 189, 198, 216);

	Color hoverItemBackgroundColor = new Color(null, 224, 233, 237);

	Color pressedItemBackgroundColor = new Color(null, 231, 231, 231);

	// arrows and text colors

	Color arrowColor = Display.getCurrent().getSystemColor(SWT.COLOR_BLACK);

	Color textColor = new Color(null, 43,73,111);

	Color hoverTextColor = new Color(null, 20, 38, 54);

	// gripper

	private final static int GRIPPER_DOT_HEIGHT = 3;

	private final static int GRIPPER_DOT_COUNT = 3;

	Color[] gripperColors = {

				new Color(null,213,218,225),new Color(null,174,186,197),new Color(null,214,219,225),

				new Color(null,246,246,243),new Color(null,247,248,246),new Color(null,245,246,242),

				new Color(null,247,248,248),new Color(null,249,249,249),new Color(null,247,248,248),

				new Color(null,208,241,222),new Color(null,173,184,197),new Color(null,208,214,222),

				new Color(null,246,247,245),new Color(null,247,248,246),new Color(null,246,247,245),

				new Color(null,240,241,244),new Color(null,247,248,247),new Color(null,240,242,244),

				new Color(null,200,208,217),new Color(null,171,183,196),new Color(null,200,208,217),

				new Color(null,244,245,244),new Color(null,247,248,246),new Color(null,244,245,244),

				new Color(null,232,235,239),new Color(null,246,247,246),new Color(null,232,235,240)

	};

	public HannoverGlobalCoolBarSkin() {

		super();

	}

	public Rectangle getInsets(int type, int state) {

		return null;

	}

	public Point getSize(int type, int state) {

		if (type == Skin.TYPE_DECORATION_GRIPPER) {

			return new Point(6, SWT.DEFAULT);

		} else if (type == Skin.TYPE_ITEM_MIN_MAX_HEIGHT) {

			return new Point(26, SWT.DEFAULT);

		} else if (type == Skin.TYPE_ITEM_MIN_MAX_WIDTHS) {

			return new Point(26, SWT.DEFAULT);

		}

		return null;

	}

	public Font getFont(int type, int state) {

		return null;

	}

	public Rectangle getMargins(int type, int state) {

		return new Rectangle(0,0,0,0);

	}

	public Rectangle getRect(int type, int state) {

		if (type == Skin.TYPE_ITEM_BORDER) {

			/*

			 * x - border on left of cool item (does not include gripper decorator.

			 * y - border on top of cool item

			 * width - border on right of cool item

			 * height - border on bottom of cool item

			 */

			return new Rectangle(0, 0, 2, 0);

		} else if (type == Skin.TYPE_BORDER) {

			/*

			 * x - border on left of coolbar

			 * y - border on top of coolbar

			 * width - border on right of coolbar

			 * height - border on bottom of coolbar

			 */

			return new Rectangle(1, 0, 1, 0);

		}

		return null;

	}

	public void drawBorder(GC gc, Rectangle rect, SWidget widget, int type, int state) {

		if (type == Skin.TYPE_BORDER) {

			// left/right edge

			gc.setForeground(borderLeftRightColor);

			gc.drawLine(rect.x, rect.y, rect.x, rect.y+rect.height-1);

			gc.drawLine(rect.x+rect.width-1, rect.y, rect.x+rect.width-1, rect.y+rect.height-1);

			// top edge

			gc.setForeground(borderTopColor);

			gc.drawLine(rect.x, rect.y, rect.x + rect.width -1, rect.y);

			// bottom edge

			gc.setForeground(borderBottomColor);

			gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width -1, rect.y + rect.height - 1);

		} else if (type == Skin.TYPE_ITEM_BORDER) {

			// top edge

			gc.setForeground(borderTopColor);

			gc.drawLine(rect.x, rect.y, rect.x + rect.width -1, rect.y);

			// bottom edge

			gc.setForeground(borderBottomColor);

			gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width -1, rect.y + rect.height - 1);

			// Right edge.

			gc.setForeground(draggerLineColor);

			gc.drawLine(rect.x + rect.width -2, rect.y, rect.x + rect.width -2, rect.y + rect.height - 2);

			gc.setForeground(draggerLineColor2);			

			gc.drawLine(rect.x + rect.width -1, rect.y, rect.x + rect.width -1, rect.y + rect.height - 2);

		}

	}

	public void drawBackground(GC gc, Rectangle rect, SWidget widget, int type, int state) {

		if (type == Skin.TYPE_BACKGROUND) {

			gc.setForeground(backgroundTopColor); 

			gc.setBackground(backgroundBottomColor); 

			gc.fillGradientRectangle(rect.x, rect.y, rect.width, rect.height, true); 

		} 

	}

	public void drawDecoration(GC gc, Rectangle rect, SWidget widget, int type, int state) {

		if (type == Skin.TYPE_DECORATION_GRIPPER) {

			drawGripper(gc, rect, widget, type, state);

		}

	}

	public void drawText(GC gc, Rectangle rect, String text, int style, SWidget widget, int type, int state) {

	}

	public void drawImage(GC gc, Rectangle rect, Image image, SWidget widget, int type, int state) {

	}

	public void dispose() {

		if (borderTopColor != null && borderTopColor.isDisposed() == false)

			borderTopColor.dispose();

		if (draggerLineColor != null && draggerLineColor.isDisposed() == false)

			draggerLineColor.dispose();

		if (shadowColor != null && shadowColor.isDisposed() == false)

			shadowColor.dispose();

		if (backgroundTopColor != null && backgroundTopColor.isDisposed() == false)

			backgroundTopColor.dispose();

		if (backgroundBottomColor != null && backgroundBottomColor.isDisposed() == false)

			backgroundBottomColor.dispose();

		if (hoverItemBackgroundColor != null && hoverItemBackgroundColor.isDisposed() == false)

			hoverItemBackgroundColor.dispose();

		if (pressedItemBackgroundColor != null && pressedItemBackgroundColor.isDisposed() == false)

			pressedItemBackgroundColor.dispose();

		if (arrowColor != null && arrowColor.isDisposed() == false)

			arrowColor.dispose();

		if (textColor != null && textColor.isDisposed() == false)

			textColor.dispose();

		if (hoverTextColor != null && hoverTextColor.isDisposed() == false)

			hoverTextColor.dispose();

		for (int i = 0; i < gripperColors.length; i++) {

			if (gripperColors[i] != null && gripperColors[i].isDisposed() == false)

				gripperColors[i].dispose();

		}

	}

	private void drawGripper(GC gc, Rectangle rect, SWidget widget, int type, int state) {

		int dotGap = GRIPPER_DOT_HEIGHT;

		int gripperImageHeight = GRIPPER_DOT_HEIGHT * GRIPPER_DOT_COUNT + dotGap * (GRIPPER_DOT_COUNT-1);

		int left = rect.x + rect.width - 3;

		int top = rect.y + (rect.height - gripperImageHeight) / 2;

		int x = left;

		int y = top;

		for (int i = 0; i < gripperColors.length; i++) {

			if (i != 0 && i % 9 == 0) {

				x = left;

				y += dotGap+1;

			} else if (i != 0 && i % 3 == 0) {

				x = left;

				y++;

			}

			gc.setForeground(gripperColors[i]); 

			gc.drawPoint(x,y);

			x++;

		}

	}

}

package org.eclipse.ui.examples.presentation.customtoolbar.widgets;

import java.util.ArrayList;

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Listener;

public class SCoolBar extends SWidget {

	private ArrayList items = new ArrayList();

	static final int DEFAULT_WIDTH	= 64;

	static final int DEFAULT_HEIGHT	= 64;

	static final int ITEM_INSET_TOP = 0;

	static final int ITEM_INSET_BOTTOM = 0;

	static final int LEFT_MARGIN = 6;

	static final int SHADOW_SIZE = 4;

	public SCoolBar(Composite parent, int style) {

		super(parent, checkStyle(style));

		Listener listener = new Listener() {

			public void handleEvent(Event event) {

				switch (event.type) {

					case SWT.Dispose:      		

						onDispose(event);

						break;

					case SWT.MouseDown:

						onMouseDown(event);

						break;

					case SWT.MouseExit:

						onMouseExit(event);

						break;

					case SWT.MouseMove:

						onMouseMove(event);

						break;

					case SWT.MouseUp:

						onMouseUp(event);

						break;

					case SWT.MouseDoubleClick:

						onMouseDoubleClick(event);

						break;

					case SWT.Paint:

						onPaint(event);

						break;

					case SWT.Resize:

						onResize(event);

						break;

				}

			}

		};

		int[] events = new int[] { 

			SWT.Dispose, 

			SWT.MouseDown,

			SWT.MouseExit, 

			SWT.MouseMove, 

			SWT.MouseUp, 

			SWT.MouseDoubleClick,

			SWT.Paint,

			SWT.Resize

		};

		for (int i = 0; i < events.length; i++) {

			addListener(events[i], listener);	

		}

	}

	private static int checkStyle(int style) {

		return style;

	}

	public Point computeSize(int wHint, int hHint) {

		return computeSize(wHint, hHint, true);

	}

	public Point computeSize(int wHint, int hHint, boolean changed) {

		checkWidget();

		int width = 0;

		int height = 0;

		int rowWidth = 0;

		int rowHeight = 0;

		for (int i = 0; i < items.size(); i++) {

			SCoolItem item = (SCoolItem)items.get(i);

			Point pt = item.getPreferredSize();

			if (i != 0 && item.wrap == true) {

				width = Math.max(rowWidth, width);

				height += rowHeight;

				rowWidth = 0;

				rowHeight = 0;

			}

			rowWidth += pt.x;

			rowHeight = Math.max(pt.y, rowHeight);

		}

		width = Math.max(rowWidth, width);

		height += rowHeight;

		if (wHint == 0) { 

			width = DEFAULT_WIDTH;

		}

		if (hHint == 0) {

			height = DEFAULT_HEIGHT;

		}

		Skin skin = getSkin();

		Rectangle borders = null;

		if (skin != null) {

			borders = skin.getRect(Skin.TYPE_BORDER, Skin.NORMAL);

		} 

		if (borders == null) {

			borders = new Rectangle(0, 0, 0, 0);

		}

		width += borders.x + borders.width;

		height += borders.y + borders.height;

		if (wHint != SWT.DEFAULT) {

			width = wHint;

		}

		if (hHint != SWT.DEFAULT) {

			height = hHint;

		}

		Rectangle trim = computeTrim(0, 0, width, height);

		Point pt = new Point(trim.width, trim.height);;

		return pt;

	}

	void createItem (SCoolItem item, int index) {

		int itemCount = getItemCount();

		if (!(0 <= index && index <= itemCount))

			SWT.error (SWT.ERROR_INVALID_RANGE);

		items.add(index, item);

		layout();

	}

	/**

	 * @return

	 */

	public int[] getAlignmentIndices () {

		checkWidget ();

		int itemCount = items.size();

		int[] indices = new int[itemCount];

		int count = 0;

		for (int i = 0; i < itemCount; i++) {

			SCoolItem item = (SCoolItem)items.get(i);

			if (item.alignment) {

				indices[count++] = i;

			}

		}

		int[] result = new int[count];

		System.arraycopy (indices, 0, result, 0, count);

		return result;		

	}

	public SCoolItem getItem(int index) {

		checkWidget();

		SCoolItem item = (SCoolItem)items.get(index);

		return item;

	}

	public int getItemCount() {

		checkWidget();

		return items.size();

	}

	public SCoolItem[] getItems() {

		checkWidget();

		if (items.size() == 0)

			return new SCoolItem[0];

		return (SCoolItem[])items.toArray(new SCoolItem[1]);

	}

	public boolean getLocked() {

		return false;

	}

	/**

	 * 

	 * @return

	 */

	public int[] getWrapIndices () {

		checkWidget ();

		int itemCount = items.size();

		int[] indices = new int[itemCount];

		int count = 0;

		for (int i = 0; i < itemCount; i++) {

			SCoolItem item = (SCoolItem)items.get(i);

			if (item.wrap) {

				indices[count++] = i;

			}

		}

		int[] result = new int[count];

		System.arraycopy (indices, 0, result, 0, count);

		return result;

	}

	public int indexOf(SCoolItem item) {

		checkWidget();

		if (item == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);

		if (item.isDisposed()) SWT.error (SWT.ERROR_INVALID_ARGUMENT);

		return items.indexOf(item);

	}

	protected void onDispose(Event event) {

		// TODO Auto-generated method stub

	}

	protected void onMouseDown(Event event) {

		// TODO Auto-generated method stub

	}

	protected void onMouseExit(Event event) {

		// TODO Auto-generated method stub

	}

	protected void onMouseMove(Event event) {

		// TODO Auto-generated method stub

	}

	protected void onMouseUp(Event event) {

		// TODO Auto-generated method stub

	}

	protected void onMouseDoubleClick(Event event) {

		// TODO Auto-generated method stub

	}

	protected void onPaint(Event event) {

		Skin skin = getSkin();

		GC gc = event.gc;

		if (skin == null)

			return;

		Rectangle rect = getClientArea();

		if (rect.width == 0 || rect.height == 0)

			return;

		int state = Skin.NORMAL;

		// paint background

		skin.drawBackground(gc, rect, this, Skin.TYPE_BACKGROUND, state);

		// paint border

		skin.drawBorder(gc, rect, this, Skin.TYPE_BORDER, state);

		// paint each item

		for (int i = 0; i < items.size(); i++) {

			SCoolItem item = getItem(i);

			if (item != null) {

				item.paint(gc, state);

			}

		}

	}

	protected void onResize(Event event) {

		layout();

	}

	/**

	 * Sets the indices of all item(s) in the receiver 

	 * that will begin right alignment on each row.

	 * For example, if indice contains 2, 

	 * that mean all the items from item2 to the end row are right aligned. 

	 *  

	 * @param indices

	 */

	public void setAlignmentIndices(int[] indices) {

		checkWidget();

		if (indices == null) 

			indices = new int[0];

		int count = items.size();

//		for (int i = 0; i< indices.length; i++) {

//			if (indices[i] < 0 || indices[i] >= count) {

//				SWT.error (SWT.ERROR_INVALID_ARGUMENT);

//			}

//		}

		for (int i = 0; i < items.size(); i++) {

			((SCoolItem)items.get(i)).alignment = false;

		}

		for (int i = 0; i < indices.length; i++) {

			int index = indices[i];

			if (index < items.size()) {

				((SCoolItem)items.get(index)).alignment = true;

			}

		}

		layout();

	}

	public void setBounds(int x, int y, int width, int height) {

		super.setBounds(x, y, width, height);

	}

	public void setBounds(Rectangle rect) {

		super.setBounds(rect);

	}

	public void setSize(int width, int height) {

		super.setSize(width, height);

	}

	public void setLocked(boolean locked) {

		// TODO Auto-generated method stub

	}

	public void setWrapIndices(int[] wrapIndices) {

		// TODO Auto-generated method stub

	}

	public void layout(boolean changed) {

		int x = 1;

		int y = 0;

		int rowHeight = 0;

		int maxHeightInRow = 0;

		int maxWidth;

		int i;

		Skin skin = getSkin();

		Rectangle borders = null;

		if (skin != null) {

			borders = skin.getRect(Skin.TYPE_BORDER, Skin.NORMAL);

		} 

		if (borders == null) {

			borders = new Rectangle(0, 0, 0, 0);

		}

		maxWidth = getClientArea().width;

		if (maxWidth == 0)

			return;

		x = borders.x;

		for (i = 0; i < items.size(); i++) {

			SCoolItem item = (SCoolItem)items.get(i);

			Point itemSize = item.computeSize(SWT.DEFAULT, SWT.DEFAULT);

			maxHeightInRow = Math.max(itemSize.y, maxHeightInRow);

		}

		for (i = 0; i < items.size(); i++) {

			// TODO: multiple row support

			// calc max height in row

//			if (i == 0 || ((SCoolItem)items.get(i)).wrap) {

//				rowHeight = maxHeightInRow;

//				maxHeightInRow = 0;

//				for (int j = i; j < items.size(); j++) {

//					SCoolItem item = (SCoolItem)items.get(j);

//					if (j != 0 && item.wrap)

//						break;

//					Point itemSize = item.computeSize(SWT.DEFAULT, SWT.DEFAULT);

//					maxHeightInRow = Math.max(itemSize.y, maxHeightInRow);

//				}

//			}

			// layout item

			SCoolItem item = (SCoolItem)items.get(i);

			Point itemSize = item.computeSize(SWT.DEFAULT, SWT.DEFAULT);

			Rectangle oldBounds = item.getBounds();

			if (i != 0 && item.wrap) {

				x = borders.x;

				y += rowHeight;

			} else if (item.alignment) {

				// right align from this item till the last item in the row

				int rightAlignWidth = 0;

				for (int j = i; j < items.size(); j++) {

					SCoolItem rightItem = (SCoolItem)items.get(j);

					int itemWidth = rightItem.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;

					rightAlignWidth += itemWidth; 

					if (rightItem.wrap == true)

						break;

				}

				int prevx = x;

				x = maxWidth - rightAlignWidth;	 // new x position after right alingn

				if (i > 0 && prevx != x) {

					// change the previous item width wider

					SCoolItem prevItem = (SCoolItem)items.get(i-1);

					Point pt = prevItem.computeSize(SWT.DEFAULT, SWT.DEFAULT);

					Rectangle r = prevItem.getBounds();

					prevItem.setBounds(r.x, r.y, pt.x + x - prevx, pt.y);

					//prevItem.setBounds(r.x, r.y, r.width + x - prevx, r.height);

				}

			}		

			if (x + itemSize.x > maxWidth) {

				itemSize.x -= (x + itemSize.x - maxWidth); 

			}

			Rectangle newBounds = new Rectangle(x, y, itemSize.x, maxHeightInRow);

			if (!oldBounds.equals(newBounds)) {

				item.setBounds(newBounds.x, newBounds.y, newBounds.width, newBounds.height);	

			}

			x += newBounds.width;

		}

		y += maxHeightInRow;

	}

}

package org.eclipse.ui.examples.presentation.customtoolbar.widgets;

import org.eclipse.swt.widgets.Canvas;

import org.eclipse.swt.widgets.Composite;

public abstract class SWidget extends Canvas {

	public static final int HOVER = 1 << 1;

	public static final int SELECTED = 1 << 2;

	public static final int PRESSED = 1 << 3;

	private Skin skin;

	public SWidget(Composite parent, int style) {

		super(parent, style);

	}

	public void setSkin(Skin skin) {

		if (this.skin != null) {

			this.skin.dispose();

			this.skin = null;

		}

		this.skin = skin;

	}

	public Skin getSkin() {

		return skin;

	}

}

package org.eclipse.ui.examples.presentation.customtoolbar.widgets;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import org.eclipse.jface.action.ContributionManager;

import org.eclipse.jface.action.IContributionItem;

import org.eclipse.jface.action.ICoolBarManager;

import org.eclipse.jface.action.IMenuManager;

import org.eclipse.jface.action.IToolBarManager;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.action.Separator;

import org.eclipse.jface.action.ToolBarContributionItem;

import org.eclipse.jface.util.Assert;

import org.eclipse.jface.util.Policy;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.CoolBar;

import org.eclipse.swt.widgets.Menu;

public class SCoolBarManager extends ContributionManager implements ICoolBarManager {

    /**

     * A separator created by the end user.

     */

    public final static String USER_SEPARATOR = "UserSeparator"; //$NON-NLS-1$

    /**

     * The original creation order of the contribution items.

     */

    private ArrayList cbItemsCreationOrder = new ArrayList();

    /**

     * MenuManager for cool bar pop-up menu, or null if none.

     */

    private MenuManager contextMenuManager = null;

    /**

     * The cool bar control; <code>null</code> before creation and after

     * disposal.

     */

    private SCoolBar coolBar = null;

    /**

     * The cool bar items style; <code>SWT.NONE</code> by default.

     */

    private int itemStyle = SWT.NONE;

    /**

     * Creates a new cool bar manager with the default style. Equivalent to

     * <code>CoolBarManager(SWT.NONE)</code>.

     */

    public SCoolBarManager() {

        // do nothing

    }

    /**

     * Creates a cool bar manager for an existing cool bar control. This

     * manager becomes responsible for the control, and will dispose of it when

     * the manager is disposed.

     * 

     * @param coolBar

     *            the cool bar control

     */

    public SCoolBarManager(SCoolBar coolBar) {

        this();

        Assert.isNotNull(coolBar);

        this.coolBar = coolBar;

        itemStyle = coolBar.getStyle();

    }

    /**

     * Creates a cool bar manager with the given SWT style. Calling <code>createControl</code>

     * will create the cool bar control.

     * 

     * @param style

     *            the cool bar item style; see

     *            {@link org.eclipse.swt.widgets.CoolBar CoolBar}for for valid

     *            style bits

     */

    public SCoolBarManager(int style) {

        itemStyle = style;

    }

    /*

     * (non-Javadoc)

     * 

     * @see org.eclipse.jface.action.ICoolBarManager#add(org.eclipse.jface.action.IToolBarManager)

     */

    public void add(IToolBarManager toolBarManager) {

        Assert.isNotNull(toolBarManager);

        SToolBarContributionItem2 toolBarContributionItem = new SToolBarContributionItem2(toolBarManager);

        super.add(toolBarContributionItem);

    }

    public void add(IContributionItem item) {

    	super.add(item);

    }

    /**

     * Collapses consecutive separators and removes a separator from the

     * beginning and end of the list.

     * 

     * @param contributionList

     *            the list of contributions; must not be <code>null</code>.

     * @return The contribution list provided with extraneous separators

     *         removed; this value is never <code>null</code>, but may be

     *         empty.

     */

    private ArrayList adjustContributionList(ArrayList contributionList) {

        IContributionItem item;

        // Fist remove a separator if it is the first element of the list

        if (contributionList.size() != 0) {

            item = (IContributionItem) contributionList.get(0);

            if (item.isSeparator()) {

                contributionList.remove(0);

            }

            ListIterator iterator = contributionList.listIterator();

            // collapse consecutive separators

            while (iterator.hasNext()) {

                item = (IContributionItem) iterator.next();

                if (item.isSeparator()) {

                    while (iterator.hasNext()) {

                        item = (IContributionItem) iterator.next();

                        if (item.isSeparator()) {

                            iterator.remove();

                        } else {

                            break;

                        }

                    }

                }

            }

            // Now check last element to see if there is a separator

            item = (IContributionItem) contributionList.get(contributionList

                    .size() - 1);

            if (item.isSeparator()) {

                contributionList.remove(contributionList.size() - 1);

            }

        }

        return contributionList;

    }

    /* (non-Javadoc)

     * @see org.eclipse.jface.action.ContributionManager#checkDuplication(org.eclipse.jface.action.IContributionItem)

     */

    protected boolean allowItem(IContributionItem itemToAdd) {

        /* We will allow as many null entries as they like, though there should

         * be none.

         */

        if (itemToAdd == null) {

            return true;

        }

        /* Null identifiers can be expected in generic contribution items.

         */

        String firstId = itemToAdd.getId();

        if (firstId == null) {

            return true;

        }

        // Cycle through the current list looking for duplicates.

        IContributionItem[] currentItems = getItems();

        for (int i = 0; i < currentItems.length; i++) {

            IContributionItem currentItem = currentItems[i];

            // We ignore null entries.

            if (currentItem == null) {

                continue;

            }

            String secondId = currentItem.getId();

            if (firstId.equals(secondId)) {

                if (Policy.TRACE_TOOLBAR) { //$NON-NLS-1$

                    System.out.println("Trying to add a duplicate item."); //$NON-NLS-1$

                    new Exception().printStackTrace(System.out);

                    System.out.println("DONE --------------------------"); //$NON-NLS-1$

                }

                return false;

            }

        }

        return true;

    }

    /**

     * Positions the list iterator to the end of all the separators. Calling

     * <code>next()</code> the iterator should return the immediate object

     * following the last separator.

     * 

     * @param iterator

     *            the list iterator.

     */

    private void collapseSeparators(ListIterator iterator) {

        while (iterator.hasNext()) {

            IContributionItem item = (IContributionItem) iterator.next();

            if (!item.isSeparator()) {

                iterator.previous();

                return;

            }

        }

    }

    /**

     * Returns whether the cool bar control has been created and not yet

     * disposed.

     * 

     * @return <code>true</code> if the control has been created and not yet

     *         disposed, <code>false</code> otherwise

     */

    private boolean coolBarExist() {

        return coolBar != null && !coolBar.isDisposed();

    }

    /**

     * Creates and returns this manager's cool bar control. Does not create a

     * new control if one already exists.

     * 

     * @param parent

     *            the parent control

     * @return the cool bar control

     */

    public Control createControl2(Composite parent) {

        Assert.isNotNull(parent);

        if (!coolBarExist()) {

       		coolBar = new SCoolBar(parent, itemStyle);

       		((SCoolBar)coolBar).setSkin(new HannoverGlobalCoolBarSkin());

            coolBar.setMenu(getContextMenuControl());

            coolBar.setLocked(false);

            coolBar.setSkin(new HannoverGlobalCoolBarSkin());

            update(false);

        }

        return coolBar;

    }

    /**

     * Disposes of this cool bar manager and frees all allocated SWT resources.

     * Notifies all contribution items of the dispose. Note that this method

     * does not clean up references between this cool bar manager and its

     * associated contribution items. Use <code>removeAll</code> for that

     * purpose.

     */

    public void dispose() {

        if (coolBarExist()) {

            IContributionItem[] items = getItems();

            for (int i = 0; i < items.length; i++) {

                // Disposes of the contribution item.

                // If Contribution Item is a toolbar then it will dispose of

                // all the nested

                // contribution items.

                items[i].dispose();

            }

            coolBar.dispose();

            coolBar = null;

        }

        // If a context menu existed then dispose of it.

        if (contextMenuManager != null) {

            contextMenuManager.dispose();

            contextMenuManager = null;

        }

    }

    /**

     * Disposes the given cool item.

     * 

     * @param item

     *            the cool item to dispose

     */

    private void dispose(SCoolItem item) {

        if ((item != null) && !item.isDisposed()) {

            item.setData(null);

            Control control = item.getControl();

            // if the control is already disposed, setting the coolitem

            // control to null will cause an SWT exception, workaround

            // for 19630

            if ((control != null) && !control.isDisposed()) {

                item.setControl(null);

            }

            item.dispose();

        }

    }

    /**

     * Finds the cool item associated with the given contribution item.

     * 

     * @param item

     *            the contribution item

     * @return the associated cool item, or <code>null</code> if not found

     */

    private SCoolItem findCoolItem(IContributionItem item) {

        if (coolBar == null)

            return null;

        SCoolItem[] items = coolBar.getItems();

        for (int i = 0; i < items.length; i++) {

            SCoolItem coolItem = items[i];

            IContributionItem data = (IContributionItem) coolItem.getData();

            if (data != null && data.equals(item))

                return coolItem;

        }

        return null;

    }

    /**

     * Return a consistent set of wrap indices. The return value will always

     * include at least one entry and the first entry will always be zero.

     * CoolBar.getWrapIndices() is inconsistent in whether or not it returns an

     * index for the first row.

     * 

     * @param wraps

     *            the wrap indicies from the cool bar widget

     * @return the adjusted wrap indicies.

     */

    private int[] getAdjustedWrapIndices(int[] wraps) {

        int[] adjustedWrapIndices;

        if (wraps.length == 0) {

            adjustedWrapIndices = new int[] { 0 };

        } else {

            if (wraps[0] != 0) {

                adjustedWrapIndices = new int[wraps.length + 1];

                adjustedWrapIndices[0] = 0;

                for (int i = 0; i < wraps.length; i++) {

                    adjustedWrapIndices[i + 1] = wraps[i];

                }

            } else {

                adjustedWrapIndices = wraps;

            }

        }

        return adjustedWrapIndices;

    }

    /**

     * Returns the control of the Menu Manager. If the menu manager does not

     * have a control then one is created.

     * 

     * @return menu control associated with manager, or null if none

     */

    private Menu getContextMenuControl() {

        if ((contextMenuManager != null) && (coolBar != null)) {

            Menu menuWidget = contextMenuManager.getMenu();

            if ((menuWidget == null) || (menuWidget.isDisposed())) {

                menuWidget = contextMenuManager.createContextMenu(coolBar);

            }

            return menuWidget;

        }

        return null;

    }

    /*

     * (non-Javadoc)

     * 

     * @see org.eclipse.jface.action.ICoolBarManager#isLayoutLocked()

     */

    public IMenuManager getContextMenuManager() {

        return contextMenuManager;

    }

    /**

     * Returns the cool bar control for this manager.

     * 

     * @return the cool bar control, or <code>null</code> if none

     */

    public CoolBar getControl() {

        return null;

    }

    /**

     * Returns an array list of all the contribution items in the manager.

     * 

     * @return an array list of contribution items.

     */

    private ArrayList getItemList() {

        IContributionItem[] cbItems = getItems();

        ArrayList list = new ArrayList(cbItems.length);

        for (int i = 0; i < cbItems.length; i++) {

            list.add(cbItems[i]);

        }

        return list;

    }

    /*

     * (non-Javadoc)

     * 

     * @see org.eclipse.jface.action.ICoolBarManager#isLayoutLocked()

     */

    public boolean getLockLayout() {

        if (!coolBarExist()) {

            return false;

        }

        return coolBar.getLocked();

    }

    /**

     * Returns the number of rows that should be displayed visually.

     * 

     * @param items

     *            the array of contributin items

     * @return the number of rows

     */

    private int getNumRows(IContributionItem[] items) {

        int numRows = 1;

        boolean separatorFound = false;

        for (int i = 0; i < items.length; i++) {

            if (items[i].isSeparator()) {

                separatorFound = true;

            }

            if ((separatorFound) && (items[i].isVisible())

                    && (!items[i].isGroupMarker()) && (!items[i].isSeparator())) {

                numRows++;

                separatorFound = false;

            }

        }

        return numRows;

    }

    /*

     * (non-Javadoc)

     * 

     * @see org.eclipse.jface.action.ICoolBarManager#getStyle()

     */

    public int getStyle() {

        return itemStyle;

    }

    /**

     * Subclasses may extend this <code>ContributionManager</code> method,

     * but must call <code>super.itemAdded</code>.

     * 

     * @see org.eclipse.jface.action.ContributionManager#itemAdded(org.eclipse.jface.action.IContributionItem)

     */

    protected void itemAdded(IContributionItem item) {

        Assert.isNotNull(item);

        super.itemAdded(item);

        int insertedAt = indexOf(item);

        boolean replaced = false;

        final int size = cbItemsCreationOrder.size();

        for (int i = 0; i < size; i++) {

            IContributionItem created = (IContributionItem) cbItemsCreationOrder

                    .get(i);

            if (created.getId() != null && created.getId().equals(item.getId())) {

                cbItemsCreationOrder.set(i, item);

                replaced = true;

                break;

            }

        }

        if (!replaced) {

            cbItemsCreationOrder.add(Math.min(Math.max(insertedAt, 0),

                    cbItemsCreationOrder.size()), item);

        }

    }

    /**

     * Subclasses may extend this <code>ContributionManager</code> method,

     * but must call <code>super.itemRemoved</code>.

     * 

     * @see org.eclipse.jface.action.ContributionManager#itemRemoved(org.eclipse.jface.action.IContributionItem)

     */

    protected void itemRemoved(IContributionItem item) {

        Assert.isNotNull(item);

        super.itemRemoved(item);

        SCoolItem coolItem = findCoolItem(item);

        if (coolItem != null) {

            coolItem.setData(null);

        }

    }

    /**

     * Positions the list iterator to the starting of the next row. By calling

     * next on the returned iterator, it will return the first element of the

     * next row.

     * 

     * @param iterator

     *            the list iterator of contribution items

     * @param ignoreCurrentItem

     *            Whether the current item in the iterator should be considered

     *            (as well as subsequent items).

     */

    private void nextRow(ListIterator iterator, boolean ignoreCurrentItem) {

        IContributionItem currentElement = null;

        if (!ignoreCurrentItem && iterator.hasPrevious()) {

            currentElement = (IContributionItem) iterator.previous();

            iterator.next();

        }

        if ((currentElement != null) && (currentElement.isSeparator())) {

            collapseSeparators(iterator);

            return;

        } else {

            //Find next separator

            while (iterator.hasNext()) {

                IContributionItem item = (IContributionItem) iterator.next();

                if (item.isSeparator()) {

                    // we we find a separator, collapse any consecutive

                    // separators

                    // and return

                    collapseSeparators(iterator);

                    return;

                }

            }

        }

    }

    /*

     * Used for debuging. Prints all the items in the internal structures.

     */

    //    private void printContributions(ArrayList contributionList) {

    //        int index = 0;

    //        System.out.println("----------------------------------\n"); //$NON-NLS-1$

    //        for (Iterator i = contributionList.iterator(); i.hasNext(); index++) {

    //            IContributionItem item = (IContributionItem) i.next();

    //            if (item.isSeparator()) {

    //                System.out.println("Separator"); //$NON-NLS-1$

    //            } else {

    //                System.out.println(index + ". Item id: " + item.getId() //$NON-NLS-1$

    //                        + " - is Visible: " //$NON-NLS-1$