<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 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 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 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 = null;

        if (toolBarContributionItem == null)

        	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$

    //                        + item.isVisible());

    //            }

    //        }

    //    }

    /**

     * Synchronizes the visual order of the cool items in the control with this

     * manager's internal data structures. This method should be called before

     * requesting the order of the contribution items to ensure that the order

     * is accurate.

     * <p>

     * Note that <code>update()</code> and <code>refresh()</code> are

     * converses: <code>update()</code> changes the visual order to match the

     * internal structures, and <code>refresh</code> changes the internal

     * structures to match the visual order.

     * </p>

     */

    public void refresh() {

        if (!coolBarExist()) {

            return;

        }

        // Retreives the list of contribution items as an array list

        ArrayList contributionList = getItemList();

        // Check the size of the list

        if (contributionList.size() == 0)

            return;

        // The list of all the cool items in their visual order

        SCoolItem[] coolItems = coolBar.getItems();

        // The wrap indicies of the coolbar

        int[] wrapIndicies = getAdjustedWrapIndices(coolBar.getWrapIndices());

        int row = 0;

        int coolItemIndex = 0;

        // Traverse through all cool items in the coolbar add them to a new

        // data structure

        // in the correct order

        ArrayList displayedItems = new ArrayList(coolBar.getItemCount());

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

            SCoolItem coolItem = coolItems[i];

            if (coolItem.getData() instanceof IContributionItem) {

                IContributionItem cbItem = (IContributionItem) coolItem

                        .getData();

                displayedItems.add(Math.min(i, displayedItems.size()), cbItem);

            }

        }

        // Add separators to the displayed Items data structure

        int offset = 0;

        for (int i = 1; i < wrapIndicies.length; i++) {

            int insertAt = wrapIndicies[i] + offset;

            displayedItems.add(insertAt, new Separator(USER_SEPARATOR));

            offset++;

        }

        // Determine which rows are invisible

        ArrayList existingVisibleRows = new ArrayList(4);

        ListIterator rowIterator = contributionList.listIterator();

        collapseSeparators(rowIterator);

        int numRow = 0;

        while (rowIterator.hasNext()) {

            // Scan row

            while (rowIterator.hasNext()) {

                IContributionItem cbItem = (IContributionItem) rowIterator

                        .next();

                if (displayedItems.contains(cbItem)) {

                    existingVisibleRows.add(new Integer(numRow));

                    break;

                }

                if (cbItem.isSeparator()) {

                    break;

                }

            }

            nextRow(rowIterator, false);

            numRow++;

        }

        Iterator existingRows = existingVisibleRows.iterator();

        // Adjust row number to the first visible

        if (existingRows.hasNext()) {

            row = ((Integer) existingRows.next()).intValue();

        }

        HashMap itemLocation = new HashMap();

        for (ListIterator locationIterator = displayedItems.listIterator(); locationIterator

                .hasNext();) {

            IContributionItem item = (IContributionItem) locationIterator

                    .next();

            if (item.isSeparator()) {

                if (existingRows.hasNext()) {

                    Integer value = (Integer) existingRows.next();

                    row = value.intValue();

                } else {

                    row++;

                }

            } else {

                itemLocation.put(item, new Integer(row));

            }

        }

        // Insert the contribution items in their correct location

        for (ListIterator iterator = displayedItems.listIterator(); iterator

                .hasNext();) {

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

            if (cbItem.isSeparator()) {

                coolItemIndex = 0;

            } else {

                relocate(cbItem, coolItemIndex, contributionList, itemLocation);

                cbItem.saveWidgetState();

                coolItemIndex++;

            }

        }

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

            contributionList = adjustContributionList(contributionList);

            IContributionItem[] array = new IContributionItem[contributionList

                    .size() - 1];

            array = (IContributionItem[]) contributionList.toArray(array);

            internalSetItems(array);

        }

    }

    /**

     * Relocates the given contribution item to the specified index.

     * 

     * @param cbItem

     *            the conribution item to relocate

     * @param index

     *            the index to locate this item

     * @param contributionList

     *            the current list of conrtributions

     * @param itemLocation

     */

    private void relocate(IContributionItem cbItem, int index,

            ArrayList contributionList, HashMap itemLocation) {

        if (!(itemLocation.get(cbItem) instanceof Integer))

            return;

        int targetRow = ((Integer) itemLocation.get(cbItem)).intValue();

        int cbInternalIndex = contributionList.indexOf(cbItem);

        //	by default add to end of list

        int insertAt = contributionList.size();

        // Find the row to place this item in.

        ListIterator iterator = contributionList.listIterator();

        // bypass any separators at the begining

        collapseSeparators(iterator);

        int currentRow = -1;

        while (iterator.hasNext()) {

            currentRow++;

            if (currentRow == targetRow) {

                // We found the row to insert the item

                int virtualIndex = 0;

                insertAt = iterator.nextIndex();

                // first check the position of the current element (item)

                // then get the next element

                while (iterator.hasNext()) {

                    IContributionItem item = (IContributionItem) iterator

                            .next();

                    Integer itemRow = (Integer) itemLocation.get(item);

                    if (item.isSeparator())

                        break;

                    // if the item has an associate widget

                    if ((itemRow != null) && (itemRow.intValue() == targetRow)) {

                        // if the next element is the index we are looking for

                        // then break

                        if (virtualIndex >= index)

                            break;

                        virtualIndex++;

                    }

                    insertAt++;

                }

                // If we don't need to move it then we return

                if (cbInternalIndex == insertAt)

                    return;

                break;

            }

            nextRow(iterator, true);

        }

        contributionList.remove(cbItem);

        // Adjust insertAt index

        if (cbInternalIndex < insertAt) {

            insertAt--;

        }

        // if we didn't find the row then add a new row

        if (currentRow != targetRow) {

            contributionList.add(new Separator(USER_SEPARATOR));

            insertAt = contributionList.size();

        }

        insertAt = Math.min(insertAt, contributionList.size());

        contributionList.add(insertAt, cbItem);

    }

    /**

     * Restores the canonical order of this cool bar manager. The canonical

     * order is the order in which the contribution items where added.

     */

    public void resetItemOrder() {

        for (ListIterator iterator = cbItemsCreationOrder.listIterator(); iterator

                .hasNext();) {

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

            // if its a user separator then do not include in original order.

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

                iterator.remove();

            }

        }

        IContributionItem[] itemsToSet = new IContributionItem[cbItemsCreationOrder

                .size()];

        cbItemsCreationOrder.toArray(itemsToSet);

        setItems(itemsToSet);

    }

    /*

     * (non-Javadoc)

     * 

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

     */

    public void setContextMenuManager(IMenuManager contextMenuManager) {

        this.contextMenuManager = (MenuManager) contextMenuManager;

        if (coolBar != null) {

            coolBar.setMenu(getContextMenuControl());

        }

    }

    /**

     * Replaces the current items with the given items.

     * Forces an update.

     * 

     * @param newItems the items with which to replace the current items

     */

    public void setItems(IContributionItem[] newItems) {

        // dispose of all the cool items on the cool bar manager

/* FIXME TFS

 *	This is disposing of the coolItems but references are still hanging around. Might

 *	be a problem with SCoolBar and or SCoolItem. [Terry Smith 12/9/2005]

 * 

        if (coolBar != null) {

            SCoolItem[] coolItems = coolBar.getItems();

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

              dispose(coolItems[i]);

            }

        }

        // Set the internal structure to this order

        internalSetItems(newItems);

*/

        // Force and update

        update(true);

    }

    /*

     * (non-Javadoc)

     * 

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

     */

    public void setLockLayout(boolean value) {

        if (!coolBarExist()) {

            return;

        }

        coolBar.setLocked(value);

    }

    /**

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

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

     * 

     * @see org.eclipse.jface.action.IContributionManager#update(boolean)

     */

    public void update(boolean force) {

        if ((!isDirty() && !force) || (!coolBarExist())) {

            return;

        }

        boolean relock = false;

        boolean changed = false;

        try {

            coolBar.setRedraw(false);

            // Refresh the widget data with the internal data structure.

            refresh();

            if (coolBar.getLocked()) {

                coolBar.setLocked(false);

                relock = true;

            }

            /*

             * Make a list of items including only those items that are

             * visible. Separators should stay because they mark line breaks in

             * a cool bar.

             */

            final IContributionItem[] items = getItems();

            final List visibleItems = new ArrayList(items.length);

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

                final IContributionItem item = items[i];

                if (item.isVisible()) {

                    visibleItems.add(item);

                }

            }

            /*

             * Make a list of CoolItem widgets in the cool bar for which there

             * is no current visible contribution item. These are the widgets

             * to be disposed. Dynamic items are also removed.

             */

            SCoolItem[] coolItems = coolBar.getItems();

            final ArrayList coolItemsToRemove = new ArrayList(coolItems.length);

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

                final Object data = coolItems[i].getData();

                if ((data == null)

                        || (!visibleItems.contains(data))

                        || ((data instanceof IContributionItem) && ((IContributionItem) data)

                                .isDynamic())) {

                    coolItemsToRemove.add(coolItems[i]);

                }

            }

            // Dispose of any items in the list to be removed.

            for (int i = coolItemsToRemove.size() - 1; i >= 0; i--) {

                SCoolItem coolItem = (SCoolItem) coolItemsToRemove.get(i);

                if (!coolItem.isDisposed()) {

                    Control control = coolItem.getControl();

                    if (control != null) {

                        coolItem.setControl(null);

                        control.dispose();

                    }

                    coolItem.dispose();

                }

            }

            // Add any new items by telling them to fill.

            coolItems = coolBar.getItems();

            IContributionItem sourceItem;

            IContributionItem destinationItem;

            int sourceIndex = 0;

            int destinationIndex = 0;

            final Iterator visibleItemItr = visibleItems.iterator();

            while (visibleItemItr.hasNext()) {

                sourceItem = (IContributionItem) visibleItemItr.next();

                // Retrieve the corresponding contribution item from SWT's

                // data.

                if (sourceIndex < coolItems.length) {

                    destinationItem = (IContributionItem) coolItems[sourceIndex]

                            .getData();

                } else {

                    destinationItem = null;

                }

                // The items match is they are equal or both separators.

                if (destinationItem != null) {

                    if (sourceItem.equals(destinationItem)) {

                        sourceIndex++;

                        destinationIndex++;

                        sourceItem.update();

                        continue;

                    } else if ((destinationItem.isSeparator())

                            && (sourceItem.isSeparator())) {

                        coolItems[sourceIndex].setData(sourceItem);

                        sourceIndex++;

                        destinationIndex++;

                        sourceItem.update();

                        continue;

                    }

                }

                // Otherwise, a new item has to be added.

                final int start = coolBar.getItemCount();

                if (sourceItem instanceof ISContributionItem)

                	((ISContributionItem)sourceItem).fill(coolBar, destinationIndex);

                final int newItems = coolBar.getItemCount() - start;

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

                    coolBar.getItem(destinationIndex++).setData(sourceItem);

                }

                changed = true;

            }

            // Remove any old widgets not accounted for.

            for (int i = coolItems.length - 1; i >= sourceIndex; i--) {

                final SCoolItem item = coolItems[i];

                if (!item.isDisposed()) {

                    Control control = item.getControl();

                    if (control != null) {

                        item.setControl(null);

                        control.dispose();

                    }

                    item.dispose();

                    changed = true;

                }

            }

            // Update wrap indices.

            updateWrapIndices();

            // Update the sizes.

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

                IContributionItem item = items[i];

                item.update(SIZE);

            }

            // if the coolBar was previously locked then lock it

            if (relock) {

                coolBar.setLocked(true);

            }

            if (changed) {

                updateTabOrder();

            }

            // We are no longer dirty.

            setDirty(false);

        } finally {

            coolBar.setRedraw(true);

        }

    }

    /**

     * Sets the tab order of the coolbar to the visual order of its items.

     */

    /* package */void updateTabOrder() {

        if (coolBar != null) {

            SCoolItem[] items = coolBar.getItems();

            if (items != null) {

                ArrayList children = new ArrayList(items.length);

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

                    if ((items[i].getControl() != null)

                            && (!items[i].getControl().isDisposed())) {

                        children.add(items[i].getControl());

                    }

                }

                // Convert array

                Control[] childrenArray = new Control[0];

                childrenArray = (Control[]) children.toArray(childrenArray);

                if (childrenArray != null) {

                    coolBar.setTabList(childrenArray);

                }

            }

        }

    }

    /**

     * Updates the indices at which the cool bar should wrap.

     */

    private void updateWrapIndices() {

        final IContributionItem[] items = getItems();

        final int numRows = getNumRows(items) - 1;

        // Generate the list of wrap indices.

        final int[] wrapIndices = new int[numRows];

        boolean foundSeparator = false;

        int j = 0;

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

            IContributionItem item = items[i];

            SCoolItem coolItem = findCoolItem(item);

            if (item.isSeparator()) {

                foundSeparator = true;

            }

            if ((!item.isSeparator()) && (!item.isGroupMarker())

                    && (item.isVisible()) && (coolItem != null)

                    && (foundSeparator)) {

                wrapIndices[j] = coolBar.indexOf(coolItem);

                j++;

                foundSeparator = false;

            }

        }

        /*

         * Check to see if these new wrap indices are different than the old

         * ones.

         */

        final int[] oldIndices = coolBar.getWrapIndices();

        boolean shouldUpdate = false;

        if (oldIndices.length == wrapIndices.length) {

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

                if (oldIndices[i] != wrapIndices[i]) {

                    shouldUpdate = true;

                    break;

                }

            }

        } else {

            shouldUpdate = true;

        }

        if (shouldUpdate) {

            coolBar.setWrapIndices(wrapIndices);

        }

    }

	public CoolBar createControl(Composite parent) {

		return null;

	}

	public Control getControl2() {

		return coolBar;

	}

}

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

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;

public interface Skin {

	// states

	public static final int NORMAL = 0;

	public static final int HOVER = 1 << 1;

	public static final int SELECTED = 1 << 2;

	public static final int PRESSED = 1 << 3;

	public static final int DISABLED = 1 << 4;

	public static final int COLLAPSED = 1 << 5;

	// decorations

	public final static int TYPE_DECORATION_CLOSE = 1;

	public final static int TYPE_DECORATION_SEPARATOR = 2;

	public final static int TYPE_DECORATION_FOCUS = 3;

	public final static int TYPE_DECORATION_ARROW = 4;

	public final static int TYPE_DECORATION_CHEVRON = 5;

	public final static int TYPE_DECORATION_DROPDOWN_BUTTON = 6;

	public final static int TYPE_DECORATION_COLLAPSE_BUTTON = 7;

	public final static int TYPE_DECORATION_EXPAND_BUTTON = 8;

	public final static int TYPE_DECORATION_GRIPPER = 9;

	public final static int TYPE_DECORATION_INTERNAL_SEPARATOR = 10;

	// borders

	public final static int TYPE_ITEM_MENU_BORDER = 11;

	public final static int TYPE_ITEM_AREA_BORDER = 12;

	public final static int TYPE_ITEM_BORDER = 13;

	public final static int TYPE_BORDER = 14;

	public final static int TYPE_GROUP_ITEM_BORDER = 15;

	public final static int TYPE_GROUP_BORDER = 16;

	public final static int TYPE_HEADER_ITEM_BORDER = 17;

	public final static int TYPE_HEADER_BORDER = 18;

	// backgrounds

	public final static int TYPE_ITEM_MENU_BACKGROUND = 19;

	public final static int TYPE_ITEM_AREA_BACKGROUND = 20;

	public final static int TYPE_ITEM_BACKGROUND = 21;

	public final static int TYPE_BACKGROUND = 22;

	public final static int TYPE_GROUP_ITEM_BACKGROUND = 23;

	public final static int TYPE_HEADER_ITEM_BACKGROUND = 24;

	public final static int TYPE_HEADER_BACKGROUND = 25;

	// fonts

	public final static int TYPE_ITEM_MENU_FONT = 26;

	public final static int TYPE_ITEM_FONT = 27;

	public final static int TYPE_FONT = 28;

	// text

	public final static int TYPE_ITEM_MENU_TEXT = 29;

	public final static int TYPE_ITEM_TEXT = 30;

	public final static int TYPE_TEXT= 31;

	public final static int TYPE_GROUP_ITEM_TEXT = 32;				

	public final static int TYPE_HEADER_ITEM_TEXT = 33;				

	// images

	public final static int TYPE_ITEM_IMAGE = 34;

	public final static int TYPE_IMAGE = 35;

	// properties

	public final static int TYPE_MARGINS = 36;

	public final static int TYPE_INSETS = 37;

	public final static int TYPE_ITEM_MARGINS = 38;

	public final static int TYPE_ITEM_INSETS = 39;

	public final static int TYPE_ITEM_AREA_MARGINS = 40;

	public final static int TYPE_ITEM_AREA_INSETS = 41;

	public final static int TYPE_ITEM_MENU_MARGINS = 42;

	public final static int TYPE_ITEM_MENU_INSETS = 43;	

	public final static int TYPE_DECORATION_CLOSE_INSETS = 44;

	public final static int TYPE_ITEM_MIN_MAX_WIDTHS = 45;

	public final static int TYPE_ITEM_ICON_SIZE = 46;

	public final static int TYPE_ITEM_MIN_MAX_HEIGHT = 47;

	abstract public Rectangle getInsets(int type, int state);

	abstract public Point getSize(int type, int state);

	abstract public Font getFont(int type, int state);

	abstract public Rectangle getMargins(int type, int state);

	abstract public Rectangle getRect(int type, int state);

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

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

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

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

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

	abstract public void dispose();

}

/*

*	Copyright IBM Corporation 2003, 2005

*	All rights reserved.

*	US Government Users Restricted Rights - Use, duplication or disclosure

*	restricted by GS ADP Schedule Contract with IBM Corp.

*/

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

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.graphics.FontMetrics;

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.Control;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Item;

import org.eclipse.swt.widgets.TypedListener;

public class SToolItem extends Item {

	SToolBar parent;

	Control control;

	int index;

	String toolTipText;

	Image disabledImage;

	Image hotImage;

	Image pressedImage;

	boolean enabled = true;

	boolean selected;

	int separatorWidth;

	int width = -1;

	Point arrowSize = new Point(5, 5);

	int state;

	int arrowState;

	/** the alignment. Either CENTER, RIGHT, LEFT. Default is LEFT */

	private int align = SWT.LEFT;

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

	Rectangle arrowRect;

	/**

	 * @param parent

	 * @param style

	 */

	public SToolItem(SToolBar parent, int style) {

		super(parent, style);

		this.parent = parent;

		parent.createItem(this, parent.getItemCount());

	}

	/**

	 * @param parent

	 * @param style

	 * @param index

	 */

	public SToolItem(SToolBar parent, int style, int index) {

		super(parent, style, index);

		this.parent = parent;

		parent.createItem(this, index);

	}

	public void addSelectionListener(SelectionListener listener) {

		checkWidget();

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

		TypedListener typedListener = new TypedListener (listener);

		addListener (SWT.Selection, typedListener);

		addListener (SWT.DefaultSelection, typedListener);

	}

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

		checkWidget();

		Skin skin = parent.getSkin();

		Rectangle insets = skin.getRect(Skin.TYPE_ITEM_INSETS, Skin.NORMAL);

		if (insets == null) {

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

		}

		Point size = null;

		String t = getText();

		if (t != null && t.length() == 0) {

			t = null;

		}

		if (control == null && (getStyle() & SWT.SEPARATOR) == SWT.SEPARATOR && 

				t == null) {

			size = skin.getSize(Skin.TYPE_DECORATION_SEPARATOR, Skin.NORMAL);

		}

		else {

			size = getContentSize(getImage(), getText());

		}

		if (size == null) {

			size = new Point(0, 0);

		}

		if (wHint == SWT.DEFAULT) {

			size.x += (insets.x + insets.width);

		} else {

			size.x = wHint;

		}

		if (hHint == SWT.DEFAULT) {

			if (size.y != SWT.DEFAULT) {

				if (getControl() == null) {

					size.y += (insets.y + insets.height);

				}

			}

		} else {

			size.y = hHint;

		}

		//

		// Everything gets measured for a min/max width and height except if